ci: also launch tests on i386

Fixes #6
Fixes #46

.github/workflows/golang.yml

@@ -33,3 +33,8 @@ jobs:
 
       - name: Launch golangci-lint
         uses: golangci/[email protected]
+
+      - name: Run tests on i386
+        run: go test
+        with:
+          goarch: '386'

conversion_non386_test.go

@@ -0,0 +1,48 @@
+//go:build !386
+
+package safecast_test
+
+import (
+	"math"
+	"testing"
+)
+
+func TestToInt32Extra(t *testing.T) {
+	t.Run("from int", func(t *testing.T) {
+		assertInt32Error(t, []caseInt32[int]{
+			{name: "positive out of range", input: math.MaxInt32 + 1},
+			{name: "negative out of range", input: math.MinInt32 - 1},
+		})
+	})
+}
+
+func TestToUint32Extra(t *testing.T) {
+	t.Run("from int", func(t *testing.T) {
+		assertUint32Error(t, []caseUint32[int]{
+			{name: "positive out of range", input: math.MaxUint32 + 1},
+			{name: "negative value", input: -1},
+		})
+	})
+}
+
+func TestToInt64Extra(t *testing.T) {
+	t.Run("from uint", func(t *testing.T) {
+		assertInt64Error(t, []caseInt64[uint]{
+			{name: "positive out of range", input: math.MaxInt64 + 1},
+		})
+	})
+}
+
+func TestToIntExtra(t *testing.T) {
+	t.Run("from uint", func(t *testing.T) {
+		assertIntError(t, []caseInt[uint]{
+			{name: "positive out of range", input: math.MaxInt64 + 1},
+		})
+	})
+
+	t.Run("from float64", func(t *testing.T) {
+		assertIntOK(t, []caseInt[float64]{
+			{name: "math.MinInt64", input: math.MinInt64, want: math.MinInt64}, // pass because of float imprecision
+		})
+	})
+}

conversion_test.go

@@ -761,10 +761,8 @@ func TestToInt32(t *testing.T) {
 			{name: "negative within range", input: -10000, want: -10000},
 		})
 
-		assertInt32Error(t, []caseInt32[int]{
-			{name: "positive out of range", input: math.MaxInt32 + 1},
-			{name: "negative out of range", input: math.MinInt32 - 1},
-		})
+		// There are extra checks in [TestToInt32Extra]
+		// the tests are separated because they cannot work on i386
 	})
 
 	t.Run("from int8", func(t *testing.T) {
@@ -916,7 +914,8 @@ func TestToUint32(t *testing.T) {
 		})
 
 		assertUint32Error(t, []caseUint32[int]{
-			{name: "positive out of range", input: math.MaxUint32 + 1},
+			// There are extra checks in [TestToUint32Extra]
+			// the tests are separated because they cannot work on i386
 			{name: "negative value", input: -1},
 		})
 	})
@@ -972,9 +971,8 @@ func TestToUint32(t *testing.T) {
 			{name: "positive within range", input: 100, want: 100},
 		})
 
-		assertUint32Error(t, []caseUint32[uint]{
-			{name: "positive out of range", input: math.MaxUint32 + 1},
-		})
+		// There are extra checks in [TestToUint32Extra]
+		// the tests are separated because they cannot work on i386
 	})
 
 	t.Run("from uint8", func(t *testing.T) {
@@ -1112,9 +1110,8 @@ func TestToInt64(t *testing.T) {
 			{name: "positive within range", input: 100, want: 100},
 		})
 
-		assertInt64Error(t, []caseInt64[uint]{
-			{name: "positive out of range", input: math.MaxInt64 + 1},
-		})
+		// There are extra checks in [TestToInt64Extra]
+		// the tests are separated because they cannot work on i386
 	})
 
 	t.Run("from uint8", func(t *testing.T) {
@@ -1419,9 +1416,8 @@ func TestToInt(t *testing.T) {
 			{name: "positive within range", input: 100, want: 100},
 		})
 
-		assertIntError(t, []caseInt[uint]{
-			{name: "positive out of range", input: math.MaxInt64 + 1},
-		})
+		// There are extra checks in [TestToIntExtra]
+		// the tests are separated because they cannot work on i386
 	})
 
 	t.Run("from uint8", func(t *testing.T) {
@@ -1477,7 +1473,8 @@ func TestToInt(t *testing.T) {
 			{name: "zero", input: 0.0, want: 0},
 			{name: "rounded value", input: 1.1, want: 1},
 			{name: "positive within range", input: 10000.9, want: 10000},
-			{name: "math.MinInt64", input: math.MinInt64, want: math.MinInt64}, // pass because of float imprecision
+			// There are extra checks in [TestToIntExtra]
+			// the tests are separated because they cannot work on i386
 		})
 
 		assertIntError(t, []caseInt[float64]{

examples_386_test.go

@@ -0,0 +1,28 @@
+//go:build 386
+
+package safecast_test
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/ccoveille/go-safecast"
+)
+
+func ExampleToInt() {
+	a := uint64(42)
+	i, err := safecast.ToInt(a)
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(i)
+
+	b := float32(math.MaxFloat32)
+	_, err = safecast.ToInt(b)
+	if err != nil {
+		fmt.Println(err)
+	}
+	// Output:
+	// 42
+	// conversion issue: 3.4028235e+38 (float32) is greater than 2147483647 (int): maximum value for this type exceeded
+}

examples_non386_test.go

@@ -0,0 +1,28 @@
+//go:build !386
+
+package safecast_test
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/ccoveille/go-safecast"
+)
+
+func ExampleToInt() {
+	a := uint64(42)
+	i, err := safecast.ToInt(a)
+	if err != nil {
+		fmt.Println(err)
+	}
+	fmt.Println(i)
+
+	b := float32(math.MaxFloat32)
+	_, err = safecast.ToInt(b)
+	if err != nil {
+		fmt.Println(err)
+	}
+	// Output:
+	// 42
+	// conversion issue: 3.4028235e+38 (float32) is greater than 9223372036854775807 (int): maximum value for this type exceeded
+}

examples_test.go

@@ -87,14 +87,14 @@ func ExampleToInt32() {
 	}
 	fmt.Println(i)
 
-	a = int(math.MaxUint32 + 1)
-	_, err = safecast.ToInt32(a)
+	b := uint32(math.MaxInt32) + 1
+	_, err = safecast.ToInt32(b)
 	if err != nil {
 		fmt.Println(err)
 	}
 	// Output:
 	// 42
-	// conversion issue: 4294967296 (int) is greater than 2147483647 (int32): maximum value for this type exceeded
+	// conversion issue: 2147483648 (uint32) is greater than 2147483647 (int32): maximum value for this type exceeded
 }
 
 func ExampleToUint32() {
@@ -151,24 +151,6 @@ func ExampleToUint64() {
 	// conversion issue: -1 (int8) is less than 0 (uint64): minimum value for this type exceeded
 }
 
-func ExampleToInt() {
-	a := uint64(42)
-	i, err := safecast.ToInt(a)
-	if err != nil {
-		fmt.Println(err)
-	}
-	fmt.Println(i)
-
-	a = uint64(math.MaxInt64) + 1
-	_, err = safecast.ToInt(a)
-	if err != nil {
-		fmt.Println(err)
-	}
-	// Output:
-	// 42
-	// conversion issue: 9223372036854775808 (uint64) is greater than 9223372036854775807 (int): maximum value for this type exceeded
-}
-
 func ExampleToUint() {
 	a := int8(42)
 	i, err := safecast.ToUint(a)