when:
        buildId = UniqueId.generate()
        outputFile.text = "outdated"

        then:
        outOfDate(builder.build(), outputFilesChanged(file: [outputFile]))
    }

    def "failed executions are never up-to-date"() {
        def failure = new RuntimeException()

        when:
        def result = execute(builder.withWork { ->
            throw failure

            }
            localRepository.get().asFileTree.matching { include("**/*.module") }.forEach {
                val content = it.readText()
                    .replace("\"buildId\":\\s+\"\\w+\"".toRegex(), "\"buildId\": \"\"")
                    .replace("\"size\":\\s+\\d+".toRegex(), "\"size\": 0")
                    .replace("\"sha512\":\\s+\"\\w+\"".toRegex(), "\"sha512\": \"\"")

import "os"

// peBuildID returns a best effort unique ID for the named executable.
//
// It would be wasteful to calculate the hash of the whole file,
// instead use the binary name and the last modified time for the buildid.
func peBuildID(file string) string {
	s, err := os.Stat(file)
	if err != nil {
		return file
	}
	return file + s.ModTime().String()

        }
        repoDir.get().asFileTree.matching { include("**/*.module") }.forEach {
            val content = it.readText()
                .replace("\"buildId\":\\s+\"\\w+\"".toRegex(), "\"buildId\": \"\"")
                .replace("\"size\":\\s+\\d+".toRegex(), "\"size\": 0")
                .replace("\"sha512\":\\s+\"\\w+\"".toRegex(), "\"sha512\": \"\"")

		// TODO(hyangah): make addMapping return *memMap or
		// take a memMap struct, and get rid of addMappingEntry
		// that takes a bunch of positional arguments.
	}
}

func readMainModuleMapping() (start, end uint64, exe, buildID string, err error) {
	return 0, 0, "", "", errors.New("not implemented")

	}

	ctxt.Out.Write([]byte{0x00, 0x61, 0x73, 0x6d}) // magic
	ctxt.Out.Write([]byte{0x01, 0x00, 0x00, 0x00}) // version

	// Add any buildid early in the binary:
	if len(buildid) != 0 {
		writeBuildID(ctxt, buildid)
	}

	writeTypeSec(ctxt, types)
	writeImportSec(ctxt, hostImports)
	writeFunctionSec(ctxt, fns)
	writeTableSec(ctxt, fns)
	writeMemorySec(ctxt, ldr)

        }
    }

    @EqualsAndHashCode
    static class CreatedBy {
        final String gradleVersion
        final String buildId

        CreatedBy(String gradleVersion, String buildId) {
            this.gradleVersion = gradleVersion
            this.buildId = buildId
        }
    }

    @EqualsAndHashCode
    static class Coords {
        final String group
        final String module

    "module": "producer",
    "version": "1.0",
    "attributes": {
      "org.gradle.status": "release"
    }
  },
  "createdBy": {
    "gradle": {
      "version": "5.3-20190124175634+0000",
      "buildId": "l63zt5h46neu3ahqbi73jsdqaa"
    }
  },
  "variants": [
    {
      "name": "runtime",
      "attributes": {
        "org.gradle.usage": "java-runtime"
      },
      "files": [
        {

                            def buildId = b.buildIdentifier
                            println "Build path=" + buildId.buildPath + " name=" + buildId.name
                        }
                    }
                }
            """
            it.buildFile << """
                subprojects {
                    // The Java plugin forces the configuration of the included builds
                    apply plugin: 'java'

    }

    def "understands project input"() {
        when:
        def buildId = new DefaultBuildIdentifier(Path.path(":build"))
        def projectState = Mock(ProjectState) {
            getComponentIdentifier() >> new DefaultProjectComponentIdentifier(buildId, Path.path(":id:bar"), Path.path(":bar"), "name")
        }
        def project = Mock(ProjectInternal) {