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()
        }