bytes, strings: add tests for TrimLeftFunc and TrimRightFunc

When I was working on the fix for #31038 (make TrimSpace return nil on
all-space input) I noticed that there were no tests for TrimLeftFunc
and TrimRightFunc, including the funky nil behavior. So add some!

I've just reused the existing TrimFunc test cases for TrimLeftFunc and
TrimRightFunc, as well as adding new tests for the empty string and
all-trimmed cases (which test the nil-returning behavior of TrimFunc and
TrimLeftFunc).

Change-Id: Ib580d4364e9b3c91350305f9d9873080d7862904
Reviewed-on: https://go-review.googlesource.com/c/go/+/170061
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

src/bytes/bytes_test.go

@@ -1261,8 +1261,11 @@ var isValidRune = predicate{
 }
 
 type TrimFuncTest struct {
-	f       predicate
+	f        predicate
-	in, out string
+	in       string
+	trimOut  []byte
+	leftOut  []byte
+	rightOut []byte
 }
 
 func not(p predicate) predicate {
@@ -1275,20 +1278,68 @@ func not(p predicate) predicate {
 }
 
 var trimFuncTests = []TrimFuncTest{
-	{isSpace, space + " hello " + space, "hello"},
+	{isSpace, space + " hello " + space,
-	{isDigit, "\u0e50\u0e5212hello34\u0e50\u0e51", "hello"},
+		[]byte("hello"),
-	{isUpper, "\u2C6F\u2C6F\u2C6F\u2C6FABCDhelloEF\u2C6F\u2C6FGH\u2C6F\u2C6F", "hello"},
+		[]byte("hello " + space),
-	{not(isSpace), "hello" + space + "hello", space},
+		[]byte(space + " hello")},
-	{not(isDigit), "hello\u0e50\u0e521234\u0e50\u0e51helo", "\u0e50\u0e521234\u0e50\u0e51"},
+	{isDigit, "\u0e50\u0e5212hello34\u0e50\u0e51",
-	{isValidRune, "ab\xc0a\xc0cd", "\xc0a\xc0"},
+		[]byte("hello"),
-	{not(isValidRune), "\xc0a\xc0", "a"},
+		[]byte("hello34\u0e50\u0e51"),
+		[]byte("\u0e50\u0e5212hello")},
+	{isUpper, "\u2C6F\u2C6F\u2C6F\u2C6FABCDhelloEF\u2C6F\u2C6FGH\u2C6F\u2C6F",
+		[]byte("hello"),
+		[]byte("helloEF\u2C6F\u2C6FGH\u2C6F\u2C6F"),
+		[]byte("\u2C6F\u2C6F\u2C6F\u2C6FABCDhello")},
+	{not(isSpace), "hello" + space + "hello",
+		[]byte(space),
+		[]byte(space + "hello"),
+		[]byte("hello" + space)},
+	{not(isDigit), "hello\u0e50\u0e521234\u0e50\u0e51helo",
+		[]byte("\u0e50\u0e521234\u0e50\u0e51"),
+		[]byte("\u0e50\u0e521234\u0e50\u0e51helo"),
+		[]byte("hello\u0e50\u0e521234\u0e50\u0e51")},
+	{isValidRune, "ab\xc0a\xc0cd",
+		[]byte("\xc0a\xc0"),
+		[]byte("\xc0a\xc0cd"),
+		[]byte("ab\xc0a\xc0")},
+	{not(isValidRune), "\xc0a\xc0",
+		[]byte("a"),
+		[]byte("a\xc0"),
+		[]byte("\xc0a")},
+	// The nils returned by TrimLeftFunc are odd behavior, but we need
+	// to preserve backwards compatibility.
+	{isSpace, "",
+		nil,
+		nil,
+		[]byte("")},
+	{isSpace, " ",
+		nil,
+		nil,
+		[]byte("")},
 }
 
 func TestTrimFunc(t *testing.T) {
 	for _, tc := range trimFuncTests {
-		actual := string(TrimFunc([]byte(tc.in), tc.f.f))
+		trimmers := []struct {
-		if actual != tc.out {
+			name string
-			t.Errorf("TrimFunc(%q, %q) = %q; want %q", tc.in, tc.f.name, actual, tc.out)
+			trim func(s []byte, f func(r rune) bool) []byte
+			out  []byte
+		}{
+			{"TrimFunc", TrimFunc, tc.trimOut},
+			{"TrimLeftFunc", TrimLeftFunc, tc.leftOut},
+			{"TrimRightFunc", TrimRightFunc, tc.rightOut},
+		}
+		for _, trimmer := range trimmers {
+			actual := trimmer.trim([]byte(tc.in), tc.f.f)
+			if actual == nil && trimmer.out != nil {
+				t.Errorf("%s(%q, %q) = nil; want %q", trimmer.name, tc.in, tc.f.name, trimmer.out)
+			}
+			if actual != nil && trimmer.out == nil {
+				t.Errorf("%s(%q, %q) = %q; want nil", trimmer.name, tc.in, tc.f.name, actual)
+			}
+			if !Equal(actual, trimmer.out) {
+				t.Errorf("%s(%q, %q) = %q; want %q", trimmer.name, tc.in, tc.f.name, actual, trimmer.out)
+			}
 		}
 	}
 }

src/strings/strings_test.go

@@ -864,23 +864,66 @@ func not(p predicate) predicate {
 }
 
 var trimFuncTests = []struct {
-	f       predicate
+	f        predicate
-	in, out string
+	in       string
+	trimOut  string
+	leftOut  string
+	rightOut string
 }{
-	{isSpace, space + " hello " + space, "hello"},
+	{isSpace, space + " hello " + space,
-	{isDigit, "\u0e50\u0e5212hello34\u0e50\u0e51", "hello"},
+		"hello",
-	{isUpper, "\u2C6F\u2C6F\u2C6F\u2C6FABCDhelloEF\u2C6F\u2C6FGH\u2C6F\u2C6F", "hello"},
+		"hello " + space,
-	{not(isSpace), "hello" + space + "hello", space},
+		space + " hello"},
-	{not(isDigit), "hello\u0e50\u0e521234\u0e50\u0e51helo", "\u0e50\u0e521234\u0e50\u0e51"},
+	{isDigit, "\u0e50\u0e5212hello34\u0e50\u0e51",
-	{isValidRune, "ab\xc0a\xc0cd", "\xc0a\xc0"},
+		"hello",
-	{not(isValidRune), "\xc0a\xc0", "a"},
+		"hello34\u0e50\u0e51",
+		"\u0e50\u0e5212hello"},
+	{isUpper, "\u2C6F\u2C6F\u2C6F\u2C6FABCDhelloEF\u2C6F\u2C6FGH\u2C6F\u2C6F",
+		"hello",
+		"helloEF\u2C6F\u2C6FGH\u2C6F\u2C6F",
+		"\u2C6F\u2C6F\u2C6F\u2C6FABCDhello"},
+	{not(isSpace), "hello" + space + "hello",
+		space,
+		space + "hello",
+		"hello" + space},
+	{not(isDigit), "hello\u0e50\u0e521234\u0e50\u0e51helo",
+		"\u0e50\u0e521234\u0e50\u0e51",
+		"\u0e50\u0e521234\u0e50\u0e51helo",
+		"hello\u0e50\u0e521234\u0e50\u0e51"},
+	{isValidRune, "ab\xc0a\xc0cd",
+		"\xc0a\xc0",
+		"\xc0a\xc0cd",
+		"ab\xc0a\xc0"},
+	{not(isValidRune), "\xc0a\xc0",
+		"a",
+		"a\xc0",
+		"\xc0a"},
+	{isSpace, "",
+		"",
+		"",
+		""},
+	{isSpace, " ",
+		"",
+		"",
+		""},
 }
 
 func TestTrimFunc(t *testing.T) {
 	for _, tc := range trimFuncTests {
-		actual := TrimFunc(tc.in, tc.f.f)
+		trimmers := []struct {
-		if actual != tc.out {
+			name string
-			t.Errorf("TrimFunc(%q, %q) = %q; want %q", tc.in, tc.f.name, actual, tc.out)
+			trim func(s string, f func(r rune) bool) string
+			out  string
+		}{
+			{"TrimFunc", TrimFunc, tc.trimOut},
+			{"TrimLeftFunc", TrimLeftFunc, tc.leftOut},
+			{"TrimRightFunc", TrimRightFunc, tc.rightOut},
+		}
+		for _, trimmer := range trimmers {
+			actual := trimmer.trim(tc.in, tc.f.f)
+			if actual != trimmer.out {
+				t.Errorf("%s(%q, %q) = %q; want %q", trimmer.name, tc.in, tc.f.name, actual, trimmer.out)
+			}
 		}
 	}
 }