--- /dev/null
+// 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 (
+ "exp/locale/collate"
+ "exp/norm"
+ "fmt"
+ "io"
+ "log"
+ "sort"
+ "strings"
+)
+
+// TODO: optimizations:
+// - expandElem is currently 20K. By putting unique colElems in a separate
+// table and having a byte array of indexes into this table, we can reduce
+// the total size to about 7K. By also factoring out the length bytes, we
+// can reduce this to about 6K.
+// - trie valueBlocks are currently 100K. There are a lot of sparse blocks
+// and many consecutive values with the same stride. This can be further
+// compacted.
+
+// entry is used to keep track of a single entry in the collation element table
+// during building. Examples of entries can be found in the Default Unicode
+// Collation Element Table.
+// See http://www.unicode.org/Public/UCA/6.0.0/allkeys.txt.
+type entry struct {
+ runes []rune
+ elems [][]int // the collation elements for runes
+ str string // same as string(runes)
+
+ decompose bool // can use NFKD decomposition to generate elems
+ expansionIndex int // used to store index into expansion table
+ contractionHandle ctHandle
+ contractionIndex int // index into contraction elements
+}
+
+func (e *entry) String() string {
+ return fmt.Sprintf("%X -> %X (ch:%x; ci:%d, ei:%d)",
+ e.runes, e.elems, e.contractionHandle, e.contractionIndex, e.expansionIndex)
+}
+
+func (e *entry) skip() bool {
+ return e.contraction()
+}
+
+func (e *entry) expansion() bool {
+ return !e.decompose && len(e.elems) > 1
+}
+
+func (e *entry) contraction() bool {
+ return len(e.runes) > 1
+}
+
+func (e *entry) contractionStarter() bool {
+ return e.contractionHandle.n != 0
+}
+
+// A Builder builds collation tables. It can generate both the root table and
+// locale-specific tables defined as tailorings to the root table.
+// The typical use case is to specify the data for the root table and all locale-specific
+// tables using Add and AddTailoring before making any call to Build. This allows
+// Builder to ensure that a root table can support tailorings for each locale.
+type Builder struct {
+ entryMap map[string]*entry
+ entry []*entry
+ t *table
+ err error
+}
+
+// NewBuilder returns a new Builder.
+func NewBuilder() *Builder {
+ b := &Builder{
+ entryMap: make(map[string]*entry),
+ }
+ return b
+}
+
+// Add adds an entry for the root collation element table, mapping
+// a slice of runes to a sequence of collation elements.
+// A collation element is specified as list of weights: []int{primary, secondary, ...}.
+// The entries are typically obtained from a collation element table
+// as defined in http://www.unicode.org/reports/tr10/#Data_Table_Format.
+// Note that the collation elements specified by colelems are only used
+// as a guide. The actual weights generated by Builder may differ.
+func (b *Builder) Add(str []rune, colelems [][]int) error {
+ e := &entry{
+ runes: make([]rune, len(str)),
+ elems: make([][]int, len(colelems)),
+ str: string(str),
+ }
+ copy(e.runes, str)
+ for i, ce := range colelems {
+ e.elems[i] = append(e.elems[i], ce...)
+ if len(ce) == 0 {
+ e.elems[i] = append(e.elems[i], []int{0, 0, 0, 0}...)
+ break
+ }
+ if len(ce) == 1 {
+ e.elems[i] = append(e.elems[i], defaultSecondary)
+ }
+ if len(ce) <= 2 {
+ e.elems[i] = append(e.elems[i], defaultTertiary)
+ }
+ if len(ce) <= 3 {
+ e.elems[i] = append(e.elems[i], ce[0])
+ }
+ }
+ b.entryMap[string(str)] = e
+ b.entry = append(b.entry, e)
+ return nil
+}
+
+// AddTailoring defines a tailoring x <_level y for the given locale.
+// For example, AddTailoring("se", "z", "ä", Primary) sorts "ä" after "z"
+// at the primary level for Swedish. AddTailoring("de", "ue", "ü", Secondary)
+// sorts "ü" after "ue" at the secondary level for German.
+// See http://www.unicode.org/reports/tr10/#Tailoring_Example for details
+// on parametric tailoring.
+func (b *Builder) AddTailoring(locale, x, y string, l collate.Level) error {
+ // TODO: implement.
+ return nil
+}
+
+func (b *Builder) baseColElem(e *entry) uint32 {
+ ce := uint32(0)
+ var err error
+ switch {
+ case e.expansion():
+ ce, err = makeExpandIndex(e.expansionIndex)
+ default:
+ if e.decompose {
+ log.Fatal("decompose should be handled elsewhere")
+ }
+ ce, err = makeCE(e.elems[0])
+ }
+ if err != nil {
+ b.error(fmt.Errorf("%s: %X -> %X", err, e.runes, e.elems))
+ }
+ return ce
+}
+
+func (b *Builder) colElem(e *entry) uint32 {
+ if e.skip() {
+ log.Fatal("cannot build colElem for entry that should be skipped")
+ }
+ ce := uint32(0)
+ var err error
+ switch {
+ case e.decompose:
+ t1 := e.elems[0][2]
+ t2 := 0
+ if len(e.elems) > 1 {
+ t2 = e.elems[1][2]
+ }
+ ce, err = makeDecompose(t1, t2)
+ case e.contractionStarter():
+ ce, err = makeContractIndex(e.contractionHandle, e.contractionIndex)
+ default:
+ if len(e.runes) > 1 {
+ log.Fatal("colElem: contractions are handled in contraction trie")
+ }
+ ce = b.baseColElem(e)
+ }
+ if err != nil {
+ b.error(err)
+ }
+ return ce
+}
+
+func (b *Builder) error(e error) {
+ if e != nil {
+ b.err = e
+ }
+}
+
+func (b *Builder) build() (*table, error) {
+ b.t = &table{}
+
+ b.contractCJK()
+ b.simplify() // requires contractCJK
+ b.processExpansions() // requires simplify
+ b.processContractions() // requires simplify
+ b.buildTrie() // requires process*
+
+ if b.err != nil {
+ return nil, b.err
+ }
+ return b.t, nil
+}
+
+// Build builds a Collator for the given locale. To build the root table, set locale to "".
+func (b *Builder) Build(locale string) (*collate.Collator, error) {
+ t, err := b.build()
+ if err != nil {
+ return nil, err
+ }
+ // TODO: support multiple locales
+ return collate.Init(t), nil
+}
+
+// Print prints all tables to a Go file that can be included in
+// the Collate package.
+func (b *Builder) Print(w io.Writer) (int, error) {
+ t, err := b.build()
+ if err != nil {
+ return 0, err
+ }
+ // TODO: support multiple locales
+ n, _, err := t.print(w, "root")
+ return n, err
+}
+
+// reproducibleFromNFKD checks whether the given expansion could be generated
+// from an NFKD expansion.
+func reproducibleFromNFKD(e *entry, exp, nfkd [][]int) bool {
+ // Length must be equal.
+ if len(exp) != len(nfkd) {
+ return false
+ }
+ for i, ce := range exp {
+ // Primary and secondary values should be equal.
+ if ce[0] != nfkd[i][0] || ce[1] != nfkd[i][1] {
+ return false
+ }
+ // Tertiary values should be equal to maxTertiary for third element onwards.
+ if i >= 2 && ce[2] != maxTertiary {
+ return false
+ }
+ }
+ return true
+}
+
+func equalCE(a, b []int) bool {
+ if len(a) != len(b) {
+ return false
+ }
+ for i := 0; i < 3; i++ {
+ if b[i] != a[i] {
+ return false
+ }
+ }
+ return true
+}
+
+func equalCEArrays(a, b [][]int) bool {
+ if len(a) != len(b) {
+ return false
+ }
+ for i := range a {
+ if !equalCE(a[i], b[i]) {
+ return false
+ }
+ }
+ return true
+}
+
+// genColElems generates a collation element array from the runes in str. This
+// assumes that all collation elements have already been added to the Builder.
+func (b *Builder) genColElems(str string) [][]int {
+ elems := [][]int{}
+ for _, r := range []rune(str) {
+ if ee, ok := b.entryMap[string(r)]; !ok {
+ elem := []int{implicitPrimary(r), defaultSecondary, defaultTertiary, int(r)}
+ elems = append(elems, elem)
+ } else {
+ elems = append(elems, ee.elems...)
+ }
+ }
+ return elems
+}
+
+func (b *Builder) simplify() {
+ // Runes that are a starter of a contraction should not be removed.
+ // (To date, there is only Kannada character 0CCA.)
+ keep := make(map[rune]bool)
+ for _, e := range b.entry {
+ if len(e.runes) > 1 {
+ keep[e.runes[0]] = true
+ }
+ }
+ // Remove entries for which the runes normalize (using NFD) to identical values.
+ for _, e := range b.entry {
+ s := e.str
+ nfd := norm.NFD.String(s)
+ if len(e.runes) > 1 || keep[e.runes[0]] || nfd == s {
+ continue
+ }
+ if equalCEArrays(b.genColElems(nfd), e.elems) {
+ delete(b.entryMap, s)
+ }
+ }
+ // Remove entries in b.entry that were removed from b.entryMap
+ k := 0
+ for _, e := range b.entry {
+ if _, ok := b.entryMap[e.str]; ok {
+ b.entry[k] = e
+ k++
+ }
+ }
+ b.entry = b.entry[:k]
+ // Tag entries for which the runes NFKD decompose to identical values.
+ for _, e := range b.entry {
+ s := e.str
+ nfkd := norm.NFKD.String(s)
+ if len(e.runes) > 1 || keep[e.runes[0]] || nfkd == s {
+ continue
+ }
+ if reproducibleFromNFKD(e, e.elems, b.genColElems(nfkd)) {
+ e.decompose = true
+ }
+ }
+}
+
+// convertLargeWeights converts collation elements with large
+// primaries (either double primaries or for illegal runes)
+// to our own representation.
+// See http://unicode.org/reports/tr10/#Implicit_Weights
+func convertLargeWeights(elems [][]int) (res [][]int, err error) {
+ const (
+ firstLargePrimary = 0xFB40
+ illegalPrimary = 0xFFFE
+ highBitsMask = 0x3F
+ lowBitsMask = 0x7FFF
+ lowBitsFlag = 0x8000
+ shiftBits = 15
+ )
+ for i := 0; i < len(elems); i++ {
+ ce := elems[i]
+ p := ce[0]
+ if p < firstLargePrimary {
+ continue
+ }
+ if p >= illegalPrimary {
+ ce[0] = illegalOffset + p - illegalPrimary
+ } else {
+ if i+1 >= len(elems) {
+ return elems, fmt.Errorf("second part of double primary weight missing: %v", elems)
+ }
+ if elems[i+1][0]&lowBitsFlag == 0 {
+ return elems, fmt.Errorf("malformed second part of double primary weight: %v", elems)
+ }
+ r := rune(((p & highBitsMask) << shiftBits) + elems[i+1][0]&lowBitsMask)
+ ce[0] = implicitPrimary(r)
+ for j := i + 1; j+1 < len(elems); j++ {
+ elems[j] = elems[j+1]
+ }
+ elems = elems[:len(elems)-1]
+ }
+ }
+ return elems, nil
+}
+
+// A CJK character C is represented in the DUCET as
+// [.FBxx.0020.0002.C][.BBBB.0000.0000.C]
+// We will rewrite these characters to a single CE.
+// We assume the CJK values start at 0x8000.
+func (b *Builder) contractCJK() {
+ for _, e := range b.entry {
+ elms, err := convertLargeWeights(e.elems)
+ e.elems = elms
+ if err != nil {
+ err = fmt.Errorf("%U: %s", e.runes, err)
+ }
+ b.error(err)
+ }
+}
+
+// appendExpansion converts the given collation sequence to
+// collation elements and adds them to the expansion table.
+// It returns an index to the expansion table.
+func (b *Builder) appendExpansion(e *entry) int {
+ t := b.t
+ i := len(t.expandElem)
+ ce := uint32(len(e.elems))
+ t.expandElem = append(t.expandElem, ce)
+ for _, w := range e.elems {
+ ce, err := makeCE(w)
+ if err != nil {
+ b.error(err)
+ return -1
+ }
+ t.expandElem = append(t.expandElem, ce)
+ }
+ return i
+}
+
+// processExpansions extracts data necessary to generate
+// the extraction tables.
+func (b *Builder) processExpansions() {
+ eidx := make(map[string]int)
+ for _, e := range b.entry {
+ if !e.expansion() {
+ continue
+ }
+ key := fmt.Sprintf("%v", e.elems)
+ i, ok := eidx[key]
+ if !ok {
+ i = b.appendExpansion(e)
+ eidx[key] = i
+ }
+ e.expansionIndex = i
+ }
+}
+
+func (b *Builder) processContractions() {
+ // Collate contractions per starter rune.
+ starters := []rune{}
+ cm := make(map[rune][]*entry)
+ for _, e := range b.entry {
+ if e.contraction() {
+ r := e.runes[0]
+ if _, ok := cm[r]; !ok {
+ starters = append(starters, r)
+ }
+ cm[r] = append(cm[r], e)
+ }
+ }
+ // Add entries of single runes that are at a start of a contraction.
+ for _, e := range b.entry {
+ if !e.contraction() {
+ r := e.runes[0]
+ if _, ok := cm[r]; ok {
+ cm[r] = append(cm[r], e)
+ }
+ }
+ }
+ // Build the tries for the contractions.
+ t := b.t
+ handlemap := make(map[string]ctHandle)
+ for _, r := range starters {
+ l := cm[r]
+ // Compute suffix strings. There are 31 different contraction suffix
+ // sets for 715 contractions and 82 contraction starter runes as of
+ // version 6.0.0.
+ sufx := []string{}
+ hasSingle := false
+ for _, e := range l {
+ if len(e.runes) > 1 {
+ sufx = append(sufx, string(e.runes[1:]))
+ } else {
+ hasSingle = true
+ }
+ }
+ if !hasSingle {
+ b.error(fmt.Errorf("no single entry for starter rune %U found", r))
+ continue
+ }
+ // Unique the suffix set.
+ sort.Strings(sufx)
+ key := strings.Join(sufx, "\n")
+ handle, ok := handlemap[key]
+ if !ok {
+ var err error
+ handle, err = t.contractTries.appendTrie(sufx)
+ if err != nil {
+ b.error(err)
+ }
+ handlemap[key] = handle
+ }
+ // Bucket sort entries in index order.
+ es := make([]*entry, len(l))
+ for _, e := range l {
+ var o, sn int
+ if len(e.runes) > 1 {
+ str := []byte(string(e.runes[1:]))
+ o, sn = t.contractTries.lookup(handle, str)
+ if sn != len(str) {
+ log.Fatalf("processContractions: unexpected length for '%X'; len=%d; want %d", []rune(string(str)), sn, len(str))
+ }
+ }
+ if es[o] != nil {
+ log.Fatalf("Multiple contractions for position %d for rune %U", o, e.runes[0])
+ }
+ es[o] = e
+ }
+ // Store info in entry for starter rune.
+ es[0].contractionIndex = len(t.contractElem)
+ es[0].contractionHandle = handle
+ // Add collation elements for contractions.
+ for _, e := range es {
+ t.contractElem = append(t.contractElem, b.baseColElem(e))
+ }
+ }
+}
+
+func (b *Builder) buildTrie() {
+ t := newNode()
+ for _, e := range b.entry {
+ if !e.skip() {
+ ce := b.colElem(e)
+ t.insert(e.runes[0], ce)
+ }
+ }
+ i, err := t.generate()
+ b.t.index = *i
+ b.error(err)
+}
--- /dev/null
+// 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) [][]int {
+ // 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 [][]int{
+ []int{base + int(r>>15), defaultSecondary, defaultTertiary, int(r)},
+ []int{int(r&0x7FFF) | 0x8000, 0, 0, int(r)},
+ }
+}
+
+func pCE(p int) [][]int {
+ return [][]int{[]int{p, defaultSecondary, defaultTertiary, 0}}
+}
+
+func pqCE(p, q int) [][]int {
+ return [][]int{[]int{p, defaultSecondary, defaultTertiary, q}}
+}
+
+func ptCE(p, t int) [][]int {
+ return [][]int{[]int{p, defaultSecondary, t, 0}}
+}
+
+func sCE(s int) [][]int {
+ return [][]int{[]int{0, s, defaultTertiary, 0}}
+}
+
+func stCE(s, t int) [][]int {
+ return [][]int{[]int{0, s, t, 0}}
+}
+
+// ducetElem is used to define test data that is used to generate a table.
+type ducetElem struct {
+ str string
+ ces [][]int
+}
+
+func newBuilder(t *testing.T, ducet []ducetElem) *Builder {
+ b := NewBuilder()
+ for _, e := range ducet {
+ if err := b.Add([]rune(e.str), e.ces); err != nil {
+ t.Errorf(err.Error())
+ }
+ }
+ b.t = &table{}
+ return b
+}
+
+type convertTest struct {
+ in, out [][]int
+ err bool
+}
+
+var convLargeTests = []convertTest{
+ {pCE(0xFB39), pCE(0xFB39), false},
+ {cjk(0x2F9B2), pqCE(0x7F4F2, 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 := &entry{elems: tt.in}
+ 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(0x1F5B0, 0xFA70)},
+ {"A\u0300", append(ptCE(100, 8), sCE(30)...)},
+ {"A\u0300\uFA70", append(ptCE(100, 8), sCE(30)[0], pqCE(0x1F5B0, 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.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)
+ b.simplify()
+
+ k := 0
+ for i, tt := range simplifyTest {
+ if simplifyRemoved.contains(tt.str) {
+ continue
+ }
+ e := b.entry[k]
+ k++
+ 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
+ }
+ }
+ k = 0
+ for i, e := range b.entry {
+ 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)
+ }
+ }
+ if k != len(simplifyMarked) {
+ t.Errorf(" an entry that should be marked as decompose was deleted")
+ }
+}
+
+var expandTest = []ducetElem{
+ {"\u00C0", append(ptCE(100, 8), sCE(30)...)},
+ {"\u00C8", append(ptCE(105, 8), sCE(30)...)},
+ {"\u00C9", append(ptCE(105, 8), sCE(30)...)}, // identical expansion
+ {"\u05F2", append(ptCE(200, 4), ptCE(200, 4)[0], ptCE(200, 4)[0])},
+}
+
+func TestExpand(t *testing.T) {
+ const (
+ totalExpansions = 3
+ totalElements = 2 + 2 + 3 + totalExpansions
+ )
+ b := newBuilder(t, expandTest)
+ b.processExpansions()
+
+ for i, tt := range expandTest {
+ e := b.entry[i]
+ 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)
+ }
+ }
+ }
+ // 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)
+ b.processContractions()
+
+ indexMap := make(map[int]bool)
+ handleMap := make(map[rune]*entry)
+ for _, e := range b.entry {
+ 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 := b.t.contractTries.lookup(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)
+ }
+}