utils/ptr_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
package utils

import (
	"reflect"
	"testing"
)

func TestPtr(t *testing.T) {
	type testCase[T any] struct {
		name string
		arg  T
	}

	tests := []testCase[any]{
		{
			name: "int value",
			arg:  42,
		},
		{
			name: "string value",
			arg:  "hello",
		},
		{
			name: "float value",
			arg:  3.14,
		},
		{
			name: "bool value",
			arg:  true,
		},
		{
			name: "struct value",
			arg:  struct{ X int }{X: 10},
		},
		{
			name: "slice value",
			arg:  []int{1, 2, 3},
		},
		{
			name: "map value",
			arg:  map[string]int{"a": 1},
		},
		{
			name: "pointer value",
			arg:  Ptr(100),
		},
		{
			name: "nil slice",
			arg:  []int(nil),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Using type assertion for generics
			switch v := tt.arg.(type) {
			case int:
				ptr := Ptr(v)
				if ptr == nil {
					t.Errorf("Ptr() returned nil")
				}
				if *ptr != v {
					t.Errorf("Ptr() = %v, want %v", *ptr, v)
				}
			case string:
				ptr := Ptr(v)
				if ptr == nil {
					t.Errorf("Ptr() returned nil")
				}
				if *ptr != v {
					t.Errorf("Ptr() = %v, want %v", *ptr, v)
				}
			case float64:
				ptr := Ptr(v)
				if ptr == nil {
					t.Errorf("Ptr() returned nil")
				}
				if *ptr != v {
					t.Errorf("Ptr() = %v, want %v", *ptr, v)
				}
			case bool:
				ptr := Ptr(v)
				if ptr == nil {
					t.Errorf("Ptr() returned nil")
				}
				if *ptr != v {
					t.Errorf("Ptr() = %v, want %v", *ptr, v)
				}
			case struct{ X int }:
				ptr := Ptr(v)
				if ptr == nil {
					t.Errorf("Ptr() returned nil")
				}
				if *ptr != v {
					t.Errorf("Ptr() = %v, want %v", *ptr, v)
				}
			case []int:
				ptr := Ptr(v)
				if ptr == nil {
					t.Errorf("Ptr() returned nil")
				}
				if !reflect.DeepEqual(*ptr, v) {
					t.Errorf("Ptr() = %v, want %v", *ptr, v)
				}
			case map[string]int:
				ptr := Ptr(v)
				if ptr == nil {
					t.Errorf("Ptr() returned nil")
				}
				if !reflect.DeepEqual(*ptr, v) {
					t.Errorf("Ptr() = %v, want %v", *ptr, v)
				}
			case *int:
				ptr := Ptr(v)
				if ptr == nil {
					t.Errorf("Ptr() returned nil")
				}
				if *ptr != v {
					t.Errorf("Ptr() = %v, want %v", *ptr, v)
				}
			default:
				t.Fatalf("Unsupported type %T", v)
			}
		})
	}
}