Function TestMatchCodeGen_ValueEnumCodeGen

pkg/codegen/match_test.go:442–498

TestMatchCodeGen_ValueEnumCodeGen tests code generation for value enum match.

(t *testing.T)

// TestMatchCodeGen_ValueEnumCodeGen tests code generation for value enum match.
func TestMatchCodeGen_ValueEnumCodeGen(t *testing.T) {
	// Create a value enum registry
	registry := ast.NewEnumRegistry()
	registry.RegisterValueEnum("Status", []string{"Pending", "Active", "Closed"}, true)

	match := &ast.MatchExpr{
		Match: 1,
		Scrutinee: &ast.RawExpr{
			Text: "status",
		},
		Arms: []*ast.MatchArm{
			{
				Pattern: &ast.ConstructorPattern{Name: "Pending"},
				Body:    &ast.RawExpr{Text: `"waiting"`},
			},
			{
				Pattern: &ast.ConstructorPattern{Name: "Active"},
				Body:    &ast.RawExpr{Text: `"running"`},
			},
			{
				Pattern: &ast.ConstructorPattern{Name: "Closed"},
				Body:    &ast.RawExpr{Text: `"done"`},
			},
		},
		IsExpr: false,
	}

	gen := &MatchCodeGen{
		BaseGenerator: NewBaseGenerator(),
		Match:         match,
		ValueEnumReg:  registry,
	}

	result := gen.Generate()
	code := string(result.Output)

	// Should use value switch (NOT type switch)
	if strings.Contains(code, ".(type)") {
		t.Errorf("Value enum should use value switch, not type switch. Got: %s", code)
	}

	// Should have prefixed const names
	if !strings.Contains(code, "case StatusPending:") {
		t.Errorf("Expected 'case StatusPending:', got: %s", code)
	}
	if !strings.Contains(code, "case StatusActive:") {
		t.Errorf("Expected 'case StatusActive:', got: %s", code)
	}
	if !strings.Contains(code, "case StatusClosed:") {
		t.Errorf("Expected 'case StatusClosed:', got: %s", code)
	}

	// Should have body expressions
	if !strings.Contains(code, `"waiting"`) {
		t.Errorf("Expected body \"waiting\", got: %s", code)
	}
}