[short] skip 'runs a test that hangs until its WaitDelay expires'

! go test -v -timeout=1m .

	# After the test process itself prints PASS and exits,
	# the kernel closes its stdin pipe to to the orphaned subprocess.
	# At that point, we expect the subprocess to print 'stdin closed'
	# and periodically log to stderr until the WaitDelay expires.
	#

    factory: (Int) -> T
): T {
    val size = readSmallInt()
    val container = factory(size)
    for (i in 0 until size) {
        val element = read()
        if (element === CircularReferenceMarker.INSTANCE) {
            // upon reading a circular reference, wait until all objects have been initialized
            // before inserting the elements in the resulting set.
            val remainingSize = size - i

    val size = readSmallInt()
    for (i in 0 until size) {
        readElement()
    }
}


inline fun <T, C : MutableCollection<T>> Decoder.readCollectionInto(
    containerForSize: (Int) -> C,
    readElement: () -> T
): C {
    val size = readSmallInt()
    val container = containerForSize(size)
    for (i in 0 until size) {
        container.add(readElement())
    }

    val builder = DefaultClassPath.builderWithExactSize(size)
    for (i in 0 until size) {
        builder.add(readFile())
    }
    return builder.build()
}


internal
fun Decoder.readTransformedClassPath(): ClassPath {
    val size = readSmallInt()
    val builder = TransformedClassPath.builderWithExactSize(size)
    for (i in 0 until size) {
        builder.add(readFile(), readFile())
    }
    return builder.build()

[short] skip

# This test could fail if the testing package does not wait until
# a panicking test does the panic. Turn off multithreading and GC
# to increase the probability of such a failure.
env GOMAXPROCS=1
env GOGC=off

# If the test exits with 'no tests to run', it means the testing package
# implementation is incorrect and does not wait until a test panic.
# If the test exits with '(?s)panic: die.*panic: die', it means

	if isWorker() {
		sendGarbageToCoordinator(f)
		time.Sleep(3600 * time.Second) // pause until coordinator terminates the process
	}
	f.Fuzz(func(*testing.T, []byte) {})
}

func FuzzClosePipeAfter(f *testing.F) {
	f.Fuzz(func(t *testing.T, _ []byte) {
		if isWorker() {
			sendGarbageToCoordinator(t)
			time.Sleep(3600 * time.Second) // pause until coordinator terminates the process
		}
	})
}
-- io_error_windows_test.go --

        verify(dependencies).add(eq("classpath"), eq(notation))
        verify(dependencies).addProvider(eq("classpath"), eq(notation), any<Action<ExternalModuleDependency>>())
        // Because it's a Provider, this isn't called until evaluation
        verify(dependency, never()).exclude(mapOf("module" to "com.google.guava"))
    }

    @Test
    fun `can use a provider convertible for the dependency declaration`() {

        with(rhs2.assigned) {
            assertIs<ObjectOrigin.NewObjectFromMemberFunction>(this)
            assertEquals("my2", function.simpleName)
        }
    }

    @Test
    fun `a local value cannot be used until assigned at top level`() {
        val resolution = schema.resolve(
            """
            my {
                my = m
            }

            val m = my1()

            my {
                my = m

                if (topLevelBlock.tokenText == identifier) {
                    state = State.SearchingBlockStart
                    inTopLevelBlock = topLevelBlock
                    blockIdentifier = tokenStart until tokenEnd
                    blockFirstAnnotation = annotationStart
                    return true
                }
            }
        }
        return false
    }

# Regression test for https://golang.org/issue/45127:
# Goroutines for completed parallel subtests should exit immediately,
# not block until earlier subtests have finished.

[short] skip

! go test .
stdout 'panic: slow failure'
! stdout '\[chan send'

-- go.mod --
module golang.org/issue45127

go 1.16
-- issue45127_test.go --
package main

import (
	"fmt"
	"runtime"
	"runtime/debug"
	"sync"
	"testing"
)