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

lint: Apply testifylint linter recommendations (#669)

Browse Source
This commit is contained in:
Nathan Baulch
2025-09-20 08:50:00 +10:00
committed by GitHub
parent ba60e479fc
commit 76b76a7adb
15 changed files with 622 additions and 622 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
channel_test.go
View File

@@ -21,13 +21,13 @@ func TestChannelDispatcher(t *testing.T) {
ch <- 2 ch <- 2
ch <- 3 ch <- 3
is.Equal(4, len(ch)) is.Len(ch, 4)
children := ChannelDispatcher(ch, 5, 10, DispatchingStrategyRoundRobin[int]) children := ChannelDispatcher(ch, 5, 10, DispatchingStrategyRoundRobin[int])
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)
// check channels allocation // check channels allocation
is.Equal(5, len(children)) is.Len(children, 5)
is.Equal(10, cap(children[0])) is.Equal(10, cap(children[0]))
is.Equal(10, cap(children[1])) is.Equal(10, cap(children[1]))
@@ -35,34 +35,34 @@ func TestChannelDispatcher(t *testing.T) {
is.Equal(10, cap(children[3])) is.Equal(10, cap(children[3]))
is.Equal(10, cap(children[4])) is.Equal(10, cap(children[4]))
is.Equal(1, len(children[0])) is.Len(children[0], 1)
is.Equal(1, len(children[1])) is.Len(children[1], 1)
is.Equal(1, len(children[2])) is.Len(children[2], 1)
is.Equal(1, len(children[3])) is.Len(children[3], 1)
is.Equal(0, len(children[4])) is.Empty(children[4])
// check channels content // check channels content
is.Equal(0, len(ch)) is.Empty(ch)
msg0, ok0 := <-children[0] msg0, ok0 := <-children[0]
is.Equal(ok0, true) is.True(ok0)
is.Equal(msg0, 0) is.Zero(msg0)
msg1, ok1 := <-children[1] msg1, ok1 := <-children[1]
is.Equal(ok1, true) is.True(ok1)
is.Equal(msg1, 1) is.Equal(1, msg1)
msg2, ok2 := <-children[2] msg2, ok2 := <-children[2]
is.Equal(ok2, true) is.True(ok2)
is.Equal(msg2, 2) is.Equal(2, msg2)
msg3, ok3 := <-children[3] msg3, ok3 := <-children[3]
is.Equal(ok3, true) is.True(ok3)
is.Equal(msg3, 3) is.Equal(3, msg3)
// msg4, ok4 := <-children[4] // msg4, ok4 := <-children[4]
// is.Equal(ok4, false) // is.False(ok4)
// is.Equal(msg4, 0) // is.Zero(msg4)
// is.Nil(children[4]) // is.Nil(children[4])
// check it is closed // check it is closed
@@ -73,28 +73,28 @@ func TestChannelDispatcher(t *testing.T) {
}) })
msg0, ok0 = <-children[0] msg0, ok0 = <-children[0]
is.Equal(ok0, false) is.False(ok0)
is.Equal(msg0, 0) is.Zero(msg0)
msg1, ok1 = <-children[1] msg1, ok1 = <-children[1]
is.Equal(ok1, false) is.False(ok1)
is.Equal(msg1, 0) is.Zero(msg1)
msg2, ok2 = <-children[2] msg2, ok2 = <-children[2]
is.Equal(ok2, false) is.False(ok2)
is.Equal(msg2, 0) is.Zero(msg2)
msg3, ok3 = <-children[3] msg3, ok3 = <-children[3]
is.Equal(ok3, false) is.False(ok3)
is.Equal(msg3, 0) is.Zero(msg3)
msg4, ok4 := <-children[4] msg4, ok4 := <-children[4]
is.Equal(ok4, false) is.False(ok4)
is.Equal(msg4, 0) is.Zero(msg4)
// unbuffered channels // unbuffered channels
children = ChannelDispatcher(ch, 5, 0, DispatchingStrategyRoundRobin[int]) children = ChannelDispatcher(ch, 5, 0, DispatchingStrategyRoundRobin[int])
is.Equal(0, cap(children[0])) is.Zero(cap(children[0]))
} }
func TestDispatchingStrategyRoundRobin(t *testing.T) { func TestDispatchingStrategyRoundRobin(t *testing.T) {
@@ -106,10 +106,10 @@ func TestDispatchingStrategyRoundRobin(t *testing.T) {
rochildren := channelsToReadOnly(children) rochildren := channelsToReadOnly(children)
defer closeChannels(children) defer closeChannels(children)
is.Equal(0, DispatchingStrategyRoundRobin(42, 0, rochildren)) is.Zero(DispatchingStrategyRoundRobin(42, 0, rochildren))
is.Equal(1, DispatchingStrategyRoundRobin(42, 1, rochildren)) is.Equal(1, DispatchingStrategyRoundRobin(42, 1, rochildren))
is.Equal(2, DispatchingStrategyRoundRobin(42, 2, rochildren)) is.Equal(2, DispatchingStrategyRoundRobin(42, 2, rochildren))
is.Equal(0, DispatchingStrategyRoundRobin(42, 3, rochildren)) is.Zero(DispatchingStrategyRoundRobin(42, 3, rochildren))
} }
func TestDispatchingStrategyRandom(t *testing.T) { func TestDispatchingStrategyRandom(t *testing.T) {
@@ -127,7 +127,7 @@ func TestDispatchingStrategyRandom(t *testing.T) {
children[1] <- i children[1] <- i
} }
is.Equal(0, DispatchingStrategyRandom(42, 0, rochildren)) is.Zero(DispatchingStrategyRandom(42, 0, rochildren))
} }
func TestDispatchingStrategyWeightedRandom(t *testing.T) { func TestDispatchingStrategyWeightedRandom(t *testing.T) {
@@ -157,9 +157,9 @@ func TestDispatchingStrategyFirst(t *testing.T) {
rochildren := channelsToReadOnly(children) rochildren := channelsToReadOnly(children)
defer closeChannels(children) defer closeChannels(children)
is.Equal(0, DispatchingStrategyFirst(42, 0, rochildren)) is.Zero(DispatchingStrategyFirst(42, 0, rochildren))
children[0] <- 0 children[0] <- 0
is.Equal(0, DispatchingStrategyFirst(42, 0, rochildren)) is.Zero(DispatchingStrategyFirst(42, 0, rochildren))
children[0] <- 1 children[0] <- 1
is.Equal(1, DispatchingStrategyFirst(42, 0, rochildren)) is.Equal(1, DispatchingStrategyFirst(42, 0, rochildren))
} }
@@ -173,15 +173,15 @@ func TestDispatchingStrategyLeast(t *testing.T) {
rochildren := channelsToReadOnly(children) rochildren := channelsToReadOnly(children)
defer closeChannels(children) defer closeChannels(children)
is.Equal(0, DispatchingStrategyLeast(42, 0, rochildren)) is.Zero(DispatchingStrategyLeast(42, 0, rochildren))
children[0] <- 0 children[0] <- 0
is.Equal(1, DispatchingStrategyLeast(42, 0, rochildren)) is.Equal(1, DispatchingStrategyLeast(42, 0, rochildren))
children[1] <- 0 children[1] <- 0
is.Equal(0, DispatchingStrategyLeast(42, 0, rochildren)) is.Zero(DispatchingStrategyLeast(42, 0, rochildren))
children[0] <- 1 children[0] <- 1
is.Equal(1, DispatchingStrategyLeast(42, 0, rochildren)) is.Equal(1, DispatchingStrategyLeast(42, 0, rochildren))
children[1] <- 1 children[1] <- 1
is.Equal(0, DispatchingStrategyLeast(42, 0, rochildren)) is.Zero(DispatchingStrategyLeast(42, 0, rochildren))
} }
func TestDispatchingStrategyMost(t *testing.T) { func TestDispatchingStrategyMost(t *testing.T) {
@@ -193,15 +193,15 @@ func TestDispatchingStrategyMost(t *testing.T) {
rochildren := channelsToReadOnly(children) rochildren := channelsToReadOnly(children)
defer closeChannels(children) defer closeChannels(children)
is.Equal(0, DispatchingStrategyMost(42, 0, rochildren)) is.Zero(DispatchingStrategyMost(42, 0, rochildren))
children[0] <- 0 children[0] <- 0
is.Equal(0, DispatchingStrategyMost(42, 0, rochildren)) is.Zero(DispatchingStrategyMost(42, 0, rochildren))
children[1] <- 0 children[1] <- 0
is.Equal(0, DispatchingStrategyMost(42, 0, rochildren)) is.Zero(DispatchingStrategyMost(42, 0, rochildren))
children[0] <- 1 children[0] <- 1
is.Equal(0, DispatchingStrategyMost(42, 0, rochildren)) is.Zero(DispatchingStrategyMost(42, 0, rochildren))
children[1] <- 1 children[1] <- 1
is.Equal(0, DispatchingStrategyMost(42, 0, rochildren)) is.Zero(DispatchingStrategyMost(42, 0, rochildren))
} }
func TestSliceToChannel(t *testing.T) { func TestSliceToChannel(t *testing.T) {
@@ -255,7 +255,7 @@ func TestGenerate(t *testing.T) {
i++ i++
} }
is.Equal(i, 4) is.Equal(4, i)
} }
func TestBuffer(t *testing.T) { func TestBuffer(t *testing.T) {
@@ -276,7 +276,7 @@ func TestBuffer(t *testing.T) {
is.Equal(1, length2) is.Equal(1, length2)
is.False(ok2) is.False(ok2)
is.Equal([]int{}, items3) is.Equal([]int{}, items3)
is.Equal(0, length3) is.Zero(length3)
is.False(ok3) is.False(ok3)
} }
@@ -336,7 +336,7 @@ func TestBufferWithTimeout(t *testing.T) {
items2, length2, _, ok2 := BufferWithTimeout(ch, 20, 2*time.Millisecond) items2, length2, _, ok2 := BufferWithTimeout(ch, 20, 2*time.Millisecond)
is.Equal([]int{}, items2) is.Equal([]int{}, items2)
is.Equal(0, length2) is.Zero(length2)
is.True(ok2) is.True(ok2)
items3, length3, _, ok3 := BufferWithTimeout(ch, 1, 30*time.Millisecond) items3, length3, _, ok3 := BufferWithTimeout(ch, 1, 30*time.Millisecond)
@@ -351,7 +351,7 @@ func TestBufferWithTimeout(t *testing.T) {
items5, length5, _, ok5 := BufferWithTimeout(ch, 3, 25*time.Millisecond) items5, length5, _, ok5 := BufferWithTimeout(ch, 3, 25*time.Millisecond)
is.Equal([]int{}, items5) is.Equal([]int{}, items5)
is.Equal(0, length5) is.Zero(length5)
is.False(ok5) is.False(ok5)
} }
@@ -373,26 +373,26 @@ func TestFanIn(t *testing.T) {
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)
// check input channels // check input channels
is.Equal(0, len(roupstreams[0])) is.Empty(roupstreams[0])
is.Equal(0, len(roupstreams[1])) is.Empty(roupstreams[1])
is.Equal(0, len(roupstreams[2])) is.Empty(roupstreams[2])
// check channels allocation // check channels allocation
is.Equal(6, len(out)) is.Len(out, 6)
is.Equal(10, cap(out)) is.Equal(10, cap(out))
// check channels content // check channels content
for i := 0; i < 6; i++ { for i := 0; i < 6; i++ {
msg0, ok0 := <-out msg0, ok0 := <-out
is.Equal(true, ok0) is.True(ok0)
is.Equal(1, msg0) is.Equal(1, msg0)
} }
// check it is closed // check it is closed
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)
msg0, ok0 := <-out msg0, ok0 := <-out
is.Equal(false, ok0) is.False(ok0)
is.Equal(0, msg0) is.Zero(msg0)
} }
func TestFanOut(t *testing.T) { func TestFanOut(t *testing.T) {
@@ -406,11 +406,11 @@ func TestFanOut(t *testing.T) {
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)
// check output channels // check output channels
is.Equal(3, len(rodownstreams)) is.Len(rodownstreams, 3)
// check channels allocation // check channels allocation
for i := range rodownstreams { for i := range rodownstreams {
is.Equal(6, len(rodownstreams[i])) is.Len(rodownstreams[i], 6)
is.Equal(10, cap(rodownstreams[i])) is.Equal(10, cap(rodownstreams[i]))
is.Equal([]int{0, 1, 2, 3, 4, 5}, ChannelToSlice(rodownstreams[i])) is.Equal([]int{0, 1, 2, 3, 4, 5}, ChannelToSlice(rodownstreams[i]))
} }
@@ -421,7 +421,7 @@ func TestFanOut(t *testing.T) {
// check channels allocation // check channels allocation
for i := range rodownstreams { for i := range rodownstreams {
msg, ok := <-rodownstreams[i] msg, ok := <-rodownstreams[i]
is.Equal(false, ok) is.False(ok)
is.Equal(0, msg) is.Zero(msg)
} }
} }

24
concurrency_test.go
View File

@@ -78,7 +78,7 @@ func TestAsync(t *testing.T) {
select { select {
case result := <-ch: case result := <-ch:
is.Equal(result, 10) is.Equal(10, result)
case <-time.After(time.Millisecond): case <-time.After(time.Millisecond):
is.Fail("Async should not block") is.Fail("Async should not block")
} }
@@ -117,7 +117,7 @@ func TestAsyncX(t *testing.T) {
select { select {
case result := <-ch: case result := <-ch:
is.Equal(result, 10) is.Equal(10, result)
case <-time.After(time.Millisecond): case <-time.After(time.Millisecond):
is.Fail("Async1 should not block") is.Fail("Async1 should not block")
} }
@@ -135,7 +135,7 @@ func TestAsyncX(t *testing.T) {
select { select {
case result := <-ch: case result := <-ch:
is.Equal(result, Tuple2[int, string]{10, "Hello"}) is.Equal(Tuple2[int, string]{10, "Hello"}, result)
case <-time.After(time.Millisecond): case <-time.After(time.Millisecond):
is.Fail("Async2 should not block") is.Fail("Async2 should not block")
} }
@@ -153,7 +153,7 @@ func TestAsyncX(t *testing.T) {
select { select {
case result := <-ch: case result := <-ch:
is.Equal(result, Tuple3[int, string, bool]{10, "Hello", true}) is.Equal(Tuple3[int, string, bool]{10, "Hello", true}, result)
case <-time.After(time.Millisecond): case <-time.After(time.Millisecond):
is.Fail("Async3 should not block") is.Fail("Async3 should not block")
} }
@@ -171,7 +171,7 @@ func TestAsyncX(t *testing.T) {
select { select {
case result := <-ch: case result := <-ch:
is.Equal(result, Tuple4[int, string, bool, float64]{10, "Hello", true, 3.14}) is.Equal(Tuple4[int, string, bool, float64]{10, "Hello", true, 3.14}, result)
case <-time.After(time.Millisecond): case <-time.After(time.Millisecond):
is.Fail("Async4 should not block") is.Fail("Async4 should not block")
} }
@@ -189,7 +189,7 @@ func TestAsyncX(t *testing.T) {
select { select {
case result := <-ch: case result := <-ch:
is.Equal(result, Tuple5[int, string, bool, float64, string]{10, "Hello", true, 3.14, "World"}) is.Equal(Tuple5[int, string, bool, float64, string]{10, "Hello", true, 3.14, "World"}, result)
case <-time.After(time.Millisecond): case <-time.After(time.Millisecond):
is.Fail("Async5 should not block") is.Fail("Async5 should not block")
} }
@@ -207,7 +207,7 @@ func TestAsyncX(t *testing.T) {
select { select {
case result := <-ch: case result := <-ch:
is.Equal(result, Tuple6[int, string, bool, float64, string, int]{10, "Hello", true, 3.14, "World", 100}) is.Equal(Tuple6[int, string, bool, float64, string, int]{10, "Hello", true, 3.14, "World", 100}, result)
case <-time.After(time.Millisecond): case <-time.After(time.Millisecond):
is.Fail("Async6 should not block") is.Fail("Async6 should not block")
} }
@@ -266,7 +266,7 @@ func TestWaitFor(t *testing.T) {
is := assert.New(t) is := assert.New(t)
iter, duration, ok := WaitFor(alwaysFalse, shortTimeout, 10*time.Millisecond) iter, duration, ok := WaitFor(alwaysFalse, shortTimeout, 10*time.Millisecond)
is.Equal(0, iter, "unexpected iteration count") is.Zero(iter, "unexpected iteration count")
is.InEpsilon(10*time.Millisecond, duration, float64(500*time.Microsecond)) is.InEpsilon(10*time.Millisecond, duration, float64(500*time.Microsecond))
is.False(ok) is.False(ok)
}) })
@@ -279,7 +279,7 @@ func TestWaitFor(t *testing.T) {
shortTimeout := 4 * time.Millisecond shortTimeout := 4 * time.Millisecond
iter, duration, ok := WaitFor(alwaysFalse, shortTimeout, 10*time.Millisecond) iter, duration, ok := WaitFor(alwaysFalse, shortTimeout, 10*time.Millisecond)
is.Equal(0, iter, "unexpected iteration count") is.Zero(iter, "unexpected iteration count")
is.InEpsilon(10*time.Millisecond, duration, float64(500*time.Microsecond)) is.InEpsilon(10*time.Millisecond, duration, float64(500*time.Microsecond))
is.False(ok) is.False(ok)
}) })
@@ -349,7 +349,7 @@ func TestWaitForWithContext(t *testing.T) {
is := assert.New(t) is := assert.New(t)
iter, duration, ok := WaitForWithContext(context.Background(), alwaysFalse, shortTimeout, 10*time.Millisecond) iter, duration, ok := WaitForWithContext(context.Background(), alwaysFalse, shortTimeout, 10*time.Millisecond)
is.Equal(0, iter, "unexpected iteration count") is.Zero(iter, "unexpected iteration count")
is.InEpsilon(10*time.Millisecond, duration, float64(500*time.Microsecond)) is.InEpsilon(10*time.Millisecond, duration, float64(500*time.Microsecond))
is.False(ok) is.False(ok)
}) })
@@ -362,7 +362,7 @@ func TestWaitForWithContext(t *testing.T) {
shortTimeout := 4 * time.Millisecond shortTimeout := 4 * time.Millisecond
iter, duration, ok := WaitForWithContext(context.Background(), alwaysFalse, shortTimeout, 10*time.Millisecond) iter, duration, ok := WaitForWithContext(context.Background(), alwaysFalse, shortTimeout, 10*time.Millisecond)
is.Equal(0, iter, "unexpected iteration count") is.Zero(iter, "unexpected iteration count")
is.InEpsilon(10*time.Millisecond, duration, float64(500*time.Microsecond)) is.InEpsilon(10*time.Millisecond, duration, float64(500*time.Microsecond))
is.False(ok) is.False(ok)
}) })
@@ -406,7 +406,7 @@ func TestWaitForWithContext(t *testing.T) {
cancel() cancel()
iter, duration, ok := WaitForWithContext(canceledCtx, alwaysFalse, 100*time.Millisecond, 1050*time.Microsecond) iter, duration, ok := WaitForWithContext(canceledCtx, alwaysFalse, 100*time.Millisecond, 1050*time.Microsecond)
is.Equal(0, iter, "unexpected iteration count") is.Zero(iter, "unexpected iteration count")
is.InEpsilon(1*time.Millisecond, duration, float64(5*time.Microsecond)) is.InEpsilon(1*time.Millisecond, duration, float64(5*time.Microsecond))
is.False(ok) is.False(ok)
}) })

