fix: handle Inf and NaN in conversions

Author: ccoVeille

conversion.go

@@ -97,6 +97,19 @@ func RequireConvert[NumOut Number, NumIn Input](t TestingT, orig NumIn) (convert
 
 func convertFromNumber[NumOut Number, NumIn Number](orig NumIn) (NumOut, error) {
 	converted := NumOut(orig)
+	if isFloat64[NumIn]() {
+		floatOrig := float64(orig)
+		if math.IsInf(floatOrig, 1) || math.IsInf(floatOrig, -1) {
+			return 0, getRangeError[NumOut](orig)
+		}
+		if math.IsNaN(floatOrig) {
+			return 0, errorHelper[NumOut]{
+				value: orig,
+				err:   ErrUnsupportedConversion,
+			}
+		}
+	}
+
 	if isFloat64[NumOut]() {
 		// float64 cannot overflow, so we don't have to worry about it
 		return converted, nil

conversion_test.go

@@ -1736,6 +1736,36 @@ func TestConvert(t *testing.T) {
 	})
 
 	for name, c := range map[string]TestRunner{
+		"math.Inf to float64": MapTest[float64, float64]{
+			Input:         math.Inf(1),
+			ExpectedError: safecast.ErrExceedMaximumValue,
+			ErrorContains: "+Inf (float64) is greater than 1.7976931348623157e+308",
+		},
+		"-math.Inf to float64": MapTest[float64, float64]{
+			Input:         math.Inf(-1),
+			ExpectedError: safecast.ErrExceedMinimumValue,
+			ErrorContains: "-Inf (float64) is less than -1.7976931348623157e+308",
+		},
+		"math.NaN to float64": MapTest[float64, float64]{
+			Input:         math.NaN(),
+			ExpectedError: safecast.ErrUnsupportedConversion,
+			ErrorContains: "NaN (float64) is not supported",
+		},
+		"math.Inf to float32": MapTest[float64, float32]{
+			Input:         math.Inf(1),
+			ExpectedError: safecast.ErrExceedMaximumValue,
+			ErrorContains: "+Inf (float64) is greater than 3.4028235e+38",
+		},
+		"-math.Inf to float32": MapTest[float64, float32]{
+			Input:         math.Inf(-1),
+			ExpectedError: safecast.ErrExceedMinimumValue,
+			ErrorContains: "-Inf (float64) is less than -3.4028235e+38",
+		},
+		"math.NaN to float32": MapTest[float64, float32]{
+			Input:         math.NaN(),
+			ExpectedError: safecast.ErrUnsupportedConversion,
+			ErrorContains: "NaN (float64) is not supported",
+		},
 		"upper bound overflows for int": MapTest[uint, int]{
 			Input:         uint(math.MaxInt + 1),
 			ExpectedError: safecast.ErrExceedMaximumValue,

errors.go

@@ -41,6 +41,8 @@ func (e errorHelper[NumOut]) Error() string {
 	case errors.Is(e.err, ErrExceedMinimumValue):
 		boundary := minOf[NumOut]()
 		errMessage = fmt.Sprintf("%s: %v (%T) is less than %v (%T)", errMessage, e.value, e.value, boundary, boundary)
+	case errors.Is(e.err, ErrUnsupportedConversion):
+		errMessage = fmt.Sprintf("%s: %v (%T) is not supported", errMessage, e.value, e.value)
 	case errors.Is(e.err, ErrStringConversion):
 		targetType := NumOut(0)
 		return fmt.Sprintf("%s: cannot convert from string %s to %T (base auto-detection)", errMessage, e.value, targetType)