gofn/slice_uniq_test.go at master · tiendc/gofn · GitHub

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
package gofn

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func Test_IsUnique(t *testing.T) {
	assert.True(t, IsUnique[int, []int](nil))
	assert.True(t, IsUnique([]int{}))
	assert.True(t, IsUnique([]string{"one"}))
	assert.True(t, IsUnique([]string{"one", "two", "One", "Two"}))
	assert.True(t, IsUnique([]float32{1.1, 2.2, 3.3, 1.11}))

	assert.False(t, IsUnique([]int{1, 2, 3, 1, 2}))
	assert.False(t, IsUnique([]string{"one", "two", "one"}))
	assert.False(t, IsUnique([]float32{1.1, 2.2, 1.100}))

	type st struct {
		I int
		S string
	}
	assert.True(t, IsUnique([]st{{1, "one"}, {2, "two"}, {3, "three"}}))
	assert.True(t, IsUnique([]st{{1, "one"}, {1, "One"}}))
	assert.False(t, IsUnique([]st{{1, "one"}, {2, "two"}, {1, "one"}}))
}

// nolint: forcetypeassert
func Test_IsUniqueBy(t *testing.T) {
	assert.True(t, IsUniqueBy[int, int, []int](nil, nil))
	assert.True(t, IsUniqueBy([]int{}, func(v int) int { return v }))
	assert.True(t, IsUniqueBy([]any{"one"},
		func(v any) string { return v.(string) }))
	assert.True(t, IsUniqueBy([]any{"one", "two", "One", "Two"},
		func(v any) string { return v.(string) }))
	assert.True(t, IsUniqueBy([]any{1.1, 2.2, 3.3, 1.11},
		func(v any) float64 { return v.(float64) }))

	assert.False(t, IsUniqueBy([]any{1, 2, 3, 1, 2},
		func(v any) int { return v.(int) }))
	assert.False(t, IsUniqueBy([]any{"one", "two", "one"},
		func(v any) string { return v.(string) }))
	assert.False(t, IsUniqueBy([]any{1.1, 2.2, 1.100},
		func(v any) float64 { return v.(float64) }))

	type st struct {
		I int
		S string
	}
	assert.True(t, IsUniqueBy([]st{{1, "one"}, {2, "two"}, {3, "three"}}, func(v st) int { return v.I }))
	assert.False(t, IsUniqueBy([]st{{1, "one"}, {1, "One"}}, func(v st) int { return v.I }))
	assert.False(t, IsUniqueBy([]st{{1, "one"}, {2, "two"}, {1, "one"}}, func(v st) int { return v.I }))
}

func Test_FindUniques(t *testing.T) {
	assert.Equal(t, []int{}, FindUniques([]int{}))
	assert.Equal(t, []int{0}, FindUniques([]int{0}))
	assert.Equal(t, []int{0, 1, 2, 3}, FindUniques([]int{0, 1, 2, 3}))
	assert.Equal(t, []int{0, 3}, FindUniques([]int{0, 1, 2, 3, 2, 1, 1}))
	assert.Equal(t, []int{}, FindUniques([]int{0, 1, 2, 3, 2, 1, 0, 0, 3}))
}

//nolint:forcetypeassert
func Test_FindUniquesBy(t *testing.T) {
	assert.Equal(t, []any{}, FindUniquesBy([]any{}, func(any) int { return 0 }))
	assert.Equal(t, []any{0}, FindUniquesBy([]any{0}, func(v any) int { return v.(int) }))
	assert.Equal(t, []any{0, 1, 2}, FindUniquesBy([]any{0, 1, 2}, func(v any) int { return v.(int) }))
	assert.Equal(t, []any{0, 3}, FindUniquesBy([]any{0, 1, 2, 3, 2, 1, 1}, func(v any) int { return v.(int) }))
	assert.Equal(t, []any{}, FindUniquesBy([]any{0, 1, 2, 3, 2, 1, 0, 0, 3}, func(v any) int { return v.(int) }))
}

func Test_FindDuplicates(t *testing.T) {
	assert.Equal(t, []int{}, FindDuplicates([]int{}))
	assert.Equal(t, []int{}, FindDuplicates([]int{0}))
	assert.Equal(t, []int{}, FindDuplicates([]int{0, 1, 2, 3}))
	assert.Equal(t, []int{1, 2}, FindDuplicates([]int{0, 1, 2, 3, 2, 1, 1}))
	assert.Equal(t, []int{0, 1, 2, 3}, FindDuplicates([]int{0, 1, 2, 3, 2, 1, 0, 0, 3}))
}

