Add safe integer conversion functions

safeconvert/int.go

@@ -0,0 +1,38 @@
+package safeconvert
+
+import (
+	"errors"
+	"math"
+)
+
+// IntToUint converts int to uint safely, checking for negative values.
+func IntToUint(i int) (uint, error) {
+	if i < 0 {
+		return 0, errors.New("cannot convert negative int to uint")
+	}
+	return uint(i), nil
+}
+
+// UintToInt converts uint to int safely, checking for overflow.
+func UintToInt(u uint) (int, error) {
+	if u > math.MaxInt {
+		return 0, errors.New("integer overflow: uint value exceeds max int value")
+	}
+	return int(u), nil
+}
+
+// Int64ToUint64 converts int64 to uint64 safely, checking for negative values.
+func Int64ToUint64(i int64) (uint64, error) {
+	if i < 0 {
+		return 0, errors.New("cannot convert negative int64 to uint64")
+	}
+	return uint64(i), nil
+}
+
+// Uint64ToInt64 converts uint64 to int64 safely, checking for overflow.
+func Uint64ToInt64(u uint64) (int64, error) {
+	if u > math.MaxInt64 {
+		return 0, errors.New("integer overflow: uint64 value exceeds max int64 value")
+	}
+	return int64(u), nil
+}

safeconvert/int_test.go

@@ -0,0 +1,95 @@
+package safeconvert
+
+import (
+	"github.com/stretchr/testify/assert"
+	"math"
+	"testing"
+)
+
+func TestSafeIntToUint(t *testing.T) {
+	tests := []struct {
+		input       int
+		expected    uint
+		errExpected bool
+	}{
+		{10, 10, false},
+		{-1, 0, true},
+		{0, 0, false},
+	}
+
+	for _, test := range tests {
+		result, err := IntToUint(test.input)
+		if test.errExpected {
+			assert.Error(t, err, "Expected an error for input: %d", test.input)
+		} else {
+			assert.NoError(t, err, "Did not expect an error for input: %d", test.input)
+			assert.Equal(t, test.expected, result, "Expected result does not match")
+		}
+	}
+}
+
+func TestSafeUintToInt(t *testing.T) {
+	tests := []struct {
+		input       uint
+		expected    int
+		errExpected bool
+	}{
+		{10, 10, false},
+		{uint(math.MaxInt), math.MaxInt, false},
+		{uint(math.MaxInt) + 1, 0, true},
+	}
+
+	for _, test := range tests {
+		result, err := UintToInt(test.input)
+		if test.errExpected {
+			assert.Error(t, err, "Expected an error for input: %d", test.input)
+		} else {
+			assert.NoError(t, err, "Did not expect an error for input: %d", test.input)
+			assert.Equal(t, test.expected, result, "Expected result does not match")
+		}
+	}
+}
+
+func TestSafeInt64ToUint64(t *testing.T) {
+	tests := []struct {
+		input       int64
+		expected    uint64
+		errExpected bool
+	}{
+		{10, 10, false},
+		{-1, 0, true},
+		{0, 0, false},
+	}
+
+	for _, test := range tests {
+		result, err := Int64ToUint64(test.input)
+		if test.errExpected {
+			assert.Error(t, err, "Expected an error for input: %d", test.input)
+		} else {
+			assert.NoError(t, err, "Did not expect an error for input: %d", test.input)
+			assert.Equal(t, test.expected, result, "Expected result does not match")
+		}
+	}
+}
+
+func TestSafeUint64ToInt64(t *testing.T) {
+	tests := []struct {
+		input       uint64
+		expected    int64
+		errExpected bool
+	}{
+		{10, 10, false},
+		{math.MaxInt64, math.MaxInt64, false},
+		{math.MaxInt64 + 1, 0, true},
+	}
+
+	for _, test := range tests {
+		result, err := Uint64ToInt64(test.input)
+		if test.errExpected {
+			assert.Error(t, err, "Expected an error for input: %d", test.input)
+		} else {
+			assert.NoError(t, err, "Did not expect an error for input: %d", test.input)
+			assert.Equal(t, test.expected, result, "Expected result does not match")
+		}
+	}
+}