code review 5430046: strings: Add ContainsAny and ContainsRune to correspond...

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"
         "io"
         "reflect"
@@ skipping 890 matching lines @@
 
 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 ContainsAnyTests = []struct {
+        str, substr string
+        expected    bool
+}{
+        {"", "", false},
+        {"", "a", false},
+        {"", "abc", false},
+        {"a", "", false},
+        {"a", "a", true},
+        {"aaa", "a", true},
+        {"abc", "xyz", false},
+        {"abc", "xcz", true},
+        {"a☺b☻c☹d", "uvw☻xyz", true},
+        {"aRegExp*", ".(|)*+?^$[]", true},
+        {dots + dots + dots, " ", false},
+}
+
+func TestContainsAny(t *testing.T) {
+        for _, ct := range ContainsAnyTests {
+                if ContainsAny(ct.str, ct.substr) != ct.expected {
+                        t.Errorf("ContainsAny(%s, %s) = %v, want %v",
+                                ct.str, ct.substr, !ct.expected, ct.expected)
+                }
+        }
+}
+
+var ContainsRuneTests = []struct {
+        str      string
+        r        rune
+        expected bool
+}{
+        {"", 'a', false},
+        {"a", 'a', true},
+        {"aaa", 'a', true},
+        {"abc", 'y', false},
+        {"abc", 'c', true},
+        {"a☺b☻c☹d", 'x', false},
+        {"a☺b☻c☹d", '☻', true},
+        {"aRegExp*", '*', true},
+}
+
+func TestContainsRune(t *testing.T) {
+        for _, ct := range ContainsRuneTests {
+                if ContainsRune(ct.str, ct.r) != ct.expected {
+                        t.Errorf("ContainsRune(%s, %s) = %v, want %v",
+                                ct.str, ct.r, !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)
                 }
         }
 }