40
condition_test.go
View File

@@ -13,8 +13,8 @@ func TestTernary(t *testing.T) {
result1 := Ternary(true, "a", "b") result1 := Ternary(true, "a", "b")
result2 := Ternary(false, "a", "b") result2 := Ternary(false, "a", "b")
is.Equal(result1, "a") is.Equal("a", result1)
is.Equal(result2, "b") is.Equal("b", result2)
} }
func TestTernaryF(t *testing.T) { func TestTernaryF(t *testing.T) {
@@ -23,8 +23,8 @@ func TestTernaryF(t *testing.T) {
result1 := TernaryF(true, func() string { return "a" }, func() string { return "b" }) result1 := TernaryF(true, func() string { return "a" }, func() string { return "b" })
result2 := TernaryF(false, func() string { return "a" }, func() string { return "b" }) result2 := TernaryF(false, func() string { return "a" }, func() string { return "b" })
is.Equal(result1, "a") is.Equal("a", result1)
is.Equal(result2, "b") is.Equal("b", result2)
} }
func TestIfElse(t *testing.T) { func TestIfElse(t *testing.T) {
@@ -36,10 +36,10 @@ func TestIfElse(t *testing.T) {
result3 := If(false, 1).ElseIf(true, 2).Else(3) result3 := If(false, 1).ElseIf(true, 2).Else(3)
result4 := If(false, 1).ElseIf(false, 2).Else(3) result4 := If(false, 1).ElseIf(false, 2).Else(3)
is.Equal(result1, 1) is.Equal(1, result1)
is.Equal(result2, 1) is.Equal(1, result2)
is.Equal(result3, 2) is.Equal(2, result3)
is.Equal(result4, 3) is.Equal(3, result4)
} }
func TestIfFElseF(t *testing.T) { func TestIfFElseF(t *testing.T) {
@@ -51,10 +51,10 @@ func TestIfFElseF(t *testing.T) {
result3 := IfF(false, func() int { return 1 }).ElseIfF(true, func() int { return 2 }).ElseF(func() int { return 3 }) result3 := IfF(false, func() int { return 1 }).ElseIfF(true, func() int { return 2 }).ElseF(func() int { return 3 })
result4 := IfF(false, func() int { return 1 }).ElseIfF(false, func() int { return 2 }).ElseF(func() int { return 3 }) result4 := IfF(false, func() int { return 1 }).ElseIfF(false, func() int { return 2 }).ElseF(func() int { return 3 })
is.Equal(result1, 1) is.Equal(1, result1)
is.Equal(result2, 1) is.Equal(1, result2)
is.Equal(result3, 2) is.Equal(2, result3)
is.Equal(result4, 3) is.Equal(3, result4)
} }
func TestSwitchCase(t *testing.T) { func TestSwitchCase(t *testing.T) {
@@ -66,10 +66,10 @@ func TestSwitchCase(t *testing.T) {
result3 := Switch[int, int](42).Case(1, 1).Case(42, 2).Default(3) result3 := Switch[int, int](42).Case(1, 1).Case(42, 2).Default(3)
result4 := Switch[int, int](42).Case(1, 1).Case(1, 2).Default(3) result4 := Switch[int, int](42).Case(1, 1).Case(1, 2).Default(3)
is.Equal(result1, 1) is.Equal(1, result1)
is.Equal(result2, 1) is.Equal(1, result2)
is.Equal(result3, 2) is.Equal(2, result3)
is.Equal(result4, 3) is.Equal(3, result4)
} }
func TestSwitchCaseF(t *testing.T) { func TestSwitchCaseF(t *testing.T) {
@@ -81,8 +81,8 @@ func TestSwitchCaseF(t *testing.T) {
result3 := Switch[int, int](42).CaseF(1, func() int { return 1 }).CaseF(42, func() int { return 2 }).DefaultF(func() int { return 3 }) result3 := Switch[int, int](42).CaseF(1, func() int { return 1 }).CaseF(42, func() int { return 2 }).DefaultF(func() int { return 3 })
result4 := Switch[int, int](42).CaseF(1, func() int { return 1 }).CaseF(1, func() int { return 2 }).DefaultF(func() int { return 3 }) result4 := Switch[int, int](42).CaseF(1, func() int { return 1 }).CaseF(1, func() int { return 2 }).DefaultF(func() int { return 3 })
is.Equal(result1, 1) is.Equal(1, result1)
is.Equal(result2, 1) is.Equal(1, result2)
is.Equal(result3, 2) is.Equal(2, result3)
is.Equal(result4, 3) is.Equal(3, result4)
} }

30
errors_test.go
View File

@@ -407,17 +407,17 @@ func TestTryOrX(t *testing.T) {
is.Equal(42, a1) is.Equal(42, a1)
is.Equal("hello", b1) is.Equal("hello", b1)
is.Equal(false, c1) is.False(c1)
is.False(ok1) is.False(ok1)
is.Equal(42, a2) is.Equal(42, a2)
is.Equal("hello", b2) is.Equal("hello", b2)
is.Equal(false, c2) is.False(c2)
is.False(ok2) is.False(ok2)
is.Equal(21, a3) is.Equal(21, a3)
is.Equal("world", b3) is.Equal("world", b3)
is.Equal(true, c3) is.True(c3)
is.True(ok3) is.True(ok3)
} }
@@ -428,19 +428,19 @@ func TestTryOrX(t *testing.T) {
is.Equal(42, a1) is.Equal(42, a1)
is.Equal("hello", b1) is.Equal("hello", b1)
is.Equal(false, c1) is.False(c1)
is.Equal(42, d1) is.Equal(42, d1)
is.False(ok1) is.False(ok1)
is.Equal(42, a2) is.Equal(42, a2)
is.Equal("hello", b2) is.Equal("hello", b2)
is.Equal(false, c2) is.False(c2)
is.Equal(42, d2) is.Equal(42, d2)
is.False(ok2) is.False(ok2)
is.Equal(21, a3) is.Equal(21, a3)
is.Equal("world", b3) is.Equal("world", b3)
is.Equal(true, c3) is.True(c3)
is.Equal(21, d3) is.Equal(21, d3)
is.True(ok3) is.True(ok3)
} }
@@ -452,21 +452,21 @@ func TestTryOrX(t *testing.T) {
is.Equal(42, a1) is.Equal(42, a1)
is.Equal("hello", b1) is.Equal("hello", b1)
is.Equal(false, c1) is.False(c1)
is.Equal(42, d1) is.Equal(42, d1)
is.Equal(42, e1) is.Equal(42, e1)
is.False(ok1) is.False(ok1)
is.Equal(42, a2) is.Equal(42, a2)
is.Equal("hello", b2) is.Equal("hello", b2)
is.Equal(false, c2) is.False(c2)
is.Equal(42, d2) is.Equal(42, d2)
is.Equal(42, e2) is.Equal(42, e2)
is.False(ok2) is.False(ok2)
is.Equal(21, a3) is.Equal(21, a3)
is.Equal("world", b3) is.Equal("world", b3)
is.Equal(true, c3) is.True(c3)
is.Equal(21, d3) is.Equal(21, d3)
is.Equal(21, e3) is.Equal(21, e3)
is.True(ok3) is.True(ok3)
@@ -479,7 +479,7 @@ func TestTryOrX(t *testing.T) {
is.Equal(42, a1) is.Equal(42, a1)
is.Equal("hello", b1) is.Equal("hello", b1)
is.Equal(false, c1) is.False(c1)
is.Equal(42, d1) is.Equal(42, d1)
is.Equal(42, e1) is.Equal(42, e1)
is.Equal(42, f1) is.Equal(42, f1)
@@ -487,7 +487,7 @@ func TestTryOrX(t *testing.T) {
is.Equal(42, a2) is.Equal(42, a2)
is.Equal("hello", b2) is.Equal("hello", b2)
is.Equal(false, c2) is.False(c2)
is.Equal(42, d2) is.Equal(42, d2)
is.Equal(42, e2) is.Equal(42, e2)
is.Equal(42, f2) is.Equal(42, f2)
@@ -495,7 +495,7 @@ func TestTryOrX(t *testing.T) {
is.Equal(21, a3) is.Equal(21, a3)
is.Equal("world", b3) is.Equal("world", b3)
is.Equal(true, c3) is.True(c3)
is.Equal(21, d3) is.Equal(21, d3)
is.Equal(21, e3) is.Equal(21, e3)
is.Equal(21, f3) is.Equal(21, f3)
@@ -524,7 +524,7 @@ func TestTryWithErrorValue(t *testing.T) {
return nil return nil
}) })
is.True(ok) is.True(ok)
is.Equal(nil, err) is.Nil(err)
} }
func TestTryCatch(t *testing.T) { func TestTryCatch(t *testing.T) {
@@ -587,7 +587,7 @@ func TestErrorsAs(t *testing.T) {
err, ok := ErrorsAs[*internalError](fmt.Errorf("hello world")) err, ok := ErrorsAs[*internalError](fmt.Errorf("hello world"))
is.False(ok) is.False(ok)
is.Nil(nil, err) is.Nil(err)
err, ok = ErrorsAs[*internalError](&internalError{foobar: "foobar"}) err, ok = ErrorsAs[*internalError](&internalError{foobar: "foobar"})
is.True(ok) is.True(ok)
@@ -595,7 +595,7 @@ func TestErrorsAs(t *testing.T) {
err, ok = ErrorsAs[*internalError](nil) err, ok = ErrorsAs[*internalError](nil)
is.False(ok) is.False(ok)
is.Nil(nil, err) is.Nil(err)
} }
func TestAssert(t *testing.T) { func TestAssert(t *testing.T) {

238
find_test.go
View File

@@ -17,8 +17,8 @@ func TestIndexOf(t *testing.T) {
result1 := IndexOf([]int{0, 1, 2, 1, 2, 3}, 2) result1 := IndexOf([]int{0, 1, 2, 1, 2, 3}, 2)
result2 := IndexOf([]int{0, 1, 2, 1, 2, 3}, 6) result2 := IndexOf([]int{0, 1, 2, 1, 2, 3}, 6)
is.Equal(result1, 2) is.Equal(2, result1)
is.Equal(result2, -1) is.Equal(-1, result2)
} }
func TestLastIndexOf(t *testing.T) { func TestLastIndexOf(t *testing.T) {
@@ -28,8 +28,8 @@ func TestLastIndexOf(t *testing.T) {
result1 := LastIndexOf([]int{0, 1, 2, 1, 2, 3}, 2) result1 := LastIndexOf([]int{0, 1, 2, 1, 2, 3}, 2)
result2 := LastIndexOf([]int{0, 1, 2, 1, 2, 3}, 6) result2 := LastIndexOf([]int{0, 1, 2, 1, 2, 3}, 6)
is.Equal(result1, 4) is.Equal(4, result1)
is.Equal(result2, -1) is.Equal(-1, result2)
} }
func TestFind(t *testing.T) { func TestFind(t *testing.T) {
@@ -48,10 +48,10 @@ func TestFind(t *testing.T) {
return item == "b" return item == "b"
}) })
is.Equal(ok1, true) is.True(ok1)
is.Equal(result1, "b") is.Equal("b", result1)
is.Equal(ok2, false) is.False(ok2)
is.Equal(result2, "") is.Empty(result2)
} }
func TestFindIndexOf(t *testing.T) { func TestFindIndexOf(t *testing.T) {
@@ -69,11 +69,11 @@ func TestFindIndexOf(t *testing.T) {
return item == "b" return item == "b"
}) })
is.Equal(item1, "b") is.Equal("b", item1)
is.Equal(ok1, true) is.True(ok1)
is.Equal(index1, 1) is.Equal(1, index1)
is.Equal(item2, "") is.Empty(item2)
is.Equal(ok2, false) is.False(ok2)
is.Equal(index2, -1) is.Equal(index2, -1)
} }
@@ -92,11 +92,11 @@ func TestFindLastIndexOf(t *testing.T) {
return item == "b" return item == "b"
}) })
is.Equal(item1, "b") is.Equal("b", item1)
is.Equal(ok1, true) is.True(ok1)
is.Equal(index1, 4) is.Equal(4, index1)
is.Equal(item2, "") is.Empty(item2)
is.Equal(ok2, false) is.False(ok2)
is.Equal(index2, -1) is.Equal(index2, -1)
} }
@@ -115,8 +115,8 @@ func TestFindOrElse(t *testing.T) {
return item == "b" return item == "b"
}) })
is.Equal(result1, "b") is.Equal("b", result1)
is.Equal(result2, "x") is.Equal("x", result2)
} }
func TestFindKey(t *testing.T) { func TestFindKey(t *testing.T) {
@@ -128,7 +128,7 @@ func TestFindKey(t *testing.T) {
is.True(ok1) is.True(ok1)
result2, ok2 := FindKey(map[string]int{"foo": 1, "bar": 2, "baz": 3}, 42) result2, ok2 := FindKey(map[string]int{"foo": 1, "bar": 2, "baz": 3}, 42)
is.Equal("", result2) is.Empty(result2)
is.False(ok2) is.False(ok2)
type test struct { type test struct {
@@ -140,7 +140,7 @@ func TestFindKey(t *testing.T) {
is.True(ok3) is.True(ok3)
result4, ok4 := FindKey(map[string]test{"foo": {"foo"}, "bar": {"bar"}, "baz": {"baz"}}, test{"hello world"}) result4, ok4 := FindKey(map[string]test{"foo": {"foo"}, "bar": {"bar"}, "baz": {"baz"}}, test{"hello world"})
is.Equal("", result4) is.Empty(result4)
is.False(ok4) is.False(ok4)
} }
@@ -157,7 +157,7 @@ func TestFindKeyBy(t *testing.T) {
result2, ok2 := FindKeyBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool { result2, ok2 := FindKeyBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool {
return false return false
}) })
is.Equal("", result2) is.Empty(result2)
is.False(ok2) is.False(ok2)
} }
@@ -167,22 +167,22 @@ func TestFindUniques(t *testing.T) {
result1 := FindUniques([]int{1, 2, 3}) result1 := FindUniques([]int{1, 2, 3})
is.Equal(3, len(result1)) 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.Equal(1, len(result2)) 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.Equal(0, len(result3)) is.Empty(result3)
is.Equal([]int{}, result3) is.Equal([]int{}, result3)
result4 := FindUniques([]int{}) result4 := FindUniques([]int{})
is.Equal(0, len(result4)) is.Empty(result4)
is.Equal([]int{}, result4) is.Equal([]int{}, result4)
type myStrings []string type myStrings []string
@@ -199,28 +199,28 @@ func TestFindUniquesBy(t *testing.T) {
return i % 3 return i % 3
}) })
is.Equal(3, len(result1)) 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.Equal(1, len(result2)) 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.Equal(0, len(result3)) is.Empty(result3)
is.Equal([]int{}, 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.Equal(0, len(result4)) is.Empty(result4)
is.Equal([]int{}, result4) is.Equal([]int{}, result4)
type myStrings []string type myStrings []string
@@ -237,17 +237,17 @@ func TestFindDuplicates(t *testing.T) {
result1 := FindDuplicates([]int{1, 2, 2, 1, 2, 3}) result1 := FindDuplicates([]int{1, 2, 2, 1, 2, 3})
is.Equal(2, len(result1)) 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.Equal(0, len(result2)) is.Empty(result2)
is.Equal([]int{}, result2) is.Equal([]int{}, result2)
result3 := FindDuplicates([]int{}) result3 := FindDuplicates([]int{})
is.Equal(0, len(result3)) is.Empty(result3)
is.Equal([]int{}, result3) is.Equal([]int{}, result3)
type myStrings []string type myStrings []string
@@ -264,21 +264,21 @@ func TestFindDuplicatesBy(t *testing.T) {
return i % 3 return i % 3
}) })
is.Equal(2, len(result1)) 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.Equal(0, len(result2)) is.Empty(result2)
is.Equal([]int{}, 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.Equal(0, len(result3)) is.Empty(result3)
is.Equal([]int{}, result3) is.Equal([]int{}, result3)
type myStrings []string type myStrings []string
@@ -298,10 +298,10 @@ func TestMin(t *testing.T) {
result3 := Min([]time.Duration{time.Second, time.Minute, time.Hour}) result3 := Min([]time.Duration{time.Second, time.Minute, time.Hour})
result4 := Min([]int{}) result4 := Min([]int{})
is.Equal(result1, 1) is.Equal(1, result1)
is.Equal(result2, 1) is.Equal(1, result2)
is.Equal(result3, time.Second) is.Equal(time.Second, result3)
is.Equal(result4, 0) is.Zero(result4)
} }
func TestMinIndex(t *testing.T) { func TestMinIndex(t *testing.T) {
@@ -313,16 +313,16 @@ func TestMinIndex(t *testing.T) {
result3, index3 := MinIndex([]time.Duration{time.Second, time.Minute, time.Hour}) result3, index3 := MinIndex([]time.Duration{time.Second, time.Minute, time.Hour})
result4, index4 := MinIndex([]int{}) result4, index4 := MinIndex([]int{})
is.Equal(result1, 1) is.Equal(1, result1)
is.Equal(index1, 0) is.Zero(index1)
is.Equal(result2, 1) is.Equal(1, result2)
is.Equal(index2, 2) is.Equal(2, index2)
is.Equal(result3, time.Second) is.Equal(time.Second, result3)
is.Equal(index3, 0) is.Zero(index3)
is.Equal(result4, 0) is.Zero(result4)
is.Equal(index4, -1) is.Equal(index4, -1)
} }
@@ -340,9 +340,9 @@ func TestMinBy(t *testing.T) {
return len(item) < len(min) return len(item) < len(min)
}) })
is.Equal(result1, "s1") is.Equal("s1", result1)
is.Equal(result2, "s3") is.Equal("s3", result2)
is.Equal(result3, "") is.Empty(result3)
} }
func TestMinIndexBy(t *testing.T) { func TestMinIndexBy(t *testing.T) {
@@ -359,13 +359,13 @@ func TestMinIndexBy(t *testing.T) {
return len(item) < len(min) return len(item) < len(min)
}) })
is.Equal(result1, "s1") is.Equal("s1", result1)
is.Equal(index1, 0) is.Zero(index1)
is.Equal(result2, "s3") is.Equal("s3", result2)
is.Equal(index2, 2) is.Equal(2, index2)
is.Equal(result3, "") is.Empty(result3)
is.Equal(index3, -1) is.Equal(index3, -1)
} }
@@ -378,8 +378,8 @@ func TestEarliest(t *testing.T) {
result1 := Earliest(a, b) result1 := Earliest(a, b)
result2 := Earliest() result2 := Earliest()
is.Equal(result1, a) is.Equal(a, result1)
is.Equal(result2, time.Time{}) is.Equal(time.Time{}, result2)
} }
func TestEarliestBy(t *testing.T) { func TestEarliestBy(t *testing.T) {
@@ -403,9 +403,9 @@ func TestEarliestBy(t *testing.T) {
return i.bar return i.bar
}) })
is.Equal(result1, foo{t3}) is.Equal(foo{t3}, result1)
is.Equal(result2, foo{t1}) is.Equal(foo{t1}, result2)
is.Equal(result3, foo{}) is.Equal(foo{}, result3)
} }
func TestMax(t *testing.T) { func TestMax(t *testing.T) {
@@ -417,10 +417,10 @@ func TestMax(t *testing.T) {
result3 := Max([]time.Duration{time.Second, time.Minute, time.Hour}) result3 := Max([]time.Duration{time.Second, time.Minute, time.Hour})
result4 := Max([]int{}) result4 := Max([]int{})
is.Equal(result1, 3) is.Equal(3, result1)
is.Equal(result2, 3) is.Equal(3, result2)
is.Equal(result3, time.Hour) is.Equal(time.Hour, result3)
is.Equal(result4, 0) is.Zero(result4)
} }
func TestMaxIndex(t *testing.T) { func TestMaxIndex(t *testing.T) {
@@ -432,16 +432,16 @@ func TestMaxIndex(t *testing.T) {
result3, index3 := MaxIndex([]time.Duration{time.Second, time.Minute, time.Hour}) result3, index3 := MaxIndex([]time.Duration{time.Second, time.Minute, time.Hour})
result4, index4 := MaxIndex([]int{}) result4, index4 := MaxIndex([]int{})
is.Equal(result1, 3) is.Equal(3, result1)
is.Equal(index1, 2) is.Equal(2, index1)
is.Equal(result2, 3) is.Equal(3, result2)
is.Equal(index2, 0) is.Zero(index2)
is.Equal(result3, time.Hour) is.Equal(time.Hour, result3)
is.Equal(index3, 2) is.Equal(2, index3)
is.Equal(result4, 0) is.Zero(result4)
is.Equal(index4, -1) is.Equal(index4, -1)
} }
@@ -459,9 +459,9 @@ func TestMaxBy(t *testing.T) {
return len(item) > len(max) return len(item) > len(max)
}) })
is.Equal(result1, "string2") is.Equal("string2", result1)
is.Equal(result2, "string1") is.Equal("string1", result2)
is.Equal(result3, "") is.Empty(result3)
} }
func TestMaxIndexBy(t *testing.T) { func TestMaxIndexBy(t *testing.T) {
@@ -478,13 +478,13 @@ func TestMaxIndexBy(t *testing.T) {
return len(item) > len(max) return len(item) > len(max)
}) })
is.Equal(result1, "string2") is.Equal("string2", result1)
is.Equal(index1, 1) is.Equal(1, index1)
is.Equal(result2, "string1") is.Equal("string1", result2)
is.Equal(index2, 0) is.Zero(index2)
is.Equal(result3, "") is.Empty(result3)
is.Equal(index3, -1) is.Equal(index3, -1)
} }
@@ -497,8 +497,8 @@ func TestLatest(t *testing.T) {
result1 := Latest(a, b) result1 := Latest(a, b)
result2 := Latest() result2 := Latest()
is.Equal(result1, b) is.Equal(b, result1)
is.Equal(result2, time.Time{}) is.Equal(time.Time{}, result2)
} }
func TestLatestBy(t *testing.T) { func TestLatestBy(t *testing.T) {
@@ -522,9 +522,9 @@ func TestLatestBy(t *testing.T) {
return i.bar return i.bar
}) })
is.Equal(result1, foo{t2}) is.Equal(foo{t2}, result1)
is.Equal(result2, foo{t1}) is.Equal(foo{t1}, result2)
is.Equal(result3, foo{}) is.Equal(foo{}, result3)
} }
func TestFirst(t *testing.T) { func TestFirst(t *testing.T) {
@@ -534,10 +534,10 @@ func TestFirst(t *testing.T) {
result1, ok1 := First([]int{1, 2, 3}) result1, ok1 := First([]int{1, 2, 3})
result2, ok2 := First([]int{}) result2, ok2 := First([]int{})
is.Equal(result1, 1) is.Equal(1, result1)
is.Equal(ok1, true) is.True(ok1)
is.Equal(result2, 0) is.Zero(result2)
is.Equal(ok2, false) is.False(ok2)
} }
func TestFirstOrEmpty(t *testing.T) { func TestFirstOrEmpty(t *testing.T) {
@@ -548,9 +548,9 @@ func TestFirstOrEmpty(t *testing.T) {
result2 := FirstOrEmpty([]int{}) result2 := FirstOrEmpty([]int{})
result3 := FirstOrEmpty([]string{}) result3 := FirstOrEmpty([]string{})
is.Equal(result1, 1) is.Equal(1, result1)
is.Equal(result2, 0) is.Zero(result2)
is.Equal(result3, "") is.Empty(result3)
} }
func TestFirstOr(t *testing.T) { func TestFirstOr(t *testing.T) {
@@ -561,9 +561,9 @@ func TestFirstOr(t *testing.T) {
result2 := FirstOr([]int{}, 23) result2 := FirstOr([]int{}, 23)
result3 := FirstOr([]string{}, "test") result3 := FirstOr([]string{}, "test")
is.Equal(result1, 1) is.Equal(1, result1)
is.Equal(result2, 23) is.Equal(23, result2)
is.Equal(result3, "test") is.Equal("test", result3)
} }
func TestLast(t *testing.T) { func TestLast(t *testing.T) {
@@ -573,9 +573,9 @@ func TestLast(t *testing.T) {
result1, ok1 := Last([]int{1, 2, 3}) result1, ok1 := Last([]int{1, 2, 3})
result2, ok2 := Last([]int{}) result2, ok2 := Last([]int{})
is.Equal(result1, 3) is.Equal(3, result1)
is.True(ok1) is.True(ok1)
is.Equal(result2, 0) is.Zero(result2)
is.False(ok2) is.False(ok2)
} }
@@ -587,9 +587,9 @@ func TestLastOrEmpty(t *testing.T) {
result2 := LastOrEmpty([]int{}) result2 := LastOrEmpty([]int{})
result3 := LastOrEmpty([]string{}) result3 := LastOrEmpty([]string{})
is.Equal(result1, 3) is.Equal(3, result1)
is.Equal(result2, 0) is.Zero(result2)
is.Equal(result3, "") is.Empty(result3)
} }
func TestLastOr(t *testing.T) { func TestLastOr(t *testing.T) {
@@ -600,9 +600,9 @@ func TestLastOr(t *testing.T) {
result2 := LastOr([]int{}, 23) result2 := LastOr([]int{}, 23)
result3 := LastOr([]string{}, "test") result3 := LastOr([]string{}, "test")
is.Equal(result1, 3) is.Equal(3, result1)
is.Equal(result2, 23) is.Equal(23, result2)
is.Equal(result3, "test") is.Equal("test", result3)
} }
func TestNth(t *testing.T) { func TestNth(t *testing.T) {
@@ -616,18 +616,18 @@ func TestNth(t *testing.T) {
result5, err5 := Nth([]int{42}, 0) result5, err5 := Nth([]int{42}, 0)
result6, err6 := Nth([]int{42}, -1) result6, err6 := Nth([]int{42}, -1)
is.Equal(result1, 2) is.Equal(2, result1)
is.Equal(err1, nil) is.NoError(err1)
is.Equal(result2, 2) is.Equal(2, result2)
is.Equal(err2, nil) is.NoError(err2)
is.Equal(result3, 0) is.Zero(result3)
is.Equal(err3, fmt.Errorf("nth: 42 out of slice bounds")) is.Equal(err3, fmt.Errorf("nth: 42 out of slice bounds"))
is.Equal(result4, 0) is.Zero(result4)
is.Equal(err4, fmt.Errorf("nth: 0 out of slice bounds")) is.Equal(err4, fmt.Errorf("nth: 0 out of slice bounds"))
is.Equal(result5, 42) is.Equal(42, result5)
is.Equal(err5, nil) is.NoError(err5)
is.Equal(result6, 42) is.Equal(42, result6)
is.Equal(err6, nil) is.NoError(err6)
} }
func TestNthOr(t *testing.T) { func TestNthOr(t *testing.T) {
@@ -726,7 +726,7 @@ func TestSample(t *testing.T) {
result2 := Sample([]string{}) result2 := Sample([]string{})
is.True(Contains([]string{"a", "b", "c"}, result1)) is.True(Contains([]string{"a", "b", "c"}, result1))
is.Equal(result2, "") is.Empty(result2)
} }
func TestSampleBy(t *testing.T) { func TestSampleBy(t *testing.T) {
@@ -739,7 +739,7 @@ func TestSampleBy(t *testing.T) {
result2 := SampleBy([]string{}, rand.Intn) result2 := SampleBy([]string{}, rand.Intn)
is.True(Contains([]string{"a", "b", "c"}, result1)) is.True(Contains([]string{"a", "b", "c"}, result1))
is.Equal(result2, "") is.Empty(result2)
} }
func TestSamples(t *testing.T) { func TestSamples(t *testing.T) {
@@ -753,8 +753,8 @@ func TestSamples(t *testing.T) {
sort.Strings(result1) sort.Strings(result1)
is.Equal(result1, []string{"a", "b", "c"}) is.Equal([]string{"a", "b", "c"}, result1)
is.Equal(result2, []string{}) is.Equal([]string{}, result2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -773,8 +773,8 @@ func TestSamplesBy(t *testing.T) {
sort.Strings(result1) sort.Strings(result1)
is.Equal(result1, []string{"a", "b", "c"}) is.Equal([]string{"a", "b", "c"}, result1)
is.Equal(result2, []string{}) is.Equal([]string{}, result2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}

80
intersect_test.go
View File

@@ -13,8 +13,8 @@ func TestContains(t *testing.T) {
result1 := Contains([]int{0, 1, 2, 3, 4, 5}, 5) result1 := Contains([]int{0, 1, 2, 3, 4, 5}, 5)
result2 := Contains([]int{0, 1, 2, 3, 4, 5}, 6) result2 := Contains([]int{0, 1, 2, 3, 4, 5}, 6)
is.Equal(result1, true) is.True(result1)
is.Equal(result2, false) is.False(result2)
} }
func TestContainsBy(t *testing.T) { func TestContainsBy(t *testing.T) {
@@ -34,10 +34,10 @@ func TestContainsBy(t *testing.T) {
result3 := ContainsBy(a2, func(t string) bool { return t == "ccc" }) result3 := ContainsBy(a2, func(t string) bool { return t == "ccc" })
result4 := ContainsBy(a2, func(t string) bool { return t == "ddd" }) result4 := ContainsBy(a2, func(t string) bool { return t == "ddd" })
is.Equal(result1, false) is.False(result1)
is.Equal(result2, true) is.True(result2)
is.Equal(result3, true) is.True(result3)
is.Equal(result4, false) is.False(result4)
} }
func TestEvery(t *testing.T) { func TestEvery(t *testing.T) {
@@ -182,11 +182,11 @@ func TestIntersect(t *testing.T) {
result4 := Intersect([]int{0, 6}, []int{0, 1, 2, 3, 4, 5}) result4 := Intersect([]int{0, 6}, []int{0, 1, 2, 3, 4, 5})
result5 := Intersect([]int{0, 6, 0}, []int{0, 1, 2, 3, 4, 5}) result5 := Intersect([]int{0, 6, 0}, []int{0, 1, 2, 3, 4, 5})
is.Equal(result1, []int{0, 2}) is.Equal([]int{0, 2}, result1)
is.Equal(result2, []int{0}) is.Equal([]int{0}, result2)
is.Equal(result3, []int{}) is.Equal([]int{}, result3)
is.Equal(result4, []int{0}) is.Equal([]int{0}, result4)
is.Equal(result5, []int{0}) is.Equal([]int{0}, result5)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -199,16 +199,16 @@ func TestDifference(t *testing.T) {
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})
is.Equal(left1, []int{1, 3, 4, 5}) is.Equal([]int{1, 3, 4, 5}, left1)
is.Equal(right1, []int{6}) is.Equal([]int{6}, right1)
left2, right2 := Difference([]int{1, 2, 3, 4, 5}, []int{0, 6}) left2, right2 := Difference([]int{1, 2, 3, 4, 5}, []int{0, 6})
is.Equal(left2, []int{1, 2, 3, 4, 5}) is.Equal([]int{1, 2, 3, 4, 5}, left2)
is.Equal(right2, []int{0, 6}) 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(left3, []int{}) is.Equal([]int{}, left3)
is.Equal(right3, []int{}) is.Equal([]int{}, right3)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -227,23 +227,23 @@ func TestUnion(t *testing.T) {
result4 := Union([]int{0, 1, 2}, []int{0, 1, 2, 3, 3}) result4 := Union([]int{0, 1, 2}, []int{0, 1, 2, 3, 3})
result5 := Union([]int{0, 1, 2}, []int{0, 1, 2}) result5 := Union([]int{0, 1, 2}, []int{0, 1, 2})
result6 := Union([]int{}, []int{}) result6 := Union([]int{}, []int{})
is.Equal(result1, []int{0, 1, 2, 3, 4, 5, 10}) is.Equal([]int{0, 1, 2, 3, 4, 5, 10}, result1)
is.Equal(result2, []int{0, 1, 2, 3, 4, 5, 6, 7}) is.Equal([]int{0, 1, 2, 3, 4, 5, 6, 7}, result2)
is.Equal(result3, []int{0, 1, 2, 3, 4, 5}) is.Equal([]int{0, 1, 2, 3, 4, 5}, result3)
is.Equal(result4, []int{0, 1, 2, 3}) is.Equal([]int{0, 1, 2, 3}, result4)
is.Equal(result5, []int{0, 1, 2}) is.Equal([]int{0, 1, 2}, result5)
is.Equal(result6, []int{}) is.Equal([]int{}, 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})
result13 := Union([]int{0, 1, 2, 3, 4, 5}, []int{}, []int{}) result13 := Union([]int{0, 1, 2, 3, 4, 5}, []int{}, []int{})
result14 := Union([]int{0, 1, 2}, []int{0, 1, 2}, []int{0, 1, 2}) result14 := Union([]int{0, 1, 2}, []int{0, 1, 2}, []int{0, 1, 2})
result15 := Union([]int{}, []int{}, []int{}) result15 := Union([]int{}, []int{}, []int{})
is.Equal(result11, []int{0, 1, 2, 3, 4, 5, 10, 11}) is.Equal([]int{0, 1, 2, 3, 4, 5, 10, 11}, result11)
is.Equal(result12, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) is.Equal([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, result12)
is.Equal(result13, []int{0, 1, 2, 3, 4, 5}) is.Equal([]int{0, 1, 2, 3, 4, 5}, result13)
is.Equal(result14, []int{0, 1, 2}) is.Equal([]int{0, 1, 2}, result14)
is.Equal(result15, []int{}) is.Equal([]int{}, result15)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -260,11 +260,11 @@ func TestWithout(t *testing.T) {
result3 := Without([]int{}, 0, 1, 2, 3, 4, 5) result3 := Without([]int{}, 0, 1, 2, 3, 4, 5)
result4 := Without([]int{0, 1, 2}, 0, 1, 2) result4 := Without([]int{0, 1, 2}, 0, 1, 2)
result5 := Without([]int{}) result5 := Without([]int{})
is.Equal(result1, []int{10}) is.Equal([]int{10}, result1)
is.Equal(result2, []int{7}) is.Equal([]int{7}, result2)
is.Equal(result3, []int{}) is.Equal([]int{}, result3)
is.Equal(result4, []int{}) is.Equal([]int{}, result4)
is.Equal(result5, []int{}) is.Equal([]int{}, result5)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -287,9 +287,9 @@ func TestWithoutBy(t *testing.T) {
}, "nick", "lily") }, "nick", "lily")
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(result1, []User{{Name: "peter"}}) is.Equal([]User{{Name: "peter"}}, result1)
is.Equal(result2, []User{}) is.Equal([]User{}, result2)
is.Equal(result3, []User{}) is.Equal([]User{}, result3)
} }
func TestWithoutEmpty(t *testing.T) { func TestWithoutEmpty(t *testing.T) {
@@ -300,10 +300,10 @@ func TestWithoutEmpty(t *testing.T) {
result2 := WithoutEmpty([]int{1, 2}) result2 := WithoutEmpty([]int{1, 2})
result3 := WithoutEmpty([]int{}) result3 := WithoutEmpty([]int{})
result4 := WithoutEmpty([]*int{ToPtr(0), ToPtr(1), nil, ToPtr(2)}) result4 := WithoutEmpty([]*int{ToPtr(0), ToPtr(1), nil, ToPtr(2)})
is.Equal(result1, []int{1, 2}) is.Equal([]int{1, 2}, result1)
is.Equal(result2, []int{1, 2}) is.Equal([]int{1, 2}, result2)
is.Equal(result3, []int{}) is.Equal([]int{}, result3)
is.Equal(result4, []*int{ToPtr(0), ToPtr(1), ToPtr(2)}) is.Equal([]*int{ToPtr(0), ToPtr(1), ToPtr(2)}, result4)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}

106
map_test.go
View File

@@ -15,21 +15,21 @@ func TestKeys(t *testing.T) {
r1 := Keys(map[string]int{"foo": 1, "bar": 2}) r1 := Keys(map[string]int{"foo": 1, "bar": 2})
sort.Strings(r1) sort.Strings(r1)
is.Equal(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) sort.Strings(r3)
is.Equal(r3, []string{"bar", "baz", "foo"}) is.Equal([]string{"bar", "baz", "foo"}, r3)
r4 := Keys[string, int]() r4 := Keys[string, int]()
is.Equal(r4, []string{}) is.Equal([]string{}, 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) sort.Strings(r5)
is.Equal(r5, []string{"bar", "bar", "foo"}) is.Equal([]string{"bar", "bar", "foo"}, r5)
} }
func TestUniqKeys(t *testing.T) { func TestUniqKeys(t *testing.T) {
@@ -38,25 +38,25 @@ func TestUniqKeys(t *testing.T) {
r1 := UniqKeys(map[string]int{"foo": 1, "bar": 2}) r1 := UniqKeys(map[string]int{"foo": 1, "bar": 2})
sort.Strings(r1) sort.Strings(r1)
is.Equal(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) sort.Strings(r3)
is.Equal(r3, []string{"bar", "baz", "foo"}) is.Equal([]string{"bar", "baz", "foo"}, r3)
r4 := UniqKeys[string, int]() r4 := UniqKeys[string, int]()
is.Equal(r4, []string{}) is.Equal([]string{}, 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) sort.Strings(r5)
is.Equal(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})
is.Equal(r6, []string{"foo", "bar"}) is.Equal([]string{"foo", "bar"}, r6)
} }
func TestHasKey(t *testing.T) { func TestHasKey(t *testing.T) {
@@ -76,21 +76,21 @@ func TestValues(t *testing.T) {
r1 := Values(map[string]int{"foo": 1, "bar": 2}) r1 := Values(map[string]int{"foo": 1, "bar": 2})
sort.Ints(r1) sort.Ints(r1)
is.Equal(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) sort.Ints(r3)
is.Equal(r3, []int{1, 2, 3}) is.Equal([]int{1, 2, 3}, r3)
r4 := Values[string, int]() r4 := Values[string, int]()
is.Equal(r4, []int{}) is.Equal([]int{}, 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) sort.Ints(r5)
is.Equal(r5, []int{1, 1, 2, 3}) is.Equal([]int{1, 1, 2, 3}, r5)
} }
func TestUniqValues(t *testing.T) { func TestUniqValues(t *testing.T) {
@@ -99,29 +99,29 @@ func TestUniqValues(t *testing.T) {
r1 := UniqValues(map[string]int{"foo": 1, "bar": 2}) r1 := UniqValues(map[string]int{"foo": 1, "bar": 2})
sort.Ints(r1) sort.Ints(r1)
is.Equal(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) sort.Ints(r3)
is.Equal(r3, []int{1, 2, 3}) is.Equal([]int{1, 2, 3}, r3)
r4 := UniqValues[string, int]() r4 := UniqValues[string, int]()
is.Equal(r4, []int{}) is.Equal([]int{}, 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) sort.Ints(r5)
is.Equal(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) sort.Ints(r6)
is.Equal(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})
is.Equal(r7, []int{1, 3}) is.Equal([]int{1, 3}, r7)
} }
func TestValueOr(t *testing.T) { func TestValueOr(t *testing.T) {
@@ -129,10 +129,10 @@ func TestValueOr(t *testing.T) {
is := assert.New(t) is := assert.New(t)
r1 := ValueOr(map[string]int{"foo": 1}, "bar", 2) r1 := ValueOr(map[string]int{"foo": 1}, "bar", 2)
is.Equal(r1, 2) is.Equal(2, r1)
r2 := ValueOr(map[string]int{"foo": 1}, "foo", 2) r2 := ValueOr(map[string]int{"foo": 1}, "foo", 2)
is.Equal(r2, 1) is.Equal(1, r2)
} }
func TestPickBy(t *testing.T) { func TestPickBy(t *testing.T) {
@@ -143,7 +143,7 @@ func TestPickBy(t *testing.T) {
return value%2 == 1 return value%2 == 1
}) })
is.Equal(r1, map[string]int{"foo": 1, "baz": 3}) is.Equal(map[string]int{"foo": 1, "baz": 3}, r1)
type myMap map[string]int type myMap map[string]int
before := myMap{"": 0, "foobar": 6, "baz": 3} before := myMap{"": 0, "foobar": 6, "baz": 3}
@@ -157,7 +157,7 @@ func TestPickByKeys(t *testing.T) {
r1 := PickByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz", "qux"}) r1 := PickByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz", "qux"})
is.Equal(r1, map[string]int{"foo": 1, "baz": 3}) is.Equal(map[string]int{"foo": 1, "baz": 3}, r1)
type myMap map[string]int type myMap map[string]int
before := myMap{"": 0, "foobar": 6, "baz": 3} before := myMap{"": 0, "foobar": 6, "baz": 3}
@@ -171,7 +171,7 @@ func TestPickByValues(t *testing.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})
is.Equal(r1, map[string]int{"foo": 1, "baz": 3}) is.Equal(map[string]int{"foo": 1, "baz": 3}, r1)
type myMap map[string]int type myMap map[string]int
before := myMap{"": 0, "foobar": 6, "baz": 3} before := myMap{"": 0, "foobar": 6, "baz": 3}
@@ -187,7 +187,7 @@ func TestOmitBy(t *testing.T) {
return value%2 == 1 return value%2 == 1
}) })
is.Equal(r1, map[string]int{"bar": 2}) is.Equal(map[string]int{"bar": 2}, r1)
type myMap map[string]int type myMap map[string]int
before := myMap{"": 0, "foobar": 6, "baz": 3} before := myMap{"": 0, "foobar": 6, "baz": 3}
@@ -201,7 +201,7 @@ func TestOmitByKeys(t *testing.T) {
r1 := OmitByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz", "qux"}) r1 := OmitByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz", "qux"})
is.Equal(r1, map[string]int{"bar": 2}) is.Equal(map[string]int{"bar": 2}, r1)
type myMap map[string]int type myMap map[string]int
before := myMap{"": 0, "foobar": 6, "baz": 3} before := myMap{"": 0, "foobar": 6, "baz": 3}
@@ -215,7 +215,7 @@ func TestOmitByValues(t *testing.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})
is.Equal(r1, map[string]int{"bar": 2}) is.Equal(map[string]int{"bar": 2}, r1)
type myMap map[string]int type myMap map[string]int
before := myMap{"": 0, "foobar": 6, "baz": 3} before := myMap{"": 0, "foobar": 6, "baz": 3}
@@ -232,7 +232,7 @@ func TestEntries(t *testing.T) {
sort.Slice(r1, func(i, j int) bool { sort.Slice(r1, func(i, j int) bool {
return r1[i].Value < r1[j].Value return r1[i].Value < r1[j].Value
}) })
is.EqualValues(r1, []Entry[string, int]{ is.Equal([]Entry[string, int]{
{ {
Key: "foo", Key: "foo",
Value: 1, Value: 1,
@@ -241,7 +241,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) {
@@ -253,7 +253,7 @@ func TestToPairs(t *testing.T) {
sort.Slice(r1, func(i, j int) bool { sort.Slice(r1, func(i, j int) bool {
return r1[i].Value < r1[j].Value return r1[i].Value < r1[j].Value
}) })
is.EqualValues(r1, []Entry[string, int]{ is.Equal([]Entry[string, int]{
{ {
Key: "baz", Key: "baz",
Value: 3, Value: 3,
@@ -262,7 +262,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) {
@@ -281,8 +281,8 @@ func TestFromEntries(t *testing.T) {
}) })
is.Len(r1, 2) is.Len(r1, 2)
is.Equal(r1["foo"], 1) is.Equal(1, r1["foo"])
is.Equal(r1["bar"], 2) is.Equal(2, r1["bar"])
} }
func TestFromPairs(t *testing.T) { func TestFromPairs(t *testing.T) {
@@ -301,8 +301,8 @@ func TestFromPairs(t *testing.T) {
}) })
is.Len(r1, 2) is.Len(r1, 2)
is.Equal(r1["baz"], 3) is.Equal(3, r1["baz"])
is.Equal(r1["qux"], 4) is.Equal(4, r1["qux"])
} }
func TestInvert(t *testing.T) { func TestInvert(t *testing.T) {
@@ -313,7 +313,7 @@ func TestInvert(t *testing.T) {
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.Len(r1, 2)
is.EqualValues(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)
} }
@@ -324,7 +324,7 @@ func TestAssign(t *testing.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.Len(result1, 3)
is.Equal(result1, map[string]int{"a": 1, "b": 3, "c": 4}) is.Equal(map[string]int{"a": 1, "b": 3, "c": 4}, result1)
type myMap map[string]int type myMap map[string]int
before := myMap{"": 0, "foobar": 6, "baz": 3} before := myMap{"": 0, "foobar": 6, "baz": 3}
@@ -375,7 +375,7 @@ func TestChunkEntries(t *testing.T) {
for k := range result6[0] { for k := range result6[0] {
result6[0][k] = 10 result6[0][k] = 10
} }
is.Equal(originalMap, map[string]int{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}) is.Equal(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}, originalMap)
} }
func TestMapKeys(t *testing.T) { func TestMapKeys(t *testing.T) {
@@ -389,9 +389,9 @@ func TestMapKeys(t *testing.T) {
return strconv.FormatInt(int64(v), 10) return strconv.FormatInt(int64(v), 10)
}) })
is.Equal(len(result1), 1) is.Len(result1, 1)
is.Equal(len(result2), 4) is.Len(result2, 4)
is.Equal(result2, map[string]int{"1": 1, "2": 2, "3": 3, "4": 4}) is.Equal(map[string]int{"1": 1, "2": 2, "3": 3, "4": 4}, result2)
} }
func TestMapValues(t *testing.T) { func TestMapValues(t *testing.T) {
@@ -405,16 +405,16 @@ func TestMapValues(t *testing.T) {
return strconv.FormatInt(int64(x), 10) return strconv.FormatInt(int64(x), 10)
}) })
is.Equal(len(result1), 4) is.Len(result1, 4)
is.Equal(len(result2), 4) is.Len(result2, 4)
is.Equal(result1, map[int]string{1: "Hello", 2: "Hello", 3: "Hello", 4: "Hello"}) is.Equal(map[int]string{1: "Hello", 2: "Hello", 3: "Hello", 4: "Hello"}, result1)
is.Equal(result2, map[int]string{1: "1", 2: "2", 3: "3", 4: "4"}) is.Equal(map[int]string{1: "1", 2: "2", 3: "3", 4: "4"}, result2)
} }
func mapEntriesTest[I any, O any](t *testing.T, in map[string]I, iteratee func(string, I) (string, O), expected map[string]O) { func mapEntriesTest[I any, O any](t *testing.T, in map[string]I, iteratee func(string, I) (string, O), expected map[string]O) {
is := assert.New(t) is := assert.New(t)
result := MapEntries(in, iteratee) result := MapEntries(in, iteratee)
is.Equal(result, expected) is.Equal(expected, result)
} }
func TestMapEntries(t *testing.T) { func TestMapEntries(t *testing.T) {
@@ -435,7 +435,7 @@ func TestMapEntries(t *testing.T) {
MapEntries(r1, func(k string, v int) (string, string) { MapEntries(r1, func(k string, v int) (string, string) {
return k, strconv.Itoa(v) + "!!" return k, strconv.Itoa(v) + "!!"
}) })
is.Equal(r1, map[string]int{"foo": 1, "bar": 2}) is.Equal(map[string]int{"foo": 1, "bar": 2}, r1)
} }
// EmptyInput // EmptyInput
{ {
@@ -507,8 +507,8 @@ func TestMapToSlice(t *testing.T) {
return strconv.FormatInt(int64(k), 10) return strconv.FormatInt(int64(k), 10)
}) })
is.Equal(len(result1), 4) is.Len(result1, 4)
is.Equal(len(result2), 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 +524,8 @@ func TestFilterMapToSlice(t *testing.T) {
return strconv.FormatInt(int64(k), 10), k%2 == 0 return strconv.FormatInt(int64(k), 10), k%2 == 0
}) })
is.Equal(len(result1), 2) is.Len(result1, 2)
is.Equal(len(result2), 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"})
} }
@@ -544,7 +544,7 @@ func TestFilterKeys(t *testing.T) {
return false return false
}) })
is.Equal([]string{}, result2) is.Equal([]string{}, result2)
is.Len(result2, 0) is.Empty(result2)
} }
func TestFilterValues(t *testing.T) { func TestFilterValues(t *testing.T) {
@@ -561,7 +561,7 @@ func TestFilterValues(t *testing.T) {
return false return false
}) })
is.Equal([]int{}, result2) is.Equal([]int{}, result2)
is.Len(result2, 0) is.Empty(result2)
} }
func BenchmarkAssign(b *testing.B) { func BenchmarkAssign(b *testing.B) {

100
math_test.go
View File

@@ -13,9 +13,9 @@ func TestRange(t *testing.T) {
result1 := Range(4) result1 := Range(4)
result2 := Range(-4) result2 := Range(-4)
result3 := Range(0) result3 := Range(0)
is.Equal(result1, []int{0, 1, 2, 3}) is.Equal([]int{0, 1, 2, 3}, result1)
is.Equal(result2, []int{0, -1, -2, -3}) is.Equal([]int{0, -1, -2, -3}, result2)
is.Equal(result3, []int{}) is.Equal([]int{}, result3)
} }
func TestRangeFrom(t *testing.T) { func TestRangeFrom(t *testing.T) {
@@ -27,11 +27,11 @@ func TestRangeFrom(t *testing.T) {
result3 := RangeFrom(10, 0) result3 := RangeFrom(10, 0)
result4 := RangeFrom(2.0, 3) result4 := RangeFrom(2.0, 3)
result5 := RangeFrom(-2.0, -3) result5 := RangeFrom(-2.0, -3)
is.Equal(result1, []int{1, 2, 3, 4, 5}) is.Equal([]int{1, 2, 3, 4, 5}, result1)
is.Equal(result2, []int{-1, -2, -3, -4, -5}) is.Equal([]int{-1, -2, -3, -4, -5}, result2)
is.Equal(result3, []int{}) is.Equal([]int{}, result3)
is.Equal(result4, []float64{2.0, 3.0, 4.0}) is.Equal([]float64{2.0, 3.0, 4.0}, result4)
is.Equal(result5, []float64{-2.0, -3.0, -4.0}) is.Equal([]float64{-2.0, -3.0, -4.0}, result5)
} }
func TestRangeClose(t *testing.T) { func TestRangeClose(t *testing.T) {
@@ -60,9 +60,9 @@ func TestClamp(t *testing.T) {
result2 := Clamp(-42, -10, 10) result2 := Clamp(-42, -10, 10)
result3 := Clamp(42, -10, 10) result3 := Clamp(42, -10, 10)
is.Equal(result1, 0) is.Zero(result1)
is.Equal(result2, -10) is.Equal(-10, result2)
is.Equal(result3, 10) is.Equal(10, result3)
} }
func TestSum(t *testing.T) { func TestSum(t *testing.T) {
@@ -74,11 +74,11 @@ func TestSum(t *testing.T) {
result4 := Sum([]uint32{}) result4 := Sum([]uint32{})
result5 := Sum([]complex128{4_4, 2_2}) result5 := Sum([]complex128{4_4, 2_2})
is.Equal(result1, float32(14.900001)) is.InEpsilon(14.9, result1, 1e-7)
is.Equal(result2, int32(14)) is.Equal(int32(14), result2)
is.Equal(result3, uint32(14)) is.Equal(uint32(14), result3)
is.Equal(result4, uint32(0)) is.Equal(uint32(0), result4)
is.Equal(result5, complex128(6_6)) is.Equal(complex128(6_6), result5)
} }
func TestSumBy(t *testing.T) { func TestSumBy(t *testing.T) {
@@ -91,11 +91,11 @@ func TestSumBy(t *testing.T) {
result4 := SumBy([]uint32{}, func(n uint32) uint32 { return n }) result4 := SumBy([]uint32{}, func(n uint32) uint32 { return n })
result5 := SumBy([]complex128{4_4, 2_2}, func(n complex128) complex128 { return n }) result5 := SumBy([]complex128{4_4, 2_2}, func(n complex128) complex128 { return n })
is.Equal(result1, float32(14.900001)) is.InEpsilon(14.9, result1, 1e-7)
is.Equal(result2, int32(14)) is.Equal(int32(14), result2)
is.Equal(result3, uint32(14)) is.Equal(uint32(14), result3)
is.Equal(result4, uint32(0)) is.Equal(uint32(0), result4)
is.Equal(result5, complex128(6_6)) is.Equal(complex128(6_6), result5)
} }
func TestProduct(t *testing.T) { func TestProduct(t *testing.T) {
@@ -110,14 +110,14 @@ func TestProduct(t *testing.T) {
result7 := Product([]complex128{4_4, 2_2}) result7 := Product([]complex128{4_4, 2_2})
result8 := Product[uint32](nil) result8 := Product[uint32](nil)
is.Equal(result1, float32(160.908)) is.InEpsilon(160.908, result1, 1e-7)
is.Equal(result2, int32(120)) is.Equal(int32(120), result2)
is.Equal(result3, int32(0)) is.Equal(int32(0), result3)
is.Equal(result4, int32(-126)) is.Equal(int32(-126), result4)
is.Equal(result5, uint32(120)) is.Equal(uint32(120), result5)
is.Equal(result6, uint32(1)) is.Equal(uint32(1), result6)
is.Equal(result7, complex128(96_8)) is.Equal(complex128(96_8), result7)
is.Equal(result8, uint32(1)) is.Equal(uint32(1), result8)
} }
func TestProductBy(t *testing.T) { func TestProductBy(t *testing.T) {
@@ -132,14 +132,14 @@ func TestProductBy(t *testing.T) {
result7 := ProductBy([]complex128{4_4, 2_2}, func(n complex128) complex128 { return n }) result7 := ProductBy([]complex128{4_4, 2_2}, func(n complex128) complex128 { return n })
result8 := ProductBy(nil, func(n uint32) uint32 { return n }) result8 := ProductBy(nil, func(n uint32) uint32 { return n })
is.Equal(result1, float32(160.908)) is.InEpsilon(160.908, result1, 1e-7)
is.Equal(result2, int32(120)) is.Equal(int32(120), result2)
is.Equal(result3, int32(0)) is.Equal(int32(0), result3)
is.Equal(result4, int32(-126)) is.Equal(int32(-126), result4)
is.Equal(result5, uint32(120)) is.Equal(uint32(120), result5)
is.Equal(result6, uint32(1)) is.Equal(uint32(1), result6)
is.Equal(result7, complex128(96_8)) is.Equal(complex128(96_8), result7)
is.Equal(result8, uint32(1)) is.Equal(uint32(1), result8)
} }
func TestMean(t *testing.T) { func TestMean(t *testing.T) {
@@ -151,10 +151,10 @@ func TestMean(t *testing.T) {
result3 := Mean([]uint32{2, 3, 4, 5}) result3 := Mean([]uint32{2, 3, 4, 5})
result4 := Mean([]uint32{}) result4 := Mean([]uint32{})
is.Equal(result1, float32(3.7250001)) is.InEpsilon(3.725, result1, 1e-7)
is.Equal(result2, int32(3)) is.Equal(int32(3), result2)
is.Equal(result3, uint32(3)) is.Equal(uint32(3), result3)
is.Equal(result4, uint32(0)) is.Equal(uint32(0), result4)
} }
func TestMeanBy(t *testing.T) { func TestMeanBy(t *testing.T) {
@@ -166,10 +166,10 @@ func TestMeanBy(t *testing.T) {
result3 := MeanBy([]uint32{2, 3, 4, 5}, func(n uint32) uint32 { return n }) result3 := MeanBy([]uint32{2, 3, 4, 5}, func(n uint32) uint32 { return n })
result4 := MeanBy([]uint32{}, func(n uint32) uint32 { return n }) result4 := MeanBy([]uint32{}, func(n uint32) uint32 { return n })
is.Equal(result1, float32(3.7250001)) is.InEpsilon(3.725, result1, 1e-7)
is.Equal(result2, int32(3)) is.Equal(int32(3), result2)
is.Equal(result3, uint32(3)) is.Equal(uint32(3), result3)
is.Equal(result4, uint32(0)) is.Equal(uint32(0), result4)
} }
func TestMode(t *testing.T) { func TestMode(t *testing.T) {
@@ -182,9 +182,9 @@ func TestMode(t *testing.T) {
result4 := Mode([]uint32{}) result4 := Mode([]uint32{})
result5 := Mode([]int{1, 2, 3, 4, 5, 6, 7, 8, 9}) result5 := Mode([]int{1, 2, 3, 4, 5, 6, 7, 8, 9})
is.Equal(result1, []float32{3.3}) is.Equal([]float32{3.3}, result1)
is.Equal(result2, []int32{2}) is.Equal([]int32{2}, result2)
is.Equal(result3, []uint32{2, 3}) is.Equal([]uint32{2, 3}, result3)
is.Equal(result4, []uint32{}) is.Equal([]uint32{}, result4)
is.Equal(result5, []int{1, 2, 3, 4, 5, 6, 7, 8, 9}) is.Equal([]int{1, 2, 3, 4, 5, 6, 7, 8, 9}, result5)
} }

36
mutable/slice_test.go
View File

@@ -15,16 +15,16 @@ func TestFilter(t *testing.T) {
return x%2 == 0 return x%2 == 0
}) })
is.Equal(input1, []int{2, 4, 3, 4}) is.Equal([]int{2, 4, 3, 4}, input1)
is.Equal(r1, []int{2, 4}) is.Equal([]int{2, 4}, r1)
input2 := []string{"", "foo", "", "bar", ""} input2 := []string{"", "foo", "", "bar", ""}
r2 := Filter(input2, func(x string) bool { r2 := Filter(input2, func(x string) bool {
return len(x) > 0 return len(x) > 0
}) })
is.Equal(input2, []string{"foo", "bar", "", "bar", ""}) is.Equal([]string{"foo", "bar", "", "bar", ""}, input2)
is.Equal(r2, []string{"foo", "bar"}) is.Equal([]string{"foo", "bar"}, r2)
} }
func TestFilterI(t *testing.T) { func TestFilterI(t *testing.T) {
@@ -36,7 +36,7 @@ func TestFilterI(t *testing.T) {
return x%2 == 0 return x%2 == 0
}) })
is.Equal(r1, []int{2, 4}) is.Equal([]int{2, 4}, r1)
} }
func TestMap(t *testing.T) { func TestMap(t *testing.T) {
@@ -47,15 +47,15 @@ func TestMap(t *testing.T) {
Map(list, func(x int) int { Map(list, func(x int) int {
return x * 2 return x * 2
}) })
is.Equal(len(list), 4) is.Len(list, 4)
is.Equal(list, []int{2, 4, 6, 8}) 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.Equal(len(list), 4) is.Len(list, 4)
is.Equal(list, []int{4, 8, 12, 16}) is.Equal([]int{4, 8, 12, 16}, list)
} }
func TestMapI(t *testing.T) { func TestMapI(t *testing.T) {
@@ -67,16 +67,16 @@ func TestMapI(t *testing.T) {
is.Equal(index, x-1) is.Equal(index, x-1)
return x * 2 return x * 2
}) })
is.Equal(len(list), 4) is.Len(list, 4)
is.Equal(list, []int{2, 4, 6, 8}) is.Equal([]int{2, 4, 6, 8}, list)
list = []int{1, 2, 3, 4} list = []int{1, 2, 3, 4}
MapI(list, func(x int, index int) int { MapI(list, func(x int, index int) int {
is.Equal(index, x-1) is.Equal(index, x-1)
return x * 4 return x * 4
}) })
is.Equal(len(list), 4) is.Len(list, 4)
is.Equal(list, []int{4, 8, 12, 16}) is.Equal([]int{4, 8, 12, 16}, list)
} }
func TestShuffle(t *testing.T) { func TestShuffle(t *testing.T) {
@@ -85,11 +85,11 @@ func TestShuffle(t *testing.T) {
list := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} list := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Shuffle(list) Shuffle(list)
is.NotEqual(list, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) is.NotEqual([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, list)
list = []int{} list = []int{}
Shuffle(list) Shuffle(list)
is.Equal(list, []int{}) is.Equal([]int{}, list)
} }
func TestReverse(t *testing.T) { func TestReverse(t *testing.T) {
@@ -98,15 +98,15 @@ func TestReverse(t *testing.T) {
list := []int{0, 1, 2, 3, 4, 5} list := []int{0, 1, 2, 3, 4, 5}
Reverse(list) Reverse(list)
is.Equal(list, []int{5, 4, 3, 2, 1, 0}) is.Equal([]int{5, 4, 3, 2, 1, 0}, list)
list = []int{0, 1, 2, 3, 4, 5, 6} list = []int{0, 1, 2, 3, 4, 5, 6}
Reverse(list) Reverse(list)
is.Equal(list, []int{6, 5, 4, 3, 2, 1, 0}) is.Equal([]int{6, 5, 4, 3, 2, 1, 0}, list)
list = []int{} list = []int{}
Reverse(list) Reverse(list)
is.Equal(list, []int{}) is.Equal([]int{}, list)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}

20
parallel/slice_test.go
View File

@@ -19,10 +19,10 @@ func TestMap(t *testing.T) {
return strconv.FormatInt(x, 10) return strconv.FormatInt(x, 10)
}) })
is.Equal(len(result1), 4) is.Len(result1, 4)
is.Equal(len(result2), 4) is.Len(result2, 4)
is.Equal(result1, []string{"Hello", "Hello", "Hello", "Hello"}) is.Equal([]string{"Hello", "Hello", "Hello", "Hello"}, result1)
is.Equal(result2, []string{"1", "2", "3", "4"}) is.Equal([]string{"1", "2", "3", "4"}, result2)
} }
func TestForEach(t *testing.T) { func TestForEach(t *testing.T) {
@@ -44,8 +44,8 @@ func TestTimes(t *testing.T) {
return strconv.FormatInt(int64(i), 10) return strconv.FormatInt(int64(i), 10)
}) })
is.Equal(len(result1), 3) is.Len(result1, 3)
is.Equal(result1, []string{"0", "1", "2"}) is.Equal([]string{"0", "1", "2"}, result1)
} }
func TestGroupBy(t *testing.T) { func TestGroupBy(t *testing.T) {
@@ -62,12 +62,12 @@ func TestGroupBy(t *testing.T) {
}) })
} }
is.EqualValues(len(result1), 3) is.Len(result1, 3)
is.EqualValues(result1, map[int][]int{ is.Equal(map[int][]int{
0: {0, 3}, 0: {0, 3},
1: {1, 4}, 1: {1, 4},
2: {2, 5}, 2: {2, 5},
}) }, result1)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -103,7 +103,7 @@ func TestPartitionBy(t *testing.T) {
} }
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(result2, [][]int{}) is.Equal([][]int{}, result2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}

