code review 1704044: strings and bytes.Split: make count of 0 mean 0, not in...

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 193 matching lines @@
         buf[n-1] = '0'
 }
 
 type ExplodeTest struct {
         s string
         n int
         a []string
 }
 
 var explodetests = []ExplodeTest{
-        ExplodeTest{abcd, 0, []string{"a", "b", "c", "d"}},
-        ExplodeTest{faces, 0, []string{"☺", "☻", "☹"}},
+        ExplodeTest{abcd, -1, []string{"a", "b", "c", "d"}},
+        ExplodeTest{faces, -1, []string{"☺", "☻", "☹"}},
         ExplodeTest{abcd, 2, []string{"a", "bcd"}},
 }
 
 func TestExplode(t *testing.T) {
         for _, tt := range explodetests {
                 a := Split([]byte(tt.s), nil, tt.n)
                 result := arrayOfString(a)
                 if !eq(result, tt.a) {
                         t.Errorf(`Explode("%s", %d) = %v; want %v`, tt.s, tt.n, result, tt.a)
                         continue
                 }
                 s := Join(a, []byte{})
                 if string(s) != tt.s {
                         t.Errorf(`Join(Explode("%s", %d), "") = "%s"`, tt.s, tt.n, s)
                 }
         }
 }
 
 
 type SplitTest struct {
         s   string
         sep string
         n   int
         a   []string
 }
 
 var splittests = []SplitTest{
-        SplitTest{abcd, "a", 0, []string{"", "bcd"}},
-        SplitTest{abcd, "z", 0, []string{"abcd"}},
-        SplitTest{abcd, "", 0, []string{"a", "b", "c", "d"}},
-        SplitTest{commas, ",", 0, []string{"1", "2", "3", "4"}},
-        SplitTest{dots, "...", 0, []string{"1", ".2", ".3", ".4"}},
-        SplitTest{faces, "☹", 0, []string{"☺☻", ""}},
-        SplitTest{faces, "~", 0, []string{faces}},
-        SplitTest{faces, "", 0, []string{"☺", "☻", "☹"}},
+        SplitTest{abcd, "a", 0, nil},
+        SplitTest{abcd, "a", -1, []string{"", "bcd"}},
+        SplitTest{abcd, "z", -1, []string{"abcd"}},
+        SplitTest{abcd, "", -1, []string{"a", "b", "c", "d"}},
+        SplitTest{commas, ",", -1, []string{"1", "2", "3", "4"}},
+        SplitTest{dots, "...", -1, []string{"1", ".2", ".3", ".4"}},
+        SplitTest{faces, "☹", -1, []string{"☺☻", ""}},
+        SplitTest{faces, "~", -1, []string{faces}},
+        SplitTest{faces, "", -1, []string{"☺", "☻", "☹"}},
         SplitTest{"1 2 3 4", " ", 3, []string{"1", "2", "3 4"}},
-        SplitTest{"1 2 3", " ", 3, []string{"1", "2", "3"}},
         SplitTest{"1 2", " ", 3, []string{"1", "2"}},
         SplitTest{"123", "", 2, []string{"1", "23"}},
         SplitTest{"123", "", 17, []string{"1", "2", "3"}},
 }
 
 func TestSplit(t *testing.T) {
         for _, tt := range splittests {
                 a := Split([]byte(tt.s), []byte(tt.sep), tt.n)
                 result := arrayOfString(a)
                 if !eq(result, tt.a) {
                         t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, result, tt.a)
                         continue
                 }
+                if tt.n == 0 {
+                        continue
+                }
                 s := Join(a, []byte(tt.sep))
                 if string(s) != tt.s {
                         t.Errorf(`Join(Split(%q, %q, %d), %q) = %q`, tt.s, tt.sep, tt.n, tt.sep, s)
                 }
         }
 }
 
 var splitaftertests = []SplitTest{
-        SplitTest{abcd, "a", 0, []string{"a", "bcd"}},
-        SplitTest{abcd, "z", 0, []string{"abcd"}},
-        SplitTest{abcd, "", 0, []string{"a", "b", "c", "d"}},
-        SplitTest{commas, ",", 0, []string{"1,", "2,", "3,", "4"}},
-        SplitTest{dots, "...", 0, []string{"1...", ".2...", ".3...", ".4"}},
-        SplitTest{faces, "☹", 0, []string{"☺☻☹", ""}},
-        SplitTest{faces, "~", 0, []string{faces}},
-        SplitTest{faces, "", 0, []string{"☺", "☻", "☹"}},
+        SplitTest{abcd, "a", -1, []string{"a", "bcd"}},
+        SplitTest{abcd, "z", -1, []string{"abcd"}},
+        SplitTest{abcd, "", -1, []string{"a", "b", "c", "d"}},
+        SplitTest{commas, ",", -1, []string{"1,", "2,", "3,", "4"}},
+        SplitTest{dots, "...", -1, []string{"1...", ".2...", ".3...", ".4"}},
+        SplitTest{faces, "☹", -1, []string{"☺☻☹", ""}},
+        SplitTest{faces, "~", -1, []string{faces}},
+        SplitTest{faces, "", -1, []string{"☺", "☻", "☹"}},
         SplitTest{"1 2 3 4", " ", 3, []string{"1 ", "2 ", "3 4"}},
         SplitTest{"1 2 3", " ", 3, []string{"1 ", "2 ", "3"}},
         SplitTest{"1 2", " ", 3, []string{"1 ", "2"}},
         SplitTest{"123", "", 2, []string{"1", "23"}},
         SplitTest{"123", "", 17, []string{"1", "2", "3"}},
 }
 
 func TestSplitAfter(t *testing.T) {
         for _, tt := range splitaftertests {
                 a := SplitAfter([]byte(tt.s), []byte(tt.sep), tt.n)
@@ skipping 355 matching lines @@
 }
 
 type ReplaceTest struct {
         in       string
         old, new string
         n        int
         out      string
 }
 
 var ReplaceTests = []ReplaceTest{
-        ReplaceTest{"hello", "l", "L", 0, "heLLo"},
-        ReplaceTest{"hello", "x", "X", 0, "hello"},
-        ReplaceTest{"", "x", "X", 0, ""},
-        ReplaceTest{"radar", "r", "<r>", 0, "<r>ada<r>"},
-        ReplaceTest{"", "", "<>", 0, "<>"},
-        ReplaceTest{"banana", "a", "<>", 0, "b<>n<>n<>"},
+        ReplaceTest{"hello", "l", "L", 0, "hello"},
+        ReplaceTest{"hello", "l", "L", -1, "heLLo"},
+        ReplaceTest{"hello", "x", "X", -1, "hello"},
+        ReplaceTest{"", "x", "X", -1, ""},
+        ReplaceTest{"radar", "r", "<r>", -1, "<r>ada<r>"},
+        ReplaceTest{"", "", "<>", -1, "<>"},
+        ReplaceTest{"banana", "a", "<>", -1, "b<>n<>n<>"},
         ReplaceTest{"banana", "a", "<>", 1, "b<>nana"},
         ReplaceTest{"banana", "a", "<>", 1000, "b<>n<>n<>"},
-        ReplaceTest{"banana", "an", "<>", 0, "b<><>a"},
-        ReplaceTest{"banana", "ana", "<>", 0, "b<>na"},
-        ReplaceTest{"banana", "", "<>", 0, "<>b<>a<>n<>a<>n<>a<>"},
+        ReplaceTest{"banana", "an", "<>", -1, "b<><>a"},
+        ReplaceTest{"banana", "ana", "<>", -1, "b<>na"},
+        ReplaceTest{"banana", "", "<>", -1, "<>b<>a<>n<>a<>n<>a<>"},
         ReplaceTest{"banana", "", "<>", 10, "<>b<>a<>n<>a<>n<>a<>"},
         ReplaceTest{"banana", "", "<>", 6, "<>b<>a<>n<>a<>n<>a"},
         ReplaceTest{"banana", "", "<>", 5, "<>b<>a<>n<>a<>na"},
         ReplaceTest{"banana", "", "<>", 1, "<>banana"},
-        ReplaceTest{"banana", "a", "a", 0, "banana"},
+        ReplaceTest{"banana", "a", "a", -1, "banana"},
         ReplaceTest{"banana", "a", "a", 1, "banana"},
-        ReplaceTest{"☺☻☹", "", "<>", 0, "<>☺<>☻<>☹<>"},
+        ReplaceTest{"☺☻☹", "", "<>", -1, "<>☺<>☻<>☹<>"},
 }
 
 func TestReplace(t *testing.T) {
         for _, tt := range ReplaceTests {
                 if s := string(Replace([]byte(tt.in), []byte(tt.old), []byte(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)
                 }
         }
 }