Debian Codegraph @

internal/gen/gentables/main_test.go

raw
1 package main
2
3 import (
4 "bytes"
5 "encoding/json"
6 "errors"
7 "flag"
8 "os"
9 "os/exec"
10 "path/filepath"
11 "reflect"
12 "slices"
13 "sort"
14 "syscall"
15 "testing"
16 "unicode"
17
18 "github.com/charlievieth/strcase/internal/gen/util"
19 "github.com/stretchr/testify/assert"
20 "golang.org/x/term"
21 "golang.org/x/text/unicode/rangetable"
22 )
23
24 func TestMain(m *testing.M) {
25 // Tests must run with the same CLDR and Unicode version of the Go
26 // version running the tests. This is because we use the unicode
27 // package to assert that our code is correct.
28 for _, name := range []string{"cldr", "unicode"} {
29 f := flag.Lookup(name)
30 if f.Value.String() != f.DefValue {
31 panic(`The "-` + name + `" flag may not be set for tests.`)
32 }
33 }
34 root, err := util.ProjectRoot()
35 if err != nil {
36 panic(err)
37 }
38
39 initTables(root, filepath.Join("../../tables", tablesFileName(unicode.Version)))
40 os.Exit(m.Run())
41 }
42
43 func sortedKeys[M ~map[string]V, V any](m M) []string {
44 a := make([]string, 0, len(m))
45 for k := range m {
46 a = append(a, k)
47 }
48 slices.Sort(a)
49 return a
50 }
51
52 func writeJSON(t testing.TB, filename string, v any) {
53 t.Helper()
54 data, err := json.MarshalIndent(v, "", " ")
55 if err != nil {
56 t.Fatal(err)
57 }
58 data = append(data, '\n')
59 if err := os.WriteFile(filename, data, 0644); err != nil {
60 t.Fatal(err)
61 }
62 }
63
64 func diff(t testing.TB, v1, v2 any) {
65 if _, err := exec.LookPath("diff"); err != nil {
66 assert.Equal(t, v1, v2)
67 return
68 }
69
70 // Don't use t.TempDir() since we want to preserve the files so
71 // that users can inspect them on test failure.
72 tmp, err := os.MkdirTemp("", "strcase.*")
73 if err != nil {
74 t.Fatal(err)
75 }
76 writeJSON(t, tmp+"/want.json", v1)
77 writeJSON(t, tmp+"/got.json", v2)
78
79 args := []string{
80 "-u",
81 tmp + "/want.json",
82 tmp + "/got.json",
83 }
84 if term.IsTerminal(syscall.Stdout) {
85 args = append([]string{"--color=always"}, args...)
86 }
87
88 cmd := exec.Command("diff", args...)
89 cmd.Dir = tmp
90
91 out, err := cmd.CombinedOutput()
92 out = bytes.TrimSpace(out)
93 if err != nil {
94 var ee *exec.ExitError
95 if errors.As(err, &ee) {
96 if ee.ExitCode() != 1 {
97 t.Fatalf("error running: %q: %v\n%s", cmd.Args, err, out)
98 }
99 }
100 // Ok, exit code is due to the diff
101 }
102 t.Errorf("\n%s\nTMPDIR: %s\nvimdiff %s %s",
103 out, tmp, tmp+"/want.json", tmp+"/got.json")
104 }
105
106 func rangetableEqual(r1, r2 *unicode.RangeTable) bool {
107 if (r1 == nil) != (r2 == nil) {
108 return false
109 }
110 return r1 != nil && r1.LatinOffset == r2.LatinOffset &&
111 slices.Equal(r1.R16, r2.R16) && slices.Equal(r1.R32, r2.R32)
112 }
113
114 func compareRangeTables(t *testing.T, want, got map[string]*unicode.RangeTable) {
115 t.Run("Keys", func(t *testing.T) {
116 k1 := sortedKeys(want)
117 k2 := sortedKeys(got)
118 if !slices.Equal(k1, k2) {
119 diff(t, k1, k2)
120 }
121 })
122 if t.Failed() {
123 return
124 }
125
126 t.Run("Tables", func(t *testing.T) {
127 failures := 0
128 for key, rt1 := range want {
129 t.Run(key, func(t *testing.T) {
130 rt2 := got[key]
131 if !rangetableEqual(rt1, rt2) {
132 diff(t, rt1, rt2)
133 t.Fail()
134 failures++
135 }
136 })
137 if failures >= 10 {
138 t.Fatal("Too many errors:", failures)
139 }
140 }
141 })
142 }
143
144 func TestCategories(t *testing.T) {
145 compareRangeTables(t, unicode.Categories, loadCategoryTables())
146 }
147
148 func TestScript(t *testing.T) {
149 compareRangeTables(t, unicode.Scripts, loadScriptOrProperty(false))
150 }
151
152 func TestProperty(t *testing.T) {
153 compareRangeTables(t, unicode.Properties, loadScriptOrProperty(true))
154 }
155
156 func TestLoadCasefold(t *testing.T) {
157 categories, scripts := loadCasefold()
158 t.Run("FoldCategory", func(t *testing.T) {
159 compareRangeTables(t, unicode.FoldCategory, categories)
160 })
161 t.Run("FoldScript", func(t *testing.T) {
162 compareRangeTables(t, unicode.FoldScript, scripts)
163 })
164 }
165
166 func TestUnicodeCategories(t *testing.T) {
167 rangeTable := func(a []map[string]*unicode.RangeTable) *unicode.RangeTable {
168 tabs := make([]*unicode.RangeTable, 0, len(a))
169 for _, m := range a {
170 for _, rt := range m {
171 tabs = append(tabs, rt)
172 }
173 }
174 return rangetable.Merge(tabs...)
175 }
176 want := []map[string]*unicode.RangeTable{
177 unicode.Categories,
178 unicode.Scripts,
179 unicode.Properties,
180 unicode.FoldCategory,
181 unicode.FoldScript,
182 }
183
184 foldCategories, foldScripts := loadCasefold()
185 got := []map[string]*unicode.RangeTable{
186 loadCategoryTables(),
187 loadScriptOrProperty(false),
188 loadScriptOrProperty(true),
189 foldCategories,
190 foldScripts,
191 }
192 for i := range want {
193 k1 := sortedKeys(want[i])
194 k2 := sortedKeys(got[i])
195 assert.Equal(t, k1, k2)
196 }
197
198 for i, name := range []string{"Categories", "Scripts", "Properties", "FoldCategory", "FoldScript"} {
199 if i >= len(want) {
200 continue
201 }
202 t.Run(name, func(t *testing.T) {
203 compareRangeTables(t, want[i], got[i])
204 })
205 }
206
207 compareRangeTables(
208 t,
209 map[string]*unicode.RangeTable{"All": rangeTable(want)},
210 map[string]*unicode.RangeTable{"All": rangeTable(got)},
211 )
212
213 rangetableEqual(rangeTable(want), categories)
214 }
215
216 func TestGenerateSpans(t *testing.T) {
217 t.Run("RandomShuffle", func(t *testing.T) {
218 var spans []span
219 for i := 0; i < 10; i++ {
220 spans = generateSpans(0, 100, 7)
221 sorted := sort.SliceIsSorted(spans, func(i, j int) bool {
222 return spans[i].Start < spans[j].Start
223 })
224 if !sorted {
225 return
226 }
227 }
228 t.Errorf("spans are not randomly shuffled: %+v", spans)
229 })
230 t.Run("Complete", func(t *testing.T) {
231 want := []span{
232 {Start: 1, End: 8},
233 {Start: 8, End: 15},
234 {Start: 15, End: 22},
235 {Start: 22, End: 29},
236 {Start: 29, End: 36},
237 {Start: 36, End: 43},
238 {Start: 43, End: 50},
239 {Start: 50, End: 50},
240 }
241 spans := generateSpans(1, 50, 7)
242 sort.Slice(spans, func(i, j int) bool {
243 return spans[i].Start < spans[j].Start
244 })
245 if !reflect.DeepEqual(want, spans) {
246 diff(t, want, spans)
247 }
248 // assert.Equal(t, want, spans)
249 })
250 }
251
252 func TestGenerateCaseRanges(t *testing.T) {
253 got := caseRanges
254 want := unicode.CaseRanges
255 if !reflect.DeepEqual(got, want) {
256 diff(t, want, got)
257 }
258 }
259
260 func TestToUpperLower(t *testing.T) {
261 for r := rune(0); r <= unicode.MaxRune; r++ {
262 if toLower(r) != unicode.ToLower(r) {
263 t.Errorf("toLower(%U) = %U; want: %U", r, toLower(r), unicode.ToLower(r))
264 }
265 if toUpper(r) != unicode.ToUpper(r) {
266 t.Errorf("toUpper(%U) = %U; want: %U", r, toUpper(r), unicode.ToUpper(r))
267 }
268 }
269 }
270
271 func TestSimpleFold(t *testing.T) {
272 for r := rune(0); r <= unicode.MaxRune; r++ {
273 if simpleFold(r) != unicode.SimpleFold(r) {
274 t.Errorf("simpleFold(%[1]q/%[1]U) = %[2]q/%[2]U; want: %[3]q/%[3]U", r,
275 simpleFold(r), unicode.SimpleFold(r))
276 }
277 }
278 }
279
280 // WARN: DELETE ME
281 // func TestFindModfile(t *testing.T) {
282 // wd, err := os.Getwd()
283 // if err != nil {
284 // t.Fatal(err)
285 // }
286 // t.Fatal(findModfile(wd, "", "github.com/charlievieth/strcase"))
287 // }
288
289 /*
290 func diff(t testing.TB, v1, v2 any) {
291 if _, err := exec.LookPath("git"); err != nil {
292 assert.Equal(t, v1, v2)
293 return
294 }
295
296 tmp, err := os.MkdirTemp("", "strcase.*")
297 if err != nil {
298 t.Fatal(err)
299 }
300 writeJSON(t, tmp+"/want.json", v1)
301 writeJSON(t, tmp+"/got.json", v2)
302
303 args := []string{
304 "diff",
305 "--no-index",
306 "--exit-code",
307 "--color=always",
308 "--histogram",
309 "--ignore-cr-at-eol",
310 "--unified=6",
311 tmp + "/want.json",
312 tmp + "/got.json",
313 }
314 cmd := exec.Command("git", args...)
315 cmd.Dir = tmp
316
317 out, err := cmd.CombinedOutput()
318 out = bytes.TrimSpace(out)
319 if err != nil {
320 var ee *exec.ExitError
321 if errors.As(err, &ee) {
322 if ee.ExitCode() != 1 {
323 t.Fatalf("error running: %q: %v\n%s", cmd.Args, err, out)
324 }
325 }
326 // Ok, exit code is due to the diff
327 }
328 t.Errorf("%s\nTMPDIR: %s\nvimdiff %s %s",
329 out, tmp, tmp+"/want.json", tmp+"/got.json")
330 }
331 */