Skip to content

Commit 281942d

Browse files
fredbifredbi
authored
test: upgraded tests to use generics (#176)
Signed-off-by: Frederic BIDON <fredbi@yahoo.com>
1 parent b9f9e45 commit 281942d

34 files changed

Lines changed: 409 additions & 409 deletions

‎conv/convert_format_test.go‎

Lines changed: 43 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -35,18 +35,18 @@ func TestConvertBool(t *testing.T) {
3535
for k := range evaluatesAsTrue {
3636
r, err := ConvertBool(k)
3737
require.NoError(t, err)
38-
assert.True(t, r)
38+
assert.TrueT(t, r)
3939
}
4040
for _, k := range []string{"a", "", "0", "false", "unchecked", "anythingElse"} {
4141
r, err := ConvertBool(k)
4242
require.NoError(t, err)
43-
assert.False(t, r)
43+
assert.FalseT(t, r)
4444
}
4545
}
4646

4747
func TestFormatBool(t *testing.T) {
48-
assert.Equal(t, "true", FormatBool(true))
49-
assert.Equal(t, "false", FormatBool(false))
48+
assert.EqualT(t, "true", FormatBool(true))
49+
assert.EqualT(t, "false", FormatBool(false))
5050
}
5151

5252
func TestConvertFloat(t *testing.T) {
@@ -58,11 +58,11 @@ func TestConvertFloat(t *testing.T) {
5858
str := FormatFloat(f)
5959
c1, err := ConvertFloat32(str)
6060
require.NoError(t, err)
61-
assert.InDelta(t, f, c1, 1e-6)
61+
assert.InDeltaT(t, f, c1, 1e-6)
6262

6363
c2, err := ConvertFloat[float32](str)
6464
require.NoError(t, err)
65-
assert.InDelta(t, c1, c2, 1e-6)
65+
assert.InDeltaT(t, c1, c2, 1e-6)
6666
}
6767

6868
for _, f := range invalidFloats {
@@ -82,11 +82,11 @@ func TestConvertFloat(t *testing.T) {
8282
str := FormatFloat(f)
8383
c1, err := ConvertFloat64(str)
8484
require.NoError(t, err)
85-
assert.InDelta(t, f, c1, 1e-6)
85+
assert.InDeltaT(t, f, c1, 1e-6)
8686

8787
c2, err := ConvertFloat64(str)
8888
require.NoError(t, err)
89-
assert.InDelta(t, c1, c2, 1e-6)
89+
assert.InDeltaT(t, c1, c2, 1e-6)
9090
}
9191

9292
for _, f := range invalidFloats {
@@ -108,11 +108,11 @@ func TestConvertInteger(t *testing.T) {
108108
str := FormatInteger(f)
109109
c1, err := ConvertInt8(str)
110110
require.NoError(t, err)
111-
assert.Equal(t, f, c1)
111+
assert.EqualT(t, f, c1)
112112

113113
c2, err := ConvertInteger[int8](str)
114114
require.NoError(t, err)
115-
assert.Equal(t, c1, c2)
115+
assert.EqualT(t, c1, c2)
116116
}
117117

118118
for _, f := range invalidInts {
@@ -132,11 +132,11 @@ func TestConvertInteger(t *testing.T) {
132132
str := FormatInteger(f)
133133
c1, err := ConvertInt16(str)
134134
require.NoError(t, err)
135-
assert.Equal(t, f, c1)
135+
assert.EqualT(t, f, c1)
136136

137137
c2, err := ConvertInteger[int16](str)
138138
require.NoError(t, err)
139-
assert.Equal(t, c1, c2)
139+
assert.EqualT(t, c1, c2)
140140
}
141141

142142
for _, f := range invalidInts {
@@ -156,11 +156,11 @@ func TestConvertInteger(t *testing.T) {
156156
str := FormatInteger(f)
157157
c1, err := ConvertInt32(str)
158158
require.NoError(t, err)
159-
assert.Equal(t, f, c1)
159+
assert.EqualT(t, f, c1)
160160

161161
c2, err := ConvertInteger[int32](str)
162162
require.NoError(t, err)
163-
assert.Equal(t, c1, c2)
163+
assert.EqualT(t, c1, c2)
164164
}
165165

166166
for _, f := range invalidInts {
@@ -180,11 +180,11 @@ func TestConvertInteger(t *testing.T) {
180180
str := FormatInteger(f)
181181
c1, err := ConvertInt64(str)
182182
require.NoError(t, err)
183-
assert.Equal(t, f, c1)
183+
assert.EqualT(t, f, c1)
184184

185185
c2, err := ConvertInt64(str)
186186
require.NoError(t, err)
187-
assert.Equal(t, c1, c2)
187+
assert.EqualT(t, c1, c2)
188188
}
189189

190190
for _, f := range invalidInts {
@@ -206,11 +206,11 @@ func TestConvertUinteger(t *testing.T) {
206206
str := FormatUinteger(f)
207207
c1, err := ConvertUint8(str)
208208
require.NoError(t, err)
209-
assert.Equal(t, f, c1)
209+
assert.EqualT(t, f, c1)
210210

211211
c2, err := ConvertUinteger[uint8](str)
212212
require.NoError(t, err)
213-
assert.Equal(t, c1, c2)
213+
assert.EqualT(t, c1, c2)
214214
}
215215

216216
for _, f := range invalidInts {
@@ -230,11 +230,11 @@ func TestConvertUinteger(t *testing.T) {
230230
str := FormatUinteger(f)
231231
c1, err := ConvertUint16(str)
232232
require.NoError(t, err)
233-
assert.Equal(t, f, c1)
233+
assert.EqualT(t, f, c1)
234234

235235
c2, err := ConvertUinteger[uint16](str)
236236
require.NoError(t, err)
237-
assert.Equal(t, c1, c2)
237+
assert.EqualT(t, c1, c2)
238238
}
239239

240240
for _, f := range invalidUints {
@@ -254,11 +254,11 @@ func TestConvertUinteger(t *testing.T) {
254254
str := FormatUinteger(f)
255255
c1, err := ConvertUint32(str)
256256
require.NoError(t, err)
257-
assert.Equal(t, f, c1)
257+
assert.EqualT(t, f, c1)
258258

259259
c2, err := ConvertUint32(str)
260260
require.NoError(t, err)
261-
assert.Equal(t, c1, c2)
261+
assert.EqualT(t, c1, c2)
262262
}
263263

264264
for _, f := range invalidUints {
@@ -278,11 +278,11 @@ func TestConvertUinteger(t *testing.T) {
278278
str := FormatUinteger(f)
279279
c1, err := ConvertUint64(str)
280280
require.NoError(t, err)
281-
assert.Equal(t, f, c1)
281+
assert.EqualT(t, f, c1)
282282

283283
c2, err := ConvertUinteger[uint64](str)
284284
require.NoError(t, err)
285-
assert.Equal(t, c1, c2)
285+
assert.EqualT(t, c1, c2)
286286
}
287287
for _, f := range invalidUints {
288288
_, err := ConvertUint64(f)
@@ -323,35 +323,35 @@ func testNotIntegers(fn func(float64) bool, skipKnownFailure bool) func(*testing
323323
_ = skipKnownFailure
324324

325325
return func(t *testing.T) {
326-
assert.False(t, fn(math.Inf(1)))
327-
assert.False(t, fn(maxJSONFloat+1))
328-
assert.False(t, fn(minJSONFloat-1))
329-
assert.False(t, fn(math.SmallestNonzeroFloat64))
330-
assert.False(t, fn(0.5))
331-
assert.False(t, fn(0.25))
332-
assert.False(t, fn(1.00/func() float64 { return 2.00 }()))
333-
assert.False(t, fn(1.00/func() float64 { return 4.00 }()))
334-
assert.False(t, fn(epsilon))
326+
assert.FalseT(t, fn(math.Inf(1)))
327+
assert.FalseT(t, fn(maxJSONFloat+1))
328+
assert.FalseT(t, fn(minJSONFloat-1))
329+
assert.FalseT(t, fn(math.SmallestNonzeroFloat64))
330+
assert.FalseT(t, fn(0.5))
331+
assert.FalseT(t, fn(0.25))
332+
assert.FalseT(t, fn(1.00/func() float64 { return 2.00 }()))
333+
assert.FalseT(t, fn(1.00/func() float64 { return 4.00 }()))
334+
assert.FalseT(t, fn(epsilon))
335335
}
336336
}
337337

338338
func testIntegers(fn func(float64) bool, skipKnownFailure bool) func(*testing.T) {
339339
// wrapping in a function forces non-constant evaluation to test float64 rounding behavior
340340
return func(t *testing.T) {
341-
assert.True(t, fn(0.0))
342-
assert.True(t, fn(1.0))
343-
assert.True(t, fn(maxJSONFloat))
344-
assert.True(t, fn(minJSONFloat))
341+
assert.TrueT(t, fn(0.0))
342+
assert.TrueT(t, fn(1.0))
343+
assert.TrueT(t, fn(maxJSONFloat))
344+
assert.TrueT(t, fn(minJSONFloat))
345345
if !skipKnownFailure {
346-
assert.True(t, fn(1/0.01*67.15000001))
346+
assert.TrueT(t, fn(1/0.01*67.15000001))
347347
}
348348
if !skipKnownFailure {
349-
assert.True(t, fn(1.00/func() float64 { return 0.01 }()*4643.4))
349+
assert.TrueT(t, fn(1.00/func() float64 { return 0.01 }()*4643.4))
350350
}
351-
assert.True(t, fn(1.00/func() float64 { return 1.00 / 3.00 }()))
352-
assert.True(t, fn(math.SmallestNonzeroFloat64/2))
353-
assert.True(t, fn(math.SmallestNonzeroFloat64/3))
354-
assert.True(t, fn(math.SmallestNonzeroFloat64/4))
351+
assert.TrueT(t, fn(1.00/func() float64 { return 1.00 / 3.00 }()))
352+
assert.TrueT(t, fn(math.SmallestNonzeroFloat64/2))
353+
assert.TrueT(t, fn(math.SmallestNonzeroFloat64/3))
354+
assert.TrueT(t, fn(math.SmallestNonzeroFloat64/4))
355355
}
356356
}
357357

‎conv/convert_types_test.go‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -131,7 +131,7 @@ func TestPointer(t *testing.T) {
131131
}
132132

133133
func assertSingleValue(t *testing.T, inElem, elem reflect.Value, expectPointer bool, idx int) {
134-
require.Equalf(t,
134+
require.EqualTf(t,
135135
expectPointer, (elem.Kind() == reflect.Ptr),
136136
"unexpected expectPointer=%t value type %T at idx %d", expectPointer, elem, idx,
137137
)
@@ -144,7 +144,7 @@ func assertSingleValue(t *testing.T, inElem, elem reflect.Value, expectPointer b
144144
elem = reflect.Indirect(elem)
145145
}
146146

147-
require.Truef(t,
147+
require.TrueTf(t,
148148
(elem.Kind() == reflect.Ptr && elem.IsNil()) ||
149149
typeutils.IsZero(elem.Interface()) == (inElem.Kind() == reflect.Ptr && inElem.IsNil()) ||
150150
typeutils.IsZero(inElem.Interface()),
@@ -168,10 +168,10 @@ func assertValues(t *testing.T, in, out any, expectPointer bool, idx int) {
168168

169169
switch vin.Kind() { //nolint:exhaustive
170170
case reflect.Slice, reflect.Map:
171-
require.Equalf(t, vin.Kind(), vout.Kind(),
171+
require.EqualTf(t, vin.Kind(), vout.Kind(),
172172
"unexpected output type at idx %d", idx,
173173
)
174-
require.Equalf(t, vin.Len(), vout.Len(),
174+
require.EqualTf(t, vin.Len(), vout.Len(),
175175
"unexpected len at idx %d", idx,
176176
)
177177

‎conv_iface_test.go‎

Lines changed: 33 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -16,109 +16,109 @@ func TestConvIface(t *testing.T) {
1616

1717
t.Run("deprecated Convert functions should work", func(t *testing.T) {
1818
// only check happy path - more comprehensive testing is carried out inside the called package
19-
assert.True(t, IsFloat64AJSONInteger(1.00))
19+
assert.TrueT(t, IsFloat64AJSONInteger(1.00))
2020

2121
b, err := ConvertBool("true")
2222
require.NoError(t, err)
23-
assert.True(t, b)
23+
assert.TrueT(t, b)
2424

2525
f32, err := ConvertFloat32("1.05")
2626
require.NoError(t, err)
27-
assert.InDelta(t, float32(1.05), f32, epsilon)
27+
assert.InDeltaT(t, float32(1.05), f32, epsilon)
2828

2929
f64, err := ConvertFloat64("1.05")
3030
require.NoError(t, err)
3131
assert.InDelta(t, float32(1.05), f64, epsilon)
3232

3333
i8, err := ConvertInt8("2")
3434
require.NoError(t, err)
35-
assert.Equal(t, int8(2), i8)
35+
assert.EqualT(t, int8(2), i8)
3636

3737
i16, err := ConvertInt16("2")
3838
require.NoError(t, err)
39-
assert.Equal(t, int16(2), i16)
39+
assert.EqualT(t, int16(2), i16)
4040

4141
i32, err := ConvertInt32("2")
4242
require.NoError(t, err)
43-
assert.Equal(t, int32(2), i32)
43+
assert.EqualT(t, int32(2), i32)
4444

4545
i64, err := ConvertInt64("2")
4646
require.NoError(t, err)
47-
assert.Equal(t, int64(2), i64)
47+
assert.EqualT(t, int64(2), i64)
4848

4949
u8, err := ConvertUint8("2")
5050
require.NoError(t, err)
51-
assert.Equal(t, uint8(2), u8)
51+
assert.EqualT(t, uint8(2), u8)
5252

5353
u16, err := ConvertUint16("2")
5454
require.NoError(t, err)
55-
assert.Equal(t, uint16(2), u16)
55+
assert.EqualT(t, uint16(2), u16)
5656

5757
u32, err := ConvertUint32("2")
5858
require.NoError(t, err)
59-
assert.Equal(t, uint32(2), u32)
59+
assert.EqualT(t, uint32(2), u32)
6060

6161
u64, err := ConvertUint64("2")
6262
require.NoError(t, err)
63-
assert.Equal(t, uint64(2), u64)
63+
assert.EqualT(t, uint64(2), u64)
6464
})
6565

6666
t.Run("deprecated Format functions should work", func(t *testing.T) {
67-
assert.Equal(t, "true", FormatBool(true))
68-
assert.Equal(t, "1.05", FormatFloat32(1.05))
69-
assert.Equal(t, "1.05", FormatFloat64(1.05))
70-
assert.Equal(t, "1", FormatInt8(1))
71-
assert.Equal(t, "1", FormatInt16(1))
72-
assert.Equal(t, "1", FormatInt32(1))
73-
assert.Equal(t, "1", FormatInt64(1))
74-
assert.Equal(t, "1", FormatUint8(1))
75-
assert.Equal(t, "1", FormatUint16(1))
76-
assert.Equal(t, "1", FormatUint32(1))
77-
assert.Equal(t, "1", FormatUint64(1))
67+
assert.EqualT(t, "true", FormatBool(true))
68+
assert.EqualT(t, "1.05", FormatFloat32(1.05))
69+
assert.EqualT(t, "1.05", FormatFloat64(1.05))
70+
assert.EqualT(t, "1", FormatInt8(1))
71+
assert.EqualT(t, "1", FormatInt16(1))
72+
assert.EqualT(t, "1", FormatInt32(1))
73+
assert.EqualT(t, "1", FormatInt64(1))
74+
assert.EqualT(t, "1", FormatUint8(1))
75+
assert.EqualT(t, "1", FormatUint16(1))
76+
assert.EqualT(t, "1", FormatUint32(1))
77+
assert.EqualT(t, "1", FormatUint64(1))
7878
})
7979

8080
t.Run("deprecated pointer functions should work", func(t *testing.T) {
81-
assert.Equal(t, "a", StringValue(String("a")))
81+
assert.EqualT(t, "a", StringValue(String("a")))
8282
assert.Equal(t, []string{"a"}, StringValueSlice(StringSlice([]string{"a"})))
8383
assert.Equal(t, map[string]string{"1": "a"}, StringValueMap(StringMap(map[string]string{"1": "a"})))
8484

85-
assert.True(t, BoolValue(Bool(true)))
85+
assert.TrueT(t, BoolValue(Bool(true)))
8686
assert.Equal(t, []bool{true}, BoolValueSlice(BoolSlice([]bool{true})))
8787
assert.Equal(t, map[string]bool{"1": true}, BoolValueMap(BoolMap(map[string]bool{"1": true})))
8888

89-
assert.Equal(t, 1, IntValue(Int(1)))
89+
assert.EqualT(t, 1, IntValue(Int(1)))
9090
assert.Equal(t, []int{1}, IntValueSlice(IntSlice([]int{1})))
9191
assert.Equal(t, map[string]int{"1": 1}, IntValueMap(IntMap(map[string]int{"1": 1})))
9292

93-
assert.Equal(t, int32(1), Int32Value(Int32(1)))
93+
assert.EqualT(t, int32(1), Int32Value(Int32(1)))
9494
assert.Equal(t, []int32{1}, Int32ValueSlice(Int32Slice([]int32{1})))
9595
assert.Equal(t, map[string]int32{"1": 1}, Int32ValueMap(Int32Map(map[string]int32{"1": 1})))
9696

97-
assert.Equal(t, int64(1), Int64Value(Int64(1)))
97+
assert.EqualT(t, int64(1), Int64Value(Int64(1)))
9898
assert.Equal(t, []int64{1}, Int64ValueSlice(Int64Slice([]int64{1})))
9999
assert.Equal(t, map[string]int64{"1": 1}, Int64ValueMap(Int64Map(map[string]int64{"1": 1})))
100100

101-
assert.Equal(t, uint16(1), Uint16Value(Uint16(1)))
101+
assert.EqualT(t, uint16(1), Uint16Value(Uint16(1)))
102102
assert.Equal(t, []uint16{1}, Uint16ValueSlice(Uint16Slice([]uint16{1})))
103103
assert.Equal(t, map[string]uint16{"1": 1}, Uint16ValueMap(Uint16Map(map[string]uint16{"1": 1})))
104104

105-
assert.Equal(t, uint32(1), Uint32Value(Uint32(1)))
105+
assert.EqualT(t, uint32(1), Uint32Value(Uint32(1)))
106106
assert.Equal(t, []uint32{1}, Uint32ValueSlice(Uint32Slice([]uint32{1})))
107107
assert.Equal(t, map[string]uint32{"1": 1}, Uint32ValueMap(Uint32Map(map[string]uint32{"1": 1})))
108108

109-
assert.Equal(t, uint64(1), Uint64Value(Uint64(1)))
109+
assert.EqualT(t, uint64(1), Uint64Value(Uint64(1)))
110110
assert.Equal(t, []uint64{1}, Uint64ValueSlice(Uint64Slice([]uint64{1})))
111111
assert.Equal(t, map[string]uint64{"1": 1}, Uint64ValueMap(Uint64Map(map[string]uint64{"1": 1})))
112112

113-
assert.Equal(t, uint(1), UintValue(Uint(1)))
113+
assert.EqualT(t, uint(1), UintValue(Uint(1)))
114114
assert.Equal(t, []uint{1}, UintValueSlice(UintSlice([]uint{1})))
115115
assert.Equal(t, map[string]uint{"1": 1}, UintValueMap(UintMap(map[string]uint{"1": 1})))
116116

117-
assert.InDelta(t, float32(1.00), Float32Value(Float32(1.00)), epsilon)
117+
assert.InDeltaT(t, float32(1.00), Float32Value(Float32(1.00)), epsilon)
118118
assert.Equal(t, []float32{1.00}, Float32ValueSlice(Float32Slice([]float32{1.00})))
119119
assert.Equal(t, map[string]float32{"1": 1.00}, Float32ValueMap(Float32Map(map[string]float32{"1": 1.00})))
120120

121-
assert.InDelta(t, float64(1.00), Float64Value(Float64(1)), epsilon)
121+
assert.InDeltaT(t, float64(1.00), Float64Value(Float64(1)), epsilon)
122122
assert.Equal(t, []float64{1.00}, Float64ValueSlice(Float64Slice([]float64{1.00})))
123123
assert.Equal(t, map[string]float64{"1": 1.00}, Float64ValueMap(Float64Map(map[string]float64{"1": 1.00})))
124124

0 commit comments

Comments
 (0)