refactoring: make test clear

strutil/string_test.go

@@ -1,7 +1,6 @@
 package strutil
 
 import (
-	"reflect"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
@@ -12,19 +11,22 @@ func TestCamelCase(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestCamelCase")
 
-	cases := map[string]string{
+	tests := []struct {
-		"":                         "",
+		input    string
-		"foobar":                   "foobar",
+		expected string
-		"&FOO:BAR$BAZ":             "fooBarBaz",
+	}{
-		"fooBar":                   "fooBar",
+		{"", ""},
-		"FOObar":                   "foObar",
+		{"foobar", "foobar"},
-		"$foo%":                    "foo",
+		{"&FOO:BAR$BAZ", "fooBarBaz"},
-		"   $#$Foo   22    bar   ": "foo22Bar",
+		{"fooBar", "fooBar"},
-		"Foo-#1😄$_%^&*(1bar":       "foo11Bar",
+		{"FOObar", "foObar"},
+		{"$foo%", "foo"},
+		{"   $#$Foo   22    bar   ", "foo22Bar"},
+		{"Foo-#1😄$_%^&*(1bar", "foo11Bar"},
 	}
 
-	for k, v := range cases {
+	for _, tt := range tests {
-		assert.Equal(v, CamelCase(k))
+		assert.Equal(tt.expected, CamelCase(tt.input))
 	}
 }
 
@@ -33,19 +35,22 @@ func TestCapitalize(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestCapitalize")
 
-	cases := map[string]string{
+	tests := []struct {
-		"":        "",
+		input    string
-		"Foo":     "Foo",
+		expected string
-		"_foo":    "_foo",
+	}{
-		"foobar":  "Foobar",
+		{"", ""},
-		"fooBar":  "Foobar",
+		{"Foo", "Foo"},
-		"foo Bar": "Foo bar",
+		{"_foo", "_foo"},
-		"foo-bar": "Foo-bar",
+		{"foobar", "Foobar"},
-		"$foo%":   "$foo%",
+		{"fooBar", "Foobar"},
+		{"foo Bar", "Foo bar"},
+		{"foo-bar", "Foo-bar"},
+		{"$foo%", "$foo%"},
 	}
 
-	for k, v := range cases {
+	for _, tt := range tests {
-		assert.Equal(v, Capitalize(k))
+		assert.Equal(tt.expected, Capitalize(tt.input))
 	}
 }
 
@@ -54,23 +59,26 @@ func TestKebabCase(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestKebabCase")
 
-	cases := map[string]string{
+	tests := []struct {
-		"":                         "",
+		input    string
-		"foo-bar":                  "foo-bar",
+		expected string
-		"--Foo---Bar-":             "foo-bar",
+	}{
-		"Foo Bar-":                 "foo-bar",
+		{"", ""},
-		"foo_Bar":                  "foo-bar",
+		{"foo-bar", "foo-bar"},
-		"fooBar":                   "foo-bar",
+		{"--Foo---Bar-", "foo-bar"},
-		"FOOBAR":                   "foobar",
+		{"Foo Bar-", "foo-bar"},
-		"FOO_BAR":                  "foo-bar",
+		{"foo_Bar", "foo-bar"},
-		"__FOO_BAR__":              "foo-bar",
+		{"fooBar", "foo-bar"},
-		"$foo@Bar":                 "foo-bar",
+		{"FOOBAR", "foobar"},
-		"   $#$Foo   22    bar   ": "foo-22-bar",
+		{"FOO_BAR", "foo-bar"},
-		"Foo-#1😄$_%^&*(1bar":       "foo-1-1-bar",
+		{"__FOO_BAR__", "foo-bar"},
+		{"$foo@Bar", "foo-bar"},
+		{"   $#$Foo   22    bar   ", "foo-22-bar"},
+		{"Foo-#1😄$_%^&*(1bar", "foo-1-1-bar"},
 	}
 
-	for k, v := range cases {
+	for _, tt := range tests {
-		assert.Equal(v, KebabCase(k))
+		assert.Equal(tt.expected, KebabCase(tt.input))
 	}
 }
 
@@ -79,23 +87,26 @@ func TestUpperKebabCase(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestUpperKebabCase")
 
-	cases := map[string]string{
+	tests := []struct {
-		"":                         "",
+		input    string
-		"foo-bar":                  "FOO-BAR",
+		expected string
-		"--Foo---Bar-":             "FOO-BAR",
+	}{
-		"Foo Bar-":                 "FOO-BAR",
+		{"", ""},
-		"foo_Bar":                  "FOO-BAR",
+		{"foo-bar", "FOO-BAR"},
-		"fooBar":                   "FOO-BAR",
+		{"--Foo---Bar-", "FOO-BAR"},
-		"FOOBAR":                   "FOOBAR",
+		{"Foo Bar-", "FOO-BAR"},
-		"FOO_BAR":                  "FOO-BAR",
+		{"foo_Bar", "FOO-BAR"},
-		"__FOO_BAR__":              "FOO-BAR",
+		{"fooBar", "FOO-BAR"},
-		"$foo@Bar":                 "FOO-BAR",
+		{"FOOBAR", "FOOBAR"},
-		"   $#$Foo   22    bar   ": "FOO-22-BAR",
+		{"FOO_BAR", "FOO-BAR"},
-		"Foo-#1😄$_%^&*(1bar":       "FOO-1-1-BAR",
+		{"__FOO_BAR__", "FOO-BAR"},
+		{"$foo@Bar", "FOO-BAR"},
+		{"   $#$Foo   22    bar   ", "FOO-22-BAR"},
+		{"Foo-#1😄$_%^&*(1bar", "FOO-1-1-BAR"},
 	}
 
-	for k, v := range cases {
+	for _, tt := range tests {
-		assert.Equal(v, UpperKebabCase(k))
+		assert.Equal(tt.expected, UpperKebabCase(tt.input))
 	}
 }
 
@@ -104,23 +115,26 @@ func TestSnakeCase(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestSnakeCase")
 
-	cases := map[string]string{
+	tests := []struct {
-		"":                         "",
+		input    string
-		"foo-bar":                  "foo_bar",
+		expected string
-		"--Foo---Bar-":             "foo_bar",
+	}{
-		"Foo Bar-":                 "foo_bar",
+		{"", ""},
-		"foo_Bar":                  "foo_bar",
+		{"foo-bar", "foo_bar"},
-		"fooBar":                   "foo_bar",
+		{"--Foo---Bar-", "foo_bar"},
-		"FOOBAR":                   "foobar",
+		{"Foo Bar-", "foo_bar"},
-		"FOO_BAR":                  "foo_bar",
+		{"foo_Bar", "foo_bar"},
-		"__FOO_BAR__":              "foo_bar",
+		{"fooBar", "foo_bar"},
-		"$foo@Bar":                 "foo_bar",
+		{"FOOBAR", "foobar"},
-		"   $#$Foo   22    bar   ": "foo_22_bar",
+		{"FOO_BAR", "foo_bar"},
-		"Foo-#1😄$_%^&*(1bar":       "foo_1_1_bar",
+		{"__FOO_BAR__", "foo_bar"},
+		{"$foo@Bar", "foo_bar"},
+		{"   $#$Foo   22    bar   ", "foo_22_bar"},
+		{"Foo-#1😄$_%^&*(1bar", "foo_1_1_bar"},
 	}
 
-	for k, v := range cases {
+	for _, tt := range tests {
-		assert.Equal(v, SnakeCase(k))
+		assert.Equal(tt.expected, SnakeCase(tt.input))
 	}
 }
 
@@ -129,23 +143,26 @@ func TestUpperSnakeCase(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestUpperSnakeCase")
 
-	cases := map[string]string{
+	tests := []struct {
-		"":                         "",
+		input    string
-		"foo-bar":                  "FOO_BAR",
+		expected string
-		"--Foo---Bar-":             "FOO_BAR",
+	}{
-		"Foo Bar-":                 "FOO_BAR",
+		{"", ""},
-		"foo_Bar":                  "FOO_BAR",
+		{"foo-bar", "FOO_BAR"},
-		"fooBar":                   "FOO_BAR",
+		{"--Foo---Bar-", "FOO_BAR"},
-		"FOOBAR":                   "FOOBAR",
+		{"Foo Bar-", "FOO_BAR"},
-		"FOO_BAR":                  "FOO_BAR",
+		{"foo_Bar", "FOO_BAR"},
-		"__FOO_BAR__":              "FOO_BAR",
+		{"fooBar", "FOO_BAR"},
-		"$foo@Bar":                 "FOO_BAR",
+		{"FOOBAR", "FOOBAR"},
-		"   $#$Foo   22    bar   ": "FOO_22_BAR",
+		{"FOO_BAR", "FOO_BAR"},
-		"Foo-#1😄$_%^&*(1bar":       "FOO_1_1_BAR",
+		{"__FOO_BAR__", "FOO_BAR"},
+		{"$foo@Bar", "FOO_BAR"},
+		{"   $#$Foo   22    bar   ", "FOO_22_BAR"},
+		{"Foo-#1😄$_%^&*(1bar", "FOO_1_1_BAR"},
 	}
 
-	for k, v := range cases {
+	for _, tt := range tests {
-		assert.Equal(v, UpperSnakeCase(k))
+		assert.Equal(tt.expected, UpperSnakeCase(tt.input))
 	}
 }
 
@@ -154,16 +171,19 @@ func TestUpperFirst(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestLowerFirst")
 
-	cases := map[string]string{
+	tests := []struct {
-		"":     "",
+		input    string
-		"foo":  "Foo",
+		expected string
-		"bAR":  "BAR",
+	}{
-		"FOo":  "FOo",
+		{"", ""},
-		"fOo大": "FOo大",
+		{"foo", "Foo"},
+		{"bAR", "BAR"},
+		{"FOo", "FOo"},
+		{"fOo大", "FOo大"},
 	}
 
-	for k, v := range cases {
+	for _, tt := range tests {
-		assert.Equal(v, UpperFirst(k))
+		assert.Equal(tt.expected, UpperFirst(tt.input))
 	}
 }
 
@@ -172,16 +192,19 @@ func TestLowerFirst(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestLowerFirst")
 
-	cases := map[string]string{
+	tests := []struct {
-		"":     "",
+		input    string
-		"foo":  "foo",
+		expected string
-		"bAR":  "bAR",
+	}{
-		"FOo":  "fOo",
+		{"", ""},
-		"fOo大": "fOo大",
+		{"foo", "foo"},
+		{"bAR", "bAR"},
+		{"FOo", "fOo"},
+		{"fOo大", "fOo大"},
 	}
 
-	for k, v := range cases {
+	for _, tt := range tests {
-		assert.Equal(v, LowerFirst(k))
+		assert.Equal(tt.expected, LowerFirst(tt.input))
 	}
 }
 
@@ -190,23 +213,48 @@ func TestPad(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestPad")
 
-	assert.Equal("a ", Pad("a", 2, ""))
+	tests := []struct {
-	assert.Equal("a", Pad("a", 1, "b"))
+		input    string
-	assert.Equal("ab", Pad("a", 2, "b"))
+		padSize  int
-	assert.Equal("mabcdm", Pad("abcd", 6, "m"))
+		padChar  string
+		expected string
+	}{
+		{"", 0, "", ""},
+		{"a", 0, "", "a"},
+		{"a", 1, "", "a"},
+		{"a", 2, "", "a "},
+		{"a", 1, "b", "a"},
+		{"a", 2, "b", "ab"},
+		{"abcd", 6, "m", "mabcdm"},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.expected, Pad(tt.input, tt.padSize, tt.padChar))
+	}
 }
 
 func TestPadEnd(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPadEnd")
 
-	assert.Equal("a ", PadEnd("a", 2, " "))
+	tests := []struct {
-	assert.Equal("a", PadEnd("a", 1, "b"))
+		input    string
-	assert.Equal("ab", PadEnd("a", 2, "b"))
+		padSize  int
-	assert.Equal("abcdmn", PadEnd("abcd", 6, "mno"))
+		padChar  string
-	assert.Equal("abcdmm", PadEnd("abcd", 6, "m"))
+		expected string
-	assert.Equal("abcaba", PadEnd("abc", 6, "ab"))
+	}{
+		{"a", 2, " ", "a "},
+		{"a", 1, "b", "a"},
+		{"a", 2, "b", "ab"},
+		{"abcd", 6, "mno", "abcdmn"},
+		{"abcd", 6, "m", "abcdmm"},
+		{"abcd", 6, "ab", "abcdab"},
+	}
 
-	assert.NotEqual("ba", PadEnd("a", 2, "b"))
+	for _, tt := range tests {
+		assert.Equal(tt.expected, PadEnd(tt.input, tt.padSize, tt.padChar))
+	}
 }
 
 func TestPadStart(t *testing.T) {
@@ -214,13 +262,22 @@ func TestPadStart(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestPadStart")
 
-	assert.Equal("a", PadStart("a", 1, "b"))
+	tests := []struct {
-	assert.Equal("ba", PadStart("a", 2, "b"))
+		input    string
-	assert.Equal("mnabcd", PadStart("abcd", 6, "mno"))
+		padSize  int
-	assert.Equal("mmabcd", PadStart("abcd", 6, "m"))
+		padChar  string
-	assert.Equal("abaabc", PadStart("abc", 6, "ab"))
+		expected string
+	}{
+		{"a", 1, "b", "a"},
+		{"a", 2, "b", "ba"},
+		{"abcd", 6, "mno", "mnabcd"},
+		{"abcd", 6, "m", "mmabcd"},
+		{"abc", 6, "ab", "abaabc"},
+	}
 
-	assert.NotEqual("ab", PadStart("a", 2, "b"))
+	for _, tt := range tests {
+		assert.Equal(tt.expected, PadStart(tt.input, tt.padSize, tt.padChar))
+	}
 }
 
 func TestBefore(t *testing.T) {
@@ -228,12 +285,21 @@ func TestBefore(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestBefore")
 
-	assert.Equal("lancet", Before("lancet", ""))
+	tests := []struct {
-	assert.Equal("", Before("lancet", "lancet"))
+		input    string
-	assert.Equal("lancet", Before("lancet", "abcdef"))
+		char     string
+		expected string
+	}{
+		{"lancet", "", "lancet"},
+		{"lancet", "lancet", ""},
+		{"lancet", "abcdef", "lancet"},
+		{"github.com/test/lancet", "/", "github.com"},
+		{"github.com/test/lancet", "test", "github.com/"},
+	}
 
-	assert.Equal("github.com", Before("github.com/test/lancet", "/"))
+	for _, tt := range tests {
-	assert.Equal("github.com/", Before("github.com/test/lancet", "test"))
+		assert.Equal(tt.expected, Before(tt.input, tt.char))
+	}
 }
 
 func TestBeforeLast(t *testing.T) {
@@ -243,7 +309,6 @@ func TestBeforeLast(t *testing.T) {
 
 	assert.Equal("lancet", BeforeLast("lancet", ""))
 	assert.Equal("lancet", BeforeLast("lancet", "abcdef"))
-
 	assert.Equal("github.com/test", BeforeLast("github.com/test/lancet", "/"))
 	assert.Equal("github.com/test/", BeforeLast("github.com/test/test/lancet", "test"))
 }
@@ -257,7 +322,6 @@ func TestAfter(t *testing.T) {
 	assert.Equal("", After("lancet", "lancet"))
 	assert.Equal("test/lancet", After("github.com/test/lancet", "/"))
 	assert.Equal("/lancet", After("github.com/test/lancet", "test"))
-
 	assert.Equal("lancet", After("lancet", "abcdef"))
 }
 
@@ -403,10 +467,8 @@ func TestStringToBytes(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestStringToBytes")
 
-	str := "abc"
+	bytes := StringToBytes("abc")
-	bytes := StringToBytes(str)
+	assert.Equal(bytes, []byte{'a', 'b', 'c'})
-
-	assert.Equal(reflect.DeepEqual(bytes, []byte{'a', 'b', 'c'}), true)
 }
 
 func TestBytesToString(t *testing.T) {
@@ -414,16 +476,15 @@ func TestBytesToString(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestBytesToString")
 
-	bytes := []byte{'a', 'b', 'c'}
+	str := BytesToString([]byte{'a', 'b', 'c'})
-	str := BytesToString(bytes)
+	assert.Equal("abc", str)
-
-	assert.Equal(str == "abc", true)
 }
 
 func TestIsBlank(t *testing.T) {
 	t.Parallel()
 
 	assert := internal.NewAssert(t, "TestIsBlank")
+
 	assert.Equal(IsBlank(""), true)
 	assert.Equal(IsBlank("\t\v\f\n"), true)
 
@@ -434,6 +495,7 @@ func TestIsNotBlank(t *testing.T) {
 	t.Parallel()
 
 	assert := internal.NewAssert(t, "TestIsBlank")
+
 	assert.Equal(IsNotBlank(""), false)
 	assert.Equal(IsNotBlank("			"), false)
 	assert.Equal(IsNotBlank("\t\v\f\n"), false)
@@ -446,6 +508,7 @@ func TestHasPrefixAny(t *testing.T) {
 	t.Parallel()
 
 	assert := internal.NewAssert(t, "TestHasPrefixAny")
+
 	str := "foo bar"
 	prefixes := []string{"fo", "xyz", "hello"}
 	notMatches := []string{"oom", "world"}
@@ -458,6 +521,7 @@ func TestHasSuffixAny(t *testing.T) {
 	t.Parallel()
 
 	assert := internal.NewAssert(t, "TestHasSuffixAny")
+
 	str := "foo bar"
 	suffixes := []string{"bar", "xyz", "hello"}
 	notMatches := []string{"oom", "world"}
@@ -503,6 +567,7 @@ func TestTrim(t *testing.T) {
 
 	assert.Equal("$ ab	cd $", Trim(str1))
 	assert.Equal("ab	cd", Trim(str1, "$"))
+
 	assert.Equal("abcd", Trim("\nabcd"))
 }
 
@@ -525,19 +590,27 @@ func TestHideString(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestTrim")
 
-	str := "13242658976"
+	tests := []struct {
+		input        string
+		start        int
+		end          int
+		replacedChar string
+		expected     string
+	}{
+		{"13242658976", 0, -1, "*", "13242658976"},
+		{"13242658976", 0, 0, "*", "13242658976"},
+		{"13242658976", 0, 4, "*", "****2658976"},
+		{"13242658976", 3, 3, "*", "13242658976"},
+		{"13242658976", 3, 4, "*", "132*2658976"},
+		{"13242658976", 3, 7, "*", "132****8976"},
+		{"13242658976", 3, 11, "*", "132********"},
+		{"13242658976", 7, 100, "*", "1324265****"},
+		{"13242658976", 100, 100, "*", "13242658976"},
+	}
 
-	assert.Equal("13242658976", HideString(str, 0, -1, "*"))
+	for _, tt := range tests {
-	assert.Equal("13242658976", HideString(str, 0, 0, "*"))
+		assert.Equal(tt.expected, HideString(tt.input, tt.start, tt.end, tt.replacedChar))
-	assert.Equal("****2658976", HideString(str, 0, 4, "*"))
+	}
-
-	assert.Equal("13242658976", HideString(str, 3, 3, "*"))
-	assert.Equal("132*2658976", HideString(str, 3, 4, "*"))
-	assert.Equal("132****8976", HideString(str, 3, 7, "*"))
-	assert.Equal("1324265****", HideString(str, 7, 11, "*"))
-
-	assert.Equal("1324265****", HideString(str, 7, 100, "*"))
-	assert.Equal("13242658976", HideString(str, 100, 100, "*"))
 }
 
 func TestContainsAll(t *testing.T) {
@@ -593,23 +666,34 @@ func TestHammingDistance(t *testing.T) {
 		return c
 	}
 
-	assert.Equal(0, hd(" ", " "))
+	tests := []struct {
-	assert.Equal(1, hd(" ", "c"))
+		strA            string
-	assert.Equal(1, hd("a", "d"))
+		strB            string
-	assert.Equal(1, hd("a", " "))
+		hammingDistance int
-	assert.Equal(1, hd("a", "f"))
+	}{
+		{" ", " ", 0},
+		{" ", "c", 1},
+		{"a", "d", 1},
+		{"a", " ", 1},
+		{"a", "f", 1},
 
-	assert.Equal(0, hd("", ""))
+		{"", "", 0},
-	assert.Equal(-1, hd("abc", "ab"))
+		{"abc", "ab", -1},
-	assert.Equal(3, hd("abc", "def"))
+		{"abc", "def", 3},
-	assert.Equal(-1, hd("kitten", "sitting"))
+		{"kitten", "sitting", -1},
-	assert.Equal(1, hd("ö", "ü"))
+		{"ö", "ü", 1},
-	assert.Equal(0, hd("日本語", "日本語"))
+		{"日本語", "日本語", 0},
-	assert.Equal(3, hd("日本語", "語日本"))
+		{"日本語", "語日本", 3},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(tt.hammingDistance, hd(tt.strA, tt.strB))
+	}
 }
 
 func TestConcat(t *testing.T) {
 	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestConcat")
 
 	assert.Equal("", Concat(0))