stat.length == 0
        assertSameAccessType(stat, VIA_SYMLINK)
    }

    @Requires(UnitTestPreconditions.UnixDerivative)
    def "stats named pipes"() {
        def pipe = tmpDir.file("testPipe").createNamedPipe()

        when:
        accessor.stat(pipe)
        then:
        thrown(UncheckedIOException)
    }

    @Requires(UnitTestPreconditions.FilePermissions)

        new TestFileHelper(this).tgzTo(tarFile, readOnly);
        return this;
    }

    public TestFile tbzTo(TestFile tarFile) {
        return tbzTo(tarFile, false);
    }

    public TestFile tbzTo(TestFile tarFile, boolean readOnly) {
        new TestFileHelper(this).tbzTo(tarFile, readOnly);
        return this;
    }

                        testType = TestSuiteType.INTEGRATION_TEST

                        dependencies {
                            implementation project()
                        }
                    }
                }
            }
            """.stripIndent()

        expect:
        succeeds "outgoingVariants"

                def testFile = file("$buildDir/out.txt")
                outputs.file testFile
                executable = org.gradle.internal.jvm.Jvm.current().getJavaExecutable()
                args '-cp', sourceSets.main.runtimeClasspath.asPath, 'org.gradle.TestMain', projectDir, testFile
                doLast {
                    assert testFile.exists()
                }
            }

	n, err := w.Write(data)
	if err != nil {
		t.Errorf("write: %v", err)
	}
	if n != len(data) {
		t.Errorf("short write: %d != %d", n, len(data))
	}
	c <- 0
}

// Test a single read/write pair.
func TestPipe1(t *testing.T) {
	c := make(chan int)
	r, w := Pipe()
	var buf = make([]byte, 64)
	go checkWrite(t, w, []byte("hello, world"), c)
	n, err := r.Read(buf)
	if err != nil {
		t.Errorf("read: %v", err)

    TestFile getSha512File(TestFile file) {
        getHashFile(file, Hashing.sha512())
    }

    TestFile sha512File(TestFile file) {
        hashFile(file, Hashing.sha512())
    }

    TestFile getMd5File(TestFile file) {
        getHashFile(file, Hashing.md5())
    }

    TestFile md5File(TestFile file) {
        hashFile(file, Hashing.md5())
    }

        }
        return new ReleasedGradleDistribution(version, previousVersionDir.file(version));
    }

    protected static TestFile file(String propertyName, String defaultPath) {
        TestFile testFile = optionalFile(propertyName);
        if (testFile != null) {
            return testFile;
        }
        if (defaultPath == null) {

        testFile("build/classes/java/test/test.resource").assertDoesNotExist()

        testFile("build/classes/java/main/Main.class").assertExists()
        testFile("build/classes/java/test/TestFoo.class").assertExists()
    }

    @Test
    void generatesArtifactsWhenVersionIsEmpty() {
        testFile("settings.gradle") << "rootProject.name = 'empty'"
        def buildFile = testFile("build.gradle")

import org.gradle.test.fixtures.file.TestFile

class StaleOutputJavaProject {
    public final static String JAR_TASK_NAME = 'jar'
    private final TestFile testDir
    private final String projectPath
    private final String projectDir
    private final String buildDirName
    private final TestFile mainSourceFile
    private final TestFile redundantSourceFile
    private final TestFile mainClassFile

    }

    def "instrumentation for #factory preserves classes"() {
        given:
        def testFile = jar(testDir.file("thing.jar")) {
            manifest {}
            entry("Foo.class", classOne())
        }

        expect:
        with(transformJar(factory, testFile)) {
            if (expectManifest) {
                assertManifestPresentAndFirstEntry()
            }