feat: allow disabling of iota (#273)

Author: abice

example/buggy.go

@@ -0,0 +1,12 @@
+//go:build example
+// +build example
+
+//go:generate ../bin/go-enum  -b example --no-iota
+package example
+
+// ENUM(
+// A = 0
+// B = 2
+// C = 1
+// )
+type Buggy uint

example/buggy_enum.go

@@ -0,0 +1,234 @@
+//go:build example
+// +build example
+
+package example
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBuggyConstants(t *testing.T) {
+	// Test that constants have correct values
+	assert.Equal(t, Buggy(0), BuggyA, "BuggyA should have value 0")
+	assert.Equal(t, Buggy(2), BuggyB, "BuggyB should have value 2")
+	assert.Equal(t, Buggy(1), BuggyC, "BuggyC should have value 1")
+}
+
+func TestBuggyString(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    Buggy
+		expected string
+	}{
+		{
+			name:     "BuggyA",
+			value:    BuggyA,
+			expected: "A",
+		},
+		{
+			name:     "BuggyB",
+			value:    BuggyB,
+			expected: "B",
+		},
+		{
+			name:     "BuggyC",
+			value:    BuggyC,
+			expected: "C",
+		},
+		{
+			name:     "Invalid value",
+			value:    Buggy(99),
+			expected: "Buggy(99)",
+		},
+		{
+			name:     "Invalid value 3",
+			value:    Buggy(3),
+			expected: "Buggy(3)",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, tt.value.String())
+		})
+	}
+}
+
+func TestBuggyIsValid(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    Buggy
+		expected bool
+	}{
+		{
+			name:     "BuggyA is valid",
+			value:    BuggyA,
+			expected: true,
+		},
+		{
+			name:     "BuggyB is valid",
+			value:    BuggyB,
+			expected: true,
+		},
+		{
+			name:     "BuggyC is valid",
+			value:    BuggyC,
+			expected: true,
+		},
+		{
+			name:     "Invalid value 99",
+			value:    Buggy(99),
+			expected: false,
+		},
+		{
+			name:     "Invalid value 3",
+			value:    Buggy(3),
+			expected: false,
+		},
+		{
+			name:     "Invalid value 3",
+			value:    Buggy(3),
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, tt.value.IsValid())
+		})
+	}
+}
+
+func TestParseBuggy(t *testing.T) {
+	tests := []struct {
+		name          string
+		input         string
+		expected      Buggy
+		errorExpected bool
+	}{
+		{
+			name:          "Parse A",
+			input:         "A",
+			expected:      BuggyA,
+			errorExpected: false,
+		},
+		{
+			name:          "Parse B",
+			input:         "B",
+			expected:      BuggyB,
+			errorExpected: false,
+		},
+		{
+			name:          "Parse C",
+			input:         "C",
+			expected:      BuggyC,
+			errorExpected: false,
+		},
+		{
+			name:          "Parse invalid string",
+			input:         "D",
+			expected:      Buggy(0),
+			errorExpected: true,
+		},
+		{
+			name:          "Parse empty string",
+			input:         "",
+			expected:      Buggy(0),
+			errorExpected: true,
+		},
+		{
+			name:          "Parse lowercase a",
+			input:         "a",
+			expected:      Buggy(0),
+			errorExpected: true,
+		},
+		{
+			name:          "Parse numeric string",
+			input:         "1",
+			expected:      Buggy(0),
+			errorExpected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := ParseBuggy(tt.input)
+
+			if tt.errorExpected {
+				require.Error(t, err, "Expected error for input: %s", tt.input)
+				assert.Contains(t, err.Error(), "not a valid Buggy", "Error should contain 'not a valid Buggy'")
+				assert.Equal(t, tt.expected, result, "Result should be zero value on error")
+			} else {
+				require.NoError(t, err, "Unexpected error for input: %s", tt.input)
+				assert.Equal(t, tt.expected, result, "Parsed value should match expected")
+			}
+		})
+	}
+}
+
+func TestBuggyErrorType(t *testing.T) {
+	// Test that ErrInvalidBuggy is properly defined
+	assert.NotNil(t, ErrInvalidBuggy)
+	assert.Equal(t, "not a valid Buggy", ErrInvalidBuggy.Error())
+
+	// Test that ParseBuggy returns an error that wraps ErrInvalidBuggy
+	_, err := ParseBuggy("invalid")
+	require.Error(t, err)
+	assert.ErrorIs(t, err, ErrInvalidBuggy)
+}
+
+func TestBuggyEdgeCases(t *testing.T) {
+	t.Run("Zero value behavior", func(t *testing.T) {
+		var b Buggy
+		// Zero value should be 0, which is BuggyA
+		assert.Equal(t, Buggy(0), b)
+		assert.Equal(t, BuggyA, b)
+		assert.True(t, b.IsValid())
+		assert.Equal(t, "A", b.String())
+	})
+
+	t.Run("Non-sequential values", func(t *testing.T) {
+		// Test that the enum handles non-sequential values correctly
+		// A=0, B=2, C=1 - so value 1 should map to C, not B
+		assert.Equal(t, "C", Buggy(1).String())
+		assert.Equal(t, "B", Buggy(2).String())
+		assert.True(t, Buggy(1).IsValid())
+		assert.True(t, Buggy(2).IsValid())
+	})
+}
+
+func BenchmarkBuggyString(b *testing.B) {
+	values := []Buggy{BuggyA, BuggyB, BuggyC, Buggy(99)}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, v := range values {
+			_ = v.String()
+		}
+	}
+}
+
+func BenchmarkParseBuggy(b *testing.B) {
+	inputs := []string{"A", "B", "C", "invalid"}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, input := range inputs {
+			_, _ = ParseBuggy(input)
+		}
+	}
+}
+
+func BenchmarkBuggyIsValid(b *testing.B) {
+	values := []Buggy{BuggyA, BuggyB, BuggyC, Buggy(99)}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, v := range values {
+			_ = v.IsValid()
+		}
+	}
+}