summaryrefslogtreecommitdiffstats
path: root/vendor/golang.org/x/text/collate/build
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/text/collate/build')
-rw-r--r--vendor/golang.org/x/text/collate/build/builder_test.go290
-rw-r--r--vendor/golang.org/x/text/collate/build/colelem_test.go215
-rw-r--r--vendor/golang.org/x/text/collate/build/contract_test.go266
-rw-r--r--vendor/golang.org/x/text/collate/build/order_test.go229
-rw-r--r--vendor/golang.org/x/text/collate/build/trie_test.go107
5 files changed, 0 insertions, 1107 deletions
diff --git a/vendor/golang.org/x/text/collate/build/builder_test.go b/vendor/golang.org/x/text/collate/build/builder_test.go
deleted file mode 100644
index ff0aba3ae..000000000
--- a/vendor/golang.org/x/text/collate/build/builder_test.go
+++ /dev/null
@@ -1,290 +0,0 @@
-// 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 "testing"
-
-// cjk returns an implicit collation element for a CJK rune.
-func cjk(r rune) []rawCE {
- // A CJK character C is represented in the DUCET as
- // [.AAAA.0020.0002.C][.BBBB.0000.0000.C]
- // Where AAAA is the most significant 15 bits plus a base value.
- // Any base value will work for the test, so we pick the common value of FB40.
- const base = 0xFB40
- return []rawCE{
- {w: []int{base + int(r>>15), defaultSecondary, defaultTertiary, int(r)}},
- {w: []int{int(r&0x7FFF) | 0x8000, 0, 0, int(r)}},
- }
-}
-
-func pCE(p int) []rawCE {
- return mkCE([]int{p, defaultSecondary, defaultTertiary, 0}, 0)
-}
-
-func pqCE(p, q int) []rawCE {
- return mkCE([]int{p, defaultSecondary, defaultTertiary, q}, 0)
-}
-
-func ptCE(p, t int) []rawCE {
- return mkCE([]int{p, defaultSecondary, t, 0}, 0)
-}
-
-func ptcCE(p, t int, ccc uint8) []rawCE {
- return mkCE([]int{p, defaultSecondary, t, 0}, ccc)
-}
-
-func sCE(s int) []rawCE {
- return mkCE([]int{0, s, defaultTertiary, 0}, 0)
-}
-
-func stCE(s, t int) []rawCE {
- return mkCE([]int{0, s, t, 0}, 0)
-}
-
-func scCE(s int, ccc uint8) []rawCE {
- return mkCE([]int{0, s, defaultTertiary, 0}, ccc)
-}
-
-func mkCE(w []int, ccc uint8) []rawCE {
- return []rawCE{rawCE{w, ccc}}
-}
-
-// ducetElem is used to define test data that is used to generate a table.
-type ducetElem struct {
- str string
- ces []rawCE
-}
-
-func newBuilder(t *testing.T, ducet []ducetElem) *Builder {
- b := NewBuilder()
- for _, e := range ducet {
- ces := [][]int{}
- for _, ce := range e.ces {
- ces = append(ces, ce.w)
- }
- if err := b.Add([]rune(e.str), ces, nil); err != nil {
- t.Errorf(err.Error())
- }
- }
- b.t = &table{}
- b.root.sort()
- return b
-}
-
-type convertTest struct {
- in, out []rawCE
- err bool
-}
-
-var convLargeTests = []convertTest{
- {pCE(0xFB39), pCE(0xFB39), false},
- {cjk(0x2F9B2), pqCE(0x3F9B2, 0x2F9B2), false},
- {pCE(0xFB40), pCE(0), true},
- {append(pCE(0xFB40), pCE(0)[0]), pCE(0), true},
- {pCE(0xFFFE), pCE(illegalOffset), false},
- {pCE(0xFFFF), pCE(illegalOffset + 1), false},
-}
-
-func TestConvertLarge(t *testing.T) {
- for i, tt := range convLargeTests {
- e := new(entry)
- for _, ce := range tt.in {
- e.elems = append(e.elems, makeRawCE(ce.w, ce.ccc))
- }
- elems, err := convertLargeWeights(e.elems)
- if tt.err {
- if err == nil {
- t.Errorf("%d: expected error; none found", i)
- }
- continue
- } else if err != nil {
- t.Errorf("%d: unexpected error: %v", i, err)
- }
- if !equalCEArrays(elems, tt.out) {
- t.Errorf("%d: conversion was %x; want %x", i, elems, tt.out)
- }
- }
-}
-
-// Collation element table for simplify tests.
-var simplifyTest = []ducetElem{
- {"\u0300", sCE(30)}, // grave
- {"\u030C", sCE(40)}, // caron
- {"A", ptCE(100, 8)},
- {"D", ptCE(104, 8)},
- {"E", ptCE(105, 8)},
- {"I", ptCE(110, 8)},
- {"z", ptCE(130, 8)},
- {"\u05F2", append(ptCE(200, 4), ptCE(200, 4)[0])},
- {"\u05B7", sCE(80)},
- {"\u00C0", append(ptCE(100, 8), sCE(30)...)}, // A with grave, can be removed
- {"\u00C8", append(ptCE(105, 8), sCE(30)...)}, // E with grave
- {"\uFB1F", append(ptCE(200, 4), ptCE(200, 4)[0], sCE(80)[0])}, // eliminated by NFD
- {"\u00C8\u0302", ptCE(106, 8)}, // block previous from simplifying
- {"\u01C5", append(ptCE(104, 9), ptCE(130, 4)[0], stCE(40, maxTertiary)[0])}, // eliminated by NFKD
- // no removal: tertiary value of third element is not maxTertiary
- {"\u2162", append(ptCE(110, 9), ptCE(110, 4)[0], ptCE(110, 8)[0])},
-}
-
-var genColTests = []ducetElem{
- {"\uFA70", pqCE(0x1FA70, 0xFA70)},
- {"A\u0300", append(ptCE(100, 8), sCE(30)...)},
- {"A\u0300\uFA70", append(ptCE(100, 8), sCE(30)[0], pqCE(0x1FA70, 0xFA70)[0])},
- {"A\u0300A\u0300", append(ptCE(100, 8), sCE(30)[0], ptCE(100, 8)[0], sCE(30)[0])},
-}
-
-func TestGenColElems(t *testing.T) {
- b := newBuilder(t, simplifyTest[:5])
-
- for i, tt := range genColTests {
- res := b.root.genColElems(tt.str)
- if !equalCEArrays(tt.ces, res) {
- t.Errorf("%d: result %X; want %X", i, res, tt.ces)
- }
- }
-}
-
-type strArray []string
-
-func (sa strArray) contains(s string) bool {
- for _, e := range sa {
- if e == s {
- return true
- }
- }
- return false
-}
-
-var simplifyRemoved = strArray{"\u00C0", "\uFB1F"}
-var simplifyMarked = strArray{"\u01C5"}
-
-func TestSimplify(t *testing.T) {
- b := newBuilder(t, simplifyTest)
- o := &b.root
- simplify(o)
-
- for i, tt := range simplifyTest {
- if simplifyRemoved.contains(tt.str) {
- continue
- }
- e := o.find(tt.str)
- if e.str != tt.str || !equalCEArrays(e.elems, tt.ces) {
- t.Errorf("%d: found element %s -> %X; want %s -> %X", i, e.str, e.elems, tt.str, tt.ces)
- break
- }
- }
- var i, k int
- for e := o.front(); e != nil; e, _ = e.nextIndexed() {
- gold := simplifyMarked.contains(e.str)
- if gold {
- k++
- }
- if gold != e.decompose {
- t.Errorf("%d: %s has decompose %v; want %v", i, e.str, e.decompose, gold)
- }
- i++
- }
- if k != len(simplifyMarked) {
- t.Errorf(" an entry that should be marked as decompose was deleted")
- }
-}
-
-var expandTest = []ducetElem{
- {"\u0300", append(scCE(29, 230), scCE(30, 230)...)},
- {"\u00C0", append(ptCE(100, 8), scCE(30, 230)...)},
- {"\u00C8", append(ptCE(105, 8), scCE(30, 230)...)},
- {"\u00C9", append(ptCE(105, 8), scCE(30, 230)...)}, // identical expansion
- {"\u05F2", append(ptCE(200, 4), ptCE(200, 4)[0], ptCE(200, 4)[0])},
- {"\u01FF", append(ptCE(200, 4), ptcCE(201, 4, 0)[0], scCE(30, 230)[0])},
-}
-
-func TestExpand(t *testing.T) {
- const (
- totalExpansions = 5
- totalElements = 2 + 2 + 2 + 3 + 3 + totalExpansions
- )
- b := newBuilder(t, expandTest)
- o := &b.root
- b.processExpansions(o)
-
- e := o.front()
- for _, tt := range expandTest {
- exp := b.t.ExpandElem[e.expansionIndex:]
- if int(exp[0]) != len(tt.ces) {
- t.Errorf("%U: len(expansion)==%d; want %d", []rune(tt.str)[0], exp[0], len(tt.ces))
- }
- exp = exp[1:]
- for j, w := range tt.ces {
- if ce, _ := makeCE(w); exp[j] != ce {
- t.Errorf("%U: element %d is %X; want %X", []rune(tt.str)[0], j, exp[j], ce)
- }
- }
- e, _ = e.nextIndexed()
- }
- // Verify uniquing.
- if len(b.t.ExpandElem) != totalElements {
- t.Errorf("len(expandElem)==%d; want %d", len(b.t.ExpandElem), totalElements)
- }
-}
-
-var contractTest = []ducetElem{
- {"abc", pCE(102)},
- {"abd", pCE(103)},
- {"a", pCE(100)},
- {"ab", pCE(101)},
- {"ac", pCE(104)},
- {"bcd", pCE(202)},
- {"b", pCE(200)},
- {"bc", pCE(201)},
- {"bd", pCE(203)},
- // shares suffixes with a*
- {"Ab", pCE(301)},
- {"A", pCE(300)},
- {"Ac", pCE(304)},
- {"Abc", pCE(302)},
- {"Abd", pCE(303)},
- // starter to be ignored
- {"z", pCE(1000)},
-}
-
-func TestContract(t *testing.T) {
- const (
- totalElements = 5 + 5 + 4
- )
- b := newBuilder(t, contractTest)
- o := &b.root
- b.processContractions(o)
-
- indexMap := make(map[int]bool)
- handleMap := make(map[rune]*entry)
- for e := o.front(); e != nil; e, _ = e.nextIndexed() {
- if e.contractionHandle.n > 0 {
- handleMap[e.runes[0]] = e
- indexMap[e.contractionHandle.index] = true
- }
- }
- // Verify uniquing.
- if len(indexMap) != 2 {
- t.Errorf("number of tries is %d; want %d", len(indexMap), 2)
- }
- for _, tt := range contractTest {
- e, ok := handleMap[[]rune(tt.str)[0]]
- if !ok {
- continue
- }
- str := tt.str[1:]
- offset, n := lookup(&b.t.ContractTries, e.contractionHandle, []byte(str))
- if len(str) != n {
- t.Errorf("%s: bytes consumed==%d; want %d", tt.str, n, len(str))
- }
- ce := b.t.ContractElem[offset+e.contractionIndex]
- if want, _ := makeCE(tt.ces[0]); want != ce {
- t.Errorf("%s: element %X; want %X", tt.str, ce, want)
- }
- }
- if len(b.t.ContractElem) != totalElements {
- t.Errorf("len(expandElem)==%d; want %d", len(b.t.ContractElem), totalElements)
- }
-}
diff --git a/vendor/golang.org/x/text/collate/build/colelem_test.go b/vendor/golang.org/x/text/collate/build/colelem_test.go
deleted file mode 100644
index d0c8d07d8..000000000
--- a/vendor/golang.org/x/text/collate/build/colelem_test.go
+++ /dev/null
@@ -1,215 +0,0 @@
-// 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 (
- "testing"
-
- "golang.org/x/text/internal/colltab"
-)
-
-type ceTest struct {
- f func(in []int) (uint32, error)
- arg []int
- val uint32
-}
-
-func normalCE(in []int) (ce uint32, err error) {
- return makeCE(rawCE{w: in[:3], ccc: uint8(in[3])})
-}
-
-func expandCE(in []int) (ce uint32, err error) {
- return makeExpandIndex(in[0])
-}
-
-func contractCE(in []int) (ce uint32, err error) {
- return makeContractIndex(ctHandle{in[0], in[1]}, in[2])
-}
-
-func decompCE(in []int) (ce uint32, err error) {
- return makeDecompose(in[0], in[1])
-}
-
-var ceTests = []ceTest{
- {normalCE, []int{0, 0, 0, 0}, 0xA0000000},
- {normalCE, []int{0, 0x28, 3, 0}, 0xA0002803},
- {normalCE, []int{0, 0x28, 3, 0xFF}, 0xAFF02803},
- {normalCE, []int{100, defaultSecondary, 3, 0}, 0x0000C883},
- // non-ignorable primary with non-default secondary
- {normalCE, []int{100, 0x28, defaultTertiary, 0}, 0x4000C828},
- {normalCE, []int{100, defaultSecondary + 8, 3, 0}, 0x0000C983},
- {normalCE, []int{100, 0, 3, 0}, 0xFFFF}, // non-ignorable primary with non-supported secondary
- {normalCE, []int{100, 1, 3, 0}, 0xFFFF},
- {normalCE, []int{1 << maxPrimaryBits, defaultSecondary, 0, 0}, 0xFFFF},
- {normalCE, []int{0, 1 << maxSecondaryBits, 0, 0}, 0xFFFF},
- {normalCE, []int{100, defaultSecondary, 1 << maxTertiaryBits, 0}, 0xFFFF},
- {normalCE, []int{0x123, defaultSecondary, 8, 0xFF}, 0x88FF0123},
- {normalCE, []int{0x123, defaultSecondary + 1, 8, 0xFF}, 0xFFFF},
-
- {contractCE, []int{0, 0, 0}, 0xC0000000},
- {contractCE, []int{1, 1, 1}, 0xC0010011},
- {contractCE, []int{1, (1 << maxNBits) - 1, 1}, 0xC001001F},
- {contractCE, []int{(1 << maxTrieIndexBits) - 1, 1, 1}, 0xC001FFF1},
- {contractCE, []int{1, 1, (1 << maxContractOffsetBits) - 1}, 0xDFFF0011},
- {contractCE, []int{1, (1 << maxNBits), 1}, 0xFFFF},
- {contractCE, []int{(1 << maxTrieIndexBits), 1, 1}, 0xFFFF},
- {contractCE, []int{1, (1 << maxContractOffsetBits), 1}, 0xFFFF},
-
- {expandCE, []int{0}, 0xE0000000},
- {expandCE, []int{5}, 0xE0000005},
- {expandCE, []int{(1 << maxExpandIndexBits) - 1}, 0xE000FFFF},
- {expandCE, []int{1 << maxExpandIndexBits}, 0xFFFF},
-
- {decompCE, []int{0, 0}, 0xF0000000},
- {decompCE, []int{1, 1}, 0xF0000101},
- {decompCE, []int{0x1F, 0x1F}, 0xF0001F1F},
- {decompCE, []int{256, 0x1F}, 0xFFFF},
- {decompCE, []int{0x1F, 256}, 0xFFFF},
-}
-
-func TestColElem(t *testing.T) {
- for i, tt := range ceTests {
- in := make([]int, len(tt.arg))
- copy(in, tt.arg)
- ce, err := tt.f(in)
- if tt.val == 0xFFFF {
- if err == nil {
- t.Errorf("%d: expected error for args %x", i, tt.arg)
- }
- continue
- }
- if err != nil {
- t.Errorf("%d: unexpected error: %v", i, err.Error())
- }
- if ce != tt.val {
- t.Errorf("%d: colElem=%X; want %X", i, ce, tt.val)
- }
- }
-}
-
-func mkRawCES(in [][]int) []rawCE {
- out := []rawCE{}
- for _, w := range in {
- out = append(out, rawCE{w: w})
- }
- return out
-}
-
-type weightsTest struct {
- a, b [][]int
- level colltab.Level
- result int
-}
-
-var nextWeightTests = []weightsTest{
- {
- a: [][]int{{100, 20, 5, 0}},
- b: [][]int{{101, defaultSecondary, defaultTertiary, 0}},
- level: colltab.Primary,
- },
- {
- a: [][]int{{100, 20, 5, 0}},
- b: [][]int{{100, 21, defaultTertiary, 0}},
- level: colltab.Secondary,
- },
- {
- a: [][]int{{100, 20, 5, 0}},
- b: [][]int{{100, 20, 6, 0}},
- level: colltab.Tertiary,
- },
- {
- a: [][]int{{100, 20, 5, 0}},
- b: [][]int{{100, 20, 5, 0}},
- level: colltab.Identity,
- },
-}
-
-var extra = [][]int{{200, 32, 8, 0}, {0, 32, 8, 0}, {0, 0, 8, 0}, {0, 0, 0, 0}}
-
-func TestNextWeight(t *testing.T) {
- for i, tt := range nextWeightTests {
- test := func(l colltab.Level, tt weightsTest, a, gold [][]int) {
- res := nextWeight(tt.level, mkRawCES(a))
- if !equalCEArrays(mkRawCES(gold), res) {
- t.Errorf("%d:%d: expected weights %d; found %d", i, l, gold, res)
- }
- }
- test(-1, tt, tt.a, tt.b)
- for l := colltab.Primary; l <= colltab.Tertiary; l++ {
- if tt.level <= l {
- test(l, tt, append(tt.a, extra[l]), tt.b)
- } else {
- test(l, tt, append(tt.a, extra[l]), append(tt.b, extra[l]))
- }
- }
- }
-}
-
-var compareTests = []weightsTest{
- {
- [][]int{{100, 20, 5, 0}},
- [][]int{{100, 20, 5, 0}},
- colltab.Identity,
- 0,
- },
- {
- [][]int{{100, 20, 5, 0}, extra[0]},
- [][]int{{100, 20, 5, 1}},
- colltab.Primary,
- 1,
- },
- {
- [][]int{{100, 20, 5, 0}},
- [][]int{{101, 20, 5, 0}},
- colltab.Primary,
- -1,
- },
- {
- [][]int{{101, 20, 5, 0}},
- [][]int{{100, 20, 5, 0}},
- colltab.Primary,
- 1,
- },
- {
- [][]int{{100, 0, 0, 0}, {0, 20, 5, 0}},
- [][]int{{0, 20, 5, 0}, {100, 0, 0, 0}},
- colltab.Identity,
- 0,
- },
- {
- [][]int{{100, 20, 5, 0}},
- [][]int{{100, 21, 5, 0}},
- colltab.Secondary,
- -1,
- },
- {
- [][]int{{100, 20, 5, 0}},
- [][]int{{100, 20, 2, 0}},
- colltab.Tertiary,
- 1,
- },
- {
- [][]int{{100, 20, 5, 1}},
- [][]int{{100, 20, 5, 2}},
- colltab.Quaternary,
- -1,
- },
-}
-
-func TestCompareWeights(t *testing.T) {
- for i, tt := range compareTests {
- test := func(tt weightsTest, a, b [][]int) {
- res, level := compareWeights(mkRawCES(a), mkRawCES(b))
- if res != tt.result {
- t.Errorf("%d: expected comparison result %d; found %d", i, tt.result, res)
- }
- if level != tt.level {
- t.Errorf("%d: expected level %d; found %d", i, tt.level, level)
- }
- }
- test(tt, tt.a, tt.b)
- test(tt, append(tt.a, extra[0]), append(tt.b, extra[0]))
- }
-}
diff --git a/vendor/golang.org/x/text/collate/build/contract_test.go b/vendor/golang.org/x/text/collate/build/contract_test.go
deleted file mode 100644
index 2e0eaecd5..000000000
--- a/vendor/golang.org/x/text/collate/build/contract_test.go
+++ /dev/null
@@ -1,266 +0,0 @@
-// 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[:] )
-`
diff --git a/vendor/golang.org/x/text/collate/build/order_test.go b/vendor/golang.org/x/text/collate/build/order_test.go
deleted file mode 100644
index 0e174bfbd..000000000
--- a/vendor/golang.org/x/text/collate/build/order_test.go
+++ /dev/null
@@ -1,229 +0,0 @@
-// 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 (
- "strconv"
- "testing"
-
- "golang.org/x/text/internal/colltab"
-)
-
-type entryTest struct {
- f func(in []int) (uint32, error)
- arg []int
- val uint32
-}
-
-// makeList returns a list of entries of length n+2, with n normal
-// entries plus a leading and trailing anchor.
-func makeList(n int) []*entry {
- es := make([]*entry, n+2)
- weights := []rawCE{{w: []int{100, 20, 5, 0}}}
- for i := range es {
- runes := []rune{rune(i)}
- es[i] = &entry{
- runes: runes,
- elems: weights,
- }
- weights = nextWeight(colltab.Primary, weights)
- }
- for i := 1; i < len(es); i++ {
- es[i-1].next = es[i]
- es[i].prev = es[i-1]
- _, es[i-1].level = compareWeights(es[i-1].elems, es[i].elems)
- }
- es[0].exclude = true
- es[0].logical = firstAnchor
- es[len(es)-1].exclude = true
- es[len(es)-1].logical = lastAnchor
- return es
-}
-
-func TestNextIndexed(t *testing.T) {
- const n = 5
- es := makeList(n)
- for i := int64(0); i < 1<<n; i++ {
- mask := strconv.FormatInt(i+(1<<n), 2)
- for i, c := range mask {
- es[i].exclude = c == '1'
- }
- e := es[0]
- for i, c := range mask {
- if c == '0' {
- e, _ = e.nextIndexed()
- if e != es[i] {
- t.Errorf("%d: expected entry %d; found %d", i, es[i].elems, e.elems)
- }
- }
- }
- if e, _ = e.nextIndexed(); e != nil {
- t.Errorf("%d: expected nil entry; found %d", i, e.elems)
- }
- }
-}
-
-func TestRemove(t *testing.T) {
- const n = 5
- for i := int64(0); i < 1<<n; i++ {
- es := makeList(n)
- mask := strconv.FormatInt(i+(1<<n), 2)
- for i, c := range mask {
- if c == '0' {
- es[i].remove()
- }
- }
- e := es[0]
- for i, c := range mask {
- if c == '1' {
- if e != es[i] {
- t.Errorf("%d: expected entry %d; found %d", i, es[i].elems, e.elems)
- }
- e, _ = e.nextIndexed()
- }
- }
- if e != nil {
- t.Errorf("%d: expected nil entry; found %d", i, e.elems)
- }
- }
-}
-
-// nextPerm generates the next permutation of the array. The starting
-// permutation is assumed to be a list of integers sorted in increasing order.
-// It returns false if there are no more permuations left.
-func nextPerm(a []int) bool {
- i := len(a) - 2
- for ; i >= 0; i-- {
- if a[i] < a[i+1] {
- break
- }
- }
- if i < 0 {
- return false
- }
- for j := len(a) - 1; j >= i; j-- {
- if a[j] > a[i] {
- a[i], a[j] = a[j], a[i]
- break
- }
- }
- for j := i + 1; j < (len(a)+i+1)/2; j++ {
- a[j], a[len(a)+i-j] = a[len(a)+i-j], a[j]
- }
- return true
-}
-
-func TestInsertAfter(t *testing.T) {
- const n = 5
- orig := makeList(n)
- perm := make([]int, n)
- for i := range perm {
- perm[i] = i + 1
- }
- for ok := true; ok; ok = nextPerm(perm) {
- es := makeList(n)
- last := es[0]
- for _, i := range perm {
- last.insertAfter(es[i])
- last = es[i]
- }
- for _, e := range es {
- e.elems = es[0].elems
- }
- e := es[0]
- for _, i := range perm {
- e, _ = e.nextIndexed()
- if e.runes[0] != orig[i].runes[0] {
- t.Errorf("%d:%d: expected entry %X; found %X", perm, i, orig[i].runes, e.runes)
- break
- }
- }
- }
-}
-
-func TestInsertBefore(t *testing.T) {
- const n = 5
- orig := makeList(n)
- perm := make([]int, n)
- for i := range perm {
- perm[i] = i + 1
- }
- for ok := true; ok; ok = nextPerm(perm) {
- es := makeList(n)
- last := es[len(es)-1]
- for _, i := range perm {
- last.insertBefore(es[i])
- last = es[i]
- }
- for _, e := range es {
- e.elems = es[0].elems
- }
- e := es[0]
- for i := n - 1; i >= 0; i-- {
- e, _ = e.nextIndexed()
- if e.runes[0] != rune(perm[i]) {
- t.Errorf("%d:%d: expected entry %X; found %X", perm, i, orig[i].runes, e.runes)
- break
- }
- }
- }
-}
-
-type entryLessTest struct {
- a, b *entry
- res bool
-}
-
-var (
- w1 = []rawCE{{w: []int{100, 20, 5, 5}}}
- w2 = []rawCE{{w: []int{101, 20, 5, 5}}}
-)
-
-var entryLessTests = []entryLessTest{
- {&entry{str: "a", elems: w1},
- &entry{str: "a", elems: w1},
- false,
- },
- {&entry{str: "a", elems: w1},
- &entry{str: "a", elems: w2},
- true,
- },
- {&entry{str: "a", elems: w1},
- &entry{str: "b", elems: w1},
- true,
- },
- {&entry{str: "a", elems: w2},
- &entry{str: "a", elems: w1},
- false,
- },
- {&entry{str: "c", elems: w1},
- &entry{str: "b", elems: w1},
- false,
- },
- {&entry{str: "a", elems: w1, logical: firstAnchor},
- &entry{str: "a", elems: w1},
- true,
- },
- {&entry{str: "a", elems: w1},
- &entry{str: "b", elems: w1, logical: firstAnchor},
- false,
- },
- {&entry{str: "b", elems: w1},
- &entry{str: "a", elems: w1, logical: lastAnchor},
- true,
- },
- {&entry{str: "a", elems: w1, logical: lastAnchor},
- &entry{str: "c", elems: w1},
- false,
- },
-}
-
-func TestEntryLess(t *testing.T) {
- for i, tt := range entryLessTests {
- if res := entryLess(tt.a, tt.b); res != tt.res {
- t.Errorf("%d: was %v; want %v", i, res, tt.res)
- }
- }
-}
diff --git a/vendor/golang.org/x/text/collate/build/trie_test.go b/vendor/golang.org/x/text/collate/build/trie_test.go
deleted file mode 100644
index 4d4f6e4d1..000000000
--- a/vendor/golang.org/x/text/collate/build/trie_test.go
+++ /dev/null
@@ -1,107 +0,0 @@
-// 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"
- "fmt"
- "testing"
-)
-
-// We take the smallest, largest and an arbitrary value for each
-// of the UTF-8 sequence lengths.
-var testRunes = []rune{
- 0x01, 0x0C, 0x7F, // 1-byte sequences
- 0x80, 0x100, 0x7FF, // 2-byte sequences
- 0x800, 0x999, 0xFFFF, // 3-byte sequences
- 0x10000, 0x10101, 0x10FFFF, // 4-byte sequences
- 0x200, 0x201, 0x202, 0x210, 0x215, // five entries in one sparse block
-}
-
-func makeTestTrie(t *testing.T) trie {
- n := newNode()
- for i, r := range testRunes {
- n.insert(r, uint32(i))
- }
- idx := newTrieBuilder()
- idx.addTrie(n)
- tr, err := idx.generate()
- if err != nil {
- t.Errorf(err.Error())
- }
- return *tr
-}
-
-func TestGenerateTrie(t *testing.T) {
- testdata := makeTestTrie(t)
- buf := &bytes.Buffer{}
- testdata.printArrays(buf, "test")
- fmt.Fprintf(buf, "var testTrie = ")
- testdata.printStruct(buf, &trieHandle{19, 0}, "test")
- if output != buf.String() {
- t.Error("output differs")
- }
-}
-
-var output = `// testValues: 832 entries, 3328 bytes
-// Block 2 is the null block.
-var testValues = [832]uint32 {
- // Block 0x0, offset 0x0
- 0x000c:0x00000001,
- // Block 0x1, offset 0x40
- 0x007f:0x00000002,
- // Block 0x2, offset 0x80
- // Block 0x3, offset 0xc0
- 0x00c0:0x00000003,
- // Block 0x4, offset 0x100
- 0x0100:0x00000004,
- // Block 0x5, offset 0x140
- 0x0140:0x0000000c, 0x0141:0x0000000d, 0x0142:0x0000000e,
- 0x0150:0x0000000f,
- 0x0155:0x00000010,
- // Block 0x6, offset 0x180
- 0x01bf:0x00000005,
- // Block 0x7, offset 0x1c0
- 0x01c0:0x00000006,
- // Block 0x8, offset 0x200
- 0x0219:0x00000007,
- // Block 0x9, offset 0x240
- 0x027f:0x00000008,
- // Block 0xa, offset 0x280
- 0x0280:0x00000009,
- // Block 0xb, offset 0x2c0
- 0x02c1:0x0000000a,
- // Block 0xc, offset 0x300
- 0x033f:0x0000000b,
-}
-
-// testLookup: 640 entries, 1280 bytes
-// Block 0 is the null block.
-var testLookup = [640]uint16 {
- // Block 0x0, offset 0x0
- // Block 0x1, offset 0x40
- // Block 0x2, offset 0x80
- // Block 0x3, offset 0xc0
- 0x0e0:0x05, 0x0e6:0x06,
- // Block 0x4, offset 0x100
- 0x13f:0x07,
- // Block 0x5, offset 0x140
- 0x140:0x08, 0x144:0x09,
- // Block 0x6, offset 0x180
- 0x190:0x03,
- // Block 0x7, offset 0x1c0
- 0x1ff:0x0a,
- // Block 0x8, offset 0x200
- 0x20f:0x05,
- // Block 0x9, offset 0x240
- 0x242:0x01, 0x244:0x02,
- 0x248:0x03,
- 0x25f:0x04,
- 0x260:0x01,
- 0x26f:0x02,
- 0x270:0x04, 0x274:0x06,
-}
-
-var testTrie = trie{ testLookup[1216:], testValues[0:], testLookup[:], testValues[:]}`
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-07-02 07:13:34 +0000