unreadableDir.makeUnreadable()

        expect:
        def stat = accessor.stat(fileInDir)
        stat.type == FileType.RegularFile
        assertSameLastModified(stat, fileInDir)
        stat.length == 0
        assertSameAccessType(stat, DIRECT)

        cleanup:
        unreadableDir.makeReadable()
    }

    @Requires(UnitTestPreconditions.FilePermissions)

    def "can visit unreadable #type"() {
        given:
        def rootDir = tmpDir.createDir("root")
        def unreadableFile = rootDir.file('unreadable')
        unreadableFile."create${type.capitalize()}"().makeUnreadable()

        when:
        snapshot(rootDir)

        then:
        def ex = thrown(UncheckedIOException)
        ex.message == String.format(message, unreadableFile)

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

        buildFile << """
            task copy(type: Copy) {
                from '${input.name}'
                into '${outputDirectory.name}'
            }
        """

        when:

        def input = file("readableFile.txt").createFile()

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

        buildFile << """
            task sync(type: Sync) {
                from '${input.name}'
                into '${outputDirectory.name}'
            }
        """

        expect:

        unreadable."create${type.capitalize()}"().makeUnreadable()

        when:
        directorySnapshotter.snapshot(rootDir.absolutePath, null, [:], unfilteredSubSnapshotsCollector)

        then:
        def ex = thrown(UncheckedIOException)
        ex.message == String.format(message, unreadable.absolutePath)
        0 * _

        cleanup:
        rootDir.listFiles()*.makeReadable()

        where:

            throw new RuntimeException(e);
        }
        return this;
    }

    public TestFile makeUnreadable() {
        boolean success = setReadable(false, false);
        assert success;
        assert !Files.isReadable(toPath());
        return this;
    }

    public TestFile makeReadable() {
        boolean success = setReadable(true, false);
        assert success;

        }
        task check {
            doLast {
                assert gradle.gradleVersion == '${otherVersion.version.version}'
            }
        }"""
        otherVersion.binDistribution.makeReadable()
        executer.withTasks('wrapper').run()

        when:
        toolingApi.withConnector { connector ->
            connector.useBuildDistribution()
        }