) : ConfigurationCacheStateFile {
        override val exists: Boolean
            get() = file.isFile

        override val stateFile: StateFile
            get() = StateFile(stateType, file)

        override fun outputStream(): OutputStream =
            throw UnsupportedOperationException()

        override fun inputStream(): InputStream =
            file.also(::markAccessed).inputStream()

        override fun delete() {

    ): T {
        return withReadContextFor(encryptionService.inputStream(stateFile.stateType, stateFile::inputStream)) { codecs ->
            ConfigurationCacheState(codecs, stateFile, eventEmitter, host).run {
                action(this)
            }
        }
    }

    private
    fun <T> writeConfigurationCacheState(
        stateFile: ConfigurationCacheStateFile,

        return loadFromCache(StateType.Model) { stateFile ->
            LoadResult(stateFile.stateFile.file) to cacheIO.readModelFrom(stateFile)
        }
    }

    private
    fun loadWorkGraph(graph: BuildTreeWorkGraph, graphBuilder: BuildTreeWorkGraphBuilder?, loadAfterStore: Boolean): BuildTreeWorkGraph.FinalizedGraph {
        return loadFromCache(StateType.Work) { stateFile ->

        private val fingerprintWriter: ConfigurationCacheFingerprintWriter,
        private val buildScopedSpoolFile: StateFile,
        private val projectScopedSpoolFile: StateFile
    ) : WritingState() {
        override fun maybeStart(buildScopedSpoolFile: StateFile, projectScopedSpoolFile: StateFile, writeContextForOutputStream: (StateFile) -> DefaultWriteContext): WritingState {
            return this
        }

        val buildOperationRunner = mock<BuildOperationRunner> {
            on { call<Unit>(any()) } doReturn Unit
        }
        val stateFile = testDirectoryProvider.file("stateFile")

        // when:
        buildOperationRunner.withStoreOperation("key") {
            StoreResult(stateFile, null)
        }

        // then:
        val runnableBuildOperation = ArgumentCaptor.forClass(RunnableBuildOperation::class.java)

    })


private
object LoadDetails : ConfigurationCacheLoadBuildOperationType.Details


internal
data class LoadResult(val stateFile: File, val originInvocationId: String? = null) : ConfigurationCacheLoadBuildOperationType.Result {
    override fun getCacheEntrySize(): Long = stateFile.length()
    override fun getOriginBuildInvocationId(): String? = originInvocationId
}


private

import org.gradle.cache.internal.streams.ValueStore
import java.io.File


internal
interface ConfigurationCacheStateStore {

    data class StateFile(val stateType: StateType, val file: File)

    fun assignSpoolFile(stateType: StateType): StateFile

    /**
     * Loads some value from zero or more state files.
     */
    fun <T : Any> useForStateLoad(action: (ConfigurationCacheRepository.Layout) -> T): T

    def "outputs are created"() {
        given:
        def outputDir = file("outDir")
        def outputFile = file("parent/outFile")
        def localStateFile = file("local-state/stateFile")
        def destroyableFile = file("destroyable/file.txt")

        when:
        step.execute(work, context)

        then:

     */
    Entry(false)
}


internal
interface ConfigurationCacheStateFile {
    val exists: Boolean
    val stateType: StateType
    val stateFile: ConfigurationCacheStateStore.StateFile
    fun outputStream(): OutputStream
    fun inputStream(): InputStream
    fun delete()

    // Replace the contents of this state file, by moving the given file to the location of this state file

	}
	stateLine := bytes.SplitN(lines[stateLineIdx], []byte{':'}, 2)
	if len(stateLine) != 2 {
		// Malformed status file?
		return false, false, fmt.Errorf("unexpected status file format: %s:\n%s", statusFile, status)
	}
	// Check if it's a zombie thread.
	return !bytes.Contains(stateLine[1], []byte{'Z'}), true, nil
}

func getcwd() (string, error) {