tests: add more tests

Author: ldez

args_test.go

@@ -8,6 +8,33 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func TestArgsFloatTypes(t *testing.T) {
+	cmd := buildMinimalTestCommand()
+	var fval float64
+	cmd.Arguments = []Argument{
+		&FloatArg{
+			Name:        "ia",
+			Destination: &fval,
+		},
+	}
+
+	err := cmd.Run(buildTestContext(t), []string{"foo", "10"})
+	r := require.New(t)
+	r.NoError(err)
+	r.Equal(float64(10), fval)
+	r.Equal(float64(10), cmd.FloatArg("ia"))
+	r.Equal(float64(10), cmd.Float64Arg("ia"))
+	r.Equal(float32(0), cmd.Float32Arg("ia"))
+	r.Equal(float64(0), cmd.FloatArg("iab"))
+	r.Equal(int8(0), cmd.Int8Arg("ia"))
+	r.Equal(int16(0), cmd.Int16Arg("ia"))
+	r.Equal(int32(0), cmd.Int32Arg("ia"))
+	r.Equal(int64(0), cmd.Int64Arg("ia"))
+	r.Empty(cmd.StringArg("ia"))
+
+	r.Error(cmd.Run(buildTestContext(t), []string{"foo", "a"}))
+}
+
 func TestArgsIntTypes(t *testing.T) {
 	cmd := buildMinimalTestCommand()
 	var ival int
@@ -34,6 +61,29 @@ func TestArgsIntTypes(t *testing.T) {
 	r.Error(cmd.Run(buildTestContext(t), []string{"foo", "10.0"}))
 }
 
+func TestArgsFloatSliceTypes(t *testing.T) {
+	cmd := buildMinimalTestCommand()
+	var fval []float64
+	cmd.Arguments = []Argument{
+		&FloatArgs{
+			Name:        "ia",
+			Min:         1,
+			Max:         -1,
+			Destination: &fval,
+		},
+	}
+
+	err := cmd.Run(buildTestContext(t), []string{"foo", "10", "20", "30"})
+	r := require.New(t)
+	r.NoError(err)
+	r.Equal([]float64{10, 20, 30}, fval)
+	r.Equal([]float64{10, 20, 30}, cmd.FloatArgs("ia"))
+	r.Equal([]float64{10, 20, 30}, cmd.Float64Args("ia"))
+	r.Nil(cmd.Float32Args("ia"))
+
+	r.Error(cmd.Run(buildTestContext(t), []string{"foo", "10", "a"}))
+}
+
 func TestArgsIntSliceTypes(t *testing.T) {
 	cmd := buildMinimalTestCommand()
 	var ival []int

flag_float_test.go

@@ -167,3 +167,10 @@ func Test_Float64Flag(t *testing.T) {
 		})
 	}
 }
+
+func Test_floatValue_String(t *testing.T) {
+	var f float64 = 100
+	fv := floatValue[float64]{val: &f}
+
+	assert.Equal(t, "100", fv.String())
+}

flag_test.go

@@ -2607,7 +2607,7 @@ func TestTimestampFlagApply_MultipleFormats(t *testing.T) {
 }
 
 func TestTimestampFlagApply_ShortenedLayouts(t *testing.T) {
-	now := time.Now().In(time.UTC)
+	now := time.Now().UTC()
 
 	shortenedLayoutsPrecisions := map[string]time.Duration{
 		time.Kitchen:    time.Minute,
@@ -2726,11 +2726,23 @@ func TestFlagDefaultValue(t *testing.T) {
 			expect:  `--flag string [ --flag string ]	(default: "default1", "default2")`,
 		},
 		{
-			name:    "float64Slice",
+			name:    "floatSlice",
 			flag:    &FloatSliceFlag{Name: "flag", Value: []float64{1.1, 2.2}},
 			toParse: []string{"--flag", "13.3"},
 			expect:  `--flag float [ --flag float ]	(default: 1.1, 2.2)`,
 		},
+		{
+			name:    "float32Slice",
+			flag:    &Float32SliceFlag{Name: "flag", Value: []float32{1.1, 2.2}},
+			toParse: []string{"--flag", "13.3"},
+			expect:  `--flag float [ --flag float ]	(default: 1.1, 2.2)`,
+		},
+		{
+			name:    "float64Slice",
+			flag:    &Float64SliceFlag{Name: "flag", Value: []float64{1.1, 2.2}},
+			toParse: []string{"--flag", "13.3"},
+			expect:  `--flag float [ --flag float ]	(default: 1.1, 2.2)`,
+		},
 		{
 			name:    "intSlice",
 			flag:    &Int64SliceFlag{Name: "flag", Value: []int64{1, 2}},
@@ -3243,11 +3255,15 @@ func TestExtFlag(t *testing.T) {
 
 func TestSliceValuesNil(t *testing.T) {
 	assert.Equal(t, []float64(nil), NewFloatSlice().Value())
+	assert.Equal(t, []float32(nil), NewFloat32Slice().Value())
+	assert.Equal(t, []float64(nil), NewFloat64Slice().Value())
 	assert.Equal(t, []int64(nil), NewInt64Slice().Value())
 	assert.Equal(t, []uint64(nil), NewUint64Slice().Value())
 	assert.Equal(t, []string(nil), NewStringSlice().Value())
 
 	assert.Equal(t, []float64(nil), (&FloatSlice{}).Value())
+	assert.Equal(t, []float32(nil), (&Float32Slice{}).Value())
+	assert.Equal(t, []float64(nil), (&Float64Slice{}).Value())
 	assert.Equal(t, []int64(nil), (&Int64Slice{}).Value())
 	assert.Equal(t, []uint64(nil), (&Uint64Slice{}).Value())
 	assert.Equal(t, []string(nil), (&StringSlice{}).Value())