zishuo/lo
1
0
Fork 0
mirror of https://github.com/samber/lo.git synced 2025-09-26 20:11:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

lint: unit test improvements (#674)

Browse Source 
* lint: pin golangci-lint version

* lint: use is.Empty where possible

* lint: use is.ElementsMatch for unsorted slices

* lint: remove redundant is.Len assertions

* lint: use is.Zero to assert zero structs

* fix: misc assertion issues

* lint: more consistent test case pattern

* fix: reversed expect/actual assert values

* lint: use is.ErrorIs and is.EqualError for errors

* Update golangci-lint version in workflow

---------

Co-authored-by: Samuel Berthe <dev@samuel-berthe.fr>
This commit is contained in:
Nathan Baulch
2025-09-25 05:02:52 +10:00
committed by GitHub
parent b5e290abe0
commit 7170719ec0
11 changed files with 275 additions and 405 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
channel_test.go
View File

@@ -275,7 +275,7 @@ func TestBuffer(t *testing.T) {
is.Equal([]int{3}, items2) is.Equal([]int{3}, items2)
is.Equal(1, length2) is.Equal(1, length2)
is.False(ok2) is.False(ok2)
is.Equal([]int{}, items3) is.Empty(items3)
is.Zero(length3) is.Zero(length3)
is.False(ok3) is.False(ok3)
} }
@@ -335,7 +335,7 @@ func TestBufferWithTimeout(t *testing.T) {
is.True(ok1) is.True(ok1)
items2, length2, _, ok2 := BufferWithTimeout(ch, 20, 2*time.Millisecond) items2, length2, _, ok2 := BufferWithTimeout(ch, 20, 2*time.Millisecond)
is.Equal([]int{}, items2) is.Empty(items2)
is.Zero(length2) is.Zero(length2)
is.True(ok2) is.True(ok2)
@@ -350,7 +350,7 @@ func TestBufferWithTimeout(t *testing.T) {
is.True(ok4) is.True(ok4)
items5, length5, _, ok5 := BufferWithTimeout(ch, 3, 25*time.Millisecond) items5, length5, _, ok5 := BufferWithTimeout(ch, 3, 25*time.Millisecond)
is.Equal([]int{}, items5) is.Empty(items5)
is.Zero(length5) is.Zero(length5)
is.False(ok5) is.False(ok5)
} }

97
find_test.go
View File