106
retry_test.go
View File

@@ -40,14 +40,14 @@ func TestAttempt(t *testing.T) {
return nil return nil
}) })
is.Equal(iter1, 1) is.Equal(1, iter1)
is.Equal(err1, nil) is.NoError(err1)
is.Equal(iter2, 6) is.Equal(6, iter2)
is.Equal(err2, nil) is.NoError(err2)
is.Equal(iter3, 2) is.Equal(2, iter3)
is.Equal(err3, err) is.Equal(err3, err)
is.Equal(iter4, 43) is.Equal(43, iter4)
is.Equal(err4, nil) is.NoError(err4)
} }
func TestAttemptWithDelay(t *testing.T) { func TestAttemptWithDelay(t *testing.T) {
@@ -81,22 +81,22 @@ func TestAttemptWithDelay(t *testing.T) {
return nil return nil
}) })
is.Equal(iter1, 1) is.Equal(1, iter1)
is.GreaterOrEqual(dur1, 0*time.Millisecond) is.GreaterOrEqual(dur1, 0*time.Millisecond)
is.Less(dur1, 1*time.Millisecond) is.Less(dur1, 1*time.Millisecond)
is.Equal(err1, nil) is.NoError(err1)
is.Equal(iter2, 6) is.Equal(6, iter2)
is.Greater(dur2, 50*time.Millisecond) is.Greater(dur2, 50*time.Millisecond)
is.Less(dur2, 60*time.Millisecond) is.Less(dur2, 60*time.Millisecond)
is.Equal(err2, nil) is.NoError(err2)
is.Equal(iter3, 2) 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.Equal(err3, err)
is.Equal(iter4, 11) 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)
is.Equal(err4, nil) is.NoError(err4)
} }
func TestAttemptWhile(t *testing.T) { func TestAttemptWhile(t *testing.T) {
@@ -108,8 +108,8 @@ func TestAttemptWhile(t *testing.T) {
return nil, true return nil, true
}) })
is.Equal(iter1, 1) is.Equal(1, iter1)
is.Nil(err1) is.NoError(err1)
iter2, err2 := AttemptWhile(42, func(i int) (error, bool) { iter2, err2 := AttemptWhile(42, func(i int) (error, bool) {
if i == 5 { if i == 5 {
@@ -119,8 +119,8 @@ func TestAttemptWhile(t *testing.T) {
return err, true return err, true
}) })
is.Equal(iter2, 6) is.Equal(6, iter2)
is.Nil(err2) is.NoError(err2)
iter3, err3 := AttemptWhile(2, func(i int) (error, bool) { iter3, err3 := AttemptWhile(2, func(i int) (error, bool) {
if i == 5 { if i == 5 {
@@ -130,7 +130,7 @@ func TestAttemptWhile(t *testing.T) {
return err, true return err, true
}) })
is.Equal(iter3, 2) is.Equal(2, iter3)
is.Equal(err3, err) is.Equal(err3, err)
iter4, err4 := AttemptWhile(0, func(i int) (error, bool) { iter4, err4 := AttemptWhile(0, func(i int) (error, bool) {
@@ -141,8 +141,8 @@ func TestAttemptWhile(t *testing.T) {
return nil, true return nil, true
}) })
is.Equal(iter4, 43) is.Equal(43, iter4)
is.Nil(err4) is.NoError(err4)
iter5, err5 := AttemptWhile(0, func(i int) (error, bool) { iter5, err5 := AttemptWhile(0, func(i int) (error, bool) {
if i == 5 { if i == 5 {
@@ -152,15 +152,15 @@ func TestAttemptWhile(t *testing.T) {
return err, true return err, true
}) })
is.Equal(iter5, 6) is.Equal(6, iter5)
is.Nil(err5) is.NoError(err5)
iter6, err6 := AttemptWhile(0, func(i int) (error, bool) { iter6, err6 := AttemptWhile(0, func(i int) (error, bool) {
return nil, false return nil, false
}) })
is.Equal(iter6, 1) is.Equal(1, iter6)
is.Nil(err6) is.NoError(err6)
iter7, err7 := AttemptWhile(42, func(i int) (error, bool) { iter7, err7 := AttemptWhile(42, func(i int) (error, bool) {
if i == 42 { if i == 42 {
@@ -173,8 +173,8 @@ func TestAttemptWhile(t *testing.T) {
return nil, true return nil, true
}) })
is.Equal(iter7, 42) is.Equal(42, iter7)
is.Nil(err7) is.NoError(err7)
} }
func TestAttemptWhileWithDelay(t *testing.T) { func TestAttemptWhileWithDelay(t *testing.T) {
@@ -186,10 +186,10 @@ func TestAttemptWhileWithDelay(t *testing.T) {
return nil, true return nil, true
}) })
is.Equal(iter1, 1) is.Equal(1, iter1)
is.GreaterOrEqual(dur1, 0*time.Millisecond) is.GreaterOrEqual(dur1, 0*time.Millisecond)
is.Less(dur1, 1*time.Millisecond) is.Less(dur1, 1*time.Millisecond)
is.Nil(err1) is.NoError(err1)
iter2, dur2, err2 := AttemptWhileWithDelay(42, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) { iter2, dur2, err2 := AttemptWhileWithDelay(42, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) {
if i == 5 { if i == 5 {
@@ -199,10 +199,10 @@ func TestAttemptWhileWithDelay(t *testing.T) {
return err, true return err, true
}) })
is.Equal(iter2, 6) is.Equal(6, iter2)
is.Greater(dur2, 50*time.Millisecond) is.Greater(dur2, 50*time.Millisecond)
is.Less(dur2, 60*time.Millisecond) is.Less(dur2, 60*time.Millisecond)
is.Nil(err2) is.NoError(err2)
iter3, dur3, err3 := AttemptWhileWithDelay(2, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) { iter3, dur3, err3 := AttemptWhileWithDelay(2, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) {
if i == 5 { if i == 5 {
@@ -212,7 +212,7 @@ func TestAttemptWhileWithDelay(t *testing.T) {
return err, true return err, true
}) })
is.Equal(iter3, 2) 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.Equal(err3, err)
@@ -225,10 +225,10 @@ func TestAttemptWhileWithDelay(t *testing.T) {
return nil, true return nil, true
}) })
is.Equal(iter4, 11) 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)
is.Nil(err4) is.NoError(err4)
iter5, dur5, err5 := AttemptWhileWithDelay(0, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) { iter5, dur5, err5 := AttemptWhileWithDelay(0, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) {
if i == 5 { if i == 5 {
@@ -238,19 +238,19 @@ func TestAttemptWhileWithDelay(t *testing.T) {
return err, true return err, true
}) })
is.Equal(iter5, 6) is.Equal(6, iter5)
is.Greater(dur5, 10*time.Millisecond) is.Greater(dur5, 10*time.Millisecond)
is.Less(dur5, 115*time.Millisecond) is.Less(dur5, 115*time.Millisecond)
is.Nil(err5) is.NoError(err5)
iter6, dur6, err6 := AttemptWhileWithDelay(0, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) { iter6, dur6, err6 := AttemptWhileWithDelay(0, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) {
return nil, false return nil, false
}) })
is.Equal(iter6, 1) is.Equal(1, iter6)
is.Less(dur6, 10*time.Millisecond) is.Less(dur6, 10*time.Millisecond)
is.Less(dur6, 115*time.Millisecond) is.Less(dur6, 115*time.Millisecond)
is.Nil(err6) is.NoError(err6)
iter7, dur7, err7 := AttemptWhileWithDelay(42, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) { iter7, dur7, err7 := AttemptWhileWithDelay(42, 10*time.Millisecond, func(i int, d time.Duration) (error, bool) {
if i == 42 { if i == 42 {
@@ -263,9 +263,9 @@ func TestAttemptWhileWithDelay(t *testing.T) {
return nil, true return nil, true
}) })
is.Equal(iter7, 42) is.Equal(42, iter7)
is.Less(dur7, 500*time.Millisecond) is.Less(dur7, 500*time.Millisecond)
is.Nil(err7) is.NoError(err7)
} }
func TestDebounce(t *testing.T) { func TestDebounce(t *testing.T) {
@@ -355,9 +355,9 @@ func TestDebounceBy(t *testing.T) {
} }
mu.Lock() mu.Lock()
is.EqualValues(output[0], 30) is.Equal(30, output[0])
is.EqualValues(output[1], 30) is.Equal(30, output[1])
is.EqualValues(output[2], 30) is.Equal(30, output[2])
mu.Unlock() mu.Unlock()
d2, _ := NewDebounceBy(10*time.Millisecond, f2) d2, _ := NewDebounceBy(10*time.Millisecond, f2)
@@ -375,9 +375,9 @@ func TestDebounceBy(t *testing.T) {
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)
mu.Lock() mu.Lock()
is.EqualValues(output[0], 45) is.Equal(45, output[0])
is.EqualValues(output[1], 45) is.Equal(45, output[1])
is.EqualValues(output[2], 45) is.Equal(45, output[2])
mu.Unlock() mu.Unlock()
// execute once because it is canceled after 200ms. // execute once because it is canceled after 200ms.
@@ -398,9 +398,9 @@ func TestDebounceBy(t *testing.T) {
} }
mu.Lock() mu.Lock()
is.EqualValues(output[0], 75) is.Equal(75, output[0])
is.EqualValues(output[1], 75) is.Equal(75, output[1])
is.EqualValues(output[2], 75) is.Equal(75, output[2])
mu.Unlock() mu.Unlock()
} }
@@ -429,7 +429,7 @@ func TestTransaction(t *testing.T) {
state, err := transaction.Process(21) state, err := transaction.Process(21)
is.Equal(142, state) is.Equal(142, state)
is.Equal(nil, err) is.NoError(err)
} }
// with error // with error
@@ -508,7 +508,7 @@ func TestNewThrottle(t *testing.T) {
} }
th, reset := NewThrottle(10*time.Millisecond, f1) th, reset := NewThrottle(10*time.Millisecond, f1)
is.Equal(0, callCount) is.Zero(callCount)
for j := 0; j < 100; j++ { for j := 0; j < 100; j++ {
th() th()
} }
@@ -574,8 +574,8 @@ func TestNewThrottleBy(t *testing.T) {
} }
th, reset := NewThrottleBy(10*time.Millisecond, f1) th, reset := NewThrottleBy(10*time.Millisecond, f1)
is.Equal(0, callCountA) is.Zero(callCountA)
is.Equal(0, callCountB) is.Zero(callCountB)
for j := 0; j < 100; j++ { for j := 0; j < 100; j++ {
th("a") th("a")
th("b") th("b")

166
slice_test.go
View File

@@ -18,12 +18,12 @@ func TestFilter(t *testing.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 {
return x%2 == 0 return x%2 == 0
}) })
is.Equal(r1, []int{2, 4}) is.Equal([]int{2, 4}, r1)
r2 := Filter([]string{"", "foo", "", "bar", ""}, func(x string, _ int) bool { r2 := Filter([]string{"", "foo", "", "bar", ""}, func(x string, _ int) bool {
return len(x) > 0 return len(x) > 0
}) })
is.Equal(r2, []string{"foo", "bar"}) is.Equal([]string{"foo", "bar"}, r2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -44,10 +44,10 @@ func TestMap(t *testing.T) {
return strconv.FormatInt(x, 10) return strconv.FormatInt(x, 10)
}) })
is.Equal(len(result1), 4) is.Len(result1, 4)
is.Equal(len(result2), 4) is.Len(result2, 4)
is.Equal(result1, []string{"Hello", "Hello", "Hello", "Hello"}) is.Equal([]string{"Hello", "Hello", "Hello", "Hello"}, result1)
is.Equal(result2, []string{"1", "2", "3", "4"}) is.Equal([]string{"1", "2", "3", "4"}, result2)
} }
func TestUniqMap(t *testing.T) { func TestUniqMap(t *testing.T) {
@@ -64,7 +64,7 @@ func TestUniqMap(t *testing.T) {
return item.Name return item.Name
}) })
is.Equal(result, []string{"Alice", "Alex"}) is.Equal([]string{"Alice", "Alex"}, result)
} }
func TestFilterMap(t *testing.T) { func TestFilterMap(t *testing.T) {
@@ -84,10 +84,10 @@ func TestFilterMap(t *testing.T) {
return "", false return "", false
}) })
is.Equal(len(r1), 2) is.Len(r1, 2)
is.Equal(len(r2), 2) is.Len(r2, 2)
is.Equal(r1, []string{"2", "4"}) is.Equal([]string{"2", "4"}, r1)
is.Equal(r2, []string{"xpu", "xpu"}) is.Equal([]string{"xpu", "xpu"}, r2)
} }
func TestFlatMap(t *testing.T) { func TestFlatMap(t *testing.T) {
@@ -105,10 +105,10 @@ func TestFlatMap(t *testing.T) {
return result return result
}) })
is.Equal(len(result1), 5) is.Len(result1, 5)
is.Equal(len(result2), 10) is.Len(result2, 10)
is.Equal(result1, []string{"Hello", "Hello", "Hello", "Hello", "Hello"}) is.Equal([]string{"Hello", "Hello", "Hello", "Hello", "Hello"}, result1)
is.Equal(result2, []string{"1", "2", "2", "3", "3", "3", "4", "4", "4", "4"}) is.Equal([]string{"1", "2", "2", "3", "3", "3", "4", "4", "4", "4"}, result2)
} }
func TestTimes(t *testing.T) { func TestTimes(t *testing.T) {
@@ -119,8 +119,8 @@ func TestTimes(t *testing.T) {
return strconv.FormatInt(int64(i), 10) return strconv.FormatInt(int64(i), 10)
}) })
is.Equal(len(result1), 3) is.Len(result1, 3)
is.Equal(result1, []string{"0", "1", "2"}) is.Equal([]string{"0", "1", "2"}, result1)
} }
func TestReduce(t *testing.T) { func TestReduce(t *testing.T) {
@@ -134,8 +134,8 @@ func TestReduce(t *testing.T) {
return agg + item return agg + item
}, 10) }, 10)
is.Equal(result1, 10) is.Equal(10, result1)
is.Equal(result2, 20) is.Equal(20, result2)
} }
func TestReduceRight(t *testing.T) { func TestReduceRight(t *testing.T) {
@@ -146,13 +146,13 @@ func TestReduceRight(t *testing.T) {
return append(agg, item...) return append(agg, item...)
}, []int{}) }, []int{})
is.Equal(result1, []int{4, 5, 2, 3, 0, 1}) is.Equal([]int{4, 5, 2, 3, 0, 1}, result1)
type collection []int type collection []int
result3 := ReduceRight(collection{1, 2, 3, 4}, func(agg int, item int, _ int) int { result3 := ReduceRight(collection{1, 2, 3, 4}, func(agg int, item int, _ int) int {
return agg + item return agg + item
}, 10) }, 10)
is.Equal(result3, 20) is.Equal(20, result3)
} }
func TestForEach(t *testing.T) { func TestForEach(t *testing.T) {
@@ -203,8 +203,8 @@ func TestUniq(t *testing.T) {
result1 := Uniq([]int{1, 2, 2, 1}) result1 := Uniq([]int{1, 2, 2, 1})
is.Equal(len(result1), 2) is.Len(result1, 2)
is.Equal(result1, []int{1, 2}) is.Equal([]int{1, 2}, result1)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -220,8 +220,8 @@ func TestUniqBy(t *testing.T) {
return i % 3 return i % 3
}) })
is.Equal(len(result1), 3) is.Len(result1, 3)
is.Equal(result1, []int{0, 1, 2}) is.Equal([]int{0, 1, 2}, result1)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -239,12 +239,12 @@ func TestGroupBy(t *testing.T) {
return i % 3 return i % 3
}) })
is.Equal(len(result1), 3) is.Len(result1, 3)
is.Equal(result1, map[int][]int{ is.Equal(map[int][]int{
0: {0, 3}, 0: {0, 3},
1: {1, 4}, 1: {1, 4},
2: {2, 5}, 2: {2, 5},
}) }, result1)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -262,12 +262,12 @@ func TestGroupByMap(t *testing.T) {
return i % 3, strconv.Itoa(i) return i % 3, strconv.Itoa(i)
}) })
is.Equal(len(result1), 3) is.Len(result1, 3)
is.Equal(result1, map[int][]string{ is.Equal(map[int][]string{
0: {"0", "3"}, 0: {"0", "3"},
1: {"1", "4"}, 1: {"1", "4"},
2: {"2", "5"}, 2: {"2", "5"},
}) }, result1)
type myInt int type myInt int
type myInts []myInt type myInts []myInt
@@ -275,12 +275,12 @@ func TestGroupByMap(t *testing.T) {
return int(i % 3), strconv.Itoa(int(i)) return int(i % 3), strconv.Itoa(int(i))
}) })
is.Equal(len(result2), 3) is.Len(result2, 3)
is.Equal(result2, map[int][]string{ is.Equal(map[int][]string{
0: {"0", "3"}, 0: {"0", "3"},
1: {"1", "4"}, 1: {"1", "4"},
2: {"2", "5"}, 2: {"2", "5"},
}) }, result2)
type product struct { type product struct {
ID int64 ID int64
@@ -297,12 +297,12 @@ func TestGroupByMap(t *testing.T) {
return item.CategoryID, "Product " + strconv.FormatInt(item.ID, 10) return item.CategoryID, "Product " + strconv.FormatInt(item.ID, 10)
}) })
is.Equal(len(result3), 3) is.Len(result3, 3)
is.Equal(result3, map[int64][]string{ is.Equal(map[int64][]string{
1: {"Product 1", "Product 2"}, 1: {"Product 1", "Product 2"},
2: {"Product 3"}, 2: {"Product 3"},
3: {"Product 4", "Product 5"}, 3: {"Product 4", "Product 5"},
}) }, result3)
} }
func TestChunk(t *testing.T) { func TestChunk(t *testing.T) {
@@ -314,10 +314,10 @@ func TestChunk(t *testing.T) {
result3 := Chunk([]int{}, 2) result3 := Chunk([]int{}, 2)
result4 := Chunk([]int{0}, 2) result4 := Chunk([]int{0}, 2)
is.Equal(result1, [][]int{{0, 1}, {2, 3}, {4, 5}}) is.Equal([][]int{{0, 1}, {2, 3}, {4, 5}}, result1)
is.Equal(result2, [][]int{{0, 1}, {2, 3}, {4, 5}, {6}}) is.Equal([][]int{{0, 1}, {2, 3}, {4, 5}, {6}}, result2)
is.Equal(result3, [][]int{}) is.Equal([][]int{}, result3)
is.Equal(result4, [][]int{{0}}) is.Equal([][]int{{0}}, result4)
is.PanicsWithValue("Second parameter must be greater than 0", func() { is.PanicsWithValue("Second parameter must be greater than 0", func() {
Chunk([]int{0}, 0) Chunk([]int{0}, 0)
}) })
@@ -331,7 +331,7 @@ func TestChunk(t *testing.T) {
originalArray := []int{0, 1, 2, 3, 4, 5} originalArray := []int{0, 1, 2, 3, 4, 5}
result5 := Chunk(originalArray, 2) result5 := Chunk(originalArray, 2)
result5[0] = append(result5[0], 6) result5[0] = append(result5[0], 6)
is.Equal(originalArray, []int{0, 1, 2, 3, 4, 5}) is.Equal([]int{0, 1, 2, 3, 4, 5}, originalArray)
} }
func TestPartitionBy(t *testing.T) { func TestPartitionBy(t *testing.T) {
@@ -350,8 +350,8 @@ func TestPartitionBy(t *testing.T) {
result1 := PartitionBy([]int{-2, -1, 0, 1, 2, 3, 4, 5}, oddEven) result1 := PartitionBy([]int{-2, -1, 0, 1, 2, 3, 4, 5}, oddEven)
result2 := PartitionBy([]int{}, oddEven) result2 := PartitionBy([]int{}, oddEven)
is.Equal(result1, [][]int{{-2, -1}, {0, 2, 4}, {1, 3, 5}}) is.Equal([][]int{{-2, -1}, {0, 2, 4}, {1, 3, 5}}, result1)
is.Equal(result2, [][]int{}) is.Equal([][]int{}, result2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -367,7 +367,7 @@ func TestFlatten(t *testing.T) {
result1 := Flatten([][]int{{0, 1}, {2, 3, 4, 5}}) result1 := Flatten([][]int{{0, 1}, {2, 3, 4, 5}})
is.Equal(result1, []int{0, 1, 2, 3, 4, 5}) is.Equal([]int{0, 1, 2, 3, 4, 5}, result1)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -435,8 +435,8 @@ func TestShuffle(t *testing.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})
result2 := Shuffle([]int{}) result2 := Shuffle([]int{})
is.NotEqual(result1, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) is.NotEqual([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, result1)
is.Equal(result2, []int{}) is.Equal([]int{}, result2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -452,9 +452,9 @@ func TestReverse(t *testing.T) {
result2 := Reverse([]int{0, 1, 2, 3, 4, 5, 6}) result2 := Reverse([]int{0, 1, 2, 3, 4, 5, 6})
result3 := Reverse([]int{}) result3 := Reverse([]int{})
is.Equal(result1, []int{5, 4, 3, 2, 1, 0}) is.Equal([]int{5, 4, 3, 2, 1, 0}, result1)
is.Equal(result2, []int{6, 5, 4, 3, 2, 1, 0}) is.Equal([]int{6, 5, 4, 3, 2, 1, 0}, result2)
is.Equal(result3, []int{}) is.Equal([]int{}, result3)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -469,8 +469,8 @@ func TestFill(t *testing.T) {
result1 := Fill([]foo{{"a"}, {"a"}}, foo{"b"}) result1 := Fill([]foo{{"a"}, {"a"}}, foo{"b"})
result2 := Fill([]foo{}, foo{"a"}) result2 := Fill([]foo{}, foo{"a"})
is.Equal(result1, []foo{{"b"}, {"b"}}) is.Equal([]foo{{"b"}, {"b"}}, result1)
is.Equal(result2, []foo{}) is.Equal([]foo{}, result2)
} }
func TestRepeat(t *testing.T) { func TestRepeat(t *testing.T) {
@@ -480,8 +480,8 @@ func TestRepeat(t *testing.T) {
result1 := Repeat(2, foo{"a"}) result1 := Repeat(2, foo{"a"})
result2 := Repeat(0, foo{"a"}) result2 := Repeat(0, foo{"a"})
is.Equal(result1, []foo{{"a"}, {"a"}}) is.Equal([]foo{{"a"}, {"a"}}, result1)
is.Equal(result2, []foo{}) is.Equal([]foo{}, result2)
} }
func TestRepeatBy(t *testing.T) { func TestRepeatBy(t *testing.T) {
@@ -509,7 +509,7 @@ func TestKeyBy(t *testing.T) {
return len(str) return len(str)
}) })
is.Equal(result1, map[int]string{1: "a", 2: "aa", 3: "aaa"}) is.Equal(map[int]string{1: "a", 2: "aa", 3: "aaa"}, result1)
} }
func TestAssociate(t *testing.T) { func TestAssociate(t *testing.T) {
@@ -624,9 +624,9 @@ func TestKeyify(t *testing.T) {
result1 := Keyify([]int{1, 2, 3, 4}) result1 := Keyify([]int{1, 2, 3, 4})
result2 := Keyify([]int{1, 1, 1, 2}) result2 := Keyify([]int{1, 1, 1, 2})
result3 := Keyify([]int{}) result3 := Keyify([]int{})
is.Equal(result1, map[int]struct{}{1: {}, 2: {}, 3: {}, 4: {}}) is.Equal(map[int]struct{}{1: {}, 2: {}, 3: {}, 4: {}}, result1)
is.Equal(result2, map[int]struct{}{1: {}, 2: {}}) is.Equal(map[int]struct{}{1: {}, 2: {}}, result2)
is.Equal(result3, map[int]struct{}{}) is.Equal(map[int]struct{}{}, result3)
} }
func TestDrop(t *testing.T) { func TestDrop(t *testing.T) {
@@ -744,13 +744,13 @@ func TestReject(t *testing.T) {
return x%2 == 0 return x%2 == 0
}) })
is.Equal(r1, []int{1, 3}) is.Equal([]int{1, 3}, r1)
r2 := Reject([]string{"Smith", "foo", "Domin", "bar", "Olivia"}, func(x string, _ int) bool { r2 := Reject([]string{"Smith", "foo", "Domin", "bar", "Olivia"}, func(x string, _ int) bool {
return len(x) > 3 return len(x) > 3
}) })
is.Equal(r2, []string{"foo", "bar"}) is.Equal([]string{"foo", "bar"}, r2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -777,10 +777,10 @@ func TestRejectMap(t *testing.T) {
return "", true return "", true
}) })
is.Equal(len(r1), 2) is.Len(r1, 2)
is.Equal(len(r2), 2) is.Len(r2, 2)
is.Equal(r1, []string{"2", "4"}) is.Equal([]string{"2", "4"}, r1)
is.Equal(r2, []string{"xpu", "xpu"}) is.Equal([]string{"xpu", "xpu"}, r2)
} }
func TestFilterReject(t *testing.T) { func TestFilterReject(t *testing.T) {
@@ -791,15 +791,15 @@ func TestFilterReject(t *testing.T) {
return x%2 == 0 return x%2 == 0
}) })
is.Equal(left1, []int{2, 4}) is.Equal([]int{2, 4}, left1)
is.Equal(right1, []int{1, 3}) is.Equal([]int{1, 3}, right1)
left2, right2 := FilterReject([]string{"Smith", "foo", "Domin", "bar", "Olivia"}, func(x string, _ int) bool { left2, right2 := FilterReject([]string{"Smith", "foo", "Domin", "bar", "Olivia"}, func(x string, _ int) bool {
return len(x) > 3 return len(x) > 3
}) })
is.Equal(left2, []string{"Smith", "Domin", "Olivia"}) is.Equal([]string{"Smith", "Domin", "Olivia"}, left2)
is.Equal(right2, []string{"foo", "bar"}) is.Equal([]string{"foo", "bar"}, right2)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -818,9 +818,9 @@ func TestCount(t *testing.T) {
count2 := Count([]int{1, 2, 1}, 3) count2 := Count([]int{1, 2, 1}, 3)
count3 := Count([]int{}, 1) count3 := Count([]int{}, 1)
is.Equal(count1, 2) is.Equal(2, count1)
is.Equal(count2, 0) is.Zero(count2)
is.Equal(count3, 0) is.Zero(count3)
} }
func TestCountBy(t *testing.T) { func TestCountBy(t *testing.T) {
@@ -839,9 +839,9 @@ func TestCountBy(t *testing.T) {
return i <= 2 return i <= 2
}) })
is.Equal(count1, 2) is.Equal(2, count1)
is.Equal(count2, 0) is.Zero(count2)
is.Equal(count3, 0) is.Zero(count3)
} }
func TestCountValues(t *testing.T) { func TestCountValues(t *testing.T) {
@@ -1025,15 +1025,15 @@ func TestCompact(t *testing.T) {
r1 := Compact([]int{2, 0, 4, 0}) r1 := Compact([]int{2, 0, 4, 0})
is.Equal(r1, []int{2, 4}) is.Equal([]int{2, 4}, r1)
r2 := Compact([]string{"", "foo", "", "bar", ""}) r2 := Compact([]string{"", "foo", "", "bar", ""})
is.Equal(r2, []string{"foo", "bar"}) is.Equal([]string{"foo", "bar"}, r2)
r3 := Compact([]bool{true, false, true, false}) r3 := Compact([]bool{true, false, true, false})
is.Equal(r3, []bool{true, true}) is.Equal([]bool{true, true}, r3)
type foo struct { type foo struct {
bar int bar int
@@ -1049,7 +1049,7 @@ func TestCompact(t *testing.T) {
{bar: 2, baz: ""}, // bar is non-zero {bar: 2, baz: ""}, // bar is non-zero
}) })
is.Equal(r4, []foo{{bar: 1, baz: "a"}, {bar: 2, baz: ""}}) is.Equal([]foo{{bar: 1, baz: "a"}, {bar: 2, baz: ""}}, r4)
// slice of pointers to structs // slice of pointers to structs
// If an element is nil, Compact removes it. // If an element is nil, Compact removes it.
@@ -1058,7 +1058,7 @@ func TestCompact(t *testing.T) {
// NOTE: e2 is a zero value of foo, but its pointer &e2 is not a zero value of *foo. // NOTE: e2 is a zero value of foo, but its pointer &e2 is not a zero value of *foo.
r5 := Compact([]*foo{&e1, &e2, nil, &e3}) r5 := Compact([]*foo{&e1, &e2, nil, &e3})
is.Equal(r5, []*foo{&e1, &e2, &e3}) is.Equal([]*foo{&e1, &e2, &e3}, r5)
type myStrings []string type myStrings []string
allStrings := myStrings{"", "foo", "bar"} allStrings := myStrings{"", "foo", "bar"}
@@ -1114,21 +1114,21 @@ func TestSplice(t *testing.T) {
// positive overflow // positive overflow
results = Splice(sample, 42, "1", "2") results = Splice(sample, 42, "1", "2")
is.Equal([]string{"a", "b", "c", "d", "e", "f", "g"}, sample) is.Equal([]string{"a", "b", "c", "d", "e", "f", "g"}, sample)
is.Equal(results, []string{"a", "b", "c", "d", "e", "f", "g", "1", "2"}) is.Equal([]string{"a", "b", "c", "d", "e", "f", "g", "1", "2"}, results)
// negative overflow // negative overflow
results = Splice(sample, -42, "1", "2") results = Splice(sample, -42, "1", "2")
is.Equal([]string{"a", "b", "c", "d", "e", "f", "g"}, sample) is.Equal([]string{"a", "b", "c", "d", "e", "f", "g"}, sample)
is.Equal(results, []string{"1", "2", "a", "b", "c", "d", "e", "f", "g"}) is.Equal([]string{"1", "2", "a", "b", "c", "d", "e", "f", "g"}, results)
// backward // backward
results = Splice(sample, -2, "1", "2") results = Splice(sample, -2, "1", "2")
is.Equal([]string{"a", "b", "c", "d", "e", "f", "g"}, sample) is.Equal([]string{"a", "b", "c", "d", "e", "f", "g"}, sample)
is.Equal(results, []string{"a", "b", "c", "d", "e", "1", "2", "f", "g"}) is.Equal([]string{"a", "b", "c", "d", "e", "1", "2", "f", "g"}, results)
results = Splice(sample, -7, "1", "2") results = Splice(sample, -7, "1", "2")
is.Equal([]string{"a", "b", "c", "d", "e", "f", "g"}, sample) is.Equal([]string{"a", "b", "c", "d", "e", "f", "g"}, sample)
is.Equal(results, []string{"1", "2", "a", "b", "c", "d", "e", "f", "g"}) is.Equal([]string{"1", "2", "a", "b", "c", "d", "e", "f", "g"}, results)
// other // other
is.Equal([]string{"1", "2"}, Splice([]string{}, 0, "1", "2")) is.Equal([]string{"1", "2"}, Splice([]string{}, 0, "1", "2"))

8
string_test.go
View File

@@ -78,8 +78,8 @@ func TestSubstring(t *testing.T) {
str14 := Substring("你好，世界", 0, 3) str14 := Substring("你好，世界", 0, 3)
str15 := Substring("hello", 5, 1) str15 := Substring("hello", 5, 1)
is.Equal("", str1) is.Empty(str1)
is.Equal("", str2) is.Empty(str2)
is.Equal("he", str3) is.Equal("he", str3)
is.Equal("hello", str4) is.Equal("hello", str4)
is.Equal("he", str5) is.Equal("he", str5)
@@ -92,7 +92,7 @@ func TestSubstring(t *testing.T) {
is.Equal("ello", str12) is.Equal("ello", str12)
is.Equal("🏠🐶", str13) is.Equal("🏠🐶", str13)
is.Equal("你好，", str14) is.Equal("你好，", str14)
is.Equal("", str15) is.Empty(str15)
} }
func TestRuneLength(t *testing.T) { func TestRuneLength(t *testing.T) {
@@ -100,7 +100,7 @@ func TestRuneLength(t *testing.T) {
is := assert.New(t) is := assert.New(t)
is.Equal(5, RuneLength("hellô")) is.Equal(5, RuneLength("hellô"))
is.Equal(6, len("hellô")) is.Len("hellô", 6)
} }
func TestAllCase(t *testing.T) { func TestAllCase(t *testing.T) {

132
tuples_test.go
View File

@@ -19,14 +19,14 @@ func TestT(t *testing.T) {
r7 := T8[string, int, float32]("j", 7, 8.0, true, "k", 9, 10.0, false) r7 := T8[string, int, float32]("j", 7, 8.0, true, "k", 9, 10.0, false)
r8 := T9[string, int, float32]("l", 8, 9.0, false, "m", 10, 11.0, true, "n") r8 := T9[string, int, float32]("l", 8, 9.0, false, "m", 10, 11.0, true, "n")
is.Equal(r1, Tuple2[string, int]{A: "a", B: 1}) is.Equal(Tuple2[string, int]{A: "a", B: 1}, r1)
is.Equal(r2, Tuple3[string, int, float32]{A: "b", B: 2, C: 3.0}) is.Equal(Tuple3[string, int, float32]{A: "b", B: 2, C: 3.0}, r2)
is.Equal(r3, Tuple4[string, int, float32, bool]{A: "c", B: 3, C: 4.0, D: true}) is.Equal(Tuple4[string, int, float32, bool]{A: "c", B: 3, C: 4.0, D: true}, r3)
is.Equal(r4, Tuple5[string, int, float32, bool, string]{A: "d", B: 4, C: 5.0, D: false, E: "e"}) is.Equal(Tuple5[string, int, float32, bool, string]{A: "d", B: 4, C: 5.0, D: false, E: "e"}, r4)
is.Equal(r5, Tuple6[string, int, float32, bool, string, int]{A: "f", B: 5, C: 6.0, D: true, E: "g", F: 7}) is.Equal(Tuple6[string, int, float32, bool, string, int]{A: "f", B: 5, C: 6.0, D: true, E: "g", F: 7}, r5)
is.Equal(r6, Tuple7[string, int, float32, bool, string, int, float64]{A: "h", B: 6, C: 7.0, D: false, E: "i", F: 8, G: 9.0}) is.Equal(Tuple7[string, int, float32, bool, string, int, float64]{A: "h", B: 6, C: 7.0, D: false, E: "i", F: 8, G: 9.0}, r6)
is.Equal(r7, Tuple8[string, int, float32, bool, string, int, float64, bool]{A: "j", B: 7, C: 8.0, D: true, E: "k", F: 9, G: 10.0, H: false}) is.Equal(Tuple8[string, int, float32, bool, string, int, float64, bool]{A: "j", B: 7, C: 8.0, D: true, E: "k", F: 9, G: 10.0, H: false}, r7)
is.Equal(r8, Tuple9[string, int, float32, bool, string, int, float64, bool, string]{A: "l", B: 8, C: 9.0, D: false, E: "m", F: 10, G: 11.0, H: true, I: "n"}) is.Equal(Tuple9[string, int, float32, bool, string, int, float64, bool, string]{A: "l", B: 8, C: 9.0, D: false, E: "m", F: 10, G: 11.0, H: true, I: "n"}, r8)
} }
func TestUnpack(t *testing.T) { func TestUnpack(t *testing.T) {
@@ -71,14 +71,14 @@ func TestUnpack(t *testing.T) {
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
r1, r2, r3, r4 = tuple.Unpack() r1, r2, r3, r4 = tuple.Unpack()
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
} }
{ {
@@ -89,7 +89,7 @@ func TestUnpack(t *testing.T) {
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
is.Equal("b", r5) is.Equal("b", r5)
r1, r2, r3, r4, r5 = tuple.Unpack() r1, r2, r3, r4, r5 = tuple.Unpack()
@@ -97,7 +97,7 @@ func TestUnpack(t *testing.T) {
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
is.Equal("b", r5) is.Equal("b", r5)
} }
@@ -109,7 +109,7 @@ func TestUnpack(t *testing.T) {
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
is.Equal("b", r5) is.Equal("b", r5)
is.Equal(2, r6) is.Equal(2, r6)
@@ -118,7 +118,7 @@ func TestUnpack(t *testing.T) {
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
is.Equal("b", r5) is.Equal("b", r5)
is.Equal(2, r6) is.Equal(2, r6)
} }
@@ -131,7 +131,7 @@ func TestUnpack(t *testing.T) {
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
is.Equal("b", r5) is.Equal("b", r5)
is.Equal(2, r6) is.Equal(2, r6)
is.Equal(3.0, r7) is.Equal(3.0, r7)
@@ -141,7 +141,7 @@ func TestUnpack(t *testing.T) {
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
is.Equal("b", r5) is.Equal("b", r5)
is.Equal(2, r6) is.Equal(2, r6)
is.Equal(3.0, r7) is.Equal(3.0, r7)
@@ -155,22 +155,22 @@ func TestUnpack(t *testing.T) {
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
is.Equal("b", r5) is.Equal("b", r5)
is.Equal(2, r6) is.Equal(2, r6)
is.Equal(3.0, r7) is.Equal(3.0, r7)
is.Equal(true, r8) is.True(r8)
r1, r2, r3, r4, r5, r6, r7, r8 = tuple.Unpack() r1, r2, r3, r4, r5, r6, r7, r8 = tuple.Unpack()
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
is.Equal("b", r5) is.Equal("b", r5)
is.Equal(2, r6) is.Equal(2, r6)
is.Equal(3.0, r7) is.Equal(3.0, r7)
is.Equal(true, r8) is.True(r8)
} }
{ {
@@ -181,11 +181,11 @@ func TestUnpack(t *testing.T) {
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
is.Equal("b", r5) is.Equal("b", r5)
is.Equal(2, r6) is.Equal(2, r6)
is.Equal(3.0, r7) is.Equal(3.0, r7)
is.Equal(true, r8) is.True(r8)
is.Equal("c", r9) is.Equal("c", r9)
r1, r2, r3, r4, r5, r6, r7, r8, r9 = tuple.Unpack() r1, r2, r3, r4, r5, r6, r7, r8, r9 = tuple.Unpack()
@@ -193,11 +193,11 @@ func TestUnpack(t *testing.T) {
is.Equal("a", r1) is.Equal("a", r1)
is.Equal(1, r2) is.Equal(1, r2)
is.Equal(1.0, r3) is.Equal(1.0, r3)
is.Equal(true, r4) is.True(r4)
is.Equal("b", r5) is.Equal("b", r5)
is.Equal(2, r6) is.Equal(2, r6)
is.Equal(3.0, r7) is.Equal(3.0, r7)
is.Equal(true, r8) is.True(r8)
is.Equal("c", r9) is.Equal("c", r9)
} }
} }
@@ -274,42 +274,42 @@ func TestZip(t *testing.T) {
[]int32{1, 2, 3, 4, 5, 6, 7, 8, 9}, []int32{1, 2, 3, 4, 5, 6, 7, 8, 9},
) )
is.Equal(r1, []Tuple2[string, int]{ is.Equal([]Tuple2[string, int]{
{A: "a", B: 1}, {A: "a", B: 1},
{A: "b", B: 2}, {A: "b", B: 2},
}) }, r1)
is.Equal(r2, []Tuple3[string, int, int]{ is.Equal([]Tuple3[string, int, int]{
{A: "a", B: 1, C: 4}, {A: "a", B: 1, C: 4},
{A: "b", B: 2, C: 5}, {A: "b", B: 2, C: 5},
{A: "c", B: 3, C: 6}, {A: "c", B: 3, C: 6},
}) }, r2)
is.Equal(r3, []Tuple4[string, int, int, bool]{ is.Equal([]Tuple4[string, int, int, bool]{
{A: "a", B: 1, C: 5, D: true}, {A: "a", B: 1, C: 5, D: true},
{A: "b", B: 2, C: 6, D: true}, {A: "b", B: 2, C: 6, D: true},
{A: "c", B: 3, C: 7, D: true}, {A: "c", B: 3, C: 7, D: true},
{A: "d", B: 4, C: 8, D: true}, {A: "d", B: 4, C: 8, D: true},
}) }, r3)
is.Equal(r4, []Tuple5[string, int, int, bool, float32]{ is.Equal([]Tuple5[string, int, int, bool, float32]{
{A: "a", B: 1, C: 6, D: true, E: 0.1}, {A: "a", B: 1, C: 6, D: true, E: 0.1},
{A: "b", B: 2, C: 7, D: true, E: 0.2}, {A: "b", B: 2, C: 7, D: true, E: 0.2},
{A: "c", B: 3, C: 8, D: true, E: 0.3}, {A: "c", B: 3, C: 8, D: true, E: 0.3},
{A: "d", B: 4, C: 9, D: true, E: 0.4}, {A: "d", B: 4, C: 9, D: true, E: 0.4},
{A: "e", B: 5, C: 10, D: true, E: 0.5}, {A: "e", B: 5, C: 10, D: true, E: 0.5},
}) }, r4)
is.Equal(r5, []Tuple6[string, int, int, bool, float32, float64]{ is.Equal([]Tuple6[string, int, int, bool, float32, float64]{
{A: "a", B: 1, C: 7, D: true, E: 0.1, F: 0.01}, {A: "a", B: 1, C: 7, D: true, E: 0.1, F: 0.01},
{A: "b", B: 2, C: 8, D: true, E: 0.2, F: 0.02}, {A: "b", B: 2, C: 8, D: true, E: 0.2, F: 0.02},
{A: "c", B: 3, C: 9, D: true, E: 0.3, F: 0.03}, {A: "c", B: 3, C: 9, D: true, E: 0.3, F: 0.03},
{A: "d", B: 4, C: 10, D: true, E: 0.4, F: 0.04}, {A: "d", B: 4, C: 10, D: true, E: 0.4, F: 0.04},
{A: "e", B: 5, C: 11, D: true, E: 0.5, F: 0.05}, {A: "e", B: 5, C: 11, D: true, E: 0.5, F: 0.05},
{A: "f", B: 6, C: 12, D: true, E: 0.6, F: 0.06}, {A: "f", B: 6, C: 12, D: true, E: 0.6, F: 0.06},
}) }, r5)
is.Equal(r6, []Tuple7[string, int, int, bool, float32, float64, int8]{ is.Equal([]Tuple7[string, int, int, bool, float32, float64, int8]{
{A: "a", B: 1, C: 8, D: true, E: 0.1, F: 0.01, G: 1}, {A: "a", B: 1, C: 8, D: true, E: 0.1, F: 0.01, G: 1},
{A: "b", B: 2, C: 9, D: true, E: 0.2, F: 0.02, G: 2}, {A: "b", B: 2, C: 9, D: true, E: 0.2, F: 0.02, G: 2},
{A: "c", B: 3, C: 10, D: true, E: 0.3, F: 0.03, G: 3}, {A: "c", B: 3, C: 10, D: true, E: 0.3, F: 0.03, G: 3},
@@ -317,9 +317,9 @@ func TestZip(t *testing.T) {
{A: "e", B: 5, C: 12, D: true, E: 0.5, F: 0.05, G: 5}, {A: "e", B: 5, C: 12, D: true, E: 0.5, F: 0.05, G: 5},
{A: "f", B: 6, C: 13, D: true, E: 0.6, F: 0.06, G: 6}, {A: "f", B: 6, C: 13, D: true, E: 0.6, F: 0.06, G: 6},
{A: "g", B: 7, C: 14, D: true, E: 0.7, F: 0.07, G: 7}, {A: "g", B: 7, C: 14, D: true, E: 0.7, F: 0.07, G: 7},
}) }, r6)
is.Equal(r7, []Tuple8[string, int, int, bool, float32, float64, int8, int16]{ is.Equal([]Tuple8[string, int, int, bool, float32, float64, int8, int16]{
{A: "a", B: 1, C: 9, D: true, E: 0.1, F: 0.01, G: 1, H: 1}, {A: "a", B: 1, C: 9, D: true, E: 0.1, F: 0.01, G: 1, H: 1},
{A: "b", B: 2, C: 10, D: true, E: 0.2, F: 0.02, G: 2, H: 2}, {A: "b", B: 2, C: 10, D: true, E: 0.2, F: 0.02, G: 2, H: 2},
{A: "c", B: 3, C: 11, D: true, E: 0.3, F: 0.03, G: 3, H: 3}, {A: "c", B: 3, C: 11, D: true, E: 0.3, F: 0.03, G: 3, H: 3},
@@ -328,9 +328,9 @@ func TestZip(t *testing.T) {
{A: "f", B: 6, C: 14, D: true, E: 0.6, F: 0.06, G: 6, H: 6}, {A: "f", B: 6, C: 14, D: true, E: 0.6, F: 0.06, G: 6, H: 6},
{A: "g", B: 7, C: 15, D: true, E: 0.7, F: 0.07, G: 7, H: 7}, {A: "g", B: 7, C: 15, D: true, E: 0.7, F: 0.07, G: 7, H: 7},
{A: "h", B: 8, C: 16, D: true, E: 0.8, F: 0.08, G: 8, H: 8}, {A: "h", B: 8, C: 16, D: true, E: 0.8, F: 0.08, G: 8, H: 8},
}) }, r7)
is.Equal(r8, []Tuple9[string, int, int, bool, float32, float64, int8, int16, int32]{ is.Equal([]Tuple9[string, int, int, bool, float32, float64, int8, int16, int32]{
{A: "a", B: 1, C: 10, D: true, E: 0.1, F: 0.01, G: 1, H: 1, I: 1}, {A: "a", B: 1, C: 10, D: true, E: 0.1, F: 0.01, G: 1, H: 1, I: 1},
{A: "b", B: 2, C: 11, D: true, E: 0.2, F: 0.02, G: 2, H: 2, I: 2}, {A: "b", B: 2, C: 11, D: true, E: 0.2, F: 0.02, G: 2, H: 2, I: 2},
{A: "c", B: 3, C: 12, D: true, E: 0.3, F: 0.03, G: 3, H: 3, I: 3}, {A: "c", B: 3, C: 12, D: true, E: 0.3, F: 0.03, G: 3, H: 3, I: 3},
@@ -340,7 +340,7 @@ func TestZip(t *testing.T) {
{A: "g", B: 7, C: 16, D: true, E: 0.7, F: 0.07, G: 7, H: 7, I: 7}, {A: "g", B: 7, C: 16, D: true, E: 0.7, F: 0.07, G: 7, H: 7, I: 7},
{A: "h", B: 8, C: 17, D: true, E: 0.8, F: 0.08, G: 8, H: 8, I: 8}, {A: "h", B: 8, C: 17, D: true, E: 0.8, F: 0.08, G: 8, H: 8, I: 8},
{A: "i", B: 9, C: 18, D: true, E: 0.9, F: 0.09, G: 9, H: 9, I: 9}, {A: "i", B: 9, C: 18, D: true, E: 0.9, F: 0.09, G: 9, H: 9, I: 9},
}) }, r8)
} }
func TestZipBy(t *testing.T) { func TestZipBy(t *testing.T) {
@@ -439,42 +439,42 @@ func TestZipBy(t *testing.T) {
}, },
) )
is.Equal(r1, []Tuple2[string, int]{ is.Equal([]Tuple2[string, int]{
{A: "a", B: 1}, {A: "a", B: 1},
{A: "b", B: 2}, {A: "b", B: 2},
}) }, r1)
is.Equal(r2, []Tuple3[string, int, int]{ is.Equal([]Tuple3[string, int, int]{
{A: "a", B: 1, C: 4}, {A: "a", B: 1, C: 4},
{A: "b", B: 2, C: 5}, {A: "b", B: 2, C: 5},
{A: "c", B: 3, C: 6}, {A: "c", B: 3, C: 6},
}) }, r2)
is.Equal(r3, []Tuple4[string, int, int, bool]{ is.Equal([]Tuple4[string, int, int, bool]{
{A: "a", B: 1, C: 5, D: true}, {A: "a", B: 1, C: 5, D: true},
{A: "b", B: 2, C: 6, D: true}, {A: "b", B: 2, C: 6, D: true},
{A: "c", B: 3, C: 7, D: true}, {A: "c", B: 3, C: 7, D: true},
{A: "d", B: 4, C: 8, D: true}, {A: "d", B: 4, C: 8, D: true},
}) }, r3)
is.Equal(r4, []Tuple5[string, int, int, bool, float32]{ is.Equal([]Tuple5[string, int, int, bool, float32]{
{A: "a", B: 1, C: 6, D: true, E: 0.1}, {A: "a", B: 1, C: 6, D: true, E: 0.1},
{A: "b", B: 2, C: 7, D: true, E: 0.2}, {A: "b", B: 2, C: 7, D: true, E: 0.2},
{A: "c", B: 3, C: 8, D: true, E: 0.3}, {A: "c", B: 3, C: 8, D: true, E: 0.3},
{A: "d", B: 4, C: 9, D: true, E: 0.4}, {A: "d", B: 4, C: 9, D: true, E: 0.4},
{A: "e", B: 5, C: 10, D: true, E: 0.5}, {A: "e", B: 5, C: 10, D: true, E: 0.5},
}) }, r4)
is.Equal(r5, []Tuple6[string, int, int, bool, float32, float64]{ is.Equal([]Tuple6[string, int, int, bool, float32, float64]{
{A: "a", B: 1, C: 7, D: true, E: 0.1, F: 0.01}, {A: "a", B: 1, C: 7, D: true, E: 0.1, F: 0.01},
{A: "b", B: 2, C: 8, D: true, E: 0.2, F: 0.02}, {A: "b", B: 2, C: 8, D: true, E: 0.2, F: 0.02},
{A: "c", B: 3, C: 9, D: true, E: 0.3, F: 0.03}, {A: "c", B: 3, C: 9, D: true, E: 0.3, F: 0.03},
{A: "d", B: 4, C: 10, D: true, E: 0.4, F: 0.04}, {A: "d", B: 4, C: 10, D: true, E: 0.4, F: 0.04},
{A: "e", B: 5, C: 11, D: true, E: 0.5, F: 0.05}, {A: "e", B: 5, C: 11, D: true, E: 0.5, F: 0.05},
{A: "f", B: 6, C: 12, D: true, E: 0.6, F: 0.06}, {A: "f", B: 6, C: 12, D: true, E: 0.6, F: 0.06},
}) }, r5)
is.Equal(r6, []Tuple7[string, int, int, bool, float32, float64, int8]{ is.Equal([]Tuple7[string, int, int, bool, float32, float64, int8]{
{A: "a", B: 1, C: 8, D: true, E: 0.1, F: 0.01, G: 1}, {A: "a", B: 1, C: 8, D: true, E: 0.1, F: 0.01, G: 1},
{A: "b", B: 2, C: 9, D: true, E: 0.2, F: 0.02, G: 2}, {A: "b", B: 2, C: 9, D: true, E: 0.2, F: 0.02, G: 2},
{A: "c", B: 3, C: 10, D: true, E: 0.3, F: 0.03, G: 3}, {A: "c", B: 3, C: 10, D: true, E: 0.3, F: 0.03, G: 3},
@@ -482,9 +482,9 @@ func TestZipBy(t *testing.T) {
{A: "e", B: 5, C: 12, D: true, E: 0.5, F: 0.05, G: 5}, {A: "e", B: 5, C: 12, D: true, E: 0.5, F: 0.05, G: 5},
{A: "f", B: 6, C: 13, D: true, E: 0.6, F: 0.06, G: 6}, {A: "f", B: 6, C: 13, D: true, E: 0.6, F: 0.06, G: 6},
{A: "g", B: 7, C: 14, D: true, E: 0.7, F: 0.07, G: 7}, {A: "g", B: 7, C: 14, D: true, E: 0.7, F: 0.07, G: 7},
}) }, r6)
is.Equal(r7, []Tuple8[string, int, int, bool, float32, float64, int8, int16]{ is.Equal([]Tuple8[string, int, int, bool, float32, float64, int8, int16]{
{A: "a", B: 1, C: 9, D: true, E: 0.1, F: 0.01, G: 1, H: 1}, {A: "a", B: 1, C: 9, D: true, E: 0.1, F: 0.01, G: 1, H: 1},
{A: "b", B: 2, C: 10, D: true, E: 0.2, F: 0.02, G: 2, H: 2}, {A: "b", B: 2, C: 10, D: true, E: 0.2, F: 0.02, G: 2, H: 2},
{A: "c", B: 3, C: 11, D: true, E: 0.3, F: 0.03, G: 3, H: 3}, {A: "c", B: 3, C: 11, D: true, E: 0.3, F: 0.03, G: 3, H: 3},
@@ -493,9 +493,9 @@ func TestZipBy(t *testing.T) {
{A: "f", B: 6, C: 14, D: true, E: 0.6, F: 0.06, G: 6, H: 6}, {A: "f", B: 6, C: 14, D: true, E: 0.6, F: 0.06, G: 6, H: 6},
{A: "g", B: 7, C: 15, D: true, E: 0.7, F: 0.07, G: 7, H: 7}, {A: "g", B: 7, C: 15, D: true, E: 0.7, F: 0.07, G: 7, H: 7},
{A: "h", B: 8, C: 16, D: true, E: 0.8, F: 0.08, G: 8, H: 8}, {A: "h", B: 8, C: 16, D: true, E: 0.8, F: 0.08, G: 8, H: 8},
}) }, r7)
is.Equal(r8, []Tuple9[string, int, int, bool, float32, float64, int8, int16, int32]{ is.Equal([]Tuple9[string, int, int, bool, float32, float64, int8, int16, int32]{
{A: "a", B: 1, C: 10, D: true, E: 0.1, F: 0.01, G: 1, H: 1, I: 1}, {A: "a", B: 1, C: 10, D: true, E: 0.1, F: 0.01, G: 1, H: 1, I: 1},
{A: "b", B: 2, C: 11, D: true, E: 0.2, F: 0.02, G: 2, H: 2, I: 2}, {A: "b", B: 2, C: 11, D: true, E: 0.2, F: 0.02, G: 2, H: 2, I: 2},
{A: "c", B: 3, C: 12, D: true, E: 0.3, F: 0.03, G: 3, H: 3, I: 3}, {A: "c", B: 3, C: 12, D: true, E: 0.3, F: 0.03, G: 3, H: 3, I: 3},
@@ -505,7 +505,7 @@ func TestZipBy(t *testing.T) {
{A: "g", B: 7, C: 16, D: true, E: 0.7, F: 0.07, G: 7, H: 7, I: 7}, {A: "g", B: 7, C: 16, D: true, E: 0.7, F: 0.07, G: 7, H: 7, I: 7},
{A: "h", B: 8, C: 17, D: true, E: 0.8, F: 0.08, G: 8, H: 8, I: 8}, {A: "h", B: 8, C: 17, D: true, E: 0.8, F: 0.08, G: 8, H: 8, I: 8},
{A: "i", B: 9, C: 18, D: true, E: 0.9, F: 0.09, G: 9, H: 9, I: 9}, {A: "i", B: 9, C: 18, D: true, E: 0.9, F: 0.09, G: 9, H: 9, I: 9},
}) }, r8)
} }
func TestUnzip(t *testing.T) { func TestUnzip(t *testing.T) {
@@ -514,8 +514,8 @@ func TestUnzip(t *testing.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}})
is.Equal(r1, []string{"a", "b"}) is.Equal([]string{"a", "b"}, r1)
is.Equal(r2, []int{1, 2}) is.Equal([]int{1, 2}, r2)
} }
func TestUnzipBy(t *testing.T) { func TestUnzipBy(t *testing.T) {
@@ -526,8 +526,8 @@ func TestUnzipBy(t *testing.T) {
return i.A + i.A, i.B + i.B return i.A + i.A, i.B + i.B
}) })
is.Equal(r1, []string{"aa", "bb"}) is.Equal([]string{"aa", "bb"}, r1)
is.Equal(r2, []int{2, 4}) is.Equal([]int{2, 4}, r2)
} }
func TestCrossJoin(t *testing.T) { func TestCrossJoin(t *testing.T) {
@@ -540,13 +540,13 @@ func TestCrossJoin(t *testing.T) {
mixedList := []any{9.6, 4, "foobar"} mixedList := []any{9.6, 4, "foobar"}
results1 := CrossJoin2(emptyList, listTwo) results1 := CrossJoin2(emptyList, listTwo)
is.Len(results1, 0) is.Empty(results1)
results2 := CrossJoin2(listOne, emptyList) results2 := CrossJoin2(listOne, emptyList)
is.Len(results2, 0) is.Empty(results2)
results3 := CrossJoin2(emptyList, emptyList) results3 := CrossJoin2(emptyList, emptyList)
is.Len(results3, 0) is.Empty(results3)
results4 := CrossJoin2([]string{"a"}, listTwo) results4 := CrossJoin2([]string{"a"}, listTwo)
is.Equal([]Tuple2[string, int]{T2("a", 1), T2("a", 2), T2("a", 3)}, results4) is.Equal([]Tuple2[string, int]{T2("a", 1), T2("a", 2), T2("a", 3)}, results4)
@@ -571,13 +571,13 @@ func TestCrossJoinBy(t *testing.T) {
mixedList := []any{9.6, 4, "foobar"} mixedList := []any{9.6, 4, "foobar"}
results1 := CrossJoinBy2(emptyList, listTwo, T2[any, int]) results1 := CrossJoinBy2(emptyList, listTwo, T2[any, int])
is.Len(results1, 0) is.Empty(results1)
results2 := CrossJoinBy2(listOne, emptyList, T2[string, any]) results2 := CrossJoinBy2(listOne, emptyList, T2[string, any])
is.Len(results2, 0) is.Empty(results2)
results3 := CrossJoinBy2(emptyList, emptyList, T2[any, any]) results3 := CrossJoinBy2(emptyList, emptyList, T2[any, any])
is.Len(results3, 0) is.Empty(results3)
results4 := CrossJoinBy2([]string{"a"}, listTwo, T2[string, int]) results4 := CrossJoinBy2([]string{"a"}, listTwo, T2[string, int])
is.Equal([]Tuple2[string, int]{T2("a", 1), T2("a", 2), T2("a", 3)}, results4) is.Equal([]Tuple2[string, int]{T2("a", 1), T2("a", 2), T2("a", 3)}, results4)

44
type_manipulation_test.go
View File

@@ -60,7 +60,7 @@ func TestToPtr(t *testing.T) {
result1 := ToPtr([]int{1, 2}) result1 := ToPtr([]int{1, 2})
is.Equal(*result1, []int{1, 2}) is.Equal([]int{1, 2}, *result1)
} }
func TestNil(t *testing.T) { func TestNil(t *testing.T) {
@@ -94,11 +94,11 @@ func TestEmptyableToPtr(t *testing.T) {
is.Nil(EmptyableToPtr[map[int]int](nil)) is.Nil(EmptyableToPtr[map[int]int](nil))
is.Nil(EmptyableToPtr[error](nil)) is.Nil(EmptyableToPtr[error](nil))
is.Equal(*EmptyableToPtr(42), 42) is.Equal(42, *EmptyableToPtr(42))
is.Equal(*EmptyableToPtr("nonempty"), "nonempty") is.Equal("nonempty", *EmptyableToPtr("nonempty"))
is.Equal(*EmptyableToPtr([]int{}), []int{}) is.Equal([]int{}, *EmptyableToPtr([]int{}))
is.Equal(*EmptyableToPtr([]int{1, 2}), []int{1, 2}) is.Equal([]int{1, 2}, *EmptyableToPtr([]int{1, 2}))
is.Equal(*EmptyableToPtr(map[int]int{}), map[int]int{}) is.Equal(map[int]int{}, *EmptyableToPtr(map[int]int{}))
is.Equal(*EmptyableToPtr(assert.AnError), assert.AnError) is.Equal(*EmptyableToPtr(assert.AnError), assert.AnError)
} }
@@ -110,10 +110,10 @@ func TestFromPtr(t *testing.T) {
ptr := &str1 ptr := &str1
is.Equal("foo", FromPtr(ptr)) is.Equal("foo", FromPtr(ptr))
is.Equal("", FromPtr[string](nil)) is.Empty(FromPtr[string](nil))
is.Equal(0, FromPtr[int](nil)) is.Zero(FromPtr[int](nil))
is.Nil(FromPtr[*string](nil)) is.Nil(FromPtr[*string](nil))
is.EqualValues(ptr, FromPtr(&ptr)) is.Equal(ptr, FromPtr(&ptr))
} }
func TestFromPtrOr(t *testing.T) { func TestFromPtrOr(t *testing.T) {
@@ -142,7 +142,7 @@ func TestToSlicePtr(t *testing.T) {
str2 := "bar" str2 := "bar"
result1 := ToSlicePtr([]string{str1, str2}) result1 := ToSlicePtr([]string{str1, str2})
is.Equal(result1, []*string{&str1, &str2}) is.Equal([]*string{&str1, &str2}, result1)
} }
func TestFromSlicePtr(t *testing.T) { func TestFromSlicePtr(t *testing.T) {
@@ -152,7 +152,7 @@ func TestFromSlicePtr(t *testing.T) {
str2 := "bar" str2 := "bar"
result1 := FromSlicePtr([]*string{&str1, &str2, nil}) result1 := FromSlicePtr([]*string{&str1, &str2, nil})
is.Equal(result1, []string{str1, str2, ""}) is.Equal([]string{str1, str2, ""}, result1)
} }
func TestFromSlicePtrOr(t *testing.T) { func TestFromSlicePtrOr(t *testing.T) {
@@ -162,7 +162,7 @@ func TestFromSlicePtrOr(t *testing.T) {
str2 := "bar" str2 := "bar"
result1 := FromSlicePtrOr([]*string{&str1, &str2, nil}, "fallback") result1 := FromSlicePtrOr([]*string{&str1, &str2, nil}, "fallback")
is.Equal(result1, []string{str1, str2, "fallback"}) is.Equal([]string{str1, str2, "fallback"}, result1)
} }
func TestToAnySlice(t *testing.T) { func TestToAnySlice(t *testing.T) {
@@ -270,7 +270,7 @@ func TestCoalesce(t *testing.T) {
result9, ok9 := Coalesce(zeroStruct, struct1) result9, ok9 := Coalesce(zeroStruct, struct1)
result10, ok10 := Coalesce(zeroStruct, struct1, struct2) result10, ok10 := Coalesce(zeroStruct, struct1, struct2)
is.Equal(0, result1) is.Zero(result1)
is.False(ok1) is.False(ok1)
is.Equal(3, result2) is.Equal(3, result2)
@@ -288,16 +288,16 @@ func TestCoalesce(t *testing.T) {
is.Equal(str1, result6) is.Equal(str1, result6)
is.True(ok6) is.True(ok6)
is.Equal(result7, 1) is.Equal(1, result7)
is.True(ok7) is.True(ok7)
is.Equal(result8, zeroStruct) is.Zero(result8)
is.False(ok8) is.False(ok8)
is.Equal(result9, struct1) is.Equal(struct1, result9)
is.True(ok9) is.True(ok9)
is.Equal(result10, struct1) is.Equal(struct1, result10)
is.True(ok10) is.True(ok10)
} }
@@ -329,16 +329,16 @@ func TestCoalesceOrEmpty(t *testing.T) {
result9 := CoalesceOrEmpty(zeroStruct, struct1) result9 := CoalesceOrEmpty(zeroStruct, struct1)
result10 := CoalesceOrEmpty(zeroStruct, struct1, struct2) result10 := CoalesceOrEmpty(zeroStruct, struct1, struct2)
is.Equal(0, result1) is.Zero(result1)
is.Equal(3, result2) is.Equal(3, result2)
is.Nil(result3) is.Nil(result3)
is.Equal(str1, result4) is.Equal(str1, result4)
is.Equal(str1, result5) is.Equal(str1, result5)
is.Equal(str1, result6) is.Equal(str1, result6)
is.Equal(result7, 1) is.Equal(1, result7)
is.Equal(result8, zeroStruct) is.Zero(result8)
is.Equal(result9, struct1) is.Equal(struct1, result9)
is.Equal(result10, struct1) is.Equal(struct1, result10)
} }
func TestCoalesceSlice(t *testing.T) { func TestCoalesceSlice(t *testing.T) {