}
         """

        outputs.snapshot { succeeds("compileDebugSwift") }

        expect:
        // rebuild for Swift4
        succeeds("compileDebugSwift", "-Pswift4")
        outputs.recompiledClasses('main', 'sum', 'greeter', 'multiply')

        and:
        // rebuild for Swift3
        succeeds("compileDebugSwift")
        outputs.recompiledClasses('main', 'sum', 'greeter', 'multiply')
    }

        """

        then:
        succeeds language.compileTaskName
        outputs.recompiledClasses('Person', 'Consumer')
    }

    def "changing an unused non-private constant incurs partial rebuild"() {
        source "class A { int foo() { return 2; } }", "class B { final static int x = 1;}"
        outputs.snapshot { run language.compileTaskName }

        when:
        source "class B { /* change */ }"

    def "task can have actions defined using Groovy script closures"() {
        given:
        settingsFile << """
            include 'a', 'b'
        """
        [file("a/build.gradle"), file("b/build.gradle")].each {
            it << """
                tasks.register("some") {
                    doFirst {
                        println("FIRST")
                    }
                    doLast {

        run("copy")
        // force rebuild
        outputDir.file("modified.txt").text = "changed"
        inputDir.forceDeleteDir()
        run("copy")
        then:
        executedAndNotSkipped(":copy")
        outputDir.assertIsEmptyDir()
    }

    def "outputs are cleaned out on rebuild (output type: #type)"() {
        file("buildSrc").deleteDir()

        'Add Java files to Java file set'           | ['G']        | ['J', 'G']           | ['a full rebuild', "UP-TO-DATE"]                             | ['J', 'G']           | ['UP-TO-DATE', 'UP-TO-DATE']
        'Add Groovy files to Groovy file set'       | ['J']        | ['J', 'G']           | ["UP-TO-DATE", "a full rebuild"]                             | ['J.changed', 'G']   | ['Incremental compilation of', 'UP-TO-DATE']

    CompiledLanguage language = CompiledLanguage.JAVA

    def "change in an upstream class with non-private constant causes rebuild if constant is used (#constantType)"() {
        source api: ["class A {}", "class B { final static $constantType x = $constantValue; }"], impl: ["class X { $constantType foo() { return B.x; }}", "class Y {int foo() { return -2; }}"]

	if err != nil {
		return fmt.Errorf("unable to refresh the port block: %v", err)
	}

	rebuilt, err := portallocator.NewInMemory(c.portRange)
	if err != nil {
		return fmt.Errorf("unable to create port allocator: %v", err)
	}
	// Check every Service's ports, and rebuild the state as we think it should be.
	for i := range list.Items {
		svc := &list.Items[i]
		ports := collectServiceNodePorts(svc)

        run "impl:${language.compileTaskName}"

        then:
        impl.noneRecompiled()
    }

    def "addition of unused class in upstream project does not rebuild"() {
        source api: ["class A {}", "class B { private final static int x = 1; }"], impl: ["class ImplA extends A {}", "class ImplB extends B {}"]
        impl.snapshot { run language.compileTaskName }

        when:

	}

	// save logic
	// Blast the rebuilt state into storage.
	for family, rebuilt := range rebuiltByFamily {
		err = c.saveSnapShot(rebuilt, c.allocatorByFamily[family], snapshotByFamily[family])
		if err != nil {
			return err
		}
	}

	return nil
}

        }
    }

    public boolean isOpen() {
        return store.isOpen();
    }

    private void rebuild() {
        LOGGER.warn("{} is corrupt. Discarding.", this);
        try {
            clear();
        } catch (Exception e) {
            LOGGER.warn("{} couldn't be rebuilt. Closing.", this);
            close();
        }
    }

    public void verify() {
        try {