@@ -1,9 +1,7 @@
package lo package lo
import ( import (
"fmt"
"math/rand" "math/rand"
"sort"
"testing" "testing"
"time" "time"
@@ -74,7 +72,7 @@ func TestFindIndexOf(t *testing.T) {
is.Equal(1, index1) is.Equal(1, index1)
is.Empty(item2) is.Empty(item2)
is.False(ok2) is.False(ok2)
is.Equal(index2, -1) is.Equal(-1, index2)
} }
func TestFindLastIndexOf(t *testing.T) { func TestFindLastIndexOf(t *testing.T) {
@@ -97,7 +95,7 @@ func TestFindLastIndexOf(t *testing.T) {
is.Equal(4, index1) is.Equal(4, index1)
is.Empty(item2) is.Empty(item2)
is.False(ok2) is.False(ok2)
is.Equal(index2, -1) is.Equal(-1, index2)
} }
func TestFindOrElse(t *testing.T) { func TestFindOrElse(t *testing.T) {
@@ -166,24 +164,16 @@ func TestFindUniques(t *testing.T) {
is := assert.New(t) is := assert.New(t)
result1 := FindUniques([]int{1, 2, 3}) result1 := FindUniques([]int{1, 2, 3})
is.Len(result1, 3)
is.Equal([]int{1, 2, 3}, result1) is.Equal([]int{1, 2, 3}, result1)
result2 := FindUniques([]int{1, 2, 2, 3, 1, 2}) result2 := FindUniques([]int{1, 2, 2, 3, 1, 2})
is.Len(result2, 1)
is.Equal([]int{3}, result2) is.Equal([]int{3}, result2)
result3 := FindUniques([]int{1, 2, 2, 1}) result3 := FindUniques([]int{1, 2, 2, 1})
is.Empty(result3) is.Empty(result3)
is.Equal([]int{}, result3)
result4 := FindUniques([]int{}) result4 := FindUniques([]int{})
is.Empty(result4) is.Empty(result4)
is.Equal([]int{}, result4)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -198,30 +188,22 @@ func TestFindUniquesBy(t *testing.T) {
result1 := FindUniquesBy([]int{0, 1, 2}, func(i int) int { result1 := FindUniquesBy([]int{0, 1, 2}, func(i int) int {
return i % 3 return i % 3
}) })
is.Len(result1, 3)
is.Equal([]int{0, 1, 2}, result1) is.Equal([]int{0, 1, 2}, result1)
result2 := FindUniquesBy([]int{0, 1, 2, 3, 4}, func(i int) int { result2 := FindUniquesBy([]int{0, 1, 2, 3, 4}, func(i int) int {
return i % 3 return i % 3
}) })
is.Len(result2, 1)
is.Equal([]int{2}, result2) is.Equal([]int{2}, result2)
result3 := FindUniquesBy([]int{0, 1, 2, 3, 4, 5}, func(i int) int { result3 := FindUniquesBy([]int{0, 1, 2, 3, 4, 5}, func(i int) int {
return i % 3 return i % 3
}) })
is.Empty(result3) is.Empty(result3)
is.Equal([]int{}, result3)
result4 := FindUniquesBy([]int{}, func(i int) int { result4 := FindUniquesBy([]int{}, func(i int) int {
return i % 3 return i % 3
}) })
is.Empty(result4) is.Empty(result4)
is.Equal([]int{}, result4)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -236,19 +218,13 @@ func TestFindDuplicates(t *testing.T) {
is := assert.New(t) is := assert.New(t)
result1 := FindDuplicates([]int{1, 2, 2, 1, 2, 3}) result1 := FindDuplicates([]int{1, 2, 2, 1, 2, 3})
is.Len(result1, 2)
is.Equal([]int{1, 2}, result1) is.Equal([]int{1, 2}, result1)
result2 := FindDuplicates([]int{1, 2, 3}) result2 := FindDuplicates([]int{1, 2, 3})
is.Empty(result2) is.Empty(result2)
is.Equal([]int{}, result2)
result3 := FindDuplicates([]int{}) result3 := FindDuplicates([]int{})
is.Empty(result3) is.Empty(result3)
is.Equal([]int{}, result3)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -263,23 +239,17 @@ func TestFindDuplicatesBy(t *testing.T) {
result1 := FindDuplicatesBy([]int{3, 4, 5, 6, 7}, func(i int) int { result1 := FindDuplicatesBy([]int{3, 4, 5, 6, 7}, func(i int) int {
return i % 3 return i % 3
}) })
is.Len(result1, 2)
is.Equal([]int{3, 4}, result1) is.Equal([]int{3, 4}, result1)
result2 := FindDuplicatesBy([]int{0, 1, 2, 3, 4}, func(i int) int { result2 := FindDuplicatesBy([]int{0, 1, 2, 3, 4}, func(i int) int {
return i % 5 return i % 5
}) })
is.Empty(result2) is.Empty(result2)
is.Equal([]int{}, result2)
result3 := FindDuplicatesBy([]int{}, func(i int) int { result3 := FindDuplicatesBy([]int{}, func(i int) int {
return i % 3 return i % 3
}) })
is.Empty(result3) is.Empty(result3)
is.Equal([]int{}, result3)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -323,7 +293,7 @@ func TestMinIndex(t *testing.T) {
is.Zero(index3) is.Zero(index3)
is.Zero(result4) is.Zero(result4)
is.Equal(index4, -1) is.Equal(-1, index4)
} }
func TestMinBy(t *testing.T) { func TestMinBy(t *testing.T) {
@@ -366,7 +336,7 @@ func TestMinIndexBy(t *testing.T) {
is.Equal(2, index2) is.Equal(2, index2)
is.Empty(result3) is.Empty(result3)
is.Equal(index3, -1) is.Equal(-1, index3)
} }
func TestEarliest(t *testing.T) { func TestEarliest(t *testing.T) {
@@ -379,7 +349,7 @@ func TestEarliest(t *testing.T) {
result2 := Earliest() result2 := Earliest()
is.Equal(a, result1) is.Equal(a, result1)
is.Equal(time.Time{}, result2) is.Zero(result2)
} }
func TestEarliestBy(t *testing.T) { func TestEarliestBy(t *testing.T) {
@@ -405,7 +375,7 @@ func TestEarliestBy(t *testing.T) {
is.Equal(foo{t3}, result1) is.Equal(foo{t3}, result1)
is.Equal(foo{t1}, result2) is.Equal(foo{t1}, result2)
is.Equal(foo{}, result3) is.Zero(result3)
} }
func TestMax(t *testing.T) { func TestMax(t *testing.T) {
@@ -442,7 +412,7 @@ func TestMaxIndex(t *testing.T) {
is.Equal(2, index3) is.Equal(2, index3)
is.Zero(result4) is.Zero(result4)
is.Equal(index4, -1) is.Equal(-1, index4)
} }
func TestMaxBy(t *testing.T) { func TestMaxBy(t *testing.T) {
@@ -485,7 +455,7 @@ func TestMaxIndexBy(t *testing.T) {
is.Zero(index2) is.Zero(index2)
is.Empty(result3) is.Empty(result3)
is.Equal(index3, -1) is.Equal(-1, index3)
} }
func TestLatest(t *testing.T) { func TestLatest(t *testing.T) {
@@ -498,7 +468,7 @@ func TestLatest(t *testing.T) {
result2 := Latest() result2 := Latest()
is.Equal(b, result1) is.Equal(b, result1)
is.Equal(time.Time{}, result2) is.Zero(result2)
} }
func TestLatestBy(t *testing.T) { func TestLatestBy(t *testing.T) {
@@ -524,7 +494,7 @@ func TestLatestBy(t *testing.T) {
is.Equal(foo{t2}, result1) is.Equal(foo{t2}, result1)
is.Equal(foo{t1}, result2) is.Equal(foo{t1}, result2)
is.Equal(foo{}, result3) is.Zero(result3)
} }
func TestFirst(t *testing.T) { func TestFirst(t *testing.T) {
@@ -621,9 +591,9 @@ func TestNth(t *testing.T) {
is.Equal(2, result2) is.Equal(2, result2)
is.NoError(err2) is.NoError(err2)
is.Zero(result3) is.Zero(result3)
is.Equal(err3, fmt.Errorf("nth: 42 out of slice bounds")) is.EqualError(err3, "nth: 42 out of slice bounds")
is.Zero(result4) is.Zero(result4)
is.Equal(err4, fmt.Errorf("nth: 0 out of slice bounds")) is.EqualError(err4, "nth: 0 out of slice bounds")
is.Equal(42, result5) is.Equal(42, result5)
is.NoError(err5) is.NoError(err5)
is.Equal(42, result6) is.Equal(42, result6)
@@ -631,9 +601,10 @@ func TestNth(t *testing.T) {
} }
func TestNthOr(t *testing.T) { func TestNthOr(t *testing.T) {
t.Parallel()
is := assert.New(t)
t.Run("Integers", func(t *testing.T) { t.Run("Integers", func(t *testing.T) {
t.Parallel()
is := assert.New(t)
const defaultValue = -1 const defaultValue = -1
intSlice := []int{10, 20, 30, 40, 50} intSlice := []int{10, 20, 30, 40, 50}
@@ -643,6 +614,9 @@ func TestNthOr(t *testing.T) {
}) })
t.Run("Strings", func(t *testing.T) { t.Run("Strings", func(t *testing.T) {
t.Parallel()
is := assert.New(t)
const defaultValue = "none" const defaultValue = "none"
strSlice := []string{"apple", "banana", "cherry", "date"} strSlice := []string{"apple", "banana", "cherry", "date"}
@@ -652,6 +626,9 @@ func TestNthOr(t *testing.T) {
}) })
t.Run("Structs", func(t *testing.T) { t.Run("Structs", func(t *testing.T) {
t.Parallel()
is := assert.New(t)
type User struct { type User struct {
ID int ID int
Name string Name string
@@ -674,27 +651,32 @@ func TestNthOr(t *testing.T) {
} }
func TestNthOrEmpty(t *testing.T) { func TestNthOrEmpty(t *testing.T) {
t.Parallel()
is := assert.New(t)
t.Run("Integers", func(t *testing.T) { t.Run("Integers", func(t *testing.T) {
const defaultValue = 0 t.Parallel()
is := assert.New(t)
intSlice := []int{10, 20, 30, 40, 50} intSlice := []int{10, 20, 30, 40, 50}
is.Equal(30, NthOrEmpty(intSlice, 2)) is.Equal(30, NthOrEmpty(intSlice, 2))
is.Equal(50, NthOrEmpty(intSlice, -1)) is.Equal(50, NthOrEmpty(intSlice, -1))
is.Equal(defaultValue, NthOrEmpty(intSlice, 10)) is.Zero(NthOrEmpty(intSlice, 10))
}) })
t.Run("Strings", func(t *testing.T) { t.Run("Strings", func(t *testing.T) {
const defaultValue = "" t.Parallel()
is := assert.New(t)
strSlice := []string{"apple", "banana", "cherry", "date"} strSlice := []string{"apple", "banana", "cherry", "date"}
is.Equal("banana", NthOrEmpty(strSlice, 1)) is.Equal("banana", NthOrEmpty(strSlice, 1))
is.Equal("cherry", NthOrEmpty(strSlice, -2)) is.Equal("cherry", NthOrEmpty(strSlice, -2))
is.Equal(defaultValue, NthOrEmpty(strSlice, 10)) is.Empty(NthOrEmpty(strSlice, 10))
}) })
t.Run("Structs", func(t *testing.T) { t.Run("Structs", func(t *testing.T) {
t.Parallel()
is := assert.New(t)
type User struct { type User struct {
ID int ID int
Name string Name string
@@ -711,8 +693,7 @@ func TestNthOrEmpty(t *testing.T) {
expectedUser = User{ID: 3, Name: "Charlie"} expectedUser = User{ID: 3, Name: "Charlie"}
is.Equal(expectedUser, NthOrEmpty(userSlice, -1)) is.Equal(expectedUser, NthOrEmpty(userSlice, -1))
expectedUser = User{ID: 0, Name: ""} is.Zero(NthOrEmpty(userSlice, 10))
is.Equal(expectedUser, NthOrEmpty(userSlice, 10))
}) })
} }
@@ -751,10 +732,8 @@ func TestSamples(t *testing.T) {
result1 := Samples([]string{"a", "b", "c"}, 3) result1 := Samples([]string{"a", "b", "c"}, 3)
result2 := Samples([]string{}, 3) result2 := Samples([]string{}, 3)
sort.Strings(result1) is.ElementsMatch(result1, []string{"a", "b", "c"})
is.Empty(result2)
is.Equal([]string{"a", "b", "c"}, result1)
is.Equal([]string{}, result2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -771,10 +750,8 @@ func TestSamplesBy(t *testing.T) {
result1 := SamplesBy([]string{"a", "b", "c"}, 3, r.Intn) result1 := SamplesBy([]string{"a", "b", "c"}, 3, r.Intn)
result2 := SamplesBy([]string{}, 3, r.Intn) result2 := SamplesBy([]string{}, 3, r.Intn)
sort.Strings(result1) is.ElementsMatch(result1, []string{"a", "b", "c"})
is.Empty(result2)
is.Equal([]string{"a", "b", "c"}, result1)
is.Equal([]string{}, result2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}

24
intersect_test.go
View File

@@ -184,7 +184,7 @@ func TestIntersect(t *testing.T) {
is.Equal([]int{0, 2}, result1) is.Equal([]int{0, 2}, result1)
is.Equal([]int{0}, result2) is.Equal([]int{0}, result2)
is.Equal([]int{}, result3) is.Empty(result3)
is.Equal([]int{0}, result4) is.Equal([]int{0}, result4)
is.Equal([]int{0}, result5) is.Equal([]int{0}, result5)
@@ -207,8 +207,8 @@ func TestDifference(t *testing.T) {
is.Equal([]int{0, 6}, right2) is.Equal([]int{0, 6}, right2)
left3, right3 := Difference([]int{0, 1, 2, 3, 4, 5}, []int{0, 1, 2, 3, 4, 5}) left3, right3 := Difference([]int{0, 1, 2, 3, 4, 5}, []int{0, 1, 2, 3, 4, 5})
is.Equal([]int{}, left3) is.Empty(left3)
is.Equal([]int{}, right3) is.Empty(right3)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -232,7 +232,7 @@ func TestUnion(t *testing.T) {
is.Equal([]int{0, 1, 2, 3, 4, 5}, result3) is.Equal([]int{0, 1, 2, 3, 4, 5}, result3)
is.Equal([]int{0, 1, 2, 3}, result4) is.Equal([]int{0, 1, 2, 3}, result4)
is.Equal([]int{0, 1, 2}, result5) is.Equal([]int{0, 1, 2}, result5)
is.Equal([]int{}, result6) is.Empty(result6)
result11 := Union([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 10}, []int{0, 1, 11}) result11 := Union([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 10}, []int{0, 1, 11})
result12 := Union([]int{0, 1, 2, 3, 4, 5}, []int{6, 7}, []int{8, 9}) result12 := Union([]int{0, 1, 2, 3, 4, 5}, []int{6, 7}, []int{8, 9})
@@ -243,7 +243,7 @@ func TestUnion(t *testing.T) {
is.Equal([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, result12) is.Equal([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, result12)
is.Equal([]int{0, 1, 2, 3, 4, 5}, result13) is.Equal([]int{0, 1, 2, 3, 4, 5}, result13)
is.Equal([]int{0, 1, 2}, result14) is.Equal([]int{0, 1, 2}, result14)
is.Equal([]int{}, result15) is.Empty(result15)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -262,9 +262,9 @@ func TestWithout(t *testing.T) {
result5 := Without([]int{}) result5 := Without([]int{})
is.Equal([]int{10}, result1) is.Equal([]int{10}, result1)
is.Equal([]int{7}, result2) is.Equal([]int{7}, result2)
is.Equal([]int{}, result3) is.Empty(result3)
is.Equal([]int{}, result4) is.Empty(result4)
is.Equal([]int{}, result5) is.Empty(result5)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -288,8 +288,8 @@ func TestWithoutBy(t *testing.T) {
result2 := WithoutBy([]User{}, func(item User) int { return item.Age }, 1, 2, 3) result2 := WithoutBy([]User{}, func(item User) int { return item.Age }, 1, 2, 3)
result3 := WithoutBy([]User{}, func(item User) string { return item.Name }) result3 := WithoutBy([]User{}, func(item User) string { return item.Name })
is.Equal([]User{{Name: "peter"}}, result1) is.Equal([]User{{Name: "peter"}}, result1)
is.Equal([]User{}, result2) is.Empty(result2)
is.Equal([]User{}, result3) is.Empty(result3)
} }
func TestWithoutEmpty(t *testing.T) { func TestWithoutEmpty(t *testing.T) {
@@ -302,7 +302,7 @@ func TestWithoutEmpty(t *testing.T) {
result4 := WithoutEmpty([]*int{ToPtr(0), ToPtr(1), nil, ToPtr(2)}) result4 := WithoutEmpty([]*int{ToPtr(0), ToPtr(1), nil, ToPtr(2)})
is.Equal([]int{1, 2}, result1) is.Equal([]int{1, 2}, result1)
is.Equal([]int{1, 2}, result2) is.Equal([]int{1, 2}, result2)
is.Equal([]int{}, result3) is.Empty(result3)
is.Equal([]*int{ToPtr(0), ToPtr(1), ToPtr(2)}, result4) is.Equal([]*int{ToPtr(0), ToPtr(1), ToPtr(2)}, result4)
type myStrings []string type myStrings []string
@@ -322,7 +322,7 @@ func TestWithoutNth(t *testing.T) {
is.Equal([]int{1, 2}, result2) is.Equal([]int{1, 2}, result2)
result3 := WithoutNth([]int{}) result3 := WithoutNth([]int{})
is.Equal([]int{}, result3) is.Empty(result3)
result4 := WithoutNth([]int{0, 1, 2, 3}, -1, 4) result4 := WithoutNth([]int{0, 1, 2, 3}, -1, 4)
is.Equal([]int{0, 1, 2, 3}, result4) is.Equal([]int{0, 1, 2, 3}, result4)

102
map_test.go
View File

@@ -2,7 +2,6 @@ package lo
import ( import (
"fmt" "fmt"
"sort"
"strconv" "strconv"
"testing" "testing"
@@ -14,22 +13,19 @@ func TestKeys(t *testing.T) {
is := assert.New(t) is := assert.New(t)
r1 := Keys(map[string]int{"foo": 1, "bar": 2}) r1 := Keys(map[string]int{"foo": 1, "bar": 2})
sort.Strings(r1) is.ElementsMatch(r1, []string{"bar", "foo"})
is.Equal([]string{"bar", "foo"}, r1)
r2 := Keys(map[string]int{}) r2 := Keys(map[string]int{})
is.Empty(r2) is.Empty(r2)
r3 := Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3}) r3 := Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
sort.Strings(r3) is.ElementsMatch(r3, []string{"bar", "baz", "foo"})
is.Equal([]string{"bar", "baz", "foo"}, r3)
r4 := Keys[string, int]() r4 := Keys[string, int]()
is.Equal([]string{}, r4) is.Empty(r4)
r5 := Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 3}) r5 := Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 3})
sort.Strings(r5) is.ElementsMatch(r5, []string{"bar", "bar", "foo"})
is.Equal([]string{"bar", "bar", "foo"}, r5)
} }
func TestUniqKeys(t *testing.T) { func TestUniqKeys(t *testing.T) {
@@ -37,22 +33,19 @@ func TestUniqKeys(t *testing.T) {
is := assert.New(t) is := assert.New(t)
r1 := UniqKeys(map[string]int{"foo": 1, "bar": 2}) r1 := UniqKeys(map[string]int{"foo": 1, "bar": 2})
sort.Strings(r1) is.ElementsMatch(r1, []string{"bar", "foo"})
is.Equal([]string{"bar", "foo"}, r1)
r2 := UniqKeys(map[string]int{}) r2 := UniqKeys(map[string]int{})
is.Empty(r2) is.Empty(r2)
r3 := UniqKeys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3}) r3 := UniqKeys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
sort.Strings(r3) is.ElementsMatch(r3, []string{"bar", "baz", "foo"})
is.Equal([]string{"bar", "baz", "foo"}, r3)
r4 := UniqKeys[string, int]() r4 := UniqKeys[string, int]()
is.Equal([]string{}, r4) is.Empty(r4)
r5 := UniqKeys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"foo": 1, "bar": 3}) r5 := UniqKeys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"foo": 1, "bar": 3})
sort.Strings(r5) is.ElementsMatch(r5, []string{"bar", "foo"})
is.Equal([]string{"bar", "foo"}, r5)
// check order // check order
r6 := UniqKeys(map[string]int{"foo": 1}, map[string]int{"bar": 3}) r6 := UniqKeys(map[string]int{"foo": 1}, map[string]int{"bar": 3})
@@ -75,22 +68,19 @@ func TestValues(t *testing.T) {
is := assert.New(t) is := assert.New(t)
r1 := Values(map[string]int{"foo": 1, "bar": 2}) r1 := Values(map[string]int{"foo": 1, "bar": 2})
sort.Ints(r1) is.ElementsMatch(r1, []int{1, 2})
is.Equal([]int{1, 2}, r1)
r2 := Values(map[string]int{}) r2 := Values(map[string]int{})
is.Empty(r2) is.Empty(r2)
r3 := Values(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3}) r3 := Values(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
sort.Ints(r3) is.ElementsMatch(r3, []int{1, 2, 3})
is.Equal([]int{1, 2, 3}, r3)
r4 := Values[string, int]() r4 := Values[string, int]()
is.Equal([]int{}, r4) is.Empty(r4)
r5 := Values(map[string]int{"foo": 1, "bar": 2}, map[string]int{"foo": 1, "bar": 3}) r5 := Values(map[string]int{"foo": 1, "bar": 2}, map[string]int{"foo": 1, "bar": 3})
sort.Ints(r5) is.ElementsMatch(r5, []int{1, 1, 2, 3})
is.Equal([]int{1, 1, 2, 3}, r5)
} }
func TestUniqValues(t *testing.T) { func TestUniqValues(t *testing.T) {
@@ -98,26 +88,22 @@ func TestUniqValues(t *testing.T) {
is := assert.New(t) is := assert.New(t)
r1 := UniqValues(map[string]int{"foo": 1, "bar": 2}) r1 := UniqValues(map[string]int{"foo": 1, "bar": 2})
sort.Ints(r1) is.ElementsMatch(r1, []int{1, 2})
is.Equal([]int{1, 2}, r1)
r2 := UniqValues(map[string]int{}) r2 := UniqValues(map[string]int{})
is.Empty(r2) is.Empty(r2)
r3 := UniqValues(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3}) r3 := UniqValues(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
sort.Ints(r3) is.ElementsMatch(r3, []int{1, 2, 3})
is.Equal([]int{1, 2, 3}, r3)
r4 := UniqValues[string, int]() r4 := UniqValues[string, int]()
is.Equal([]int{}, r4) is.Empty(r4)
r5 := UniqValues(map[string]int{"foo": 1, "bar": 2}, map[string]int{"foo": 1, "bar": 3}) r5 := UniqValues(map[string]int{"foo": 1, "bar": 2}, map[string]int{"foo": 1, "bar": 3})
sort.Ints(r5) is.ElementsMatch(r5, []int{1, 2, 3})
is.Equal([]int{1, 2, 3}, r5)
r6 := UniqValues(map[string]int{"foo": 1, "bar": 1}, map[string]int{"foo": 1, "bar": 3}) r6 := UniqValues(map[string]int{"foo": 1, "bar": 1}, map[string]int{"foo": 1, "bar": 3})
sort.Ints(r6) is.ElementsMatch(r6, []int{1, 3})
is.Equal([]int{1, 3}, r6)
// check order // check order
r7 := UniqValues(map[string]int{"foo": 1}, map[string]int{"bar": 3}) r7 := UniqValues(map[string]int{"foo": 1}, map[string]int{"bar": 3})
@@ -228,11 +214,7 @@ func TestEntries(t *testing.T) {
is := assert.New(t) is := assert.New(t)
r1 := Entries(map[string]int{"foo": 1, "bar": 2}) r1 := Entries(map[string]int{"foo": 1, "bar": 2})
is.ElementsMatch(r1, []Entry[string, int]{
sort.Slice(r1, func(i, j int) bool {
return r1[i].Value < r1[j].Value
})
is.Equal([]Entry[string, int]{
{ {
Key: "foo", Key: "foo",
Value: 1, Value: 1,
@@ -241,7 +223,7 @@ func TestEntries(t *testing.T) {
Key: "bar", Key: "bar",
Value: 2, Value: 2,
}, },
}, r1) })
} }
func TestToPairs(t *testing.T) { func TestToPairs(t *testing.T) {
@@ -249,11 +231,7 @@ func TestToPairs(t *testing.T) {
is := assert.New(t) is := assert.New(t)
r1 := ToPairs(map[string]int{"baz": 3, "qux": 4}) r1 := ToPairs(map[string]int{"baz": 3, "qux": 4})
is.ElementsMatch(r1, []Entry[string, int]{
sort.Slice(r1, func(i, j int) bool {
return r1[i].Value < r1[j].Value
})
is.Equal([]Entry[string, int]{
{ {
Key: "baz", Key: "baz",
Value: 3, Value: 3,
@@ -262,7 +240,7 @@ func TestToPairs(t *testing.T) {
Key: "qux", Key: "qux",
Value: 4, Value: 4,
}, },
}, r1) })
} }
func TestFromEntries(t *testing.T) { func TestFromEntries(t *testing.T) {
@@ -312,7 +290,6 @@ func TestInvert(t *testing.T) {
r1 := Invert(map[string]int{"a": 1, "b": 2}) r1 := Invert(map[string]int{"a": 1, "b": 2})
r2 := Invert(map[string]int{"a": 1, "b": 2, "c": 1}) r2 := Invert(map[string]int{"a": 1, "b": 2, "c": 1})
is.Len(r1, 2)
is.Equal(map[int]string{1: "a", 2: "b"}, r1) is.Equal(map[int]string{1: "a", 2: "b"}, r1)
is.Len(r2, 2) is.Len(r2, 2)
} }
@@ -322,8 +299,6 @@ func TestAssign(t *testing.T) {
is := assert.New(t) is := assert.New(t)
result1 := Assign(map[string]int{"a": 1, "b": 2}, map[string]int{"b": 3, "c": 4}) result1 := Assign(map[string]int{"a": 1, "b": 2}, map[string]int{"b": 3, "c": 4})
is.Len(result1, 3)
is.Equal(map[string]int{"a": 1, "b": 3, "c": 4}, result1) is.Equal(map[string]int{"a": 1, "b": 3, "c": 4}, result1)
type myMap map[string]int type myMap map[string]int
@@ -342,17 +317,11 @@ func TestChunkEntries(t *testing.T) {
result4 := ChunkEntries(map[string]int{"a": 1}, 2) result4 := ChunkEntries(map[string]int{"a": 1}, 2)
result5 := ChunkEntries(map[string]int{"a": 1, "b": 2}, 1) result5 := ChunkEntries(map[string]int{"a": 1, "b": 2}, 1)
expectedCount1 := 3 is.Len(result1, 3)
expectedCount2 := 2 is.Len(result2, 2)
expectedCount3 := 0 is.Empty(result3)
expectedCount4 := 1 is.Len(result4, 1)
expectedCount5 := 2 is.Len(result5, 2)
is.Len(result1, expectedCount1)
is.Len(result2, expectedCount2)
is.Len(result3, expectedCount3)
is.Len(result4, expectedCount4)
is.Len(result5, expectedCount5)
is.PanicsWithValue("lo.ChunkEntries: size must be greater than 0", func() { is.PanicsWithValue("lo.ChunkEntries: size must be greater than 0", func() {
ChunkEntries(map[string]int{"a": 1}, 0) ChunkEntries(map[string]int{"a": 1}, 0)
@@ -390,7 +359,6 @@ func TestMapKeys(t *testing.T) {
}) })
is.Len(result1, 1) is.Len(result1, 1)
is.Len(result2, 4)
is.Equal(map[string]int{"1": 1, "2": 2, "3": 3, "4": 4}, result2) is.Equal(map[string]int{"1": 1, "2": 2, "3": 3, "4": 4}, result2)
} }
@@ -405,8 +373,6 @@ func TestMapValues(t *testing.T) {
return strconv.FormatInt(int64(x), 10) return strconv.FormatInt(int64(x), 10)
}) })
is.Len(result1, 4)
is.Len(result2, 4)
is.Equal(map[int]string{1: "Hello", 2: "Hello", 3: "Hello", 4: "Hello"}, result1) is.Equal(map[int]string{1: "Hello", 2: "Hello", 3: "Hello", 4: "Hello"}, result1)
is.Equal(map[int]string{1: "1", 2: "2", 3: "3", 4: "4"}, result2) is.Equal(map[int]string{1: "1", 2: "2", 3: "3", 4: "4"}, result2)
} }
@@ -507,8 +473,6 @@ func TestMapToSlice(t *testing.T) {
return strconv.FormatInt(int64(k), 10) return strconv.FormatInt(int64(k), 10)
}) })
is.Len(result1, 4)
is.Len(result2, 4)
is.ElementsMatch(result1, []string{"1_5", "2_6", "3_7", "4_8"}) is.ElementsMatch(result1, []string{"1_5", "2_6", "3_7", "4_8"})
is.ElementsMatch(result2, []string{"1", "2", "3", "4"}) is.ElementsMatch(result2, []string{"1", "2", "3", "4"})
} }
@@ -524,8 +488,6 @@ func TestFilterMapToSlice(t *testing.T) {
return strconv.FormatInt(int64(k), 10), k%2 == 0 return strconv.FormatInt(int64(k), 10), k%2 == 0
}) })
is.Len(result1, 2)
is.Len(result2, 2)
is.ElementsMatch(result1, []string{"2_6", "4_8"}) is.ElementsMatch(result1, []string{"2_6", "4_8"})
is.ElementsMatch(result2, []string{"2", "4"}) is.ElementsMatch(result2, []string{"2", "4"})
} }
@@ -538,12 +500,10 @@ func TestFilterKeys(t *testing.T) {
return v == "foo" return v == "foo"
}) })
is.Equal([]int{1}, result1) is.Equal([]int{1}, result1)
is.Len(result1, 1)
result2 := FilterKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool { result2 := FilterKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool {
return false return false
}) })
is.Equal([]string{}, result2)
is.Empty(result2) is.Empty(result2)
} }
@@ -555,12 +515,10 @@ func TestFilterValues(t *testing.T) {
return v == "foo" return v == "foo"
}) })
is.Equal([]string{"foo"}, result1) is.Equal([]string{"foo"}, result1)
is.Len(result1, 1)
result2 := FilterValues(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool { result2 := FilterValues(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool {
return false return false
}) })
is.Equal([]int{}, result2)
is.Empty(result2) is.Empty(result2)
} }
@@ -606,19 +564,19 @@ func BenchmarkAssign(b *testing.B) {
sameMap := allTheSameMap(b, count) sameMap := allTheSameMap(b, count)
b.Run(fmt.Sprintf("%d", count), func(b *testing.B) { b.Run(fmt.Sprintf("%d", count), func(b *testing.B) {
testcase := []struct { testCases := []struct {
name string name string
maps []map[string]int in []map[string]int
}{ }{
{"different", differentMap}, {"different", differentMap},
{"same", sameMap}, {"same", sameMap},
} }
for _, tc := range testcase { for _, tc := range testCases {
b.Run(tc.name, func(b *testing.B) { b.Run(tc.name, func(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
result := Assign(tc.maps...) result := Assign(tc.in...)
_ = result _ = result
} }
}) })

12
math_test.go
View File

@@ -15,7 +15,7 @@ func TestRange(t *testing.T) {
result3 := Range(0) result3 := Range(0)
is.Equal([]int{0, 1, 2, 3}, result1) is.Equal([]int{0, 1, 2, 3}, result1)
is.Equal([]int{0, -1, -2, -3}, result2) is.Equal([]int{0, -1, -2, -3}, result2)
is.Equal([]int{}, result3) is.Empty(result3)
} }
func TestRangeFrom(t *testing.T) { func TestRangeFrom(t *testing.T) {
@@ -29,7 +29,7 @@ func TestRangeFrom(t *testing.T) {
result5 := RangeFrom(-2.0, -3) result5 := RangeFrom(-2.0, -3)
is.Equal([]int{1, 2, 3, 4, 5}, result1) is.Equal([]int{1, 2, 3, 4, 5}, result1)
is.Equal([]int{-1, -2, -3, -4, -5}, result2) is.Equal([]int{-1, -2, -3, -4, -5}, result2)
is.Equal([]int{}, result3) is.Empty(result3)
is.Equal([]float64{2.0, 3.0, 4.0}, result4) is.Equal([]float64{2.0, 3.0, 4.0}, result4)
is.Equal([]float64{-2.0, -3.0, -4.0}, result5) is.Equal([]float64{-2.0, -3.0, -4.0}, result5)
} }
@@ -45,9 +45,9 @@ func TestRangeClose(t *testing.T) {
result5 := RangeWithSteps(1.0, 4.0, 2.0) result5 := RangeWithSteps(1.0, 4.0, 2.0)
result6 := RangeWithSteps[float32](-1.0, -4.0, -1.0) result6 := RangeWithSteps[float32](-1.0, -4.0, -1.0)
is.Equal([]int{0, 6, 12, 18}, result1) is.Equal([]int{0, 6, 12, 18}, result1)
is.Equal([]int{}, result2) is.Empty(result2)
is.Equal([]int{}, result3) is.Empty(result3)
is.Equal([]int{}, result4) is.Empty(result4)
is.Equal([]float64{1.0, 3.0}, result5) is.Equal([]float64{1.0, 3.0}, result5)
is.Equal([]float32{-1.0, -2.0, -3.0}, result6) is.Equal([]float32{-1.0, -2.0, -3.0}, result6)
} }
@@ -185,6 +185,6 @@ func TestMode(t *testing.T) {
is.Equal([]float32{3.3}, result1) is.Equal([]float32{3.3}, result1)
is.Equal([]int32{2}, result2) is.Equal([]int32{2}, result2)
is.Equal([]uint32{2, 3}, result3) is.Equal([]uint32{2, 3}, result3)
is.Equal([]uint32{}, result4) is.Empty(result4)
is.Equal([]int{1, 2, 3, 4, 5, 6, 7, 8, 9}, result5) is.Equal([]int{1, 2, 3, 4, 5, 6, 7, 8, 9}, result5)
} }

10
mutable/slice_test.go
View File

@@ -47,14 +47,12 @@ func TestMap(t *testing.T) {
Map(list, func(x int) int { Map(list, func(x int) int {
return x * 2 return x * 2
}) })
is.Len(list, 4)
is.Equal([]int{2, 4, 6, 8}, list) is.Equal([]int{2, 4, 6, 8}, list)
list = []int{1, 2, 3, 4} list = []int{1, 2, 3, 4}
Map(list, func(x int) int { Map(list, func(x int) int {
return x * 4 return x * 4
}) })
is.Len(list, 4)
is.Equal([]int{4, 8, 12, 16}, list) is.Equal([]int{4, 8, 12, 16}, list)
} }
@@ -67,7 +65,6 @@ func TestMapI(t *testing.T) {
is.Equal(index, x-1) is.Equal(index, x-1)
return x * 2 return x * 2
}) })
is.Len(list, 4)
is.Equal([]int{2, 4, 6, 8}, list) is.Equal([]int{2, 4, 6, 8}, list)
list = []int{1, 2, 3, 4} list = []int{1, 2, 3, 4}
@@ -75,7 +72,6 @@ func TestMapI(t *testing.T) {
is.Equal(index, x-1) is.Equal(index, x-1)
return x * 4 return x * 4
}) })
is.Len(list, 4)
is.Equal([]int{4, 8, 12, 16}, list) is.Equal([]int{4, 8, 12, 16}, list)
} }
@@ -89,7 +85,7 @@ func TestShuffle(t *testing.T) {
list = []int{} list = []int{}
Shuffle(list) Shuffle(list)
is.Equal([]int{}, list) is.Empty(list)
} }
func TestReverse(t *testing.T) { func TestReverse(t *testing.T) {
@@ -106,7 +102,7 @@ func TestReverse(t *testing.T) {
list = []int{} list = []int{}
Reverse(list) Reverse(list)
is.Equal([]int{}, list) is.Empty(list)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -124,5 +120,5 @@ func TestFill(t *testing.T) {
list2 := []string{} list2 := []string{}
Fill(list2, "b") Fill(list2, "b")
is.Equal([]string{}, list2) is.Empty(list2)
} }

14
parallel/slice_test.go
View File

@@ -19,8 +19,6 @@ func TestMap(t *testing.T) {
return strconv.FormatInt(x, 10) return strconv.FormatInt(x, 10)
}) })
is.Len(result1, 4)
is.Len(result2, 4)
is.Equal([]string{"Hello", "Hello", "Hello", "Hello"}, result1) is.Equal([]string{"Hello", "Hello", "Hello", "Hello"}, result1)
is.Equal([]string{"1", "2", "3", "4"}, result2) is.Equal([]string{"1", "2", "3", "4"}, result2)
} }
@@ -44,7 +42,6 @@ func TestTimes(t *testing.T) {
return strconv.FormatInt(int64(i), 10) return strconv.FormatInt(int64(i), 10)
}) })
is.Len(result1, 3)
is.Equal([]string{"0", "1", "2"}, result1) is.Equal([]string{"0", "1", "2"}, result1)
} }
@@ -57,12 +54,9 @@ func TestGroupBy(t *testing.T) {
// order // order
for x := range result1 { for x := range result1 {
sort.Slice(result1[x], func(i, j int) bool { sort.Ints(result1[x])
return result1[x][i] < result1[x][j]
})
} }
is.Len(result1, 3)
is.Equal(map[int][]int{ is.Equal(map[int][]int{
0: {0, 3}, 0: {0, 3},
1: {1, 4}, 1: {1, 4},
@@ -97,13 +91,11 @@ func TestPartitionBy(t *testing.T) {
return result1[i][0] < result1[j][0] return result1[i][0] < result1[j][0]
}) })
for x := range result1 { for x := range result1 {
sort.Slice(result1[x], func(i, j int) bool { sort.Ints(result1[x])
return result1[x][i] < result1[x][j]
})
} }
is.ElementsMatch(result1, [][]int{{-2, -1}, {0, 2, 4}, {1, 3, 5}}) is.ElementsMatch(result1, [][]int{{-2, -1}, {0, 2, 4}, {1, 3, 5}})
is.Equal([][]int{}, result2) is.Empty(result2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}

12
retry_test.go
View File

@@ -45,7 +45,7 @@ func TestAttempt(t *testing.T) {
is.Equal(6, iter2) is.Equal(6, iter2)
is.NoError(err2) is.NoError(err2)
is.Equal(2, iter3) is.Equal(2, iter3)
is.Equal(err3, err) is.ErrorIs(err3, err)
is.Equal(43, iter4) is.Equal(43, iter4)
is.NoError(err4) is.NoError(err4)
} }
@@ -92,7 +92,7 @@ func TestAttemptWithDelay(t *testing.T) {
is.Equal(2, iter3) is.Equal(2, iter3)
is.Greater(dur3, 10*time.Millisecond) is.Greater(dur3, 10*time.Millisecond)
is.Less(dur3, 20*time.Millisecond) is.Less(dur3, 20*time.Millisecond)
is.Equal(err3, err) is.ErrorIs(err3, err)
is.Equal(11, iter4) is.Equal(11, iter4)
is.Greater(dur4, 100*time.Millisecond) is.Greater(dur4, 100*time.Millisecond)
is.Less(dur4, 115*time.Millisecond) is.Less(dur4, 115*time.Millisecond)
@@ -131,7 +131,7 @@ func TestAttemptWhile(t *testing.T) {
}) })
is.Equal(2, iter3) is.Equal(2, iter3)
is.Equal(err3, err) is.ErrorIs(err3, err)
iter4, err4 := AttemptWhile(0, func(i int) (error, bool) { iter4, err4 := AttemptWhile(0, func(i int) (error, bool) {
if i < 42 { if i < 42 {
@@ -215,7 +215,7 @@ func TestAttemptWhileWithDelay(t *testing.T) {
is.Equal(2, iter3) is.Equal(2, iter3)
is.Greater(dur3, 10*time.Millisecond) is.Greater(dur3, 10*time.Millisecond)
is.Less(dur3, 20*time.Millisecond) is.Less(dur3, 20*time.Millisecond)
is.Equal(err3, err) is.ErrorIs(err3, err)
iter4, dur4, err4 := AttemptWhileWithDelay(0, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) { iter4, dur4, err4 := AttemptWhileWithDelay(0, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) {
if i < 10 { if i < 10 {
@@ -462,7 +462,7 @@ func TestTransaction(t *testing.T) {
state, err := transaction.Process(21) state, err := transaction.Process(21)
is.Equal(21, state) is.Equal(21, state)
is.Equal(assert.AnError, err) is.ErrorIs(err, assert.AnError)
} }
// with error + update value // with error + update value
@@ -495,7 +495,7 @@ func TestTransaction(t *testing.T) {
state, err := transaction.Process(21) state, err := transaction.Process(21)
is.Equal(42, state) is.Equal(42, state)
is.Equal(assert.AnError, err) is.ErrorIs(err, assert.AnError)
} }
} }

182
slice_test.go
View File

@@ -3,7 +3,6 @@ package lo
import ( import (
"fmt" "fmt"
"math" "math"
"reflect"
"strconv" "strconv"
"strings" "strings"
"testing" "testing"
@@ -44,8 +43,6 @@ func TestMap(t *testing.T) {
return strconv.FormatInt(x, 10) return strconv.FormatInt(x, 10)
}) })
is.Len(result1, 4)
is.Len(result2, 4)
is.Equal([]string{"Hello", "Hello", "Hello", "Hello"}, result1) is.Equal([]string{"Hello", "Hello", "Hello", "Hello"}, result1)
is.Equal([]string{"1", "2", "3", "4"}, result2) is.Equal([]string{"1", "2", "3", "4"}, result2)
} }
@@ -84,8 +81,6 @@ func TestFilterMap(t *testing.T) {
return "", false return "", false
}) })
is.Len(r1, 2)
is.Len(r2, 2)
is.Equal([]string{"2", "4"}, r1) is.Equal([]string{"2", "4"}, r1)
is.Equal([]string{"xpu", "xpu"}, r2) is.Equal([]string{"xpu", "xpu"}, r2)
} }
@@ -105,8 +100,6 @@ func TestFlatMap(t *testing.T) {
return result return result
}) })
is.Len(result1, 5)
is.Len(result2, 10)
is.Equal([]string{"Hello", "Hello", "Hello", "Hello", "Hello"}, result1) is.Equal([]string{"Hello", "Hello", "Hello", "Hello", "Hello"}, result1)
is.Equal([]string{"1", "2", "2", "3", "3", "3", "4", "4", "4", "4"}, result2) is.Equal([]string{"1", "2", "2", "3", "3", "3", "4", "4", "4", "4"}, result2)
} }
@@ -118,8 +111,6 @@ func TestTimes(t *testing.T) {
result1 := Times(3, func(i int) string { result1 := Times(3, func(i int) string {
return strconv.FormatInt(int64(i), 10) return strconv.FormatInt(int64(i), 10)
}) })
is.Len(result1, 3)
is.Equal([]string{"0", "1", "2"}, result1) is.Equal([]string{"0", "1", "2"}, result1)
} }
@@ -169,8 +160,8 @@ func TestForEach(t *testing.T) {
callParams2 = append(callParams2, i) callParams2 = append(callParams2, i)
}) })
is.ElementsMatch([]string{"a", "b", "c"}, callParams1) is.Equal([]string{"a", "b", "c"}, callParams1)
is.ElementsMatch([]int{0, 1, 2}, callParams2) is.Equal([]int{0, 1, 2}, callParams2)
is.IsIncreasing(callParams2) is.IsIncreasing(callParams2)
} }
@@ -192,8 +183,8 @@ func TestForEachWhile(t *testing.T) {
return true return true
}) })
is.ElementsMatch([]string{"a", "b"}, callParams1) is.Equal([]string{"a", "b"}, callParams1)
is.ElementsMatch([]int{0, 1}, callParams2) is.Equal([]int{0, 1}, callParams2)
is.IsIncreasing(callParams2) is.IsIncreasing(callParams2)
} }
@@ -202,8 +193,6 @@ func TestUniq(t *testing.T) {
is := assert.New(t) is := assert.New(t)
result1 := Uniq([]int{1, 2, 2, 1}) result1 := Uniq([]int{1, 2, 2, 1})
is.Len(result1, 2)
is.Equal([]int{1, 2}, result1) is.Equal([]int{1, 2}, result1)
type myStrings []string type myStrings []string
@@ -219,8 +208,6 @@ func TestUniqBy(t *testing.T) {
result1 := UniqBy([]int{0, 1, 2, 3, 4, 5}, func(i int) int { result1 := UniqBy([]int{0, 1, 2, 3, 4, 5}, func(i int) int {
return i % 3 return i % 3
}) })
is.Len(result1, 3)
is.Equal([]int{0, 1, 2}, result1) is.Equal([]int{0, 1, 2}, result1)
type myStrings []string type myStrings []string
@@ -238,8 +225,6 @@ func TestGroupBy(t *testing.T) {
result1 := GroupBy([]int{0, 1, 2, 3, 4, 5}, func(i int) int { result1 := GroupBy([]int{0, 1, 2, 3, 4, 5}, func(i int) int {
return i % 3 return i % 3
}) })
is.Len(result1, 3)
is.Equal(map[int][]int{ is.Equal(map[int][]int{
0: {0, 3}, 0: {0, 3},
1: {1, 4}, 1: {1, 4},
@@ -261,8 +246,6 @@ func TestGroupByMap(t *testing.T) {
result1 := GroupByMap([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, string) { result1 := GroupByMap([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, string) {
return i % 3, strconv.Itoa(i) return i % 3, strconv.Itoa(i)
}) })
is.Len(result1, 3)
is.Equal(map[int][]string{ is.Equal(map[int][]string{
0: {"0", "3"}, 0: {"0", "3"},
1: {"1", "4"}, 1: {"1", "4"},
@@ -274,8 +257,6 @@ func TestGroupByMap(t *testing.T) {
result2 := GroupByMap(myInts{1, 0, 2, 3, 4, 5}, func(i myInt) (int, string) { result2 := GroupByMap(myInts{1, 0, 2, 3, 4, 5}, func(i myInt) (int, string) {
return int(i % 3), strconv.Itoa(int(i)) return int(i % 3), strconv.Itoa(int(i))
}) })
is.Len(result2, 3)
is.Equal(map[int][]string{ is.Equal(map[int][]string{
0: {"0", "3"}, 0: {"0", "3"},
1: {"1", "4"}, 1: {"1", "4"},
@@ -296,8 +277,6 @@ func TestGroupByMap(t *testing.T) {
result3 := GroupByMap(products, func(item product) (int64, string) { result3 := GroupByMap(products, func(item product) (int64, string) {
return item.CategoryID, "Product " + strconv.FormatInt(item.ID, 10) return item.CategoryID, "Product " + strconv.FormatInt(item.ID, 10)
}) })
is.Len(result3, 3)
is.Equal(map[int64][]string{ is.Equal(map[int64][]string{
1: {"Product 1", "Product 2"}, 1: {"Product 1", "Product 2"},
2: {"Product 3"}, 2: {"Product 3"},
@@ -316,7 +295,7 @@ func TestChunk(t *testing.T) {
is.Equal([][]int{{0, 1}, {2, 3}, {4, 5}}, result1) is.Equal([][]int{{0, 1}, {2, 3}, {4, 5}}, result1)
is.Equal([][]int{{0, 1}, {2, 3}, {4, 5}, {6}}, result2) is.Equal([][]int{{0, 1}, {2, 3}, {4, 5}, {6}}, result2)
is.Equal([][]int{}, result3) is.Empty(result3)
is.Equal([][]int{{0}}, result4) is.Equal([][]int{{0}}, result4)
is.PanicsWithValue("lo.Chunk: size must be greater than 0", func() { is.PanicsWithValue("lo.Chunk: size must be greater than 0", func() {
Chunk([]int{0}, 0) Chunk([]int{0}, 0)
@@ -351,7 +330,7 @@ func TestPartitionBy(t *testing.T) {
result2 := PartitionBy([]int{}, oddEven) result2 := PartitionBy([]int{}, oddEven)
is.Equal([][]int{{-2, -1}, {0, 2, 4}, {1, 3, 5}}, result1) is.Equal([][]int{{-2, -1}, {0, 2, 4}, {1, 3, 5}}, result1)
is.Equal([][]int{}, result2) is.Empty(result2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -378,10 +357,10 @@ func TestFlatten(t *testing.T) {
func TestInterleave(t *testing.T) { func TestInterleave(t *testing.T) {
is := assert.New(t) is := assert.New(t)
tests := []struct { testCases := []struct {
name string name string
collections [][]int in [][]int
want []int want []int
}{ }{
{ {
"nil", "nil",
@@ -414,11 +393,11 @@ func TestInterleave(t *testing.T) {
[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
}, },
} }
for _, tt := range tests { for _, tc := range testCases {
t.Run(tt.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
if got := Interleave(tt.collections...); !reflect.DeepEqual(got, tt.want) { tc := tc
t.Errorf("Interleave() = %v, want %v", got, tt.want) t.Parallel()
} assert.Equal(t, tc.want, Interleave(tc.in...))
}) })
} }
@@ -436,7 +415,7 @@ func TestShuffle(t *testing.T) {
result2 := Shuffle([]int{}) result2 := Shuffle([]int{})
is.NotEqual([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, result1) is.NotEqual([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, result1)
is.Equal([]int{}, result2) is.Empty(result2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -454,7 +433,7 @@ func TestReverse(t *testing.T) {
is.Equal([]int{5, 4, 3, 2, 1, 0}, result1) is.Equal([]int{5, 4, 3, 2, 1, 0}, result1)
is.Equal([]int{6, 5, 4, 3, 2, 1, 0}, result2) is.Equal([]int{6, 5, 4, 3, 2, 1, 0}, result2)
is.Equal([]int{}, result3) is.Empty(result3)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -470,7 +449,7 @@ func TestFill(t *testing.T) {
result2 := Fill([]foo{}, foo{"a"}) result2 := Fill([]foo{}, foo{"a"})
is.Equal([]foo{{"b"}, {"b"}}, result1) is.Equal([]foo{{"b"}, {"b"}}, result1)
is.Equal([]foo{}, result2) is.Empty(result2)
} }
func TestRepeat(t *testing.T) { func TestRepeat(t *testing.T) {
@@ -481,7 +460,7 @@ func TestRepeat(t *testing.T) {
result2 := Repeat(0, foo{"a"}) result2 := Repeat(0, foo{"a"})
is.Equal([]foo{{"a"}, {"a"}}, result1) is.Equal([]foo{{"a"}, {"a"}}, result1)
is.Equal([]foo{}, result2) is.Empty(result2)
} }
func TestRepeatBy(t *testing.T) { func TestRepeatBy(t *testing.T) {
@@ -496,7 +475,7 @@ func TestRepeatBy(t *testing.T) {
result2 := RepeatBy(2, cb) result2 := RepeatBy(2, cb)
result3 := RepeatBy(5, cb) result3 := RepeatBy(5, cb)
is.Equal([]int{}, result1) is.Empty(result1)
is.Equal([]int{0, 1}, result2) is.Equal([]int{0, 1}, result2)
is.Equal([]int{0, 1, 4, 9, 16}, result3) is.Equal([]int{0, 1, 4, 9, 16}, result3)
} }
@@ -523,26 +502,27 @@ func TestAssociate(t *testing.T) {
return f.baz, f.bar return f.baz, f.bar
} }
testCases := []struct { testCases := []struct {
in []*foo in []*foo
expect map[string]int want map[string]int
}{ }{
{ {
in: []*foo{{baz: "apple", bar: 1}}, in: []*foo{{baz: "apple", bar: 1}},
expect: map[string]int{"apple": 1}, want: map[string]int{"apple": 1},
}, },
{ {
in: []*foo{{baz: "apple", bar: 1}, {baz: "banana", bar: 2}}, in: []*foo{{baz: "apple", bar: 1}, {baz: "banana", bar: 2}},
expect: map[string]int{"apple": 1, "banana": 2}, want: map[string]int{"apple": 1, "banana": 2},
}, },
{ {
in: []*foo{{baz: "apple", bar: 1}, {baz: "apple", bar: 2}}, in: []*foo{{baz: "apple", bar: 1}, {baz: "apple", bar: 2}},
expect: map[string]int{"apple": 2}, want: map[string]int{"apple": 2},
}, },
} }
for i, testCase := range testCases { for i, tc := range testCases {
t.Run(fmt.Sprintf("test_%d", i), func(t *testing.T) { t.Run(fmt.Sprintf("test_%d", i), func(t *testing.T) {
is := assert.New(t) tc := tc
is.Equal(Associate(testCase.in, transform), testCase.expect) t.Parallel()
assert.Equal(t, tc.want, Associate(tc.in, transform))
}) })
} }
} }
@@ -558,26 +538,27 @@ func TestSliceToMap(t *testing.T) {
return f.baz, f.bar return f.baz, f.bar
} }
testCases := []struct { testCases := []struct {
in []*foo in []*foo
expect map[string]int want map[string]int
}{ }{
{ {
in: []*foo{{baz: "apple", bar: 1}}, in: []*foo{{baz: "apple", bar: 1}},
expect: map[string]int{"apple": 1}, want: map[string]int{"apple": 1},
}, },
{ {
in: []*foo{{baz: "apple", bar: 1}, {baz: "banana", bar: 2}}, in: []*foo{{baz: "apple", bar: 1}, {baz: "banana", bar: 2}},
expect: map[string]int{"apple": 1, "banana": 2}, want: map[string]int{"apple": 1, "banana": 2},
}, },
{ {
in: []*foo{{baz: "apple", bar: 1}, {baz: "apple", bar: 2}}, in: []*foo{{baz: "apple", bar: 1}, {baz: "apple", bar: 2}},
expect: map[string]int{"apple": 2}, want: map[string]int{"apple": 2},
}, },
} }
for i, testCase := range testCases { for i, tc := range testCases {
t.Run(fmt.Sprintf("test_%d", i), func(t *testing.T) { t.Run(fmt.Sprintf("test_%d", i), func(t *testing.T) {
is := assert.New(t) tc := tc
is.Equal(SliceToMap(testCase.in, transform), testCase.expect) t.Parallel()
assert.Equal(t, tc.want, SliceToMap(tc.in, transform))
}) })
} }
} }
@@ -593,26 +574,27 @@ func TestFilterSliceToMap(t *testing.T) {
return f.baz, f.bar, f.bar > 1 return f.baz, f.bar, f.bar > 1
} }
testCases := []struct { testCases := []struct {
in []*foo in []*foo
expect map[string]int want map[string]int
}{ }{
{ {
in: []*foo{{baz: "apple", bar: 1}}, in: []*foo{{baz: "apple", bar: 1}},
expect: map[string]int{}, want: map[string]int{},
}, },
{ {
in: []*foo{{baz: "apple", bar: 1}, {baz: "banana", bar: 2}}, in: []*foo{{baz: "apple", bar: 1}, {baz: "banana", bar: 2}},
expect: map[string]int{"banana": 2}, want: map[string]int{"banana": 2},
}, },
{ {
in: []*foo{{baz: "apple", bar: 1}, {baz: "apple", bar: 2}}, in: []*foo{{baz: "apple", bar: 1}, {baz: "apple", bar: 2}},
expect: map[string]int{"apple": 2}, want: map[string]int{"apple": 2},
}, },
} }
for i, testCase := range testCases { for i, tc := range testCases {
t.Run(fmt.Sprintf("test_%d", i), func(t *testing.T) { t.Run(fmt.Sprintf("test_%d", i), func(t *testing.T) {
is := assert.New(t) tc := tc
is.Equal(FilterSliceToMap(testCase.in, transform), testCase.expect) t.Parallel()
assert.Equal(t, tc.want, FilterSliceToMap(tc.in, transform))
}) })
} }
} }
@@ -626,7 +608,7 @@ func TestKeyify(t *testing.T) {
result3 := Keyify([]int{}) result3 := Keyify([]int{})
is.Equal(map[int]struct{}{1: {}, 2: {}, 3: {}, 4: {}}, result1) is.Equal(map[int]struct{}{1: {}, 2: {}, 3: {}, 4: {}}, result1)
is.Equal(map[int]struct{}{1: {}, 2: {}}, result2) is.Equal(map[int]struct{}{1: {}, 2: {}}, result2)
is.Equal(map[int]struct{}{}, result3) is.Empty(result3)
} }
func TestDrop(t *testing.T) { func TestDrop(t *testing.T) {
@@ -637,8 +619,8 @@ func TestDrop(t *testing.T) {
is.Equal([]int{2, 3, 4}, Drop([]int{0, 1, 2, 3, 4}, 2)) is.Equal([]int{2, 3, 4}, Drop([]int{0, 1, 2, 3, 4}, 2))
is.Equal([]int{3, 4}, Drop([]int{0, 1, 2, 3, 4}, 3)) is.Equal([]int{3, 4}, Drop([]int{0, 1, 2, 3, 4}, 3))
is.Equal([]int{4}, Drop([]int{0, 1, 2, 3, 4}, 4)) is.Equal([]int{4}, Drop([]int{0, 1, 2, 3, 4}, 4))
is.Equal([]int{}, Drop([]int{0, 1, 2, 3, 4}, 5)) is.Empty(Drop([]int{0, 1, 2, 3, 4}, 5))
is.Equal([]int{}, Drop([]int{0, 1, 2, 3, 4}, 6)) is.Empty(Drop([]int{0, 1, 2, 3, 4}, 6))
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -654,8 +636,8 @@ func TestDropRight(t *testing.T) {
is.Equal([]int{0, 1, 2}, DropRight([]int{0, 1, 2, 3, 4}, 2)) is.Equal([]int{0, 1, 2}, DropRight([]int{0, 1, 2, 3, 4}, 2))
is.Equal([]int{0, 1}, DropRight([]int{0, 1, 2, 3, 4}, 3)) is.Equal([]int{0, 1}, DropRight([]int{0, 1, 2, 3, 4}, 3))
is.Equal([]int{0}, DropRight([]int{0, 1, 2, 3, 4}, 4)) is.Equal([]int{0}, DropRight([]int{0, 1, 2, 3, 4}, 4))
is.Equal([]int{}, DropRight([]int{0, 1, 2, 3, 4}, 5)) is.Empty(DropRight([]int{0, 1, 2, 3, 4}, 5))
is.Equal([]int{}, DropRight([]int{0, 1, 2, 3, 4}, 6)) is.Empty(DropRight([]int{0, 1, 2, 3, 4}, 6))
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -671,7 +653,7 @@ func TestDropWhile(t *testing.T) {
return t != 4 return t != 4
})) }))
is.Equal([]int{}, DropWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool { is.Empty(DropWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
return true return true
})) }))
@@ -703,7 +685,7 @@ func TestDropRightWhile(t *testing.T) {
return t == 10 return t == 10
})) }))
is.Equal([]int{}, DropRightWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool { is.Empty(DropRightWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
return t != 10 return t != 10
})) }))
@@ -729,11 +711,11 @@ func TestDropByIndex(t *testing.T) {
is.Equal([]int{0, 1, 2, 3, 4}, DropByIndex([]int{0, 1, 2, 3, 4}, 5)) is.Equal([]int{0, 1, 2, 3, 4}, DropByIndex([]int{0, 1, 2, 3, 4}, 5))
is.Equal([]int{0, 1, 2, 3, 4}, DropByIndex([]int{0, 1, 2, 3, 4}, 100)) is.Equal([]int{0, 1, 2, 3, 4}, DropByIndex([]int{0, 1, 2, 3, 4}, 100))
is.Equal([]int{0, 1, 2, 3}, DropByIndex([]int{0, 1, 2, 3, 4}, -1)) is.Equal([]int{0, 1, 2, 3}, DropByIndex([]int{0, 1, 2, 3, 4}, -1))
is.Equal([]int{}, DropByIndex([]int{}, 0, 1)) is.Empty(DropByIndex([]int{}, 0, 1))
is.Equal([]int{}, DropByIndex([]int{42}, 0, 1)) is.Empty(DropByIndex([]int{42}, 0, 1))
is.Equal([]int{}, DropByIndex([]int{42}, 1, 0)) is.Empty(DropByIndex([]int{42}, 1, 0))
is.Equal([]int{}, DropByIndex([]int{}, 1)) is.Empty(DropByIndex([]int{}, 1))
is.Equal([]int{}, DropByIndex([]int{1}, 0)) is.Empty(DropByIndex([]int{1}, 0))
} }
func TestReject(t *testing.T) { func TestReject(t *testing.T) {
@@ -777,8 +759,6 @@ func TestRejectMap(t *testing.T) {
return "", true return "", true
}) })
is.Len(r1, 2)
is.Len(r2, 2)
is.Equal([]string{"2", "4"}, r1) is.Equal([]string{"2", "4"}, r1)
is.Equal([]string{"xpu", "xpu"}, r2) is.Equal([]string{"xpu", "xpu"}, r2)
} }
@@ -848,7 +828,7 @@ func TestCountValues(t *testing.T) {
t.Parallel() t.Parallel()
is := assert.New(t) is := assert.New(t)
is.Equal(map[int]int{}, CountValues([]int{})) is.Empty(CountValues([]int{}))
is.Equal(map[int]int{1: 1, 2: 1}, CountValues([]int{1, 2})) is.Equal(map[int]int{1: 1, 2: 1}, CountValues([]int{1, 2}))
is.Equal(map[int]int{1: 1, 2: 2}, CountValues([]int{1, 2, 2})) is.Equal(map[int]int{1: 1, 2: 2}, CountValues([]int{1, 2, 2}))
is.Equal(map[string]int{"": 1, "foo": 1, "bar": 1}, CountValues([]string{"foo", "bar", ""})) is.Equal(map[string]int{"": 1, "foo": 1, "bar": 1}, CountValues([]string{"foo", "bar", ""}))
@@ -872,7 +852,7 @@ func TestCountValuesBy(t *testing.T) {
result4 := CountValuesBy([]string{"foo", "bar", ""}, length) result4 := CountValuesBy([]string{"foo", "bar", ""}, length)
result5 := CountValuesBy([]string{"foo", "bar", "bar"}, length) result5 := CountValuesBy([]string{"foo", "bar", "bar"}, length)
is.Equal(map[bool]int{}, result1) is.Empty(result1)
is.Equal(map[bool]int{true: 1, false: 1}, result2) is.Equal(map[bool]int{true: 1, false: 1}, result2)
is.Equal(map[bool]int{true: 2, false: 1}, result3) is.Equal(map[bool]int{true: 2, false: 1}, result3)
is.Equal(map[int]int{0: 1, 3: 2}, result4) is.Equal(map[int]int{0: 1, 3: 2}, result4)
@@ -898,8 +878,8 @@ func TestSubset(t *testing.T) {
out11 := Subset(in, -4, 1) out11 := Subset(in, -4, 1)
out12 := Subset(in, -4, math.MaxUint) out12 := Subset(in, -4, math.MaxUint)
is.Equal([]int{}, out1) is.Empty(out1)
is.Equal([]int{}, out2) is.Empty(out2)
is.Equal([]int{0, 1}, out3) is.Equal([]int{0, 1}, out3)
is.Equal([]int{0, 1, 2, 3, 4}, out4) is.Equal([]int{0, 1, 2, 3, 4}, out4)
is.Equal([]int{0, 1}, out5) is.Equal([]int{0, 1}, out5)
@@ -942,21 +922,21 @@ func TestSlice(t *testing.T) {
out17 := Slice(in, -1, 3) out17 := Slice(in, -1, 3)
out18 := Slice(in, -10, 7) out18 := Slice(in, -10, 7)
is.Equal([]int{}, out1) is.Empty(out1)
is.Equal([]int{0}, out2) is.Equal([]int{0}, out2)
is.Equal([]int{0, 1, 2, 3, 4}, out3) is.Equal([]int{0, 1, 2, 3, 4}, out3)
is.Equal([]int{0, 1, 2, 3, 4}, out4) is.Equal([]int{0, 1, 2, 3, 4}, out4)
is.Equal([]int{}, out5) is.Empty(out5)
is.Equal([]int{1, 2, 3, 4}, out6) is.Equal([]int{1, 2, 3, 4}, out6)
is.Equal([]int{1, 2, 3, 4}, out7) is.Equal([]int{1, 2, 3, 4}, out7)
is.Equal([]int{4}, out8) is.Equal([]int{4}, out8)
is.Equal([]int{}, out9) is.Empty(out9)
is.Equal([]int{}, out10) is.Empty(out10)
is.Equal([]int{}, out11) is.Empty(out11)
is.Equal([]int{}, out12) is.Empty(out12)
is.Equal([]int{}, out13) is.Empty(out13)
is.Equal([]int{}, out14) is.Empty(out14)
is.Equal([]int{}, out15) is.Empty(out15)
is.Equal([]int{0}, out16) is.Equal([]int{0}, out16)
is.Equal([]int{0, 1, 2}, out17) is.Equal([]int{0, 1, 2}, out17)
is.Equal([]int{0, 1, 2, 3, 4}, out18) is.Equal([]int{0, 1, 2, 3, 4}, out18)

191
string_test.go
View File

@@ -110,309 +110,308 @@ func TestAllCase(t *testing.T) {
KebabCase string KebabCase string
SnakeCase string SnakeCase string
} }
name := "" testCases := []struct {
tests := []struct { name string
name string in string
input string want output
output output
}{ }{
{name: name, output: output{}}, {want: output{}},
{name: name, input: ".", output: output{}}, {in: ".", want: output{}},
{name: name, input: "Hello world!", output: output{ {in: "Hello world!", want: output{
PascalCase: "HelloWorld", PascalCase: "HelloWorld",
CamelCase: "helloWorld", CamelCase: "helloWorld",
KebabCase: "hello-world", KebabCase: "hello-world",
SnakeCase: "hello_world", SnakeCase: "hello_world",
}}, }},
{name: name, input: "A", output: output{ {in: "A", want: output{
PascalCase: "A", PascalCase: "A",
CamelCase: "a", CamelCase: "a",
KebabCase: "a", KebabCase: "a",
SnakeCase: "a", SnakeCase: "a",
}}, }},
{name: name, input: "a", output: output{ {in: "a", want: output{
PascalCase: "A", PascalCase: "A",
CamelCase: "a", CamelCase: "a",
KebabCase: "a", KebabCase: "a",
SnakeCase: "a", SnakeCase: "a",
}}, }},
{name: name, input: "foo", output: output{ {in: "foo", want: output{
PascalCase: "Foo", PascalCase: "Foo",
CamelCase: "foo", CamelCase: "foo",
KebabCase: "foo", KebabCase: "foo",
SnakeCase: "foo", SnakeCase: "foo",
}}, }},
{name: name, input: "snake_case", output: output{ {in: "snake_case", want: output{
PascalCase: "SnakeCase", PascalCase: "SnakeCase",
CamelCase: "snakeCase", CamelCase: "snakeCase",
KebabCase: "snake-case", KebabCase: "snake-case",
SnakeCase: "snake_case", SnakeCase: "snake_case",
}}, }},
{name: name, input: "SNAKE_CASE", output: output{ {in: "SNAKE_CASE", want: output{
PascalCase: "SnakeCase", PascalCase: "SnakeCase",
CamelCase: "snakeCase", CamelCase: "snakeCase",
KebabCase: "snake-case", KebabCase: "snake-case",
SnakeCase: "snake_case", SnakeCase: "snake_case",
}}, }},
{name: name, input: "kebab-case", output: output{ {in: "kebab-case", want: output{
PascalCase: "KebabCase", PascalCase: "KebabCase",
CamelCase: "kebabCase", CamelCase: "kebabCase",
KebabCase: "kebab-case", KebabCase: "kebab-case",
SnakeCase: "kebab_case", SnakeCase: "kebab_case",
}}, }},
{name: name, input: "PascalCase", output: output{ {in: "PascalCase", want: output{
PascalCase: "PascalCase", PascalCase: "PascalCase",
CamelCase: "pascalCase", CamelCase: "pascalCase",
KebabCase: "pascal-case", KebabCase: "pascal-case",
SnakeCase: "pascal_case", SnakeCase: "pascal_case",
}}, }},
{name: name, input: "camelCase", output: output{ {in: "camelCase", want: output{
PascalCase: "CamelCase", PascalCase: "CamelCase",
CamelCase: "camelCase", CamelCase: "camelCase",
KebabCase: `camel-case`, KebabCase: `camel-case`,
SnakeCase: "camel_case", SnakeCase: "camel_case",
}}, }},
{name: name, input: "Title Case", output: output{ {in: "Title Case", want: output{
PascalCase: "TitleCase", PascalCase: "TitleCase",
CamelCase: "titleCase", CamelCase: "titleCase",
KebabCase: "title-case", KebabCase: "title-case",
SnakeCase: "title_case", SnakeCase: "title_case",
}}, }},
{name: name, input: "point.case", output: output{ {in: "point.case", want: output{
PascalCase: "PointCase", PascalCase: "PointCase",
CamelCase: "pointCase", CamelCase: "pointCase",
KebabCase: "point-case", KebabCase: "point-case",
SnakeCase: "point_case", SnakeCase: "point_case",
}}, }},
{name: name, input: "snake_case_with_more_words", output: output{ {in: "snake_case_with_more_words", want: output{
PascalCase: "SnakeCaseWithMoreWords", PascalCase: "SnakeCaseWithMoreWords",
CamelCase: "snakeCaseWithMoreWords", CamelCase: "snakeCaseWithMoreWords",
KebabCase: "snake-case-with-more-words", KebabCase: "snake-case-with-more-words",
SnakeCase: "snake_case_with_more_words", SnakeCase: "snake_case_with_more_words",
}}, }},
{name: name, input: "SNAKE_CASE_WITH_MORE_WORDS", output: output{ {in: "SNAKE_CASE_WITH_MORE_WORDS", want: output{
PascalCase: "SnakeCaseWithMoreWords", PascalCase: "SnakeCaseWithMoreWords",
CamelCase: "snakeCaseWithMoreWords", CamelCase: "snakeCaseWithMoreWords",
KebabCase: "snake-case-with-more-words", KebabCase: "snake-case-with-more-words",
SnakeCase: "snake_case_with_more_words", SnakeCase: "snake_case_with_more_words",
}}, }},
{name: name, input: "kebab-case-with-more-words", output: output{ {in: "kebab-case-with-more-words", want: output{
PascalCase: "KebabCaseWithMoreWords", PascalCase: "KebabCaseWithMoreWords",
CamelCase: "kebabCaseWithMoreWords", CamelCase: "kebabCaseWithMoreWords",
KebabCase: "kebab-case-with-more-words", KebabCase: "kebab-case-with-more-words",
SnakeCase: "kebab_case_with_more_words", SnakeCase: "kebab_case_with_more_words",
}}, }},
{name: name, input: "PascalCaseWithMoreWords", output: output{ {in: "PascalCaseWithMoreWords", want: output{
PascalCase: "PascalCaseWithMoreWords", PascalCase: "PascalCaseWithMoreWords",
CamelCase: "pascalCaseWithMoreWords", CamelCase: "pascalCaseWithMoreWords",
KebabCase: "pascal-case-with-more-words", KebabCase: "pascal-case-with-more-words",
SnakeCase: "pascal_case_with_more_words", SnakeCase: "pascal_case_with_more_words",
}}, }},
{name: name, input: "camelCaseWithMoreWords", output: output{ {in: "camelCaseWithMoreWords", want: output{
PascalCase: "CamelCaseWithMoreWords", PascalCase: "CamelCaseWithMoreWords",
CamelCase: "camelCaseWithMoreWords", CamelCase: "camelCaseWithMoreWords",
KebabCase: "camel-case-with-more-words", KebabCase: "camel-case-with-more-words",
SnakeCase: "camel_case_with_more_words", SnakeCase: "camel_case_with_more_words",
}}, }},
{name: name, input: "Title Case With More Words", output: output{ {in: "Title Case With More Words", want: output{
PascalCase: "TitleCaseWithMoreWords", PascalCase: "TitleCaseWithMoreWords",
CamelCase: "titleCaseWithMoreWords", CamelCase: "titleCaseWithMoreWords",
KebabCase: "title-case-with-more-words", KebabCase: "title-case-with-more-words",
SnakeCase: "title_case_with_more_words", SnakeCase: "title_case_with_more_words",
}}, }},
{name: name, input: "point.case.with.more.words", output: output{ {in: "point.case.with.more.words", want: output{
PascalCase: "PointCaseWithMoreWords", PascalCase: "PointCaseWithMoreWords",
CamelCase: "pointCaseWithMoreWords", CamelCase: "pointCaseWithMoreWords",
KebabCase: "point-case-with-more-words", KebabCase: "point-case-with-more-words",
SnakeCase: "point_case_with_more_words", SnakeCase: "point_case_with_more_words",
}}, }},
{name: name, input: "snake_case__with___multiple____delimiters", output: output{ {in: "snake_case__with___multiple____delimiters", want: output{
PascalCase: "SnakeCaseWithMultipleDelimiters", PascalCase: "SnakeCaseWithMultipleDelimiters",
CamelCase: "snakeCaseWithMultipleDelimiters", CamelCase: "snakeCaseWithMultipleDelimiters",
KebabCase: "snake-case-with-multiple-delimiters", KebabCase: "snake-case-with-multiple-delimiters",
SnakeCase: "snake_case_with_multiple_delimiters", SnakeCase: "snake_case_with_multiple_delimiters",
}}, }},
{name: name, input: "SNAKE_CASE__WITH___multiple____DELIMITERS", output: output{ {in: "SNAKE_CASE__WITH___multiple____DELIMITERS", want: output{
PascalCase: "SnakeCaseWithMultipleDelimiters", PascalCase: "SnakeCaseWithMultipleDelimiters",
CamelCase: "snakeCaseWithMultipleDelimiters", CamelCase: "snakeCaseWithMultipleDelimiters",
KebabCase: "snake-case-with-multiple-delimiters", KebabCase: "snake-case-with-multiple-delimiters",
SnakeCase: "snake_case_with_multiple_delimiters", SnakeCase: "snake_case_with_multiple_delimiters",
}}, }},
{name: name, input: "kebab-case--with---multiple----delimiters", output: output{ {in: "kebab-case--with---multiple----delimiters", want: output{
PascalCase: "KebabCaseWithMultipleDelimiters", PascalCase: "KebabCaseWithMultipleDelimiters",
CamelCase: "kebabCaseWithMultipleDelimiters", CamelCase: "kebabCaseWithMultipleDelimiters",
KebabCase: "kebab-case-with-multiple-delimiters", KebabCase: "kebab-case-with-multiple-delimiters",
SnakeCase: "kebab_case_with_multiple_delimiters", SnakeCase: "kebab_case_with_multiple_delimiters",
}}, }},
{name: name, input: "Title Case With Multiple Delimiters", output: output{ {in: "Title Case With Multiple Delimiters", want: output{
PascalCase: "TitleCaseWithMultipleDelimiters", PascalCase: "TitleCaseWithMultipleDelimiters",
CamelCase: "titleCaseWithMultipleDelimiters", CamelCase: "titleCaseWithMultipleDelimiters",
KebabCase: "title-case-with-multiple-delimiters", KebabCase: "title-case-with-multiple-delimiters",
SnakeCase: "title_case_with_multiple_delimiters", SnakeCase: "title_case_with_multiple_delimiters",
}}, }},
{name: name, input: "point.case..with...multiple....delimiters", output: output{ {in: "point.case..with...multiple....delimiters", want: output{
PascalCase: "PointCaseWithMultipleDelimiters", PascalCase: "PointCaseWithMultipleDelimiters",
CamelCase: "pointCaseWithMultipleDelimiters", CamelCase: "pointCaseWithMultipleDelimiters",
KebabCase: "point-case-with-multiple-delimiters", KebabCase: "point-case-with-multiple-delimiters",
SnakeCase: "point_case_with_multiple_delimiters", SnakeCase: "point_case_with_multiple_delimiters",
}}, }},
{name: name, input: " leading space", output: output{ {in: " leading space", want: output{
PascalCase: "LeadingSpace", PascalCase: "LeadingSpace",
CamelCase: "leadingSpace", CamelCase: "leadingSpace",
KebabCase: "leading-space", KebabCase: "leading-space",
SnakeCase: "leading_space", SnakeCase: "leading_space",
}}, }},
{name: name, input: " leading spaces", output: output{ {in: " leading spaces", want: output{
PascalCase: "LeadingSpaces", PascalCase: "LeadingSpaces",
CamelCase: "leadingSpaces", CamelCase: "leadingSpaces",
KebabCase: "leading-spaces", KebabCase: "leading-spaces",
SnakeCase: "leading_spaces", SnakeCase: "leading_spaces",
}}, }},
{name: name, input: "\t\t\r\n leading whitespaces", output: output{ {in: "\t\t\r\n leading whitespaces", want: output{
PascalCase: "LeadingWhitespaces", PascalCase: "LeadingWhitespaces",
CamelCase: "leadingWhitespaces", CamelCase: "leadingWhitespaces",
KebabCase: "leading-whitespaces", KebabCase: "leading-whitespaces",
SnakeCase: "leading_whitespaces", SnakeCase: "leading_whitespaces",
}}, }},
{name: name, input: "trailing space ", output: output{ {in: "trailing space ", want: output{
PascalCase: "TrailingSpace", PascalCase: "TrailingSpace",
CamelCase: "trailingSpace", CamelCase: "trailingSpace",
KebabCase: "trailing-space", KebabCase: "trailing-space",
SnakeCase: "trailing_space", SnakeCase: "trailing_space",
}}, }},
{name: name, input: "trailing spaces ", output: output{ {in: "trailing spaces ", want: output{
PascalCase: "TrailingSpaces", PascalCase: "TrailingSpaces",
CamelCase: "trailingSpaces", CamelCase: "trailingSpaces",
KebabCase: "trailing-spaces", KebabCase: "trailing-spaces",
SnakeCase: "trailing_spaces", SnakeCase: "trailing_spaces",
}}, }},
{name: name, input: "trailing whitespaces\t\t\r\n", output: output{ {in: "trailing whitespaces\t\t\r\n", want: output{
PascalCase: "TrailingWhitespaces", PascalCase: "TrailingWhitespaces",
CamelCase: "trailingWhitespaces", CamelCase: "trailingWhitespaces",
KebabCase: "trailing-whitespaces", KebabCase: "trailing-whitespaces",
SnakeCase: "trailing_whitespaces", SnakeCase: "trailing_whitespaces",
}}, }},
{name: name, input: " on both sides ", output: output{ {in: " on both sides ", want: output{
PascalCase: "OnBothSides", PascalCase: "OnBothSides",
CamelCase: "onBothSides", CamelCase: "onBothSides",
KebabCase: "on-both-sides", KebabCase: "on-both-sides",
SnakeCase: "on_both_sides", SnakeCase: "on_both_sides",
}}, }},
{name: name, input: " many on both sides ", output: output{ {in: " many on both sides ", want: output{
PascalCase: "ManyOnBothSides", PascalCase: "ManyOnBothSides",
CamelCase: "manyOnBothSides", CamelCase: "manyOnBothSides",
KebabCase: "many-on-both-sides", KebabCase: "many-on-both-sides",
SnakeCase: "many_on_both_sides", SnakeCase: "many_on_both_sides",
}}, }},
{name: name, input: "\r whitespaces on both sides\t\t\r\n", output: output{ {in: "\r whitespaces on both sides\t\t\r\n", want: output{
PascalCase: "WhitespacesOnBothSides", PascalCase: "WhitespacesOnBothSides",
CamelCase: "whitespacesOnBothSides", CamelCase: "whitespacesOnBothSides",
KebabCase: "whitespaces-on-both-sides", KebabCase: "whitespaces-on-both-sides",
SnakeCase: "whitespaces_on_both_sides", SnakeCase: "whitespaces_on_both_sides",
}}, }},
{name: name, input: " extraSpaces in_This TestCase Of MIXED_CASES\t", output: output{ {in: " extraSpaces in_This TestCase Of MIXED_CASES\t", want: output{
PascalCase: "ExtraSpacesInThisTestCaseOfMixedCases", PascalCase: "ExtraSpacesInThisTestCaseOfMixedCases",
CamelCase: "extraSpacesInThisTestCaseOfMixedCases", CamelCase: "extraSpacesInThisTestCaseOfMixedCases",
KebabCase: "extra-spaces-in-this-test-case-of-mixed-cases", KebabCase: "extra-spaces-in-this-test-case-of-mixed-cases",
SnakeCase: "extra_spaces_in_this_test_case_of_mixed_cases", SnakeCase: "extra_spaces_in_this_test_case_of_mixed_cases",
}}, }},
{name: name, input: "CASEBreak", output: output{ {in: "CASEBreak", want: output{
PascalCase: "CaseBreak", PascalCase: "CaseBreak",
CamelCase: "caseBreak", CamelCase: "caseBreak",
KebabCase: "case-break", KebabCase: "case-break",
SnakeCase: "case_break", SnakeCase: "case_break",
}}, }},
{name: name, input: "ID", output: output{ {in: "ID", want: output{
PascalCase: "Id", PascalCase: "Id",
CamelCase: "id", CamelCase: "id",
KebabCase: "id", KebabCase: "id",
SnakeCase: "id", SnakeCase: "id",
}}, }},
{name: name, input: "userID", output: output{ {in: "userID", want: output{
PascalCase: "UserId", PascalCase: "UserId",
CamelCase: "userId", CamelCase: "userId",
KebabCase: "user-id", KebabCase: "user-id",
SnakeCase: "user_id", SnakeCase: "user_id",
}}, }},
{name: name, input: "JSON_blob", output: output{ {in: "JSON_blob", want: output{
PascalCase: "JsonBlob", PascalCase: "JsonBlob",
CamelCase: "jsonBlob", CamelCase: "jsonBlob",
KebabCase: "json-blob", KebabCase: "json-blob",
SnakeCase: "json_blob", SnakeCase: "json_blob",
}}, }},
{name: name, input: "HTTPStatusCode", output: output{ {in: "HTTPStatusCode", want: output{
PascalCase: "HttpStatusCode", PascalCase: "HttpStatusCode",
CamelCase: "httpStatusCode", CamelCase: "httpStatusCode",
KebabCase: "http-status-code", KebabCase: "http-status-code",
SnakeCase: "http_status_code", SnakeCase: "http_status_code",
}}, }},
{name: name, input: "FreeBSD and SSLError are not golang initialisms", output: output{ {in: "FreeBSD and SSLError are not golang initialisms", want: output{
PascalCase: "FreeBsdAndSslErrorAreNotGolangInitialisms", PascalCase: "FreeBsdAndSslErrorAreNotGolangInitialisms",
CamelCase: "freeBsdAndSslErrorAreNotGolangInitialisms", CamelCase: "freeBsdAndSslErrorAreNotGolangInitialisms",
KebabCase: "free-bsd-and-ssl-error-are-not-golang-initialisms", KebabCase: "free-bsd-and-ssl-error-are-not-golang-initialisms",
SnakeCase: "free_bsd_and_ssl_error_are_not_golang_initialisms", SnakeCase: "free_bsd_and_ssl_error_are_not_golang_initialisms",
}}, }},
{name: name, input: "David's Computer", output: output{ {in: "David's Computer", want: output{
PascalCase: "DavidSComputer", PascalCase: "DavidSComputer",
CamelCase: "davidSComputer", CamelCase: "davidSComputer",
KebabCase: "david-s-computer", KebabCase: "david-s-computer",
SnakeCase: "david_s_computer", SnakeCase: "david_s_computer",
}}, }},
{name: name, input: "http200", output: output{ {in: "http200", want: output{
PascalCase: "Http200", PascalCase: "Http200",
CamelCase: "http200", CamelCase: "http200",
KebabCase: "http-200", KebabCase: "http-200",
SnakeCase: "http_200", SnakeCase: "http_200",
}}, }},
{name: name, input: "NumberSplittingVersion1.0r3", output: output{ {in: "NumberSplittingVersion1.0r3", want: output{
PascalCase: "NumberSplittingVersion10R3", PascalCase: "NumberSplittingVersion10R3",
CamelCase: "numberSplittingVersion10R3", CamelCase: "numberSplittingVersion10R3",
KebabCase: "number-splitting-version-1-0-r3", KebabCase: "number-splitting-version-1-0-r3",
SnakeCase: "number_splitting_version_1_0_r3", SnakeCase: "number_splitting_version_1_0_r3",
}}, }},
{name: name, input: "When you have a comma, odd results", output: output{ {in: "When you have a comma, odd results", want: output{
PascalCase: "WhenYouHaveACommaOddResults", PascalCase: "WhenYouHaveACommaOddResults",
CamelCase: "whenYouHaveACommaOddResults", CamelCase: "whenYouHaveACommaOddResults",
KebabCase: "when-you-have-a-comma-odd-results", KebabCase: "when-you-have-a-comma-odd-results",
SnakeCase: "when_you_have_a_comma_odd_results", SnakeCase: "when_you_have_a_comma_odd_results",
}}, }},
{name: name, input: "Ordinal numbers work: 1st 2nd and 3rd place", output: output{ {in: "Ordinal numbers work: 1st 2nd and 3rd place", want: output{
PascalCase: "OrdinalNumbersWork1St2NdAnd3RdPlace", PascalCase: "OrdinalNumbersWork1St2NdAnd3RdPlace",
CamelCase: "ordinalNumbersWork1St2NdAnd3RdPlace", CamelCase: "ordinalNumbersWork1St2NdAnd3RdPlace",
KebabCase: "ordinal-numbers-work-1-st-2-nd-and-3-rd-place", KebabCase: "ordinal-numbers-work-1-st-2-nd-and-3-rd-place",
SnakeCase: "ordinal_numbers_work_1_st_2_nd_and_3_rd_place", SnakeCase: "ordinal_numbers_work_1_st_2_nd_and_3_rd_place",
}}, }},
{name: name, input: "BadUTF8\xe2\xe2\xa1", output: output{ {in: "BadUTF8\xe2\xe2\xa1", want: output{
PascalCase: "BadUtf8", PascalCase: "BadUtf8",
CamelCase: "badUtf8", CamelCase: "badUtf8",
KebabCase: "bad-utf-8", KebabCase: "bad-utf-8",
SnakeCase: "bad_utf_8", SnakeCase: "bad_utf_8",
}}, }},
{name: name, input: "IDENT3", output: output{ {in: "IDENT3", want: output{
PascalCase: "Ident3", PascalCase: "Ident3",
CamelCase: "ident3", CamelCase: "ident3",
KebabCase: "ident-3", KebabCase: "ident-3",
SnakeCase: "ident_3", SnakeCase: "ident_3",
}}, }},
{name: name, input: "LogRouterS3BucketName", output: output{ {in: "LogRouterS3BucketName", want: output{
PascalCase: "LogRouterS3BucketName", PascalCase: "LogRouterS3BucketName",
CamelCase: "logRouterS3BucketName", CamelCase: "logRouterS3BucketName",
KebabCase: "log-router-s3-bucket-name", KebabCase: "log-router-s3-bucket-name",
SnakeCase: "log_router_s3_bucket_name", SnakeCase: "log_router_s3_bucket_name",
}}, }},
{name: name, input: "PINEAPPLE", output: output{ {in: "PINEAPPLE", want: output{
PascalCase: "Pineapple", PascalCase: "Pineapple",
CamelCase: "pineapple", CamelCase: "pineapple",
KebabCase: "pineapple", KebabCase: "pineapple",
SnakeCase: "pineapple", SnakeCase: "pineapple",
}}, }},
{name: name, input: "Int8Value", output: output{ {in: "Int8Value", want: output{
PascalCase: "Int8Value", PascalCase: "Int8Value",
CamelCase: "int8Value", CamelCase: "int8Value",
KebabCase: "int-8-value", KebabCase: "int-8-value",
SnakeCase: "int_8_value", SnakeCase: "int_8_value",
}}, }},
{name: name, input: "first.last", output: output{ {in: "first.last", want: output{
PascalCase: "FirstLast", PascalCase: "FirstLast",
CamelCase: "firstLast", CamelCase: "firstLast",
KebabCase: "first-last", KebabCase: "first-last",
@@ -420,68 +419,56 @@ func TestAllCase(t *testing.T) {
}}, }},
} }
for _, test := range tests { for _, tc := range testCases {
t.Run(test.name, func(t *testing.T) { t.Run(tc.in, func(t *testing.T) {
pascal := PascalCase(test.input) tc := tc
if pascal != test.output.PascalCase { t.Parallel()
t.Errorf("PascalCase(%q) = %q; expected %q", test.input, pascal, test.output.PascalCase) is := assert.New(t)
} is.Equalf(tc.want.PascalCase, PascalCase(tc.in), "PascalCase(%v)", tc.in)
camel := CamelCase(test.input) is.Equalf(tc.want.CamelCase, CamelCase(tc.in), "CamelCase(%v)", tc.in)
if camel != test.output.CamelCase { is.Equalf(tc.want.KebabCase, KebabCase(tc.in), "KebabCase(%v)", tc.in)
t.Errorf("CamelCase(%q) = %q; expected %q", test.input, camel, test.output.CamelCase) is.Equalf(tc.want.SnakeCase, SnakeCase(tc.in), "SnakeCase(%v)", tc.in)
}
kebab := KebabCase(test.input)
if kebab != test.output.KebabCase {
t.Errorf("KebabCase(%q) = %q; expected %q", test.input, kebab, test.output.KebabCase)
}
snake := SnakeCase(test.input)
if snake != test.output.SnakeCase {
t.Errorf("SnakeCase(%q) = %q; expected %q", test.input, snake, test.output.SnakeCase)
}
}) })
} }
} }
func TestWords(t *testing.T) { func TestWords(t *testing.T) {
type args struct { testCases := []struct {
str string in string
}
tests := []struct {
name string
args args
want []string want []string
}{ }{
{"", args{"PascalCase"}, []string{"Pascal", "Case"}}, {"PascalCase", []string{"Pascal", "Case"}},
{"", args{"camelCase"}, []string{"camel", "Case"}}, {"camelCase", []string{"camel", "Case"}},
{"", args{"snake_case"}, []string{"snake", "case"}}, {"snake_case", []string{"snake", "case"}},
{"", args{"kebab_case"}, []string{"kebab", "case"}}, {"kebab_case", []string{"kebab", "case"}},
{"", args{"_test text_"}, []string{"test", "text"}}, {"_test text_", []string{"test", "text"}},
{"", args{"UPPERCASE"}, []string{"UPPERCASE"}}, {"UPPERCASE", []string{"UPPERCASE"}},
{"", args{"HTTPCode"}, []string{"HTTP", "Code"}}, {"HTTPCode", []string{"HTTP", "Code"}},
{"", args{"Int8Value"}, []string{"Int", "8", "Value"}}, {"Int8Value", []string{"Int", "8", "Value"}},
} }
for _, tt := range tests { for _, tc := range testCases {
t.Run(tt.name, func(t *testing.T) { t.Run(tc.in, func(t *testing.T) {
assert.Equalf(t, tt.want, Words(tt.args.str), "words(%v)", tt.args.str) tc := tc
t.Parallel()
assert.Equalf(t, tc.want, Words(tc.in), "Words(%v)", tc.in)
}) })
} }
} }
func TestCapitalize(t *testing.T) { func TestCapitalize(t *testing.T) {
type args struct { testCases := []struct {
word string
}
tests := []struct {
name string name string
args args in string
want string want string
}{ }{
{"", args{"hello"}, "Hello"}, {"lower case", "hello", "Hello"},
{"", args{"heLLO"}, "Hello"}, {"mixed case", "heLLO", "Hello"},
} }
for _, tt := range tests { for _, tc := range testCases {
t.Run(tt.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
assert.Equalf(t, tt.want, Capitalize(tt.args.word), "Capitalize(%v)", tt.args.word) tc := tc
t.Parallel()
assert.Equalf(t, tc.want, Capitalize(tc.in), "Capitalize(%v)", tc.in)
}) })
} }
} }

30
type_manipulation_test.go
View File

@@ -96,10 +96,10 @@ func TestEmptyableToPtr(t *testing.T) {
is.Equal(42, *EmptyableToPtr(42)) is.Equal(42, *EmptyableToPtr(42))
is.Equal("nonempty", *EmptyableToPtr("nonempty")) is.Equal("nonempty", *EmptyableToPtr("nonempty"))
is.Equal([]int{}, *EmptyableToPtr([]int{})) is.Empty(*EmptyableToPtr([]int{}))
is.Equal([]int{1, 2}, *EmptyableToPtr([]int{1, 2})) is.Equal([]int{1, 2}, *EmptyableToPtr([]int{1, 2}))
is.Equal(map[int]int{}, *EmptyableToPtr(map[int]int{})) is.Empty(*EmptyableToPtr(map[int]int{}))
is.Equal(*EmptyableToPtr(assert.AnError), assert.AnError) is.Equal(assert.AnError, *EmptyableToPtr(assert.AnError))
} }
func TestFromPtr(t *testing.T) { func TestFromPtr(t *testing.T) {
@@ -175,7 +175,7 @@ func TestToAnySlice(t *testing.T) {
out2 := ToAnySlice(in2) out2 := ToAnySlice(in2)
is.Equal([]any{0, 1, 2, 3}, out1) is.Equal([]any{0, 1, 2, 3}, out1)
is.Equal([]any{}, out2) is.Empty(out2)
} }
func TestFromAnySlice(t *testing.T) { func TestFromAnySlice(t *testing.T) {
@@ -186,7 +186,7 @@ func TestFromAnySlice(t *testing.T) {
out1, ok1 := FromAnySlice[string]([]any{"foobar", 42}) out1, ok1 := FromAnySlice[string]([]any{"foobar", 42})
out2, ok2 := FromAnySlice[string]([]any{"foobar", "42"}) out2, ok2 := FromAnySlice[string]([]any{"foobar", "42"})
is.Equal([]string{}, out1) is.Empty(out1)
is.False(ok1) is.False(ok1)
is.Equal([]string{"foobar", "42"}, out2) is.Equal([]string{"foobar", "42"}, out2)
is.True(ok2) is.True(ok2)
@@ -363,27 +363,22 @@ func TestCoalesceSlice(t *testing.T) {
is.NotNil(result1) is.NotNil(result1)
is.Empty(result1) is.Empty(result1)
is.Equal([]int{}, result1)
is.False(ok1) is.False(ok1)
is.NotNil(result2) is.NotNil(result2)
is.Empty(result2) is.Empty(result2)
is.Equal([]int{}, result2)
is.False(ok2) is.False(ok2)
is.NotNil(result3) is.NotNil(result3)
is.Empty(result3) is.Empty(result3)
is.Equal([]int{}, result3)
is.False(ok3) is.False(ok3)
is.NotNil(result4) is.NotNil(result4)
is.Empty(result4) is.Empty(result4)
is.Equal([]int{}, result4)
is.False(ok4) is.False(ok4)
is.NotNil(result5) is.NotNil(result5)
is.Empty(result5) is.Empty(result5)
is.Equal([]int{}, result5)
is.False(ok5) is.False(ok5)
is.NotNil(result6) is.NotNil(result6)
@@ -429,19 +424,14 @@ func TestCoalesceSliceOrEmpty(t *testing.T) {
is.NotNil(result1) is.NotNil(result1)
is.Empty(result1) is.Empty(result1)
is.Equal([]int{}, result1)
is.NotNil(result2) is.NotNil(result2)
is.Empty(result2) is.Empty(result2)
is.Equal([]int{}, result2)
is.NotNil(result3) is.NotNil(result3)
is.Empty(result3) is.Empty(result3)
is.Equal([]int{}, result3)
is.NotNil(result4) is.NotNil(result4)
is.Empty(result4) is.Empty(result4)
is.Equal([]int{}, result4)
is.NotNil(result5) is.NotNil(result5)
is.Empty(result5) is.Empty(result5)
is.Equal([]int{}, result5)
is.NotNil(result6) is.NotNil(result6)
is.Equal(slice2, result6) is.Equal(slice2, result6)
is.NotNil(result7) is.NotNil(result7)
@@ -476,27 +466,22 @@ func TestCoalesceMap(t *testing.T) {
is.NotNil(result1) is.NotNil(result1)
is.Empty(result1) is.Empty(result1)
is.Equal(map[int]int{}, result1)
is.False(ok1) is.False(ok1)
is.NotNil(result2) is.NotNil(result2)
is.Empty(result2) is.Empty(result2)
is.Equal(map[int]int{}, result2)
is.False(ok2) is.False(ok2)
is.NotNil(result3) is.NotNil(result3)
is.Empty(result3) is.Empty(result3)
is.Equal(map[int]int{}, result3)
is.False(ok3) is.False(ok3)
is.NotNil(result4) is.NotNil(result4)
is.Empty(result4) is.Empty(result4)
is.Equal(map[int]int{}, result4)
is.False(ok4) is.False(ok4)
is.NotNil(result5) is.NotNil(result5)
is.Empty(result5) is.Empty(result5)
is.Equal(map[int]int{}, result5)
is.False(ok5) is.False(ok5)
is.NotNil(result6) is.NotNil(result6)
@@ -542,19 +527,14 @@ func TestCoalesceMapOrEmpty(t *testing.T) {
is.NotNil(result1) is.NotNil(result1)
is.Empty(result1) is.Empty(result1)
is.Equal(map[int]int{}, result1)
is.NotNil(result2) is.NotNil(result2)
is.Empty(result2) is.Empty(result2)
is.Equal(map[int]int{}, result2)
is.NotNil(result3) is.NotNil(result3)
is.Empty(result3) is.Empty(result3)
is.Equal(map[int]int{}, result3)
is.NotNil(result4) is.NotNil(result4)
is.Empty(result4) is.Empty(result4)
is.Equal(map[int]int{}, result4)
is.NotNil(result5) is.NotNil(result5)
is.Empty(result5) is.Empty(result5)
is.Equal(map[int]int{}, result5)
is.NotNil(result6) is.NotNil(result6)
is.Equal(map2, result6) is.Equal(map2, result6)
is.NotNil(result7) is.NotNil(result7)