1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
| // Copyright 2013 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 strings_test
|
| // Derived from bytes/compare_test.go.
| // Benchmarks omitted since the underlying implementation is identical.
|
| import (
| "internal/testenv"
| . "strings"
| "testing"
| "unsafe"
| )
|
| var compareTests = []struct {
| a, b string
| i int
| }{
| {"", "", 0},
| {"a", "", 1},
| {"", "a", -1},
| {"abc", "abc", 0},
| {"ab", "abc", -1},
| {"abc", "ab", 1},
| {"x", "ab", 1},
| {"ab", "x", -1},
| {"x", "a", 1},
| {"b", "x", -1},
| // test runtime·memeq's chunked implementation
| {"abcdefgh", "abcdefgh", 0},
| {"abcdefghi", "abcdefghi", 0},
| {"abcdefghi", "abcdefghj", -1},
| }
|
| func TestCompare(t *testing.T) {
| for _, tt := range compareTests {
| cmp := Compare(tt.a, tt.b)
| if cmp != tt.i {
| t.Errorf(`Compare(%q, %q) = %v`, tt.a, tt.b, cmp)
| }
| }
| }
|
| func TestCompareIdenticalString(t *testing.T) {
| var s = "Hello Gophers!"
| if Compare(s, s) != 0 {
| t.Error("s != s")
| }
| if Compare(s, s[:1]) != 1 {
| t.Error("s > s[:1] failed")
| }
| }
|
| func TestCompareStrings(t *testing.T) {
| // unsafeString converts a []byte to a string with no allocation.
| // The caller must not modify b while the result string is in use.
| unsafeString := func(b []byte) string {
| return *(*string)(unsafe.Pointer(&b))
| }
|
| lengths := make([]int, 0) // lengths to test in ascending order
| for i := 0; i <= 128; i++ {
| lengths = append(lengths, i)
| }
| lengths = append(lengths, 256, 512, 1024, 1333, 4095, 4096, 4097)
|
| if !testing.Short() || testenv.Builder() != "" {
| lengths = append(lengths, 65535, 65536, 65537, 99999)
| }
|
| n := lengths[len(lengths)-1]
| a := make([]byte, n+1)
| b := make([]byte, n+1)
| lastLen := 0
| for _, len := range lengths {
| // randomish but deterministic data. No 0 or 255.
| for i := 0; i < len; i++ {
| a[i] = byte(1 + 31*i%254)
| b[i] = byte(1 + 31*i%254)
| }
| // data past the end is different
| for i := len; i <= n; i++ {
| a[i] = 8
| b[i] = 9
| }
|
| sa, sb := unsafeString(a), unsafeString(b)
| cmp := Compare(sa[:len], sb[:len])
| if cmp != 0 {
| t.Errorf(`CompareIdentical(%d) = %d`, len, cmp)
| }
| if len > 0 {
| cmp = Compare(sa[:len-1], sb[:len])
| if cmp != -1 {
| t.Errorf(`CompareAshorter(%d) = %d`, len, cmp)
| }
| cmp = Compare(sa[:len], sb[:len-1])
| if cmp != 1 {
| t.Errorf(`CompareBshorter(%d) = %d`, len, cmp)
| }
| }
| for k := lastLen; k < len; k++ {
| b[k] = a[k] - 1
| cmp = Compare(unsafeString(a[:len]), unsafeString(b[:len]))
| if cmp != 1 {
| t.Errorf(`CompareAbigger(%d,%d) = %d`, len, k, cmp)
| }
| b[k] = a[k] + 1
| cmp = Compare(unsafeString(a[:len]), unsafeString(b[:len]))
| if cmp != -1 {
| t.Errorf(`CompareBbigger(%d,%d) = %d`, len, k, cmp)
| }
| b[k] = a[k]
| }
| lastLen = len
| }
| }
|
|