//nolint:forcetypeassert
func Test_FindDuplicatesBy(t *testing.T) {
	assert.Equal(t, []any{}, FindDuplicatesBy([]any{}, func(any) int { return 0 }))
	assert.Equal(t, []any{}, FindDuplicatesBy([]any{0}, func(v any) int { return v.(int) }))
	assert.Equal(t, []any{}, FindDuplicatesBy([]any{0, 1, 2, 3}, func(v any) int { return v.(int) }))
	assert.Equal(t, []any{1, 2}, FindDuplicatesBy([]any{0, 1, 2, 3, 2, 1, 1}, func(v any) int { return v.(int) }))
	assert.Equal(t, []any{0, 1, 2, 3},
		FindDuplicatesBy([]any{0, 1, 2, 3, 2, 1, 0, 0, 3}, func(v any) int { return v.(int) }))
}

func Test_ToSet(t *testing.T) {
	assert.Equal(t, []int{}, ToSet([]int{}))
	assert.Equal(t, []string{"one"}, ToSet([]string{"one"}))
	assert.Equal(t, []string{"one", "two", "Two"}, ToSet([]string{"one", "two", "one", "Two"}))
	assert.Equal(t, []int{1, 2, 3}, ToSet([]int{1, 2, 3, 1, 2}))
	assert.Equal(t, []float32{float32(1.1), float32(2.2), float32(3.3), float32(1.11)},
		ToSet([]float32{1.1, 1.1, 2.2, 3.3, 1.11}))

	type st struct {
		I int
		S string
	}
	assert.Equal(t, []st{{1, "one"}, {2, "two"}},
		ToSet([]st{{1, "one"}, {2, "two"}, {1, "one"}}))
}

// nolint: forcetypeassert
func Test_ToSetBy(t *testing.T) {
	// Comparable types
	assert.Equal(t, []int{},
		ToSetBy([]int{}, func(t int) int { return t }))
	assert.Equal(t, []string{"one"},
		ToSetBy([]string{"one"}, func(t string) string { return t }))
	assert.Equal(t, []string{"one", "two", "Two"},
		ToSetBy([]string{"one", "two", "one", "Two"}, func(t string) string { return t }))
	assert.Equal(t, []int{1, 2, 3},
		ToSetBy([]int{1, 2, 3, 1, 2}, func(t int) int { return t }))
	assert.Equal(t, []float32{float32(1.1), float32(2.2), float32(3.3), float32(1.11)},
		ToSetBy([]float32{1.1, 1.1, 2.2, 3.3, 1.11}, func(t float32) float32 { return t }))

	// Incomparable types
	assert.Equal(t, []any{},
		ToSetBy([]any{}, func(t any) int { return t.(int) }))
	assert.Equal(t, []any{"one"},
		ToSetBy([]any{"one"}, func(t any) string { return t.(string) }))
	assert.Equal(t, []any{"one", "two", "Two"},
		ToSetBy([]any{"one", "two", "one", "Two"}, func(t any) string { return t.(string) }))
	assert.Equal(t, []any{1, 2, 3},
		ToSetBy([]any{1, 2, 3, 1, 2}, func(t any) int { return t.(int) }))
	assert.Equal(t, []any{1.1, 2.2, 3.3, 1.11},
		ToSetBy([]any{1.1, 1.1, 2.2, 3.3, 1.11}, func(t any) float64 { return t.(float64) }))
}

// nolint: forcetypeassert
func Test_ToSetByReverse(t *testing.T) {
	// Comparable types
	assert.Equal(t, []int{},
		ToSetByReverse([]int{}, func(t int) int { return t }))
	assert.Equal(t, []string{"one"},
		ToSetByReverse([]string{"one"}, func(t string) string { return t }))
	assert.Equal(t, []string{"Two", "one", "two"},
		ToSetByReverse([]string{"one", "two", "one", "Two"}, func(t string) string { return t }))
	assert.Equal(t, []int{2, 1, 3},
		ToSetByReverse([]int{1, 2, 3, 1, 2}, func(t int) int { return t }))
	assert.Equal(t, []float32{float32(1.1), float32(2.2), float32(3.3), float32(1.11)},
		ToSetByReverse([]float32{1.11, 3.3, 2.2, 1.1}, func(t float32) float32 { return t }))

	// Incomparable types
	assert.Equal(t, []any{},
		ToSetByReverse([]any{}, func(t any) int { return t.(int) }))
	assert.Equal(t, []any{"one"},
		ToSetByReverse([]any{"one"}, func(t any) string { return t.(string) }))
	assert.Equal(t, []any{"Two", "one", "two"},
		ToSetByReverse([]any{"one", "two", "one", "Two"}, func(t any) string { return t.(string) }))
	assert.Equal(t, []any{2, 1, 3},
		ToSetByReverse([]any{1, 2, 3, 1, 2}, func(t any) int { return t.(int) }))
	assert.Equal(t, []any{1.11, 3.3, 2.2, 1.1},
		ToSetByReverse([]any{1.1, 1.1, 2.2, 3.3, 1.11}, func(t any) float64 { return t.(float64) }))
}