| // Copyright 2025 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // This program generates tests to verify that conditional comparisons |
| // with constants are properly optimized by the compiler through constant folding. |
| // The generated test should be compiled with a known working version of Go. |
| // Run with `go run conditionalCmpConstGen.go` to generate a file called |
| // conditionalCmpConst_test.go in the grandparent directory. |
| |
| package main |
| |
| import ( |
| "bytes" |
| "fmt" |
| "go/format" |
| "log" |
| "os" |
| "strings" |
| ) |
| |
| // IntegerConstraint defines a type constraint for all integer types |
| func writeIntegerConstraint(w *bytes.Buffer) { |
| fmt.Fprintf(w, "type IntegerConstraint interface {\n") |
| fmt.Fprintf(w, "\tint | uint | int8 | uint8 | int16 | ") |
| fmt.Fprintf(w, "uint16 | int32 | uint32 | int64 | uint64\n") |
| fmt.Fprintf(w, "}\n\n") |
| } |
| |
| // TestCase describes a parameterized test case with comparison and logical operations |
| func writeTestCaseStruct(w *bytes.Buffer) { |
| fmt.Fprintf(w, "type TestCase[T IntegerConstraint] struct {\n") |
| fmt.Fprintf(w, "\tcmp1, cmp2 func(a, b T) bool\n") |
| fmt.Fprintf(w, "\tcombine func(x, y bool) bool\n") |
| fmt.Fprintf(w, "\ttargetFunc func(a, b, c, d T) bool\n") |
| fmt.Fprintf(w, "\tcmp1Expr, cmp2Expr, logicalExpr string // String representations for debugging\n") |
| fmt.Fprintf(w, "}\n\n") |
| } |
| |
| // BoundaryValues contains base value and its variations for edge case testing |
| func writeBoundaryValuesStruct(w *bytes.Buffer) { |
| fmt.Fprintf(w, "type BoundaryValues[T IntegerConstraint] struct {\n") |
| fmt.Fprintf(w, "\tbase T\n") |
| fmt.Fprintf(w, "\tvariants [3]T\n") |
| fmt.Fprintf(w, "}\n\n") |
| } |
| |
| // writeTypeDefinitions generates all necessary type declarations |
| func writeTypeDefinitions(w *bytes.Buffer) { |
| writeIntegerConstraint(w) |
| writeTestCaseStruct(w) |
| writeBoundaryValuesStruct(w) |
| } |
| |
| // comparisonOperators contains format strings for comparison operators |
| var comparisonOperators = []string{ |
| "%s == %s", "%s <= %s", "%s < %s", |
| "%s != %s", "%s >= %s", "%s > %s", |
| } |
| |
| // logicalOperators contains format strings for logical combination of boolean expressions |
| var logicalOperators = []string{ |
| "(%s) && (%s)", "(%s) && !(%s)", "!(%s) && (%s)", "!(%s) && !(%s)", |
| "(%s) || (%s)", "(%s) || !(%s)", "!(%s) || (%s)", "!(%s) || !(%s)", |
| } |
| |
| // writeComparator generates a comparator function based on the comparison operator |
| func writeComparator(w *bytes.Buffer, fieldName, operatorFormat string) { |
| expression := fmt.Sprintf(operatorFormat, "a", "b") |
| fmt.Fprintf(w, "\t\t\t%s: func(a, b T) bool { return %s },\n", fieldName, expression) |
| } |
| |
| // writeLogicalCombiner generates a function to combine two boolean values |
| func writeLogicalCombiner(w *bytes.Buffer, logicalOperator string) { |
| expression := fmt.Sprintf(logicalOperator, "x", "y") |
| fmt.Fprintf(w, "\t\t\tcombine: func(x, y bool) bool { return %s },\n", expression) |
| } |
| |
| // writeTargetFunction generates the target function with conditional expression |
| func writeTargetFunction(w *bytes.Buffer, cmp1, cmp2, logicalOp string) { |
| leftExpr := fmt.Sprintf(cmp1, "a", "b") |
| rightExpr := fmt.Sprintf(cmp2, "c", "d") |
| condition := fmt.Sprintf(logicalOp, leftExpr, rightExpr) |
| |
| fmt.Fprintf(w, "\t\t\ttargetFunc: func(a, b, c, d T) bool {\n") |
| fmt.Fprintf(w, "\t\t\t\tif %s {\n", condition) |
| fmt.Fprintf(w, "\t\t\t\t\treturn true\n") |
| fmt.Fprintf(w, "\t\t\t\t}\n") |
| fmt.Fprintf(w, "\t\t\t\treturn false\n") |
| fmt.Fprintf(w, "\t\t\t},\n") |
| } |
| |
| // writeTestCase creates a single test case with given comparison and logical operators |
| func writeTestCase(w *bytes.Buffer, cmp1, cmp2, logicalOp string) { |
| fmt.Fprintf(w, "\t\t{\n") |
| writeComparator(w, "cmp1", cmp1) |
| writeComparator(w, "cmp2", cmp2) |
| writeLogicalCombiner(w, logicalOp) |
| writeTargetFunction(w, cmp1, cmp2, logicalOp) |
| |
| // Store string representations for debugging |
| cmp1Expr := fmt.Sprintf(cmp1, "a", "b") |
| cmp2Expr := fmt.Sprintf(cmp2, "c", "d") |
| logicalExpr := fmt.Sprintf(logicalOp, cmp1Expr, cmp2Expr) |
| |
| fmt.Fprintf(w, "\t\t\tcmp1Expr: %q,\n", cmp1Expr) |
| fmt.Fprintf(w, "\t\t\tcmp2Expr: %q,\n", cmp2Expr) |
| fmt.Fprintf(w, "\t\t\tlogicalExpr: %q,\n", logicalExpr) |
| |
| fmt.Fprintf(w, "\t\t},\n") |
| } |
| |
| // generateTestCases creates a slice of all possible test cases |
| func generateTestCases(w *bytes.Buffer) { |
| fmt.Fprintf(w, "func generateTestCases[T IntegerConstraint]() []TestCase[T] {\n") |
| fmt.Fprintf(w, "\treturn []TestCase[T]{\n") |
| |
| for _, cmp1 := range comparisonOperators { |
| for _, cmp2 := range comparisonOperators { |
| for _, logicalOp := range logicalOperators { |
| writeTestCase(w, cmp1, cmp2, logicalOp) |
| } |
| } |
| } |
| |
| fmt.Fprintf(w, "\t}\n") |
| fmt.Fprintf(w, "}\n\n") |
| } |
| |
| // TypeConfig defines a type and its test base value |
| type TypeConfig struct { |
| typeName, baseValue string |
| } |
| |
| // typeConfigs contains all integer types to test with their base values |
| var typeConfigs = []TypeConfig{ |
| {typeName: "int8", baseValue: "1 << 6"}, |
| {typeName: "uint8", baseValue: "1 << 6"}, |
| {typeName: "int16", baseValue: "1 << 14"}, |
| {typeName: "uint16", baseValue: "1 << 14"}, |
| {typeName: "int32", baseValue: "1 << 30"}, |
| {typeName: "uint32", baseValue: "1 << 30"}, |
| {typeName: "int", baseValue: "1 << 30"}, |
| {typeName: "uint", baseValue: "1 << 30"}, |
| {typeName: "int64", baseValue: "1 << 62"}, |
| {typeName: "uint64", baseValue: "1 << 62"}, |
| } |
| |
| // writeTypeSpecificTest generates test for a specific integer type |
| func writeTypeSpecificTest(w *bytes.Buffer, typeName, baseValue string) { |
| typeTitle := strings.Title(typeName) |
| |
| fmt.Fprintf(w, "func Test%sConditionalCmpConst(t *testing.T) {\n", typeTitle) |
| |
| fmt.Fprintf(w, "\ttestCases := generateTestCases[%s]()\n", typeName) |
| fmt.Fprintf(w, "\tbase := %s(%s)\n", typeName, baseValue) |
| fmt.Fprintf(w, "\tvalues := [3]%s{base - 1, base, base + 1}\n\n", typeName) |
| |
| fmt.Fprintf(w, "\tfor _, tc := range testCases {\n") |
| fmt.Fprintf(w, "\t\ta, c := base, base\n") |
| fmt.Fprintf(w, "\t\tfor _, b := range values {\n") |
| fmt.Fprintf(w, "\t\t\tfor _, d := range values {\n") |
| fmt.Fprintf(w, "\t\t\t\texpected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))\n") |
| fmt.Fprintf(w, "\t\t\t\tactual := tc.targetFunc(a, b, c, d)\n") |
| fmt.Fprintf(w, "\t\t\t\tif actual != expected {\n") |
| fmt.Fprintf(w, "\t\t\t\t\tt.Errorf(\"conditional comparison failed:\\n\"+\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\t\" type: %%T\\n\"+\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\t\" condition: %%s\\n\"+\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\t\" values: a=%%v, b=%%v, c=%%v, d=%%v\\n\"+\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\t\" cmp1(a,b)=%%v (%%s)\\n\"+\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\t\" cmp2(c,d)=%%v (%%s)\\n\"+\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\t\" expected: combine(%%v, %%v)=%%v\\n\"+\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\t\" actual: %%v\\n\"+\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\t\" logical expression: %%s\",\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\ta,\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\ttc.logicalExpr,\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\ta, b, c, d,\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\ttc.cmp1(a, b), tc.cmp1Expr,\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\ttc.cmp2(c, d), tc.cmp2Expr,\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\ttc.cmp1(a, b), tc.cmp2(c, d), expected,\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\tactual,\n") |
| fmt.Fprintf(w, "\t\t\t\t\t\ttc.logicalExpr)\n") |
| fmt.Fprintf(w, "\t\t\t\t}\n") |
| fmt.Fprintf(w, "\t\t\t}\n") |
| fmt.Fprintf(w, "\t\t}\n") |
| fmt.Fprintf(w, "\t}\n") |
| |
| fmt.Fprintf(w, "}\n\n") |
| } |
| |
| // writeAllTests generates tests for all supported integer types |
| func writeAllTests(w *bytes.Buffer) { |
| for _, config := range typeConfigs { |
| writeTypeSpecificTest(w, config.typeName, config.baseValue) |
| } |
| } |
| |
| func main() { |
| buffer := new(bytes.Buffer) |
| |
| // Header for generated file |
| fmt.Fprintf(buffer, "// Code generated by conditionalCmpConstGen.go; DO NOT EDIT.\n\n") |
| fmt.Fprintf(buffer, "package test\n\n") |
| fmt.Fprintf(buffer, "import \"testing\"\n\n") |
| |
| // Generate type definitions |
| writeTypeDefinitions(buffer) |
| |
| // Generate test cases |
| generateTestCases(buffer) |
| |
| // Generate specific tests for each integer type |
| writeAllTests(buffer) |
| |
| // Format generated source code |
| rawSource := buffer.Bytes() |
| formattedSource, err := format.Source(rawSource) |
| if err != nil { |
| // Output raw source for debugging if formatting fails |
| fmt.Printf("%s\n", rawSource) |
| log.Fatal("error formatting generated code: ", err) |
| } |
| |
| // Write to output file |
| outputPath := "../../conditionalCmpConst_test.go" |
| if err := os.WriteFile(outputPath, formattedSource, 0666); err != nil { |
| log.Fatal("failed to write output file: ", err) |
| } |
| |
| log.Printf("Tests successfully generated to %s", outputPath) |
| } |
