}
                }
            }
        """.stripIndent()
        file('src/test/java/org/gradle/Unloadable.java') << """
            package org.gradle;

            ${testFrameworkImports}

            public class Unloadable {
                static {
                    fail("failed");
                }

                @Test
                public void ok() {

    String pluralCategoryOrTagName = "categories"

    @Override
    boolean supportsCategoryOnNestedClass() {
        return !(version in ['4.10', '4.11', '4.12'])
    }

    def 'reports unloadable #type'() {
        given:
        testSources.with {
            testClass('SomeTestClass').with {
                testMethod('ok1')
                testMethod('ok2')
            }
        }

                Gradle Central Plugin Repository(${pluginRepo.uri})
        """.stripIndent().trim()))
        failure.assertHasLineNumber(2)
    }

    def "failure due to plugin class is unloadable"() {
        when:
        pluginBuilder.with {
            addUnloadablePlugin(PLUGIN_ID, "OtherPlugin")
            publishAs(GROUP, ARTIFACT, VERSION, pluginRepo, executer).allowAll()
        }

        addPluginSource(id, className, """
            ${packageName ? "package $packageName" : ""}

            class $className implements $Plugin.name<$Project.name> {
                static { throw new Exception("unloadable plugin class") }
                void apply($Project.name project) {
                }
            }
        """)
        this
    }

        skipped(":mySubclassOfUntrackedTask")
    }

    @Requires(UnitTestPreconditions.FilePermissions)
    def "untracked tasks can produce and consume unreadable content"() {
        def rootDir = file("build/root")
        def unreadableDir = rootDir.file("unreadable")

        buildFile generateProducerTask(true)
        buildFile generateConsumerTask(true)

        buildFile("""

        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

plugins {
    id 'war'
}

tasks.register("deployToTomcat", Copy) {
    from war
    into layout.projectDirectory.dir('tomcat/webapps')
    doNotTrackState("Deployment directory contains unreadable files")

plugins {
    war
}

tasks.register<Copy>("deployToTomcat") {
    from(tasks.war)
    into(layout.projectDirectory.dir("tomcat/webapps"))
    doNotTrackState("Deployment directory contains unreadable files")

    private static final Logger LOG = Logging.getLogger(DaemonRegistryUnavailableExpirationStrategy.class);
    public static final String REGISTRY_BECAME_UNREADABLE = "after the daemon registry became unreadable";
    public static final String REGISTRY_ENTRY_UNEXPECTEDLY_LOST = "after the daemon was no longer found in the daemon registry";

		if err != nil {
			fmt.Printf("unreadable on source: %s (%s)\n", srcCtnt.Key, err)
			sourceFailed = true
		} else if srcSize != srcCtnt.Size {
			fmt.Printf("unreadable on source - size differs upon read: %s\n", srcCtnt.Key)
			sourceFailed = true
		}
	}()
	go func() {
		defer wg.Done()
		tgtSize, err := io.Copy(tgtSha256, tobj)
		if err != nil {
			fmt.Printf("unreadable on target: %s (%s)\n", tgtCtnt.Key, err)