zishuo/lo
1
0
Fork 0
mirror of https://github.com/samber/lo.git synced 2025-10-25 00:40:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

test: parallel tests everywhere (#228)

Browse Source
This commit is contained in:
Samuel Berthe
2022-10-02 21:38:26 +02:00
committed by GitHub
parent 282789fe09
commit 31f3bc3a85
12 changed files with 122 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
channel_test.go
View File

@@ -7,32 +7,6 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
func TestChannelDispatcher2(t *testing.T) {
ch := make(chan int, 42)
for i := 0; i <= 10; i++ {
ch <- i
}
children := ChannelDispatcher(ch, 5, 10, DispatchingStrategyRoundRobin[int])
// []<-chan int{...}
consumer := func(c <-chan int) {
for {
msg, ok := <-c
if !ok {
println("closed")
break
}
println(msg)
}
}
for i := range children {
go consumer(children[i])
}
}
func TestChannelDispatcher(t *testing.T) { func TestChannelDispatcher(t *testing.T) {
t.Parallel() t.Parallel()
testWithTimeout(t, 100*time.Millisecond) testWithTimeout(t, 100*time.Millisecond)

5
condition_test.go
View File

@@ -7,6 +7,7 @@ import (
) )
func TestTernary(t *testing.T) { func TestTernary(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Ternary(true, "a", "b") result1 := Ternary(true, "a", "b")
@@ -17,6 +18,7 @@ func TestTernary(t *testing.T) {
} }
func TestIfElse(t *testing.T) { func TestIfElse(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := If(true, 1).ElseIf(false, 2).Else(3) result1 := If(true, 1).ElseIf(false, 2).Else(3)
@@ -31,6 +33,7 @@ func TestIfElse(t *testing.T) {
} }
func TestIfFElseF(t *testing.T) { func TestIfFElseF(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := IfF(true, func() int { return 1 }).ElseIfF(false, func() int { return 2 }).ElseF(func() int { return 3 }) result1 := IfF(true, func() int { return 1 }).ElseIfF(false, func() int { return 2 }).ElseF(func() int { return 3 })
@@ -45,6 +48,7 @@ func TestIfFElseF(t *testing.T) {
} }
func TestSwitchCase(t *testing.T) { func TestSwitchCase(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Switch[int, int](42).Case(42, 1).Case(1, 2).Default(3) result1 := Switch[int, int](42).Case(42, 1).Case(1, 2).Default(3)
@@ -59,6 +63,7 @@ func TestSwitchCase(t *testing.T) {
} }
func TestSwitchCaseF(t *testing.T) { func TestSwitchCaseF(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Switch[int, int](42).CaseF(42, func() int { return 1 }).CaseF(1, func() int { return 2 }).DefaultF(func() int { return 3 }) result1 := Switch[int, int](42).CaseF(42, func() int { return 1 }).CaseF(1, func() int { return 2 }).DefaultF(func() int { return 3 })

20
find_test.go
View File

@@ -11,6 +11,7 @@ import (
) )
func TestIndexOf(t *testing.T) { func TestIndexOf(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := IndexOf([]int{0, 1, 2, 1, 2, 3}, 2) result1 := IndexOf([]int{0, 1, 2, 1, 2, 3}, 2)
@@ -21,6 +22,7 @@ func TestIndexOf(t *testing.T) {
} }
func TestLastIndexOf(t *testing.T) { func TestLastIndexOf(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := LastIndexOf([]int{0, 1, 2, 1, 2, 3}, 2) result1 := LastIndexOf([]int{0, 1, 2, 1, 2, 3}, 2)
@@ -31,6 +33,7 @@ func TestLastIndexOf(t *testing.T) {
} }
func TestFind(t *testing.T) { func TestFind(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1, ok1 := Find([]string{"a", "b", "c", "d"}, func(i string) bool { result1, ok1 := Find([]string{"a", "b", "c", "d"}, func(i string) bool {
@@ -47,6 +50,7 @@ func TestFind(t *testing.T) {
} }
func TestFindIndexOf(t *testing.T) { func TestFindIndexOf(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
item1, index1, ok1 := FindIndexOf([]string{"a", "b", "c", "d", "b"}, func(i string) bool { item1, index1, ok1 := FindIndexOf([]string{"a", "b", "c", "d", "b"}, func(i string) bool {
@@ -65,6 +69,7 @@ func TestFindIndexOf(t *testing.T) {
} }
func TestFindLastIndexOf(t *testing.T) { func TestFindLastIndexOf(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
item1, index1, ok1 := FindLastIndexOf([]string{"a", "b", "c", "d", "b"}, func(i string) bool { item1, index1, ok1 := FindLastIndexOf([]string{"a", "b", "c", "d", "b"}, func(i string) bool {
@@ -83,6 +88,7 @@ func TestFindLastIndexOf(t *testing.T) {
} }
func TestFindOrElse(t *testing.T) { func TestFindOrElse(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := FindOrElse([]string{"a", "b", "c", "d"}, "x", func(i string) bool { result1 := FindOrElse([]string{"a", "b", "c", "d"}, "x", func(i string) bool {
@@ -97,6 +103,7 @@ func TestFindOrElse(t *testing.T) {
} }
func TestFindKey(t *testing.T) { func TestFindKey(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1, ok1 := FindKey(map[string]int{"foo": 1, "bar": 2, "baz": 3}, 2) result1, ok1 := FindKey(map[string]int{"foo": 1, "bar": 2, "baz": 3}, 2)
@@ -121,6 +128,7 @@ func TestFindKey(t *testing.T) {
} }
func TestFindKeyBy(t *testing.T) { func TestFindKeyBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1, ok1 := FindKeyBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool { result1, ok1 := FindKeyBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool {
@@ -137,6 +145,7 @@ func TestFindKeyBy(t *testing.T) {
} }
func TestFindUniques(t *testing.T) { func TestFindUniques(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := FindUniques[int]([]int{1, 2, 3}) result1 := FindUniques[int]([]int{1, 2, 3})
@@ -161,6 +170,7 @@ func TestFindUniques(t *testing.T) {
} }
func TestFindUniquesBy(t *testing.T) { func TestFindUniquesBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := FindUniquesBy[int, int]([]int{0, 1, 2}, func(i int) int { result1 := FindUniquesBy[int, int]([]int{0, 1, 2}, func(i int) int {
@@ -193,6 +203,7 @@ func TestFindUniquesBy(t *testing.T) {
} }
func TestFindDuplicates(t *testing.T) { func TestFindDuplicates(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := FindDuplicates[int]([]int{1, 2, 2, 1, 2, 3}) result1 := FindDuplicates[int]([]int{1, 2, 2, 1, 2, 3})
@@ -212,6 +223,7 @@ func TestFindDuplicates(t *testing.T) {
} }
func TestFindDuplicatesBy(t *testing.T) { func TestFindDuplicatesBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := FindDuplicatesBy[int, int]([]int{3, 4, 5, 6, 7}, func(i int) int { result1 := FindDuplicatesBy[int, int]([]int{3, 4, 5, 6, 7}, func(i int) int {
@@ -237,6 +249,7 @@ func TestFindDuplicatesBy(t *testing.T) {
} }
func TestMin(t *testing.T) { func TestMin(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Min([]int{1, 2, 3}) result1 := Min([]int{1, 2, 3})
@@ -249,6 +262,7 @@ func TestMin(t *testing.T) {
} }
func TestMinBy(t *testing.T) { func TestMinBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := MinBy([]string{"s1", "string2", "s3"}, func(item string, min string) bool { result1 := MinBy([]string{"s1", "string2", "s3"}, func(item string, min string) bool {
@@ -267,6 +281,7 @@ func TestMinBy(t *testing.T) {
} }
func TestMax(t *testing.T) { func TestMax(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Max([]int{1, 2, 3}) result1 := Max([]int{1, 2, 3})
@@ -279,6 +294,7 @@ func TestMax(t *testing.T) {
} }
func TestMaxBy(t *testing.T) { func TestMaxBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := MaxBy([]string{"s1", "string2", "s3"}, func(item string, max string) bool { result1 := MaxBy([]string{"s1", "string2", "s3"}, func(item string, max string) bool {
@@ -297,6 +313,7 @@ func TestMaxBy(t *testing.T) {
} }
func TestLast(t *testing.T) { func TestLast(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1, err1 := Last([]int{1, 2, 3}) result1, err1 := Last([]int{1, 2, 3})
@@ -309,6 +326,7 @@ func TestLast(t *testing.T) {
} }
func TestNth(t *testing.T) { func TestNth(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1, err1 := Nth([]int{0, 1, 2, 3}, 2) result1, err1 := Nth([]int{0, 1, 2, 3}, 2)
@@ -333,6 +351,7 @@ func TestNth(t *testing.T) {
} }
func TestSample(t *testing.T) { func TestSample(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())
@@ -345,6 +364,7 @@ func TestSample(t *testing.T) {
} }
func TestSamples(t *testing.T) { func TestSamples(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())

1
func_test.go
View File

@@ -8,6 +8,7 @@ import (
) )
func TestPartial(t *testing.T) { func TestPartial(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
add := func(x float64, y int) string { add := func(x float64, y int) string {

16
intersect_test.go
View File

@@ -7,6 +7,7 @@ import (
) )
func TestContains(t *testing.T) { func TestContains(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Contains([]int{0, 1, 2, 3, 4, 5}, 5) result1 := Contains([]int{0, 1, 2, 3, 4, 5}, 5)
@@ -17,6 +18,7 @@ func TestContains(t *testing.T) {
} }
func TestContainsBy(t *testing.T) { func TestContainsBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
type a struct { type a struct {
@@ -39,6 +41,7 @@ func TestContainsBy(t *testing.T) {
} }
func TestEvery(t *testing.T) { func TestEvery(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Every([]int{0, 1, 2, 3, 4, 5}, []int{0, 2}) result1 := Every([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
@@ -53,6 +56,7 @@ func TestEvery(t *testing.T) {
} }
func TestEveryBy(t *testing.T) { func TestEveryBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := EveryBy([]int{1, 2, 3, 4}, func(x int) bool { result1 := EveryBy([]int{1, 2, 3, 4}, func(x int) bool {
@@ -81,6 +85,7 @@ func TestEveryBy(t *testing.T) {
} }
func TestSome(t *testing.T) { func TestSome(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Some([]int{0, 1, 2, 3, 4, 5}, []int{0, 2}) result1 := Some([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
@@ -95,6 +100,7 @@ func TestSome(t *testing.T) {
} }
func TestSomeBy(t *testing.T) { func TestSomeBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := SomeBy([]int{1, 2, 3, 4}, func(x int) bool { result1 := SomeBy([]int{1, 2, 3, 4}, func(x int) bool {
@@ -123,6 +129,7 @@ func TestSomeBy(t *testing.T) {
} }
func TestNone(t *testing.T) { func TestNone(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := None([]int{0, 1, 2, 3, 4, 5}, []int{0, 2}) result1 := None([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
@@ -137,6 +144,7 @@ func TestNone(t *testing.T) {
} }
func TestNoneBy(t *testing.T) { func TestNoneBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := NoneBy([]int{1, 2, 3, 4}, func(x int) bool { result1 := NoneBy([]int{1, 2, 3, 4}, func(x int) bool {
@@ -165,6 +173,7 @@ func TestNoneBy(t *testing.T) {
} }
func TestIntersect(t *testing.T) { func TestIntersect(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Intersect([]int{0, 1, 2, 3, 4, 5}, []int{0, 2}) result1 := Intersect([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
@@ -181,6 +190,7 @@ func TestIntersect(t *testing.T) {
} }
func TestDifference(t *testing.T) { func TestDifference(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
left1, right1 := Difference([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 6}) left1, right1 := Difference([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 6})
@@ -197,7 +207,9 @@ func TestDifference(t *testing.T) {
} }
func TestUnion(t *testing.T) { func TestUnion(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Union([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 10}) result1 := Union([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 10})
result2 := Union([]int{0, 1, 2, 3, 4, 5}, []int{6, 7}) result2 := Union([]int{0, 1, 2, 3, 4, 5}, []int{6, 7})
result3 := Union([]int{0, 1, 2, 3, 4, 5}, []int{}) result3 := Union([]int{0, 1, 2, 3, 4, 5}, []int{})
@@ -211,7 +223,9 @@ func TestUnion(t *testing.T) {
} }
func TestWithout(t *testing.T) { func TestWithout(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Without([]int{0, 2, 10}, 0, 1, 2, 3, 4, 5) result1 := Without([]int{0, 2, 10}, 0, 1, 2, 3, 4, 5)
result2 := Without([]int{0, 7}, 0, 1, 2, 3, 4, 5) result2 := Without([]int{0, 7}, 0, 1, 2, 3, 4, 5)
result3 := Without([]int{}, 0, 1, 2, 3, 4, 5) result3 := Without([]int{}, 0, 1, 2, 3, 4, 5)
@@ -225,7 +239,9 @@ func TestWithout(t *testing.T) {
} }
func TestWithoutEmpty(t *testing.T) { func TestWithoutEmpty(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := WithoutEmpty([]int{0, 1, 2}) result1 := WithoutEmpty([]int{0, 1, 2})
result2 := WithoutEmpty([]int{1, 2}) result2 := WithoutEmpty([]int{1, 2})
result3 := WithoutEmpty([]int{}) result3 := WithoutEmpty([]int{})

15
map_test.go
View File

@@ -10,6 +10,7 @@ import (
) )
func TestKeys(t *testing.T) { func TestKeys(t *testing.T) {
t.Parallel()
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})
@@ -19,6 +20,7 @@ func TestKeys(t *testing.T) {
} }
func TestValues(t *testing.T) { func TestValues(t *testing.T) {
t.Parallel()
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})
@@ -28,6 +30,7 @@ func TestValues(t *testing.T) {
} }
func TestPickBy(t *testing.T) { func TestPickBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := PickBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) bool { r1 := PickBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) bool {
@@ -38,6 +41,7 @@ func TestPickBy(t *testing.T) {
} }
func TestPickByKeys(t *testing.T) { func TestPickByKeys(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := PickByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz"}) r1 := PickByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz"})
@@ -46,6 +50,7 @@ func TestPickByKeys(t *testing.T) {
} }
func TestPickByValues(t *testing.T) { func TestPickByValues(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := PickByValues(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []int{1, 3}) r1 := PickByValues(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []int{1, 3})
@@ -54,6 +59,7 @@ func TestPickByValues(t *testing.T) {
} }
func TestOmitBy(t *testing.T) { func TestOmitBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := OmitBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) bool { r1 := OmitBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) bool {
@@ -64,6 +70,7 @@ func TestOmitBy(t *testing.T) {
} }
func TestOmitByKeys(t *testing.T) { func TestOmitByKeys(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := OmitByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz"}) r1 := OmitByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz"})
@@ -72,6 +79,7 @@ func TestOmitByKeys(t *testing.T) {
} }
func TestOmitByValues(t *testing.T) { func TestOmitByValues(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := OmitByValues(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []int{1, 3}) r1 := OmitByValues(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []int{1, 3})
@@ -80,6 +88,7 @@ func TestOmitByValues(t *testing.T) {
} }
func TestEntries(t *testing.T) { func TestEntries(t *testing.T) {
t.Parallel()
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})
@@ -100,6 +109,7 @@ func TestEntries(t *testing.T) {
} }
func TestFromEntries(t *testing.T) { func TestFromEntries(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := FromEntries([]Entry[string, int]{ r1 := FromEntries([]Entry[string, int]{
@@ -119,6 +129,7 @@ func TestFromEntries(t *testing.T) {
} }
func TestInvert(t *testing.T) { func TestInvert(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := Invert(map[string]int{"a": 1, "b": 2}) r1 := Invert(map[string]int{"a": 1, "b": 2})
@@ -130,6 +141,7 @@ func TestInvert(t *testing.T) {
} }
func TestAssign(t *testing.T) { func TestAssign(t *testing.T) {
t.Parallel()
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})
@@ -139,6 +151,7 @@ func TestAssign(t *testing.T) {
} }
func TestMapKeys(t *testing.T) { func TestMapKeys(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := MapKeys(map[int]int{1: 1, 2: 2, 3: 3, 4: 4}, func(x int, _ int) string { result1 := MapKeys(map[int]int{1: 1, 2: 2, 3: 3, 4: 4}, func(x int, _ int) string {
@@ -154,6 +167,7 @@ func TestMapKeys(t *testing.T) {
} }
func TestMapValues(t *testing.T) { func TestMapValues(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := MapValues(map[int]int{1: 1, 2: 2, 3: 3, 4: 4}, func(x int, _ int) string { result1 := MapValues(map[int]int{1: 1, 2: 2, 3: 3, 4: 4}, func(x int, _ int) string {
@@ -170,6 +184,7 @@ func TestMapValues(t *testing.T) {
} }
func TestMapToSlice(t *testing.T) { func TestMapToSlice(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := MapToSlice(map[int]int{1: 5, 2: 6, 3: 7, 4: 8}, func(k int, v int) string { result1 := MapToSlice(map[int]int{1: 5, 2: 6, 3: 7, 4: 8}, func(k int, v int) string {

8
math_test.go
View File

@@ -7,7 +7,9 @@ import (
) )
func TestRange(t *testing.T) { func TestRange(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Range(4) result1 := Range(4)
result2 := Range(-4) result2 := Range(-4)
result3 := Range(0) result3 := Range(0)
@@ -17,7 +19,9 @@ func TestRange(t *testing.T) {
} }
func TestRangeFrom(t *testing.T) { func TestRangeFrom(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := RangeFrom(1, 5) result1 := RangeFrom(1, 5)
result2 := RangeFrom(-1, -5) result2 := RangeFrom(-1, -5)
result3 := RangeFrom(10, 0) result3 := RangeFrom(10, 0)
@@ -31,7 +35,9 @@ func TestRangeFrom(t *testing.T) {
} }
func TestRangeClose(t *testing.T) { func TestRangeClose(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := RangeWithSteps(0, 20, 6) result1 := RangeWithSteps(0, 20, 6)
result2 := RangeWithSteps(0, 3, -5) result2 := RangeWithSteps(0, 3, -5)
result3 := RangeWithSteps(1, 1, 0) result3 := RangeWithSteps(1, 1, 0)
@@ -47,6 +53,7 @@ func TestRangeClose(t *testing.T) {
} }
func TestClamp(t *testing.T) { func TestClamp(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Clamp(0, -10, 10) result1 := Clamp(0, -10, 10)
@@ -59,6 +66,7 @@ func TestClamp(t *testing.T) {
} }
func TestSumBy(t *testing.T) { func TestSumBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := SumBy([]float32{2.3, 3.3, 4, 5.3}, func(n float32) float32 { return n }) result1 := SumBy([]float32{2.3, 3.3, 4, 5.3}, func(n float32) float32 { return n })

4
retry_test.go
View File

@@ -9,6 +9,7 @@ import (
) )
func TestAttempt(t *testing.T) { func TestAttempt(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
err := fmt.Errorf("failed") err := fmt.Errorf("failed")
@@ -49,6 +50,7 @@ func TestAttempt(t *testing.T) {
} }
func TestAttemptWithDelay(t *testing.T) { func TestAttemptWithDelay(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
err := fmt.Errorf("failed") err := fmt.Errorf("failed")
@@ -97,6 +99,8 @@ func TestAttemptWithDelay(t *testing.T) {
} }
func TestDebounce(t *testing.T) { func TestDebounce(t *testing.T) {
t.Parallel()
f1 := func() { f1 := func() {
println("1. Called once after 10ms when func stopped invoking!") println("1. Called once after 10ms when func stopped invoking!")
} }

36
slice_test.go
View File

@@ -19,6 +19,7 @@ func (f foo) Clone() foo {
} }
func TestFilter(t *testing.T) { func TestFilter(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := Filter([]int{1, 2, 3, 4}, func(x int, _ int) bool { r1 := Filter([]int{1, 2, 3, 4}, func(x int, _ int) bool {
@@ -35,6 +36,7 @@ func TestFilter(t *testing.T) {
} }
func TestMap(t *testing.T) { func TestMap(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Map([]int{1, 2, 3, 4}, func(x int, _ int) string { result1 := Map([]int{1, 2, 3, 4}, func(x int, _ int) string {
@@ -51,6 +53,7 @@ func TestMap(t *testing.T) {
} }
func TestFilterMap(t *testing.T) { func TestFilterMap(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := FilterMap([]int64{1, 2, 3, 4}, func(x int64, _ int) (string, bool) { r1 := FilterMap([]int64{1, 2, 3, 4}, func(x int64, _ int) (string, bool) {
@@ -73,6 +76,7 @@ func TestFilterMap(t *testing.T) {
} }
func TestFlatMap(t *testing.T) { func TestFlatMap(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := FlatMap([]int{0, 1, 2, 3, 4}, func(x int, _ int) []string { result1 := FlatMap([]int{0, 1, 2, 3, 4}, func(x int, _ int) []string {
@@ -93,6 +97,7 @@ func TestFlatMap(t *testing.T) {
} }
func TestTimes(t *testing.T) { func TestTimes(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Times(3, func(i int) string { result1 := Times(3, func(i int) string {
@@ -104,6 +109,7 @@ func TestTimes(t *testing.T) {
} }
func TestReduce(t *testing.T) { func TestReduce(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Reduce([]int{1, 2, 3, 4}, func(agg int, item int, _ int) int { result1 := Reduce([]int{1, 2, 3, 4}, func(agg int, item int, _ int) int {
@@ -118,6 +124,7 @@ func TestReduce(t *testing.T) {
} }
func TestReduceRight(t *testing.T) { func TestReduceRight(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := ReduceRight([][]int{{0, 1}, {2, 3}, {4, 5}}, func(agg []int, item []int, _ int) []int { result1 := ReduceRight([][]int{{0, 1}, {2, 3}, {4, 5}}, func(agg []int, item []int, _ int) []int {
@@ -128,6 +135,7 @@ func TestReduceRight(t *testing.T) {
} }
func TestForEach(t *testing.T) { func TestForEach(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
// check of callback is called for every element and in proper order // check of callback is called for every element and in proper order
@@ -146,6 +154,7 @@ func TestForEach(t *testing.T) {
} }
func TestUniq(t *testing.T) { func TestUniq(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Uniq([]int{1, 2, 2, 1}) result1 := Uniq([]int{1, 2, 2, 1})
@@ -155,6 +164,7 @@ func TestUniq(t *testing.T) {
} }
func TestUniqBy(t *testing.T) { func TestUniqBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(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 {
@@ -166,6 +176,7 @@ func TestUniqBy(t *testing.T) {
} }
func TestGroupBy(t *testing.T) { func TestGroupBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(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 {
@@ -181,6 +192,7 @@ func TestGroupBy(t *testing.T) {
} }
func TestChunk(t *testing.T) { func TestChunk(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Chunk([]int{0, 1, 2, 3, 4, 5}, 2) result1 := Chunk([]int{0, 1, 2, 3, 4, 5}, 2)
@@ -195,6 +207,7 @@ func TestChunk(t *testing.T) {
} }
func TestPartitionBy(t *testing.T) { func TestPartitionBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
oddEven := func(x int) string { oddEven := func(x int) string {
@@ -214,6 +227,7 @@ func TestPartitionBy(t *testing.T) {
} }
func TestFlatten(t *testing.T) { func TestFlatten(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Flatten([][]int{{0, 1}, {2, 3, 4, 5}}) result1 := Flatten([][]int{{0, 1}, {2, 3, 4, 5}})
@@ -222,6 +236,7 @@ func TestFlatten(t *testing.T) {
} }
func TestShuffle(t *testing.T) { func TestShuffle(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Shuffle([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) result1 := Shuffle([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
@@ -232,6 +247,7 @@ func TestShuffle(t *testing.T) {
} }
func TestReverse(t *testing.T) { func TestReverse(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Reverse([]int{0, 1, 2, 3, 4, 5}) result1 := Reverse([]int{0, 1, 2, 3, 4, 5})
@@ -244,6 +260,7 @@ func TestReverse(t *testing.T) {
} }
func TestFill(t *testing.T) { func TestFill(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Fill([]foo{{"a"}, {"a"}}, foo{"b"}) result1 := Fill([]foo{{"a"}, {"a"}}, foo{"b"})
@@ -254,6 +271,7 @@ func TestFill(t *testing.T) {
} }
func TestRepeat(t *testing.T) { func TestRepeat(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := Repeat(2, foo{"a"}) result1 := Repeat(2, foo{"a"})
@@ -264,6 +282,7 @@ func TestRepeat(t *testing.T) {
} }
func TestRepeatBy(t *testing.T) { func TestRepeatBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
cb := func(i int) int { cb := func(i int) int {
@@ -280,6 +299,7 @@ func TestRepeatBy(t *testing.T) {
} }
func TestKeyBy(t *testing.T) { func TestKeyBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := KeyBy([]string{"a", "aa", "aaa"}, func(str string) int { result1 := KeyBy([]string{"a", "aa", "aaa"}, func(str string) int {
@@ -290,6 +310,8 @@ func TestKeyBy(t *testing.T) {
} }
func TestAssociate(t *testing.T) { func TestAssociate(t *testing.T) {
t.Parallel()
type foo struct { type foo struct {
baz string baz string
bar int bar int
@@ -323,6 +345,7 @@ func TestAssociate(t *testing.T) {
} }
func TestDrop(t *testing.T) { func TestDrop(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
is.Equal([]int{1, 2, 3, 4}, Drop([]int{0, 1, 2, 3, 4}, 1)) is.Equal([]int{1, 2, 3, 4}, Drop([]int{0, 1, 2, 3, 4}, 1))
@@ -334,6 +357,7 @@ func TestDrop(t *testing.T) {
} }
func TestDropRight(t *testing.T) { func TestDropRight(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
is.Equal([]int{0, 1, 2, 3}, DropRight([]int{0, 1, 2, 3, 4}, 1)) is.Equal([]int{0, 1, 2, 3}, DropRight([]int{0, 1, 2, 3, 4}, 1))
@@ -345,6 +369,7 @@ func TestDropRight(t *testing.T) {
} }
func TestDropWhile(t *testing.T) { func TestDropWhile(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
is.Equal([]int{4, 5, 6}, DropWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool { is.Equal([]int{4, 5, 6}, DropWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
@@ -361,6 +386,7 @@ func TestDropWhile(t *testing.T) {
} }
func TestDropRightWhile(t *testing.T) { func TestDropRightWhile(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
is.Equal([]int{0, 1, 2, 3}, DropRightWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool { is.Equal([]int{0, 1, 2, 3}, DropRightWhile([]int{0, 1, 2, 3, 4, 5, 6}, func(t int) bool {
@@ -381,6 +407,7 @@ func TestDropRightWhile(t *testing.T) {
} }
func TestReject(t *testing.T) { func TestReject(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := Reject([]int{1, 2, 3, 4}, func(x int, _ int) bool { r1 := Reject([]int{1, 2, 3, 4}, func(x int, _ int) bool {
@@ -397,6 +424,7 @@ func TestReject(t *testing.T) {
} }
func TestCount(t *testing.T) { func TestCount(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
count1 := Count([]int{1, 2, 1}, 1) count1 := Count([]int{1, 2, 1}, 1)
@@ -409,6 +437,7 @@ func TestCount(t *testing.T) {
} }
func TestCountBy(t *testing.T) { func TestCountBy(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
count1 := CountBy([]int{1, 2, 1}, func(i int) bool { count1 := CountBy([]int{1, 2, 1}, func(i int) bool {
@@ -429,6 +458,7 @@ func TestCountBy(t *testing.T) {
} }
func TestSubset(t *testing.T) { func TestSubset(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
in := []int{0, 1, 2, 3, 4} in := []int{0, 1, 2, 3, 4}
@@ -461,6 +491,7 @@ func TestSubset(t *testing.T) {
} }
func TestSlice(t *testing.T) { func TestSlice(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
in := []int{0, 1, 2, 3, 4} in := []int{0, 1, 2, 3, 4}
@@ -497,6 +528,7 @@ func TestSlice(t *testing.T) {
} }
func TestReplace(t *testing.T) { func TestReplace(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
in := []int{0, 1, 0, 1, 2, 3, 0} in := []int{0, 1, 0, 1, 2, 3, 0}
@@ -525,6 +557,7 @@ func TestReplace(t *testing.T) {
} }
func TestReplaceAll(t *testing.T) { func TestReplaceAll(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
in := []int{0, 1, 0, 1, 2, 3, 0} in := []int{0, 1, 0, 1, 2, 3, 0}
@@ -537,6 +570,7 @@ func TestReplaceAll(t *testing.T) {
} }
func TestCompact(t *testing.T) { func TestCompact(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := Compact([]int{2, 0, 4, 0}) r1 := Compact([]int{2, 0, 4, 0})
@@ -578,6 +612,7 @@ func TestCompact(t *testing.T) {
} }
func TestIsSorted(t *testing.T) { func TestIsSorted(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
is.True(IsSorted([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})) is.True(IsSorted([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}))
@@ -588,6 +623,7 @@ func TestIsSorted(t *testing.T) {
} }
func TestIsSortedByKey(t *testing.T) { func TestIsSortedByKey(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
is.True(IsSortedByKey([]string{"a", "bb", "ccc"}, func(s string) int { is.True(IsSortedByKey([]string{"a", "bb", "ccc"}, func(s string) int {

3
string_test.go
View File

@@ -8,6 +8,7 @@ import (
) )
func TestChunkString(t *testing.T) { func TestChunkString(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := ChunkString("12345", 2) result1 := ChunkString("12345", 2)
@@ -34,6 +35,7 @@ func TestChunkString(t *testing.T) {
} }
func TestSubstring(t *testing.T) { func TestSubstring(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
str1 := Substring("hello", 0, 0) str1 := Substring("hello", 0, 0)
@@ -64,6 +66,7 @@ func TestSubstring(t *testing.T) {
} }
func TestRuneLength(t *testing.T) { func TestRuneLength(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
is.Equal(5, RuneLength("hellô")) is.Equal(5, RuneLength("hellô"))

4
tuples_test.go
View File

@@ -7,6 +7,7 @@ import (
) )
func TestT(t *testing.T) { func TestT(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := T2("a", 1) r1 := T2("a", 1)
@@ -29,6 +30,7 @@ func TestT(t *testing.T) {
} }
func TestUnpack(t *testing.T) { func TestUnpack(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
{ {
@@ -133,6 +135,7 @@ func TestUnpack(t *testing.T) {
} }
func TestZip(t *testing.T) { func TestZip(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1 := Zip2( r1 := Zip2(
@@ -272,6 +275,7 @@ func TestZip(t *testing.T) {
} }
func TestUnzip(t *testing.T) { func TestUnzip(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
r1, r2 := Unzip2([]Tuple2[string, int]{{A: "a", B: 1}, {A: "b", B: 2}}) r1, r2 := Unzip2([]Tuple2[string, int]{{A: "a", B: 1}, {A: "b", B: 2}})

10
type_manipulation_test.go
View File

@@ -7,6 +7,7 @@ import (
) )
func TestToPtr(t *testing.T) { func TestToPtr(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
result1 := ToPtr([]int{1, 2}) result1 := ToPtr([]int{1, 2})
@@ -15,6 +16,7 @@ func TestToPtr(t *testing.T) {
} }
func TestFromPtr(t *testing.T) { func TestFromPtr(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
str1 := "foo" str1 := "foo"
@@ -28,6 +30,7 @@ func TestFromPtr(t *testing.T) {
} }
func TestFromPtrOr(t *testing.T) { func TestFromPtrOr(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
const fallbackStr = "fallback" const fallbackStr = "fallback"
@@ -45,6 +48,7 @@ func TestFromPtrOr(t *testing.T) {
} }
func TestToSlicePtr(t *testing.T) { func TestToSlicePtr(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
str1 := "foo" str1 := "foo"
@@ -55,6 +59,7 @@ func TestToSlicePtr(t *testing.T) {
} }
func TestToAnySlice(t *testing.T) { func TestToAnySlice(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
in1 := []int{0, 1, 2, 3} in1 := []int{0, 1, 2, 3}
@@ -67,6 +72,7 @@ func TestToAnySlice(t *testing.T) {
} }
func TestFromAnySlice(t *testing.T) { func TestFromAnySlice(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
is.NotPanics(func() { is.NotPanics(func() {
@@ -81,6 +87,7 @@ func TestFromAnySlice(t *testing.T) {
} }
func TestEmpty(t *testing.T) { func TestEmpty(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
//nolint:unused //nolint:unused
@@ -95,6 +102,7 @@ func TestEmpty(t *testing.T) {
} }
func TestIsEmpty(t *testing.T) { func TestIsEmpty(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
//nolint:unused //nolint:unused
@@ -111,6 +119,7 @@ func TestIsEmpty(t *testing.T) {
} }
func TestIsNotEmpty(t *testing.T) { func TestIsNotEmpty(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
//nolint:unused //nolint:unused
@@ -127,6 +136,7 @@ func TestIsNotEmpty(t *testing.T) {
} }
func TestCoalesce(t *testing.T) { func TestCoalesce(t *testing.T) {
t.Parallel()
is := assert.New(t) is := assert.New(t)
newStr := func(v string) *string { return &v } newStr := func(v string) *string { return &v }