def "creates null reference for a null jar url"() {
        expect:
        factory.fromJarURI(null) == null
    }

    def "creates null reference for a null file path"() {
        expect:
        factory.fromPath(null) == null
    }

    def "creates a reference from a variable path"() {
        TestFile file = rootDir.file("a/file.txt")

        expect:

func TestHasTestFiles(t *testing.T) {
	cases := []struct {
		input  []string
		expect bool
	}{{
		input:  nil,
		expect: false,
	}, {
		input:  []string{},
		expect: false,
	}, {
		input:  []string{"foo.go"},
		expect: false,
	}, {
		input:  []string{"foo.go", "bar.go"},
		expect: false,
	}, {
		input:  []string{"foo_test.go"},
		expect: true,
	}, {
		input:  []string{"foo.go", "foo_test.go"},

	g.Expect(NewScopedFqdn("foo", "foo", "*.xyz.abc")).To(Equal(ScopedFqdn("foo/*.xyz.abc")))
	// wildcard, all namespaces scope
	g.Expect(NewScopedFqdn("*", "foo", "*")).To(Equal(ScopedFqdn("*/*")))
	// wildcard sub domain, all namespaces scope
	g.Expect(NewScopedFqdn("*", "foo", "*.xyz.abc")).To(Equal(ScopedFqdn("*/*.xyz.abc")))

	// external host, local scope

    def "can serialize BuildEvent messages"() {
        expect:
        def event = new BuildEvent(["a", "b", "c"])
        def result = serialize(event, serializer)
        result instanceof BuildEvent
        result.payload == ["a", "b", "c"]
    }

    def "can serialize LogLevelChangeEvent messages"() {
        expect:
        def event = new LogLevelChangeEvent(LogLevel.LIFECYCLE)

    }

    def "wrapper gets bad archive on 2 attempts"() {
        given:
        server.expect(server.head(GRADLE_BIN_ZIP))
        server.expect(server.get(GRADLE_BIN_ZIP).sendFile(badArchive))
        server.expect(server.get(GRADLE_BIN_HASH).missing())
        server.expect(server.get(GRADLE_BIN_ZIP).sendFile(badArchive))
        server.expect(server.get(GRADLE_BIN_ZIP).sendFile(distribution.binDistribution))
        server.start()

        expect:
        matches("someName", "someName", "someNameWithExtra")
    }

    def "prefers exact match over camel case match"() {
        expect:
        matches("sName", "sName", "someName", "sNames")
        matches("so Name", "so Name", "some Name", "so name")
        matches("ABC", "ABC", "AaBbCc")
    }

    def "prefers exact match over kebab case match"() {
        expect:

		{"FUNCDATA", "", "expect two operands for FUNCDATA"},
		{"FUNCDATA", "(SB ", "expect two operands for FUNCDATA"},
		{"DATA", "", "expect two operands for DATA"},
		{"DATA", "0", "expect two operands for DATA"},
		{"DATA", "(0), 1", "expect /size for DATA argument"},
		{"DATA", "@B(SB)/4,0", "expected '(', found B"}, // Issue 23580.

        expect:
        resolvedModules 'b'
    }

    def "replaces already resolved module"() {
        declaredDependencies 'a', 'b'
        declaredReplacements 'a->b'
        expect:
        resolvedModules 'b'
    }

    def "replaces not yet resolved module"() {
        declaredDependencies 'b', 'a'
        declaredReplacements 'a->b'
        expect:
        resolvedModules 'b'

    }

    def "makes a ProcessEnvironment available"() {
        expect:
        services.get(ProcessEnvironment) != null
    }

    def "makes an OperatingSystem available"() {
        expect:
        services.get(OperatingSystem) != null
    }

    def "makes a FileSystem available"() {
        expect:
        services.get(FileSystem) != null
        services.get(Chmod) != null

    // region: Single Attribute tests
    def "attribute without any @Incubating is not reported"() {
        expect:
        !IncubatingAttributesChecker.isIncubating(Usage.USAGE_ATTRIBUTE)
    }

    def "attribute with @Incubating annotation on class is reported"() {
        expect:
        !IncubatingAttributesChecker.isIncubating(TestSuiteType.TEST_SUITE_TYPE_ATTRIBUTE)
    }