}

int clean_test(void) {
    return 0;
}

void test_sum(void) {
  CU_ASSERT(sum(0, 2) == 2);
#ifndef ONE_TEST
  CU_ASSERT(sum(0, -2) == -2);
  CU_ASSERT(sum(2, 2) == 4);
#endif
}

void gradle_cunit_register() {
    CU_pSuite pSuiteMath = CU_add_suite("hello test", init_test, clean_test);
    CU_add_test(pSuiteMath, "test_sum", test_sum);
}
                    """),
            ]

        def testResults = new GoogleTestTestResults(file("build/test-results/helloTest/test_detail.xml"))
        testResults.suiteNames == ['HelloTest']
        testResults.suites['HelloTest'].passingTests == ['test_sum']
        testResults.suites['HelloTest'].failingTests == []
        testResults.checkTestCases(1, 1, 0)
    }

    @ToBeFixedForConfigurationCache
    def "assemble does not build or run tests"() {

        def testResults = new CUnitTestResults(file("build/test-results/helloTest/CUnitAutomated-Results.xml"))
        testResults.suiteNames == ['hello test']
        testResults.suites['hello test'].passingTests == ['test_sum']
        testResults.suites['hello test'].failingTests == []
        testResults.checkTestCases(1, 1, 0)
        testResults.checkAssertions(3, 3, 0)
    }

    @ToBeFixedForConfigurationCache

            List<SourceFile> sourceFiles = [
                    sourceFile("cpp", "test.cpp", """
#include "gtest/gtest.h"
#include "hello.h"

using namespace testing;

TEST(HelloTest, test_sum) {
  ASSERT_TRUE(sum(0, 2) == 2);
#ifndef ONE_TEST
  ASSERT_TRUE(sum(0, -2) == -2);
  ASSERT_TRUE(sum(2, 2) == 4);
#endif
}

int main(int argc, char **argv) {
  testing::InitGoogleTest(&argc, argv);

	rh := &testRecordHook{}
	monitoring.RegisterRecordHook(testSum.Name(), rh)

	testSum.With(name.Value("foo"), kind.Value("bart")).Increment()
	testSum.With(name.Value("baz"), kind.Value("bart")).Record(45)

	mt.Assert(testSum.Name(), map[string]string{"name": "foo", "kind": "bart"}, monitortest.Exactly(1))

    assertThat(Enums.getIfPresent(TestEnum.class, "HONDA")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).isPresent();

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).hasValue(TestEnum.CHEETO);
    assertThat(Enums.getIfPresent(TestEnum.class, "HONDA")).hasValue(TestEnum.HONDA);
    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).hasValue(TestEnum.POODLE);
  }

        [String]         | [TestEnum.ABC]        | "one arg"
        [Long, TestEnum] | [TestEnum.ABC, "abc"] | "two args"
    }

    def "exception thrown when coercing invalid string to enum"() {
        when:
        transformer.transformValue(TestEnum, "invalid")

        then:
        def e = thrown IllegalArgumentException
        TestEnum.values().every { e.message.contains(it.name()) }
    }

		}
	}
	if gomodIdx < 0 {
		return false
	}

	var cmd string
	switch *testSum {
	case "tidy":
		cmd = "go mod tidy"
	case "listm":
		cmd = "go list -m -mod=mod all"
	case "listall":
		cmd = "go list -mod=mod all"
	default:
		t.Fatalf(`unknown value for -testsum %q; may be "tidy", "listm", or "listall"`, *testSum)
	}

	log := new(strings.Builder)

    }
}

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")