}
}

enum TestEnum {
    ABC, DEF
}

class EnumCoerceTestSubject {
    TestEnum enumProperty

    String stringValue

    void someEnumMethod(TestEnum testEnum) {
        this.enumProperty = testEnum
    }

    void enumMethodWithStringOverload(TestEnum testEnum) {
        enumProperty = testEnum
    }

        expect:
        TestEnum.ENUM1 == toEnum(TestEnum, "ENUM1")
        TestEnum.ENUM1 == toEnum(TestEnum, "enum1")
        TestEnum.ENUM1 == toEnum(TestEnum, "EnUm1")
        TestEnum.ENUM2 == toEnum(TestEnum, "enum2")
        TestEnum.ENUM3 == toEnum(TestEnum, "enum3")
        TestEnum.ENUM_4_1 == toEnum(TestEnum, "enum_4_1")
        TestEnum.STANDARD_OUT == toEnum(TestEnum, "Standard_Out")

        'Long'           | []                                   | 'null'              | 'not provided'
        'TestEnum'       | ['--myProp=OPT_2']                   | 'OPT_2'             | 'provided with upper case'
        'TestEnum'       | ['--myProp=opt_2']                   | 'OPT_2'             | 'provided with lower case'
        'TestEnum'       | []                                   | 'null'              | 'not provided'

        given:
        OptionValueNotationParserFactory factory = new OptionValueNotationParserFactory()
        when:
        def parser = factory.toComposite(TestEnum.class);
        then:
        parser.parseNotation("ABC") == TestEnum.ABC
    }

    def "creates notationparser for handling handles integers"(){
        given:
        OptionValueNotationParserFactory factory = new OptionValueNotationParserFactory()

    @Option(option = "enumValue", description = "Configures an enum value in CustomTask.")
    public void setEnumValue(TestEnum value) {
    }

    @Option(option = "booleanValue", description = "Configures a boolean flag in CustomTask.")
    public void setBooleanValue(boolean value) {
    }
}

enum TestEnum {
    ABC, DEF, GHIJKL

            ${taskWithSingleOption('TestEnum')}
        """

        when:
        runAndFail 'someTask', '--myProp', 'unsupportedValue'

        then:
        failure.assertHasDescription("Problem configuring option 'myProp' on task ':someTask' from command line.")

def test_openapi_schema_sub():
    response = client.get("/subapi/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == openapi_schema_sub


def test_sub():
    response = client.get("/subapi/sub")
    assert response.status_code == 200, response.text

                @TaskAction
                public void renderOptionValue() {
                    System.out.println("Value of myProp: " + myProp);
                }
                
                private static enum TestEnum {
                    OPT_1, OPT_2, OPT_3
                }
            }
        """
    }

    String taskWithFlagMethod() {
        """
            import org.gradle.api.DefaultTask;

	"os"
	"path/filepath"
	"testing"
)

const asmData = `
GLOBL zeros<>(SB),8,$64
TEXT ·testASM(SB),4,$0
VMOVUPS zeros<>(SB), %s // PC relative relocation is off by 1, for Y8-Y15, Z8-15 and Z24-Z31
RET
`

const goData = `
package main

func testASM()

func main() {
	testASM()
}
`

func objdumpOutput(t *testing.T, mname, source string) []byte {
	tmpdir, err := os.MkdirTemp("", mname)

		t.Errorf("got %q; want %q", got, want)
	}
}

func TestCompose(t *testing.T) {
	var buf strings.Builder
	var testNum int

	connectStart := func(b byte) func(network, addr string) {
		return func(network, addr string) {
			if addr != "addr" {
				t.Errorf(`%d. args for %q case = %q, %q; want addr of "addr"`, testNum, b, network, addr)
			}
			buf.WriteByte(b)
		}
	}

	tests := [...]struct {
		trace, old *ClientTrace