cleanup:
        unreadableDir.makeReadable()
    }

    @Requires(UnitTestPreconditions.FilePermissions)
    def "stat an unreadable file"() {
        def unreadableFile = tmpDir.createFile("unreadable")
        unreadableFile.makeUnreadable()

        expect:
        def stat = accessor.stat(unreadableFile)
        stat.type == FileType.RegularFile

	}

	realGoroot := testenv.GOROOT(t)

	// To ensure that bootstrapping doesn't unexpectedly depend
	// on the Go repo's git metadata, add a fake (unreadable) git
	// directory above the simulated GOROOT.
	// This mimics the configuration one much have when
	// building from distro-packaged source code
	// (see https://go.dev/issue/54852).
	parent := t.TempDir()

    @Issue('https://github.com/gradle/gradle/issues/9576')
    def "unreadable #type not produced by task fails"() {
        given:
        def input = file("readableFile.txt").createFile()

        def outputDirectory = file("output")
        def unreadableOutput = file("${outputDirectory.name}/unreadable${type.capitalize()}")
        create(unreadableOutput).makeUnreadable()

        buildFile << """

                .withAdvice("Declare the task as untracked by using Task.doNotTrackState().");
        } else if (isDestinationDir && task instanceof Sync) {
            builder.withSummary("Cannot access a file in the destination directory.")
                .withContext("Syncing to a directory which contains unreadable content is not supported.")

  override fun source() = buffer()

  override fun read(
    sink: Buffer,
    byteCount: Long,
  ): Long {
    throw IllegalStateException(
      """
      |Unreadable ResponseBody! These Response objects have bodies that are stripped:
      | * Response.cacheResponse
      | * Response.networkResponse
      | * Response.priorResponse
      | * EventSourceListener

    source1.close() // Not exhausted!
    assertThat(relay1.isClosed).isTrue()
    assertFailsWith<IOException> {
      read(file)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("unreadable cache file")
    }
    assertFile(Relay.PREFIX_DIRTY, -1L, -1, null, null)
  }

  @Test
  fun redundantCallsToCloseAreIgnored() {
    val upstream = Buffer()
    upstream.writeUtf8("abcde")

        expect:
        fails 'syncIt'

        cleanup:
        ins.close()
    }

    @Requires(UnitTestPreconditions.FilePermissions)
    def "sync fails when the output contains unreadable files"() {
        given:
        def input = file("readableFile.txt").createFile()

        def outputDirectory = file("output")
        def unreadableOutput = outputDirectory.file("unreadableFile").createFile()

		cmd.Dir = instdira
		run(cmd, t)
	}

	// Do some error testing to ensure that various bad options and
	// combinations are properly rejected.

	// Expect error if config file inaccessible/unreadable.
	mode := "atomic"
	errExpected := true
	tag := "errors"
	_, _, errmsg := runPkgCover(t, instdira, tag, "/not/a/file", mode,
		apkgfiles, errExpected)
	want := "error reading pkgconfig file"

      val header = Buffer()
      fileOperator.read(0, header, FILE_HEADER_SIZE)
      val prefix = header.readByteString(PREFIX_CLEAN.size.toLong())
      if (prefix != PREFIX_CLEAN) throw IOException("unreadable cache file")
      val upstreamSize = header.readLong()
      val metadataSize = header.readLong()

      // Read the metadata.
      val metadataBuffer = Buffer()

==== Declaring input or output directories which contain unreadable content

For up-to-date checks Gradle relies on tracking the state of the inputs and the outputs of a task.
Gradle used to ignore unreadable files in the input or outputs to support certain use-cases, although it cannot track their state.