code review 781041: bytes, strings: IndexOfAny

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 (
         . "strings"
         "testing"
         "unicode"
@@ skipping 54 matching lines @@
         IndexTest{"foo", "f", 0},
         IndexTest{"oofofoofooo", "f", 7},
         IndexTest{"oofofoofooo", "foo", 7},
         IndexTest{"barfoobarfoo", "foo", 9},
         IndexTest{"foo", "", 3},
         IndexTest{"foo", "o", 2},
         IndexTest{"abcABCabc", "A", 3},
         IndexTest{"abcABCabc", "a", 6},
 }
 
-var indexOfAnyTests = []IndexTest{
+var indexAnyTests = []IndexTest{
         IndexTest{"", "", -1},
         IndexTest{"", "a", -1},
         IndexTest{"", "abc", -1},
         IndexTest{"a", "", -1},
         IndexTest{"a", "a", 0},
         IndexTest{"aaa", "a", 0},
         IndexTest{"abc", "xyz", -1},
         IndexTest{"abc", "xcz", 2},
         IndexTest{"a☺b☻c☹d", "uvw☻xyz", 2 + len("☺")},
         IndexTest{"aRegExp*", ".(|)*+?^$[]", 7},
         IndexTest{dots + dots + dots, " ", -1},
 }
 
 // Execute f on each test case.  funcName should be the name of f; it's used
 // in failure reports.
 func runIndexTests(t *testing.T, f func(s, sep string) int, funcName string, testCases []IndexTest) {
         for _, test := range testCases {
                 actual := f(test.s, test.sep)
                 if actual != test.out {
                         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 TestIndexOfAny(t *testing.T) { runIndexTests(t, IndexOfAny, "IndexOfAny", indexOfAnyTests) }
+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) }
 
 type ExplodeTest struct {
         s string
         n int
         a []string
 }
 
 var explodetests = []ExplodeTest{
         ExplodeTest{abcd, 4, []string{"a", "b", "c", "d"}},
         ExplodeTest{faces, 3, []string{"☺", "☻", "☹"}},
@@ skipping 351 matching lines @@
                 }
                 if !tt.lossy {
                         // can only test reassembly if we didn't lose information
                         s := string(a)
                         if s != tt.in {
                                 t.Errorf("string([]int(%q)) = %x; want %x", tt.in, s, tt.in)
                         }
                 }
         }
 }