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

        def outputDirectory = file("output").createDir()
        def pipe = outputDirectory.file("testPipe").createNamedPipe()

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

        when:

        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)

    def "tracked task producing named pipe fails"() {
        def rootDir = file("build/root")
        def namedPipe = rootDir.file("unreadable")
        rootDir.mkdirs()
        namedPipe.createNamedPipe()

        buildFile generateProducerTask(false)

        buildFile("""
            tasks.register("producer", Producer) {
                outputDir = project.layout.buildDirectory.dir("root")
            }

    @Issue("https://github.com/gradle/gradle/issues/2552")
    def "snapshotting named pipe fails"() {
        def rootDir = tmpDir.createDir("root")
        def pipe = rootDir.file("testPipe").createNamedPipe()

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

        then:
        def ex = thrown(UncheckedIOException)

        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
        clearCanonCaches();
        return this;
    }

    public TestFile createNamedPipe() {
        try {
            Process mkfifo = new ProcessBuilder("mkfifo", getAbsolutePath())
                .redirectErrorStream(true)
                .start();

	LHND                = LMEM_MOVEABLE | LMEM_ZEROINIT
	LPTR                = LMEM_FIXED | LMEM_ZEROINIT
	NONZEROLHND         = LMEM_MOVEABLE
	NONZEROLPTR         = LMEM_FIXED
)

// Constants for the CreateNamedPipe-family of functions.
const (
	PIPE_ACCESS_INBOUND  = 0x1
	PIPE_ACCESS_OUTBOUND = 0x2
	PIPE_ACCESS_DUPLEX   = 0x3

	PIPE_CLIENT_END = 0x0
	PIPE_SERVER_END = 0x1

//sys	CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile Handle) (handle Handle, err error) [failretval==InvalidHandle] = CreateFileW
//sys	CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error)  [failretval==InvalidHandle] = CreateNamedPipeW

	handle = Handle(r0)
	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
		err = errnoErr(e1)
	}
	return
}

func CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error) {