utils/first_test.go at master · msumera/utils · 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
package utils

import "testing"

func TestFirst(t *testing.T) {
	type args[T any] struct {
		list []T
	}
	type testCase[T any] struct {
		name string
		args args[T]
		want *T
	}

	// String test cases
	stringTests := []testCase[string]{
		{
			name: "empty string slice",
			args: args[string]{list: []string{}},
			want: nil,
		},
		{
			name: "single string",
			args: args[string]{list: []string{"xd"}},
			want: Ptr("xd"),
		},
		{
			name: "two strings",
			args: args[string]{list: []string{"xd", "dx"}},
			want: Ptr("xd"),
		},
		{
			name: "multiple strings",
			args: args[string]{list: []string{"xd", "dx", "a", "b", "c", "d"}},
			want: Ptr("xd"),
		},
	}

	// Int test cases
	intTests := []testCase[int]{
		{
			name: "empty int slice",
			args: args[int]{list: []int{}},
			want: nil,
		},
		{
			name: "single int",
			args: args[int]{list: []int{42}},
			want: Ptr(42),
		},
		{
			name: "multiple ints",
			args: args[int]{list: []int{1, 2, 3, 4}},
			want: Ptr(1),
		},
	}

	// Float test cases
	floatTests := []testCase[float64]{
		{
			name: "empty float slice",
			args: args[float64]{list: []float64{}},
			want: nil,
		},
		{
			name: "single float",
			args: args[float64]{list: []float64{3.14}},
			want: Ptr(3.14),
		},
		{
			name: "multiple floats",
			args: args[float64]{list: []float64{1.1, 2.2, 3.3}},
			want: Ptr(1.1),
		},
	}

	// Struct test cases
	type MyStruct struct{ X int }
	structTests := []testCase[MyStruct]{
		{
			name: "empty struct slice",
			args: args[MyStruct]{list: []MyStruct{}},
			want: nil,
		},
		{
			name: "single struct",
			args: args[MyStruct]{list: []MyStruct{{X: 10}}},
			want: Ptr(MyStruct{X: 10}),
		},
		{
			name: "multiple structs",
			args: args[MyStruct]{list: []MyStruct{{X: 10}, {X: 20}, {X: 30}}},
			want: Ptr(MyStruct{X: 10}),
		},
	}

	for _, tt := range stringTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := First(tt.args.list); !ValueEqual(got, tt.want) {
				t.Errorf("First() = %v, want %v", got, tt.want)
			}
		})
	}

	for _, tt := range intTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := First(tt.args.list); !ValueEqual(got, tt.want) {
				t.Errorf("First() = %v, want %v", got, tt.want)
			}
		})
	}

	for _, tt := range floatTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := First(tt.args.list); !ValueEqual(got, tt.want) {
				t.Errorf("First() = %v, want %v", got, tt.want)
			}
		})
	}

	for _, tt := range structTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := First(tt.args.list); !ValueEqual(got, tt.want) {
				t.Errorf("First() = %v, want %v", got, tt.want)
			}
		})
	}
}