← Back to branch summary

~vtuson/scopecreator/twitter-template

« back to all changes in this revision

Viewing changes to src/go/src/code.google.com/p/go.text/collate/build/colelem_test.go

  • Committer: Victor Palau
  • Date: 2015-03-11 14:24:42 UTC
  • Revision ID: vtuson@gmail.com-20150311142442-f2pxp111c8ynv232
public release

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/go/src/code.google.com/p/go.text/collate/build/colelem_test.go
 
1
// Copyright 2012 The Go Authors. All rights reserved.
 
2
// Use of this source code is governed by a BSD-style
 
3
// license that can be found in the LICENSE file.
 
4
 
 
5
package build
 
6
 
 
7
import (
 
8
        "testing"
 
9
 
 
10
        "code.google.com/p/go.text/collate/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
        // non-ignorable primary with non-default secondary
 
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}, // non-ignorable primary with non-supported secondary
 
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 comparisson 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
}