mirror of
https://github.com/miniflux/v2.git
synced 2024-08-30 16:17:20 +02:00
267 lines
4.8 KiB
Go
267 lines
4.8 KiB
Go
// Copyright 2012 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package build
|
|
|
|
import (
|
|
"bytes"
|
|
"sort"
|
|
"testing"
|
|
|
|
"golang.org/x/text/internal/colltab"
|
|
)
|
|
|
|
var largetosmall = []stridx{
|
|
{"a", 5},
|
|
{"ab", 4},
|
|
{"abc", 3},
|
|
{"abcd", 2},
|
|
{"abcde", 1},
|
|
{"abcdef", 0},
|
|
}
|
|
|
|
var offsetSortTests = [][]stridx{
|
|
{
|
|
{"bcde", 1},
|
|
{"bc", 5},
|
|
{"ab", 4},
|
|
{"bcd", 3},
|
|
{"abcd", 0},
|
|
{"abc", 2},
|
|
},
|
|
largetosmall,
|
|
}
|
|
|
|
func TestOffsetSort(t *testing.T) {
|
|
for i, st := range offsetSortTests {
|
|
sort.Sort(offsetSort(st))
|
|
for j, si := range st {
|
|
if j != si.index {
|
|
t.Errorf("%d: failed: %v", i, st)
|
|
}
|
|
}
|
|
}
|
|
for i, tt := range genStateTests {
|
|
// ensure input is well-formed
|
|
sort.Sort(offsetSort(tt.in))
|
|
for j, si := range tt.in {
|
|
if si.index != j+1 {
|
|
t.Errorf("%dth sort failed: %v", i, tt.in)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var genidxtest1 = []stridx{
|
|
{"bcde", 3},
|
|
{"bc", 6},
|
|
{"ab", 2},
|
|
{"bcd", 5},
|
|
{"abcd", 0},
|
|
{"abc", 1},
|
|
{"bcdf", 4},
|
|
}
|
|
|
|
var genidxSortTests = [][]stridx{
|
|
genidxtest1,
|
|
largetosmall,
|
|
}
|
|
|
|
func TestGenIdxSort(t *testing.T) {
|
|
for i, st := range genidxSortTests {
|
|
sort.Sort(genidxSort(st))
|
|
for j, si := range st {
|
|
if j != si.index {
|
|
t.Errorf("%dth sort failed %v", i, st)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var entrySortTests = []colltab.ContractTrieSet{
|
|
{
|
|
{10, 0, 1, 3},
|
|
{99, 0, 1, 0},
|
|
{20, 50, 0, 2},
|
|
{30, 0, 1, 1},
|
|
},
|
|
}
|
|
|
|
func TestEntrySort(t *testing.T) {
|
|
for i, et := range entrySortTests {
|
|
sort.Sort(entrySort(et))
|
|
for j, fe := range et {
|
|
if j != int(fe.I) {
|
|
t.Errorf("%dth sort failed %v", i, et)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
type GenStateTest struct {
|
|
in []stridx
|
|
firstBlockLen int
|
|
out colltab.ContractTrieSet
|
|
}
|
|
|
|
var genStateTests = []GenStateTest{
|
|
{[]stridx{
|
|
{"abc", 1},
|
|
},
|
|
1,
|
|
colltab.ContractTrieSet{
|
|
{'a', 0, 1, noIndex},
|
|
{'b', 0, 1, noIndex},
|
|
{'c', 'c', final, 1},
|
|
},
|
|
},
|
|
{[]stridx{
|
|
{"abc", 1},
|
|
{"abd", 2},
|
|
{"abe", 3},
|
|
},
|
|
1,
|
|
colltab.ContractTrieSet{
|
|
{'a', 0, 1, noIndex},
|
|
{'b', 0, 1, noIndex},
|
|
{'c', 'e', final, 1},
|
|
},
|
|
},
|
|
{[]stridx{
|
|
{"abc", 1},
|
|
{"ab", 2},
|
|
{"a", 3},
|
|
},
|
|
1,
|
|
colltab.ContractTrieSet{
|
|
{'a', 0, 1, 3},
|
|
{'b', 0, 1, 2},
|
|
{'c', 'c', final, 1},
|
|
},
|
|
},
|
|
{[]stridx{
|
|
{"abc", 1},
|
|
{"abd", 2},
|
|
{"ab", 3},
|
|
{"ac", 4},
|
|
{"a", 5},
|
|
{"b", 6},
|
|
},
|
|
2,
|
|
colltab.ContractTrieSet{
|
|
{'b', 'b', final, 6},
|
|
{'a', 0, 2, 5},
|
|
{'c', 'c', final, 4},
|
|
{'b', 0, 1, 3},
|
|
{'c', 'd', final, 1},
|
|
},
|
|
},
|
|
{[]stridx{
|
|
{"bcde", 2},
|
|
{"bc", 7},
|
|
{"ab", 6},
|
|
{"bcd", 5},
|
|
{"abcd", 1},
|
|
{"abc", 4},
|
|
{"bcdf", 3},
|
|
},
|
|
2,
|
|
colltab.ContractTrieSet{
|
|
{'b', 3, 1, noIndex},
|
|
{'a', 0, 1, noIndex},
|
|
{'b', 0, 1, 6},
|
|
{'c', 0, 1, 4},
|
|
{'d', 'd', final, 1},
|
|
{'c', 0, 1, 7},
|
|
{'d', 0, 1, 5},
|
|
{'e', 'f', final, 2},
|
|
},
|
|
},
|
|
}
|
|
|
|
func TestGenStates(t *testing.T) {
|
|
for i, tt := range genStateTests {
|
|
si := []stridx{}
|
|
for _, e := range tt.in {
|
|
si = append(si, e)
|
|
}
|
|
// ensure input is well-formed
|
|
sort.Sort(genidxSort(si))
|
|
ct := colltab.ContractTrieSet{}
|
|
n, _ := genStates(&ct, si)
|
|
if nn := tt.firstBlockLen; nn != n {
|
|
t.Errorf("%d: block len %v; want %v", i, n, nn)
|
|
}
|
|
if lv, lw := len(ct), len(tt.out); lv != lw {
|
|
t.Errorf("%d: len %v; want %v", i, lv, lw)
|
|
continue
|
|
}
|
|
for j, fe := range tt.out {
|
|
const msg = "%d:%d: value %s=%v; want %v"
|
|
if fe.L != ct[j].L {
|
|
t.Errorf(msg, i, j, "l", ct[j].L, fe.L)
|
|
}
|
|
if fe.H != ct[j].H {
|
|
t.Errorf(msg, i, j, "h", ct[j].H, fe.H)
|
|
}
|
|
if fe.N != ct[j].N {
|
|
t.Errorf(msg, i, j, "n", ct[j].N, fe.N)
|
|
}
|
|
if fe.I != ct[j].I {
|
|
t.Errorf(msg, i, j, "i", ct[j].I, fe.I)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLookupContraction(t *testing.T) {
|
|
for i, tt := range genStateTests {
|
|
input := []string{}
|
|
for _, e := range tt.in {
|
|
input = append(input, e.str)
|
|
}
|
|
cts := colltab.ContractTrieSet{}
|
|
h, _ := appendTrie(&cts, input)
|
|
for j, si := range tt.in {
|
|
str := si.str
|
|
for _, s := range []string{str, str + "X"} {
|
|
msg := "%d:%d: %s(%s) %v; want %v"
|
|
idx, sn := lookup(&cts, h, []byte(s))
|
|
if idx != si.index {
|
|
t.Errorf(msg, i, j, "index", s, idx, si.index)
|
|
}
|
|
if sn != len(str) {
|
|
t.Errorf(msg, i, j, "sn", s, sn, len(str))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPrintContractionTrieSet(t *testing.T) {
|
|
testdata := colltab.ContractTrieSet(genStateTests[4].out)
|
|
buf := &bytes.Buffer{}
|
|
print(&testdata, buf, "test")
|
|
if contractTrieOutput != buf.String() {
|
|
t.Errorf("output differs; found\n%s", buf.String())
|
|
println(string(buf.Bytes()))
|
|
}
|
|
}
|
|
|
|
const contractTrieOutput = `// testCTEntries: 8 entries, 32 bytes
|
|
var testCTEntries = [8]struct{L,H,N,I uint8}{
|
|
{0x62, 0x3, 1, 255},
|
|
{0x61, 0x0, 1, 255},
|
|
{0x62, 0x0, 1, 6},
|
|
{0x63, 0x0, 1, 4},
|
|
{0x64, 0x64, 0, 1},
|
|
{0x63, 0x0, 1, 7},
|
|
{0x64, 0x0, 1, 5},
|
|
{0x65, 0x66, 0, 2},
|
|
}
|
|
var testContractTrieSet = colltab.ContractTrieSet( testCTEntries[:] )
|
|
`
|