1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
package funk
import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
)
func TestJoin_InnerJoin(t *testing.T) {
testCases := []struct {
LeftArr interface{}
RightArr interface{}
Expect interface{}
}{
{[]string{"foo", "bar"}, []string{"bar", "baz"}, []string{"bar"}},
{[]string{"foo", "bar", "bar"}, []string{"bar", "baz"}, []string{"bar"}},
{[]string{"foo", "bar"}, []string{"bar", "bar", "baz"}, []string{"bar"}},
{[]string{"foo", "bar", "bar"}, []string{"bar", "bar", "baz"}, []string{"bar"}},
{[]int{0, 1, 2, 3, 4}, []int{3, 4, 5, 6, 7}, []int{3, 4}},
{[]*Foo{f, b}, []*Foo{b, c}, []*Foo{b}},
}
for idx, tt := range testCases {
t.Run(fmt.Sprintf("test case #%d", idx+1), func(t *testing.T) {
is := assert.New(t)
actual := Join(tt.LeftArr, tt.RightArr, InnerJoin)
is.Equal(tt.Expect, actual)
})
}
}
func TestJoin_OuterJoin(t *testing.T) {
testCases := []struct {
LeftArr interface{}
RightArr interface{}
Expect interface{}
}{
{[]string{"foo", "bar"}, []string{"bar", "baz"}, []string{"foo", "baz"}},
{[]int{0, 1, 2, 3, 4}, []int{3, 4, 5, 6, 7}, []int{0, 1, 2, 5, 6, 7}},
{[]*Foo{f, b}, []*Foo{b, c}, []*Foo{f, c}},
}
for idx, tt := range testCases {
t.Run(fmt.Sprintf("test case #%d", idx+1), func(t *testing.T) {
is := assert.New(t)
actual := Join(tt.LeftArr, tt.RightArr, OuterJoin)
is.Equal(tt.Expect, actual)
})
}
}
func TestJoin_LeftJoin(t *testing.T) {
testCases := []struct {
LeftArr interface{}
RightArr interface{}
Expect interface{}
}{
{[]string{"foo", "bar"}, []string{"bar", "baz"}, []string{"foo"}},
{[]int{0, 1, 2, 3, 4}, []int{3, 4, 5, 6, 7}, []int{0, 1, 2}},
{[]*Foo{f, b}, []*Foo{b, c}, []*Foo{f}},
}
for idx, tt := range testCases {
t.Run(fmt.Sprintf("test case #%d", idx+1), func(t *testing.T) {
is := assert.New(t)
actual := Join(tt.LeftArr, tt.RightArr, LeftJoin)
is.Equal(tt.Expect, actual)
})
}
}
func TestJoin_RightJoin(t *testing.T) {
testCases := []struct {
LeftArr interface{}
RightArr interface{}
Expect interface{}
}{
{[]string{"foo", "bar"}, []string{"bar", "baz"}, []string{"baz"}},
{[]int{0, 1, 2, 3, 4}, []int{3, 4, 5, 6, 7}, []int{5, 6, 7}},
{[]*Foo{f, b}, []*Foo{b, c}, []*Foo{c}},
}
for idx, tt := range testCases {
t.Run(fmt.Sprintf("test case #%d", idx+1), func(t *testing.T) {
is := assert.New(t)
actual := Join(tt.LeftArr, tt.RightArr, RightJoin)
is.Equal(tt.Expect, actual)
})
}
}
// Struct which implements the String() method to test StringerJoin().
type S struct {
Value string
}
func (s S) String() string {
return s.Value
}
func TestJoin_StringerJoin(t *testing.T) {
testCases := []struct {
Arr []interface{ String() string }
Sep string
Expect string
}{
{[]interface{ String() string }{}, ", ", ""},
{[]interface{ String() string }{S{"foo"}}, ", ", "foo"},
{[]interface{ String() string }{S{"foo"}, S{"bar"}, S{"baz"}}, ", ", "foo, bar, baz"},
}
for idx, tt := range testCases {
t.Run(fmt.Sprintf("test case #%d", idx+1), func(t *testing.T) {
is := assert.New(t)
actual := StringerJoin(tt.Arr, tt.Sep)
is.Equal(tt.Expect, actual)
})
}
}
|
