1
2
3
4
5 package build
6
7 import (
8 "testing"
9
10 "golang.org/x/text/internal/colltab"
11 )
12
13 type ceTest struct {
14 f func(in []int) (uint32, error)
15 arg []int
16 val uint32
17 }
18
19 func normalCE(in []int) (ce uint32, err error) {
20 return makeCE(rawCE{w: in[:3], ccc: uint8(in[3])})
21 }
22
23 func expandCE(in []int) (ce uint32, err error) {
24 return makeExpandIndex(in[0])
25 }
26
27 func contractCE(in []int) (ce uint32, err error) {
28 return makeContractIndex(ctHandle{in[0], in[1]}, in[2])
29 }
30
31 func decompCE(in []int) (ce uint32, err error) {
32 return makeDecompose(in[0], in[1])
33 }
34
35 var ceTests = []ceTest{
36 {normalCE, []int{0, 0, 0, 0}, 0xA0000000},
37 {normalCE, []int{0, 0x28, 3, 0}, 0xA0002803},
38 {normalCE, []int{0, 0x28, 3, 0xFF}, 0xAFF02803},
39 {normalCE, []int{100, defaultSecondary, 3, 0}, 0x0000C883},
40
41 {normalCE, []int{100, 0x28, defaultTertiary, 0}, 0x4000C828},
42 {normalCE, []int{100, defaultSecondary + 8, 3, 0}, 0x0000C983},
43 {normalCE, []int{100, 0, 3, 0}, 0xFFFF},
44 {normalCE, []int{100, 1, 3, 0}, 0xFFFF},
45 {normalCE, []int{1 << maxPrimaryBits, defaultSecondary, 0, 0}, 0xFFFF},
46 {normalCE, []int{0, 1 << maxSecondaryBits, 0, 0}, 0xFFFF},
47 {normalCE, []int{100, defaultSecondary, 1 << maxTertiaryBits, 0}, 0xFFFF},
48 {normalCE, []int{0x123, defaultSecondary, 8, 0xFF}, 0x88FF0123},
49 {normalCE, []int{0x123, defaultSecondary + 1, 8, 0xFF}, 0xFFFF},
50
51 {contractCE, []int{0, 0, 0}, 0xC0000000},
52 {contractCE, []int{1, 1, 1}, 0xC0010011},
53 {contractCE, []int{1, (1 << maxNBits) - 1, 1}, 0xC001001F},
54 {contractCE, []int{(1 << maxTrieIndexBits) - 1, 1, 1}, 0xC001FFF1},
55 {contractCE, []int{1, 1, (1 << maxContractOffsetBits) - 1}, 0xDFFF0011},
56 {contractCE, []int{1, (1 << maxNBits), 1}, 0xFFFF},
57 {contractCE, []int{(1 << maxTrieIndexBits), 1, 1}, 0xFFFF},
58 {contractCE, []int{1, (1 << maxContractOffsetBits), 1}, 0xFFFF},
59
60 {expandCE, []int{0}, 0xE0000000},
61 {expandCE, []int{5}, 0xE0000005},
62 {expandCE, []int{(1 << maxExpandIndexBits) - 1}, 0xE000FFFF},
63 {expandCE, []int{1 << maxExpandIndexBits}, 0xFFFF},
64
65 {decompCE, []int{0, 0}, 0xF0000000},
66 {decompCE, []int{1, 1}, 0xF0000101},
67 {decompCE, []int{0x1F, 0x1F}, 0xF0001F1F},
68 {decompCE, []int{256, 0x1F}, 0xFFFF},
69 {decompCE, []int{0x1F, 256}, 0xFFFF},
70 }
71
72 func TestColElem(t *testing.T) {
73 for i, tt := range ceTests {
74 in := make([]int, len(tt.arg))
75 copy(in, tt.arg)
76 ce, err := tt.f(in)
77 if tt.val == 0xFFFF {
78 if err == nil {
79 t.Errorf("%d: expected error for args %x", i, tt.arg)
80 }
81 continue
82 }
83 if err != nil {
84 t.Errorf("%d: unexpected error: %v", i, err.Error())
85 }
86 if ce != tt.val {
87 t.Errorf("%d: colElem=%X; want %X", i, ce, tt.val)
88 }
89 }
90 }
91
92 func mkRawCES(in [][]int) []rawCE {
93 out := []rawCE{}
94 for _, w := range in {
95 out = append(out, rawCE{w: w})
96 }
97 return out
98 }
99
100 type weightsTest struct {
101 a, b [][]int
102 level colltab.Level
103 result int
104 }
105
106 var nextWeightTests = []weightsTest{
107 {
108 a: [][]int{{100, 20, 5, 0}},
109 b: [][]int{{101, defaultSecondary, defaultTertiary, 0}},
110 level: colltab.Primary,
111 },
112 {
113 a: [][]int{{100, 20, 5, 0}},
114 b: [][]int{{100, 21, defaultTertiary, 0}},
115 level: colltab.Secondary,
116 },
117 {
118 a: [][]int{{100, 20, 5, 0}},
119 b: [][]int{{100, 20, 6, 0}},
120 level: colltab.Tertiary,
121 },
122 {
123 a: [][]int{{100, 20, 5, 0}},
124 b: [][]int{{100, 20, 5, 0}},
125 level: colltab.Identity,
126 },
127 }
128
129 var extra = [][]int{{200, 32, 8, 0}, {0, 32, 8, 0}, {0, 0, 8, 0}, {0, 0, 0, 0}}
130
131 func TestNextWeight(t *testing.T) {
132 for i, tt := range nextWeightTests {
133 test := func(l colltab.Level, tt weightsTest, a, gold [][]int) {
134 res := nextWeight(tt.level, mkRawCES(a))
135 if !equalCEArrays(mkRawCES(gold), res) {
136 t.Errorf("%d:%d: expected weights %d; found %d", i, l, gold, res)
137 }
138 }
139 test(-1, tt, tt.a, tt.b)
140 for l := colltab.Primary; l <= colltab.Tertiary; l++ {
141 if tt.level <= l {
142 test(l, tt, append(tt.a, extra[l]), tt.b)
143 } else {
144 test(l, tt, append(tt.a, extra[l]), append(tt.b, extra[l]))
145 }
146 }
147 }
148 }
149
150 var compareTests = []weightsTest{
151 {
152 [][]int{{100, 20, 5, 0}},
153 [][]int{{100, 20, 5, 0}},
154 colltab.Identity,
155 0,
156 },
157 {
158 [][]int{{100, 20, 5, 0}, extra[0]},
159 [][]int{{100, 20, 5, 1}},
160 colltab.Primary,
161 1,
162 },
163 {
164 [][]int{{100, 20, 5, 0}},
165 [][]int{{101, 20, 5, 0}},
166 colltab.Primary,
167 -1,
168 },
169 {
170 [][]int{{101, 20, 5, 0}},
171 [][]int{{100, 20, 5, 0}},
172 colltab.Primary,
173 1,
174 },
175 {
176 [][]int{{100, 0, 0, 0}, {0, 20, 5, 0}},
177 [][]int{{0, 20, 5, 0}, {100, 0, 0, 0}},
178 colltab.Identity,
179 0,
180 },
181 {
182 [][]int{{100, 20, 5, 0}},
183 [][]int{{100, 21, 5, 0}},
184 colltab.Secondary,
185 -1,
186 },
187 {
188 [][]int{{100, 20, 5, 0}},
189 [][]int{{100, 20, 2, 0}},
190 colltab.Tertiary,
191 1,
192 },
193 {
194 [][]int{{100, 20, 5, 1}},
195 [][]int{{100, 20, 5, 2}},
196 colltab.Quaternary,
197 -1,
198 },
199 }
200
201 func TestCompareWeights(t *testing.T) {
202 for i, tt := range compareTests {
203 test := func(tt weightsTest, a, b [][]int) {
204 res, level := compareWeights(mkRawCES(a), mkRawCES(b))
205 if res != tt.result {
206 t.Errorf("%d: expected comparison result %d; found %d", i, tt.result, res)
207 }
208 if level != tt.level {
209 t.Errorf("%d: expected level %d; found %d", i, tt.level, level)
210 }
211 }
212 test(tt, tt.a, tt.b)
213 test(tt, append(tt.a, extra[0]), append(tt.b, extra[0]))
214 }
215 }
216
View as plain text