test5(c)
	wait()

	test6(c)
	wait()
}

// run all test with 4 buffser sizes
func main() {

	tests(0)
	tests(1)
	tests(10)
	tests(100)

	t := 4 * // buffer sizes
		(4*4 + // tests 1,2,3,4 channels
			8 + // test 5 channels
			12) * // test 6 channels
		76 // sends/recvs on a channel

	if tots != t || totr != t {
		print("tots=", tots, " totr=", totr, " sb=", t, "\n")
		os.Exit(1)

stdout '^ok$'  # 'go test' combines the test's stdout into stderr

go test -v .
! stdout panic
! stderr panic
stdout '^ok$'  # 'go test' combines the test's stdout into stderr

[cgo] go tool cgo main.go
[cgo] grep '//line .*'${/}'link'${/}'main\.go:1:1' _obj/main.cgo1.go
[cgo] ! grep 'uh-oh' _obj/main.cgo1.go

-- $WORK/go.mod --
module example
go 1.19
-- $WORK/main.go --
package main

import "C"

        found == ['test1', 'test2', 'test3', 'test4', 'system1', 'system2', 'system3', 'system4', 'DEFINED1', 'DEFINED2']
    }

    def "finds #directive surrounded by different whitespace"() {
        when:
        sourceFile << """
#include     "test1"
#include\t"test2"\t
\t#include\t"test3"
#include"test4"

#include     <system1>
#include\t<system2>\t
\t#include\t<system3>
#include<system4>
"""

import org.gradle.integtests.fixtures.SourceFile;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public abstract class TestApp extends TestNativeComponent {
    public abstract SourceFile getMainSource();
    public abstract SourceFile getLibraryHeader();
    public abstract List<SourceFile> getLibrarySources();

	t.tester = t.tester.ClusterScope()
	return t
}

func (t *Tester) Namer(namer func(int) string) *Tester {
	t.tester = t.tester.Namer(namer)
	return t
}

func (t *Tester) AllowCreateOnUpdate() *Tester {
	t.tester = t.tester.AllowCreateOnUpdate()
	return t
}

func (t *Tester) GeneratesName() *Tester {
	t.tester = t.tester.GeneratesName()
	return t
}

func (t *Tester) ReturnDeletedObject() *Tester {

    }

    /**
     * @throws Exception
     */
    @Test
    public void test4() throws Exception {
        DisposableUtil.add(new TestDisposable("a"));
        DisposableUtil.addFirst(new TestDisposable("b"));
        assertThat(DisposableUtil.disposables.size(), is(2));
        DisposableUtil.dispose();
        assertThat(count, is(2));
        assertThat(names, is("ab"));

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

package org.gradle.process.internal;

import java.util.Arrays;

public class TestApp {
    public static void main(String[] args) {
        System.out.print("output args: " + Arrays.asList(args));
        System.err.print("error args: " + Arrays.asList(args));
    }

//     in its Cancel function
//   - if the test has a deadline, adds a Context timeout and WaitDelay
//     for an arbitrary grace period before the test's deadline expires,
//   - fails the test if the command does not complete before the test's deadline, and
//   - sets a Cleanup function that verifies that the test did not leak a subprocess.

        Node root = session.collectDependencies(artifact);
        assertNotNull(root);
    }

    @Test
    void testResolveArtifactCoordinateDependencies() {
        DependencyCoordinate coord = session.createDependencyCoordinate(
                session.createArtifactCoordinate("org.apache.maven.core.test", "test-extension", "1", "jar"));

        List<Path> paths = session.resolveDependencies(coord);

    def setup() {
        buildFile << """
repositories {
    ivy {
        url '${ivyRepo.uri}'
    }
}

configurations {
    compile
}

dependencies {
    compile 'org.gradle.test:a:1.0'
}

task check(type: Sync) {
    from configurations.compile
    into 'libs'
}
"""
    }

    protected void succeedsDependencyResolution() {
        succeeds 'check'
    }