expect:
        isDynamic("[1.0,2.0]")
        isDynamic("[1.0,)")
        isDynamic("[1.0]")
    }

    def "never needs metadata"() {
        expect:
        !requiresMetadata("[1.0,2.0]")
        !requiresMetadata("[1.0,)")
        !requiresMetadata("[1.0]")
    }

    def "excluded upper bound corner cases"() {
        expect:
        !accept("[1.0,2.0)", "2.0-final")

        """
        expect:
        succeeds("help")
        outputDoesNotContain("withType(Sub) called on")
    }

    def "addLater(Sub) triggers configuration with eager all"() {
        buildFile << """
            container.all {
                println "all called on " + it
            }
            container.addLater(provider { create(Sub) })
        """
        expect:
        succeeds("help")

        expect:
        Amount.valueOf(a, Fruit.apples) * b == Amount.valueOf(c, Fruit.apples)

        where:
        a     | b   | c
        0     | 200 | 0
        2     | 1   | 2
        5     | 10  | 50
        10    | -2  | -20
        0.25  | 8   | 2
    }

    def "can convert to absolute value"() {
        expect:

)

func init() {
	register("CoroLockOSThreadIterLock", func() {
		println("expect: OK")
		CoroLockOSThread(callerExhaust, iterLock)
	})
	register("CoroLockOSThreadIterLockYield", func() {
		println("expect: OS thread locking must match")
		CoroLockOSThread(callerExhaust, iterLockYield)
	})
	register("CoroLockOSThreadLock", func() {
		println("expect: OK")
		CoroLockOSThread(callerExhaustLocked, iterSimple)
	})

	for _, tc := range testCases {
		got := tc.trustDomainBundle.ReplaceTrustDomainAliases(tc.principals)
		if !reflect.DeepEqual(got, tc.expect) {
			t.Errorf("%s failed. Expect: %s. Got: %s", tc.name, tc.expect, got)
		}
	}
}

func TestReplaceTrustDomainInPrincipal(t *testing.T) {
	cases := []struct {
		name          string
		trustDomainIn string
		principal     string
		out           string
		expectedError string

        given:
        vswhereInProgramFiles()

        expect:
        locator.getVswhereInstall().absolutePath == vswhere.absolutePath
    }

    def "finds vswhere executable in Program Files (X86)"() {
        given:
        vswhereInProgramFilesX86()

        expect:
        locator.getVswhereInstall().absolutePath == vswhere.absolutePath
    }

    }

    def "generates options for an unconfigured spec"() {
        expect:
        builder.build() == defaultOptions
    }

    def "generates -source option when current Jvm Version is used"() {
        spec.sourceCompatibility = JavaVersion.current().toString()

        expect:
        builder.build() == ["-source", JavaVersion.current().toString()] + defaultOptions
    }

        def file = new File("a.txt")

        expect:
        pathNotationParser.parseNotation(file) == file.path
    }

    def "with Number"() {
        expect:
        expected == pathNotationParser.parseNotation(input);
        where:
        input << [1, 1.5, -1]
        expected << ["1", "1.5", "-1"]
    }

    def "with Boolean"() {
        expect:
        expected == pathNotationParser.parseNotation(input);

        """.stripIndent()
    }

    def "analyze good code"() {
        goodCode()

        expect:
        succeeds("check")
        file("build/reports/pmd/main.xml").exists()
        file("build/reports/pmd/test.xml").exists()
    }

    def "analyze bad code"() {
        badCode()

        expect:
        fails("check")
        failure.assertHasDescription("Execution failed for task ':pmdTest'.")

        assert file.exists() && file.file

        expect:
        normalize(file) == file
    }

    @Requires(UnitTestPreconditions.CaseInsensitiveFs)
    def "does not normalize case"() {
        def file = createFile(new File(tmpDir.testDirectory, 'dir/file.txt'))
        def path = new File(tmpDir.testDirectory, 'dir/FILE.txt')
        assert path.exists() && path.file

        expect:
        normalize(path) == path
    }