code review 5143044: strings: add CaseFoldedEqual

src/pkg/strings/strings_test.go

 // Copyright 2009 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
 
 import (
         "bytes"
         "os"
         "reflect"
@@ skipping 102 matching lines @@
                         t.Errorf("%s(%q,%q) = %v; want %v", funcName, test.s, test.sep, actual, test.out)
                 }
         }
 }
 
 func TestIndex(t *testing.T)        { runIndexTests(t, Index, "Index", indexTests) }
 func TestLastIndex(t *testing.T)    { runIndexTests(t, LastIndex, "LastIndex", lastIndexTests) }
 func TestIndexAny(t *testing.T)     { runIndexTests(t, IndexAny, "IndexAny", indexAnyTests) }
 func TestLastIndexAny(t *testing.T) { runIndexTests(t, LastIndexAny, "LastIndexAny", lastIndexAnyTests) }
 
-type IndexRuneTest struct {
+var indexRuneTests = []struct {
         s    string
         rune int
         out  int
-}
-
-var indexRuneTests = []IndexRuneTest{
+}{
         {"a A x", 'A', 2},
         {"some_text=some_value", '=', 9},
         {"☺a", 'a', 3},
         {"a☻☺b", '☺', 4},
 }
 
 func TestIndexRune(t *testing.T) {
         for _, test := range indexRuneTests {
                 if actual := IndexRune(test.s, test.rune); actual != test.out {
                         t.Errorf("IndexRune(%q,%d)= %v; want %v", test.s, test.rune, actual, test.out)
@@ skipping 23 matching lines @@
 
 func BenchmarkIndex(b *testing.B) {
         if got := Index(benchmarkString, "v"); got != 17 {
                 panic("wrong index: got=" + strconv.Itoa(got))
         }
         for i := 0; i < b.N; i++ {
                 Index(benchmarkString, "v")
         }
 }
 
-type ExplodeTest struct {
+var explodetests = []struct {
         s string
         n int
         a []string
-}
-
-var explodetests = []ExplodeTest{
+}{
         {"", -1, []string{}},
         {abcd, 4, []string{"a", "b", "c", "d"}},
         {faces, 3, []string{"☺", "☻", "☹"}},
         {abcd, 2, []string{"a", "bcd"}},
 }
 
 func TestExplode(t *testing.T) {
         for _, tt := range explodetests {
                 a := SplitN(tt.s, "", tt.n)
                 if !eq(a, tt.a) {
@@ skipping 111 matching lines @@
 func TestFields(t *testing.T) {
         for _, tt := range fieldstests {
                 a := Fields(tt.s)
                 if !eq(a, tt.a) {
                         t.Errorf("Fields(%q) = %v; want %v", tt.s, a, tt.a)
                         continue
                 }
         }
 }
 
+var FieldsFuncTests = []FieldsTest{
+        {"", []string{}},
+        {"XX", []string{}},
+        {"XXhiXXX", []string{"hi"}},
+        {"aXXbXXXcX", []string{"a", "b", "c"}},
+}
+
 func TestFieldsFunc(t *testing.T) {
         pred := func(c int) bool { return c == 'X' }
-        var fieldsFuncTests = []FieldsTest{
-                {"", []string{}},
-                {"XX", []string{}},
-                {"XXhiXXX", []string{"hi"}},
-                {"aXXbXXXcX", []string{"a", "b", "c"}},
-        }
-        for _, tt := range fieldsFuncTests {
+        for _, tt := range FieldsFuncTests {
                 a := FieldsFunc(tt.s, pred)
                 if !eq(a, tt.a) {
                         t.Errorf("FieldsFunc(%q) = %v, want %v", tt.s, a, tt.a)
                 }
         }
 }
 
 // Test case for any function which accepts and returns a single string.
 type StringTest struct {
         in, out string
@@ skipping 154 matching lines @@
                 t.Errorf("Lower(lower) is %s not %s", l, lower)
         }
         l = ToLowerSpecial(unicode.TurkishCase, upper)
         if l != lower {
                 t.Errorf("Lower(upper) is %s not %s", l, lower)
         }
 }
 
 func TestTrimSpace(t *testing.T) { runStringTests(t, TrimSpace, "TrimSpace", trimSpaceTests) }
 
-type TrimTest struct {
+var trimTests = []struct {
         f               func(string, string) string
         in, cutset, out string
-}
-
-var trimTests = []TrimTest{
+}{
         {Trim, "abba", "a", "bb"},
         {Trim, "abba", "ab", ""},
         {TrimLeft, "abba", "ab", ""},
         {TrimRight, "abba", "ab", ""},
         {TrimLeft, "abba", "a", "bba"},
         {TrimRight, "abba", "a", "abb"},
         {Trim, "<tag>", "<>", "tag"},
         {Trim, "* listitem", " *", "listitem"},
         {Trim, `"quote"`, `"`, "quote"},
         {Trim, "\u2C6F\u2C6F\u0250\u0250\u2C6F\u2C6F", "\u2C6F", "\u0250\u0250"},
@@ skipping 38 matching lines @@
 var isSpace = predicate{unicode.IsSpace, "IsSpace"}
 var isDigit = predicate{unicode.IsDigit, "IsDigit"}
 var isUpper = predicate{unicode.IsUpper, "IsUpper"}
 var isValidRune = predicate{
         func(r int) bool {
                 return r != utf8.RuneError
         },
         "IsValidRune",
 }
 
-type TrimFuncTest struct {
-        f       predicate
-        in, out string
-}
-
 func not(p predicate) predicate {
         return predicate{
                 func(r int) bool {
                         return !p.f(r)
                 },
                 "not " + p.name,
         }
 }
 
-var trimFuncTests = []TrimFuncTest{
+var trimFuncTests = []struct {
+        f       predicate
+        in, out string
+}{
         {isSpace, space + " hello " + space, "hello"},
         {isDigit, "\u0e50\u0e5212hello34\u0e50\u0e51", "hello"},
         {isUpper, "\u2C6F\u2C6F\u2C6F\u2C6FABCDhelloEF\u2C6F\u2C6FGH\u2C6F\u2C6F", "hello"},
         {not(isSpace), "hello" + space + "hello", space},
         {not(isDigit), "hello\u0e50\u0e521234\u0e50\u0e51helo", "\u0e50\u0e521234\u0e50\u0e51"},
         {isValidRune, "ab\xc0a\xc0cd", "\xc0a\xc0"},
         {not(isValidRune), "\xc0a\xc0", "a"},
 }
 
 func TestTrimFunc(t *testing.T) {
         for _, tc := range trimFuncTests {
                 actual := TrimFunc(tc.in, tc.f.f)
                 if actual != tc.out {
                         t.Errorf("TrimFunc(%q, %q) = %q; want %q", tc.in, tc.f.name, actual, tc.out)
                 }
         }
 }
 
-type IndexFuncTest struct {
+var indexFuncTests = []struct {
         in          string
         f           predicate
         first, last int
-}
-
-var indexFuncTests = []IndexFuncTest{
+}{
         {"", isValidRune, -1, -1},
         {"abc", isDigit, -1, -1},
         {"0123", isDigit, 0, 3},
         {"a1b", isDigit, 1, 1},
         {space, isSpace, 0, len(space) - 3}, // last rune in space is 3 bytes
         {"\u0e50\u0e5212hello34\u0e50\u0e51", isDigit, 0, 18},
         {"\u2C6F\u2C6F\u2C6F\u2C6FABCDhelloEF\u2C6F\u2C6FGH\u2C6F\u2C6F", isUpper, 0, 34},
         {"12\u0e50\u0e52hello34\u0e50\u0e51", not(isDigit), 8, 12},
 
         // tests of invalid UTF-8
@@ skipping 77 matching lines @@
 
                 if !equal("ToUpper(lower)", ToUpper(lower), upper, t) {
                         t.Error("ToUpper(lower) consistency fail");
                 }
                 if !equal("ToLower(upper)", ToLower(upper), lower, t) {
                         t.Error("ToLower(upper) consistency fail");
                 }
         */
 }
 
-type RepeatTest struct {
+var RepeatTests = []struct {
         in, out string
         count   int
-}
-
-var RepeatTests = []RepeatTest{
+}{
         {"", "", 0},
         {"", "", 1},
         {"", "", 2},
         {"-", "", 0},
         {"-", "-", 1},
         {"-", "----------", 10},
         {"abc ", "abc abc abc ", 3},
 }
 
 func TestRepeat(t *testing.T) {
@@ skipping 11 matching lines @@
                 return false
         }
         for i, r := range a {
                 if r != b[i] {
                         return false
                 }
         }
         return true
 }
 
-type RunesTest struct {
+var RunesTests = []struct {
         in    string
         out   []int
         lossy bool
-}
-
-var RunesTests = []RunesTest{
+}{
         {"", []int{}, false},
         {" ", []int{32}, false},
         {"ABC", []int{65, 66, 67}, false},
         {"abc", []int{97, 98, 99}, false},
         {"\u65e5\u672c\u8a9e", []int{26085, 26412, 35486}, false},
         {"ab\x80c", []int{97, 98, 0xFFFD, 99}, true},
         {"ab\xc0c", []int{97, 98, 0xFFFD, 99}, true},
 }
 
 func TestRunes(t *testing.T) {
@@ skipping 90 matching lines @@
                                 t.Errorf("Reading %q after unreading: want size %d, got %d", s, z, z1)
                                 break
                         }
                 }
                 if res != s {
                         t.Errorf("Reader(%q).ReadRune() produced %q", s, res)
                 }
         }
 }
 
-type ReplaceTest struct {
+var ReplaceTests = []struct {
         in       string
         old, new string
         n        int
         out      string
-}
-
-var ReplaceTests = []ReplaceTest{
+}{
         {"hello", "l", "L", 0, "hello"},
         {"hello", "l", "L", -1, "heLLo"},
         {"hello", "x", "X", -1, "hello"},
         {"", "x", "X", -1, ""},
         {"radar", "r", "<r>", -1, "<r>ada<r>"},
         {"", "", "<>", -1, "<>"},
         {"banana", "a", "<>", -1, "b<>n<>n<>"},
         {"banana", "a", "<>", 1, "b<>nana"},
         {"banana", "a", "<>", 1000, "b<>n<>n<>"},
         {"banana", "an", "<>", -1, "b<><>a"},
         {"banana", "ana", "<>", -1, "b<>na"},
         {"banana", "", "<>", -1, "<>b<>a<>n<>a<>n<>a<>"},
         {"banana", "", "<>", 10, "<>b<>a<>n<>a<>n<>a<>"},
         {"banana", "", "<>", 6, "<>b<>a<>n<>a<>n<>a"},
         {"banana", "", "<>", 5, "<>b<>a<>n<>a<>na"},
         {"banana", "", "<>", 1, "<>banana"},
         {"banana", "a", "a", -1, "banana"},
         {"banana", "a", "a", 1, "banana"},
         {"☺☻☹", "", "<>", -1, "<>☺<>☻<>☹<>"},
 }
 
 func TestReplace(t *testing.T) {
         for _, tt := range ReplaceTests {
                 if s := Replace(tt.in, tt.old, tt.new, tt.n); s != tt.out {
                         t.Errorf("Replace(%q, %q, %q, %d) = %q, want %q", tt.in, tt.old, tt.new, tt.n, s, tt.out)
                 }
         }
 }
 
-type TitleTest struct {
+var TitleTests = []struct {
         in, out string
-}
-
-var TitleTests = []TitleTest{
+}{
         {"", ""},
         {"a", "A"},
         {" aaa aaa aaa ", " Aaa Aaa Aaa "},
         {" Aaa Aaa Aaa ", " Aaa Aaa Aaa "},
         {"123a456", "123a456"},
         {"double-blind", "Double-Blind"},
         {"ÿøû", "Ÿøû"},
 }
 
 func TestTitle(t *testing.T) {
         for _, tt := range TitleTests {
                 if s := Title(tt.in); s != tt.out {
                         t.Errorf("Title(%q) = %q, want %q", tt.in, s, tt.out)
                 }
         }
 }
 
-type ContainsTest struct {
+var ContainsTests = []struct {
         str, substr string
         expected    bool
-}
-
-var ContainsTests = []ContainsTest{
+}{
         {"abc", "bc", true},
         {"abc", "bcd", false},
         {"abc", "", true},
         {"", "a", false},
 }
 
 func TestContains(t *testing.T) {
         for _, ct := range ContainsTests {
                 if Contains(ct.str, ct.substr) != ct.expected {
                         t.Errorf("Contains(%s, %s) = %v, want %v",
                                 ct.str, ct.substr, !ct.expected, ct.expected)
                 }
         }
 }
+
+var EqualFoldTests = []struct {
+        s, t string
+        out  bool
+}{
+        {"abc", "abc", true},
+        {"ABcd", "ABcd", true},
+        {"123abc", "123ABC", true},
+        {"αβδ", "ΑΒΔ", true},
+        {"abc", "xyz", false},
+        {"abc", "XYZ", false},
+        {"abcdefghijk", "abcdefghijX", false},
+        {"abcdefghijk", "abcdefghij\u212A", true},
+        {"abcdefghijK", "abcdefghij\u212A", true},
+        {"abcdefghijkz", "abcdefghij\u212Ay", false},
+        {"abcdefghijKz", "abcdefghij\u212Ay", false},
+}
+
+func TestEqualFold(t *testing.T) {
+        for _, tt := range EqualFoldTests {
+                if out := EqualFold(tt.s, tt.t); out != tt.out {
+                        t.Errorf("EqualFold(%#q, %#q) = %v, want %v", tt.s, tt.t, out, tt.out)
+                }
+                if out := EqualFold(tt.t, tt.s); out != tt.out {
+                        t.Errorf("EqualFold(%#q, %#q) = %v, want %v", tt.t, tt.s, out, tt.out)
+                }
+        }
+}