fix(memprovider): use int64 type in IntEvaluation to match API (#464)

The IntEvaluation method was using genericResolve[int] which caused
TYPE_MISMATCH errors when users stored int64 values in Variants.

The FeatureProvider interface defines IntEvaluation with int64:
  IntEvaluation(ctx, flag string, defaultValue int64, ...) IntResolutionDetail

The type assertion in genericResolve should use int64 to match.

Before this fix:
- User stores: Variants{"max": int64(100)}
- genericResolve[int] tries: value.(int)
- Type assertion fails because int64 != int
- Returns default value with TYPE_MISMATCH error

After this fix:
- User stores: Variants{"max": int64(100)}
- genericResolve[int64] tries: value.(int64)
- Type assertion succeeds
- Returns correct value

Updated tests to use explicit int64 types in Variants to match the
expected usage pattern for the IntEvaluation API.
---------

Signed-off-by: Leo Romanovsky <leo.romanovsky@datadoghq.com>
Signed-off-by: Roman Dmytrenko <rdmytrenko@gmail.com>
Co-authored-by: Roman Dmytrenko <rdmytrenko@gmail.com>

Author: leoromanovsky

openfeature/memprovider/in_memory_provider.go

@@ -95,10 +95,10 @@ func (i InMemoryProvider) IntEvaluation(ctx context.Context, flag string, defaul
 	}
 
 	resolveFlag, detail := memoryFlag.Resolve(defaultValue, flatCtx)
-	result := genericResolve[int](resolveFlag, int(defaultValue), &detail)
+	result := genericResolve[int64](resolveFlag, defaultValue, &detail)
 
 	return openfeature.IntResolutionDetail{
-		Value:                    int64(result),
+		Value:                    result,
 		ProviderResolutionDetail: detail,
 	}
 }
@@ -156,14 +156,41 @@ func (i InMemoryProvider) find(flag string) (*InMemoryFlag, *openfeature.Provide
 
 // helpers
 
-// genericResolve is a helper to extract type verified evaluation and fill openfeature.ProviderResolutionDetail
+// genericResolve is a helper to extract type verified evaluation and fill openfeature.ProviderResolutionDetail.
+// It coerces smaller numeric types to their canonical forms (int* -> int64, float32 -> float64)
+// to provide a more forgiving API for test flag configuration.
+//
+// Note: Only signed integer types are supported for conversion. Unsigned integer types
+// (uint, uint8, uint16, uint32, uint64) will result in type mismatch errors.
 func genericResolve[T comparable](value any, defaultValue T, detail *openfeature.ProviderResolutionDetail) T {
-	v, ok := value.(T)
-
-	if ok {
+	// Try direct type assertion first
+	if v, ok := value.(T); ok {
 		return v
 	}
 
+	// Handle type conversions based on target type
+	switch any(defaultValue).(type) {
+	case int64:
+		// Convert various int types to int64
+		switch v := value.(type) {
+		case int8:
+			return any(int64(v)).(T)
+		case int16:
+			return any(int64(v)).(T)
+		case int32:
+			return any(int64(v)).(T)
+		case int:
+			return any(int64(v)).(T)
+		}
+	case float64:
+		// Convert float32 to float64 and int types to float64
+		switch v := value.(type) {
+		case float32:
+			return any(float64(v)).(T)
+		}
+	}
+
+	// If no conversion worked, return error
 	detail.Reason = openfeature.ErrorReason
 	detail.ResolutionError = openfeature.NewTypeMismatchResolutionError("incorrect type association")
 	return defaultValue

openfeature/memprovider/in_memory_provider_test.go

@@ -1,6 +1,7 @@
 package memprovider
 
 import (
+	"math"
 	"testing"
 
 	"github.com/open-feature/go-sdk/openfeature"
@@ -68,6 +69,16 @@ func TestInMemoryProvider_Float(t *testing.T) {
 			},
 			ContextEvaluator: nil,
 		},
+		"float32Flag": {
+			Key:            "float32Flag",
+			State:          Enabled,
+			DefaultVariant: "fOne",
+			Variants: map[string]any{
+				"fOne": float32(3.5),
+				"fTwo": float32(4.5),
+			},
+			ContextEvaluator: nil,
+		},
 	})
 
 	ctx := t.Context()
@@ -79,31 +90,80 @@ func TestInMemoryProvider_Float(t *testing.T) {
 			t.Errorf("incorrect evaluation, expected %f, got %f", 1.1, evaluation.Value)
 		}
 	})
+
+	t.Run("test float32 conversion success", func(t *testing.T) {
+		evaluation := memoryProvider.FloatEvaluation(ctx, "float32Flag", 1.0, nil)
+		expected := 3.5
+		if evaluation.Value != expected {
+			t.Errorf("incorrect evaluation, expected %f, got %f", expected, evaluation.Value)
+		}
+	})
 }
 
 func TestInMemoryProvider_Int(t *testing.T) {
-	memoryProvider := NewInMemoryProvider(map[string]InMemoryFlag{
-		"intFlag": {
-			Key:            "intFlag",
-			State:          Enabled,
-			DefaultVariant: "max",
-			Variants: map[string]any{
-				"min": -9223372036854775808,
-				"max": 9223372036854775807,
-			},
-			ContextEvaluator: nil,
+	// Test that both int and int64 variants work correctly.
+	// The provider coerces int to int64 internally to match the API contract.
+	tests := []struct {
+		name         string
+		variant      any
+		defaultValue int64
+		expected     int64
+	}{
+		{
+			name:         "int64 max value",
+			variant:      int64(math.MaxInt64),
+			defaultValue: 1,
+			expected:     math.MaxInt64,
 		},
-	})
-
-	ctx := t.Context()
-
-	t.Run("test integer success", func(t *testing.T) {
-		evaluation := memoryProvider.IntEvaluation(ctx, "intFlag", 1, nil)
+		{
+			name:         "int64 min value",
+			variant:      int64(math.MinInt64),
+			defaultValue: 1,
+			expected:     math.MinInt64,
+		},
+		{
+			name:         "plain int coerced to int64",
+			variant:      42,
+			defaultValue: 0,
+			expected:     42,
+		},
+		{
+			name:         "int8 coerced to int64",
+			variant:      int8(8),
+			defaultValue: 0,
+			expected:     8,
+		},
+		{
+			name:         "int16 coerced to int64",
+			variant:      int16(16),
+			defaultValue: 0,
+			expected:     16,
+		},
+		{
+			name:         "int32 coerced to int64",
+			variant:      int32(32),
+			defaultValue: 0,
+			expected:     32,
+		},
+	}
 
-		if evaluation.Value != 9223372036854775807 {
-			t.Errorf("incorrect evaluation, expected %d, got %d", 1, evaluation.Value)
-		}
-	})
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			memoryProvider := NewInMemoryProvider(map[string]InMemoryFlag{
+				"intFlag": {
+					State:          Enabled,
+					DefaultVariant: "value",
+					Variants:       map[string]any{"value": tt.variant},
+				},
+			})
+
+			evaluation := memoryProvider.IntEvaluation(t.Context(), "intFlag", tt.defaultValue, nil)
+
+			if evaluation.Value != tt.expected {
+				t.Errorf("expected %d, got %d", tt.expected, evaluation.Value)
+			}
+		})
+	}
 }
 
 func TestInMemoryProvider_Object(t *testing.T) {