summaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/text/collate/build/contract_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/text/collate/build/contract_test.go')
-rw-r--r--vendor/golang.org/x/text/collate/build/contract_test.go266
1 files changed, 266 insertions, 0 deletions
diff --git a/vendor/golang.org/x/text/collate/build/contract_test.go b/vendor/golang.org/x/text/collate/build/contract_test.go
new file mode 100644
index 0000000..2e0eaec
--- /dev/null
+++ b/vendor/golang.org/x/text/collate/build/contract_test.go
@@ -0,0 +1,266 @@
+// 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[:] )
+`