code review 781041: bytes, strings: IndexOfAny

src/pkg/bytes/bytes_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 bytes_test
 
 import (
         . "bytes"
         "testing"
         "unicode"
@@ skipping 92 matching lines @@
         BinOpTest{"foo", "f", 0},
         BinOpTest{"oofofoofooo", "f", 7},
         BinOpTest{"oofofoofooo", "foo", 7},
         BinOpTest{"barfoobarfoo", "foo", 9},
         BinOpTest{"foo", "", 3},
         BinOpTest{"foo", "o", 2},
         BinOpTest{"abcABCabc", "A", 3},
         BinOpTest{"abcABCabc", "a", 6},
 }
 
-var indexOfAnyTests = []BinOpTest{
+var indexAnyTests = []BinOpTest{
         BinOpTest{"", "", -1},
         BinOpTest{"", "a", -1},
         BinOpTest{"", "abc", -1},
         BinOpTest{"a", "", -1},
         BinOpTest{"a", "a", 0},
         BinOpTest{"aaa", "a", 0},
         BinOpTest{"abc", "xyz", -1},
         BinOpTest{"abc", "xcz", 2},
         BinOpTest{"aRegExp*", ".(|)*+?^$[]", 7},
         BinOpTest{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 []byte) int, funcName string, testCases []BinOpTest) {
         for _, test := range testCases {
                 a := []byte(test.a)
                 b := []byte(test.b)
                 actual := f(a, b)
                 if actual != test.i {
                         t.Errorf("%s(%q,%q) = %v; want %v", funcName, a, b, actual, test.i)
                 }
         }
 }
 
-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) }
 
 func TestIndexByte(t *testing.T) {
         for _, tt := range indexTests {
                 if len(tt.b) != 1 {
                         continue
                 }
                 a := []byte(tt.a)
                 b := tt.b[0]
                 pos := IndexByte(a, b)
                 if pos != tt.i {
@@ skipping 407 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(Runes(%q)) = %x; want %x", tin, s, tin)
                         }
                 }
         }
 }