func sendSomeSignals() {
	done := make(chan struct{})
	go func() {
		spin()
		close(done)
	}()
	winch()
	<-done
}

// testPipe tests pipe operations.
func testPipe(wg *sync.WaitGroup) {
	r, w, err := os.Pipe()
	if err != nil {
		log.Fatal(err)
	}
	if err := syscall.SetNonblock(int(r.Fd()), false); err != nil {
		log.Fatal(err)
	}

// license that can be found in the LICENSE file.

package net_test

import (
	"io"
	"net"
	"testing"
	"time"

	"golang.org/x/net/nettest"
)

func TestPipe(t *testing.T) {
	nettest.TestConn(t, func() (c1, c2 net.Conn, stop func(), err error) {
		c1, c2 = net.Pipe()
		stop = func() {
			c1.Close()
			c2.Close()
		}
		return
	})
}

    def "copying files to a directory with named pipes fails"() {
        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}'
            }
        """

        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)

    @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)

        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;
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package gradlebuild.basics.testing

import org.gradle.api.tasks.testing.Test


enum class TestType(val prefix: String, val executers: List<String>) {
    INTEGRATION("integ", listOf("embedded", "forking", "noDaemon", "parallel", "configCache", "isolatedProjects")),
    CROSSVERSION("crossVersion", listOf("embedded", "forking"))
}

                        testType = TestSuiteType.INTEGRATION_TEST

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

        expect:
        succeeds "outgoingVariants"

    def "init"() {
        given:
        def task1 = Mock(Task)
        def task2 = Mock(Task)

        when:
        def publishArtifact = new DefaultPublishArtifact(testName, testExt, testType,
                testClassifier, date, testFile, task1, task2)
        then:
        publishArtifact.buildDependencies.getDependencies(null) == [task1, task2] as Set
        assertCommonPropertiesAreSet(publishArtifact, true)
    }

    }

    protected void assertCommonPropertiesAreSet(PublishArtifact artifact, boolean shouldHaveClassifier) {
        assert testName == artifact.name
        assert testType == artifact.type
        assert testExt == artifact.extension
        assert testFile == artifact.file
        if (shouldHaveClassifier) {
            assert testClassifier == artifact.classifier
        }
    }