Dragonfly2

1
/*
2
 *     Copyright 2020 The Dragonfly Authors
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *      http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16

17
package set
18

19
import (
20
	"testing"
21

22
	"github.com/stretchr/testify/assert"
23
)
24

25
func TestSetAdd(t *testing.T) {
26
	tests := []struct {
27
		name   string
28
		value  string
29
		expect func(t *testing.T, ok bool, s Set[string], value string)
30
	}{
31
		{
32
			name:  "add value",
33
			value: "foo",
34
			expect: func(t *testing.T, ok bool, s Set[string], value string) {
35
				assert := assert.New(t)
36
				assert.Equal(ok, true)
37
				assert.Equal(s.Values(), []string{value})
38
			},
39
		},
40
		{
41
			name:  "add value failed",
42
			value: "foo",
43
			expect: func(t *testing.T, _ bool, s Set[string], value string) {
44
				assert := assert.New(t)
45
				ok := s.Add("foo")
46
				assert.Equal(ok, false)
47
				assert.Equal(s.Values(), []string{value})
48
			},
49
		},
50
	}
51

52
	for _, tc := range tests {
53
		t.Run(tc.name, func(t *testing.T) {
54
			s := New[string]()
55
			tc.expect(t, s.Add(tc.value), s, tc.value)
56
		})
57
	}
58
}
59

60
func TestSetDelete(t *testing.T) {
61
	tests := []struct {
62
		name   string
63
		value  string
64
		expect func(t *testing.T, s Set[string], value string)
65
	}{
66
		{
67
			name:  "delete value",
68
			value: "foo",
69
			expect: func(t *testing.T, s Set[string], value string) {
70
				assert := assert.New(t)
71
				s.Delete(value)
72
				assert.Equal(s.Len(), uint(0))
73
			},
74
		},
75
		{
76
			name:  "delete value does not exist",
77
			value: "foo",
78
			expect: func(t *testing.T, s Set[string], _ string) {
79
				assert := assert.New(t)
80
				s.Delete("bar")
81
				assert.Equal(s.Len(), uint(1))
82
			},
83
		},
84
	}
85

86
	for _, tc := range tests {
87
		t.Run(tc.name, func(t *testing.T) {
88
			s := New[string]()
89
			s.Add(tc.value)
90
			tc.expect(t, s, tc.value)
91
		})
92
	}
93
}
94

95
func TestSetContains(t *testing.T) {
96
	tests := []struct {
97
		name   string
98
		value  string
99
		expect func(t *testing.T, s Set[string], value string)
100
	}{
101
		{
102
			name:  "contains value",
103
			value: "foo",
104
			expect: func(t *testing.T, s Set[string], value string) {
105
				assert := assert.New(t)
106
				assert.Equal(s.Contains(value), true)
107
			},
108
		},
109
		{
110
			name:  "contains value does not exist",
111
			value: "foo",
112
			expect: func(t *testing.T, s Set[string], _ string) {
113
				assert := assert.New(t)
114
				assert.Equal(s.Contains("bar"), false)
115
			},
116
		},
117
	}
118

119
	for _, tc := range tests {
120
		t.Run(tc.name, func(t *testing.T) {
121
			s := New[string]()
122
			s.Add(tc.value)
123
			tc.expect(t, s, tc.value)
124
		})
125
	}
126
}
127

128
func TestSetLen(t *testing.T) {
129
	tests := []struct {
130
		name   string
131
		expect func(t *testing.T, s Set[string])
132
	}{
133
		{
134
			name: "get length",
135
			expect: func(t *testing.T, s Set[string]) {
136
				assert := assert.New(t)
137
				s.Add("foo")
138
				assert.Equal(s.Len(), uint(1))
139
			},
140
		},
141
		{
142
			name: "get empty set length",
143
			expect: func(t *testing.T, s Set[string]) {
144
				assert := assert.New(t)
145
				assert.Equal(s.Len(), uint(0))
146
			},
147
		},
148
	}
149

150
	for _, tc := range tests {
151
		t.Run(tc.name, func(t *testing.T) {
152
			s := New[string]()
153
			tc.expect(t, s)
154
		})
155
	}
156
}
157

158
func TestSetValues(t *testing.T) {
159
	tests := []struct {
160
		name   string
161
		expect func(t *testing.T, s Set[string])
162
	}{
163
		{
164
			name: "get values",
165
			expect: func(t *testing.T, s Set[string]) {
166
				assert := assert.New(t)
167
				s.Add("foo")
168
				assert.Equal(s.Values(), []string{"foo"})
169
			},
170
		},
171
		{
172
			name: "get empty values",
173
			expect: func(t *testing.T, s Set[string]) {
174
				assert := assert.New(t)
175
				assert.Equal(s.Values(), []string(nil))
176
			},
177
		},
178
		{
179
			name: "get multi values",
180
			expect: func(t *testing.T, s Set[string]) {
181
				assert := assert.New(t)
182
				s.Add("foo")
183
				s.Add("bar")
184
				assert.Contains(s.Values(), "bar")
185
				assert.Contains(s.Values(), "foo")
186
			},
187
		},
188
	}
189

190
	for _, tc := range tests {
191
		t.Run(tc.name, func(t *testing.T) {
192
			s := New[string]()
193
			tc.expect(t, s)
194
		})
195
	}
196
}
197

198
func TestSetClear(t *testing.T) {
199
	tests := []struct {
200
		name   string
201
		expect func(t *testing.T, s Set[string])
202
	}{
203
		{
204
			name: "clear empty set",
205
			expect: func(t *testing.T, s Set[string]) {
206
				assert := assert.New(t)
207
				s.Clear()
208
				assert.Equal(s.Values(), []string(nil))
209
			},
210
		},
211
		{
212
			name: "clear set",
213
			expect: func(t *testing.T, s Set[string]) {
214
				assert := assert.New(t)
215
				assert.Equal(s.Add("foo"), true)
216
				s.Clear()
217
				assert.Equal(s.Values(), []string(nil))
218
				assert.Equal(s.Add("foo"), true)
219
				assert.Equal(s.Values(), []string{"foo"})
220
			},
221
		},
222
	}
223

224
	for _, tc := range tests {
225
		t.Run(tc.name, func(t *testing.T) {
226
			s := New[string]()
227
			tc.expect(t, s)
228
		})
229
	}
230
}
231