def m1 = ivyRepo.module("test", "test", "1.3")
        m1.artifact(name: "test-one", conf: "*")
        m1.artifact(name: "test-two", conf: "*")
        m1.publish()
        def m2 = ivyRepo.module("test", "test2", "2.3").dependsOn(m1).exclude(module: "test", artifact: "test-one")
        m2.publish()
        def m3 = ivyRepo.module("test", "test3", "3.4").dependsOn(m1).exclude(module: "test", artifact: "test-two")

                    System.out.println("Test2.afterClass()");
                }
            }
        """

        when: succeeds "test"

        then:
        outputContains("""
Test1.beforeClass()
Test1.test1()
Test1.test2()
Test1.afterClass()
""")
        outputContains("""
Test2.beforeClass()
Test2.test1()
Test2.test2()
Test2.afterClass()
""")
    }

go test -v -run Test -skip T skip_test.go
! stdout RUN
stdout '^ok.*\[no tests to run\]'

go test -v -skip T skip_test.go
! stdout RUN

go test -v -skip 1 skip_test.go
! stdout Test1
stdout RUN.*Test2
stdout RUN.*Test2/3

go test -v -skip 2/3 skip_test.go
stdout RUN.*Test1
stdout RUN.*Test2
stdout RUN.*ExampleTest1
! stdout Test2/3

go test -v -skip 2/4 skip_test.go
stdout RUN.*Test1
stdout RUN.*Test2

	}
	for _, test := range tl {
		if test.got != test.exp {
			t.Errorf("On %v, expected '%v', but got '%v'",
				test.name, test.exp, test.got)
		}
	}
}

func TestPrintDeployment(t *testing.T) {

	testDeployment := apps.Deployment{
		ObjectMeta: metav1.ObjectMeta{
			Name:              "test1",
			CreationTimestamp: metav1.Time{Time: time.Now().Add(1.9e9)},

/*-----------------------------------------------------------------
 * CU_Test, CU_pTest
 *-----------------------------------------------------------------*/
/** CUnit test case data type.
 *  CU_Test is a double linked list of unit tests.  Each test has
 *  a name, a callable test function, and a flag for whether the 
 *  test is active and thus executed during a  test run.  A test 

    def "can have multiple test task instances"() {
        given:
        file('src/test/java/org/gradle/Test1.java') << """
            package org.gradle;
            ${testFrameworkImports}
            public class Test1 {
                @Test public void ok() { }
            }
        """.stripIndent()
        file('src/test2/java/org/gradle/Test2.java') << """
            package org.gradle;

go list -f '{{.Dir}}' example.com/test
stdout '^'$PWD${/}test'$'

-- go.work --
go 1.18

use (
	./test2
	./test2/sub
)
-- test/go.mod --
module example.com/test

go 1.18
-- test/file.go --
package test

func DoSomething() {
}
-- test2/go.mod --
module example.com/test2

go 1.18

replace example.com/test => ../test

require example.com/test v0.0.0-00010101000000-000000000000

def test_post_files(tmp_path):
    path = tmp_path / "test.txt"
    path.write_bytes(b"<file content>")
    path2 = tmp_path / "test2.txt"
    path2.write_bytes(b"<file content2>")

    client = TestClient(app)
    with path.open("rb") as file, path2.open("rb") as file2:
        response = client.post(
            "/files/",
            files=(
                ("files", ("test.txt", file)),
                ("files", ("test2.txt", file2)),

import XCTest

class SomeIntegTest: XCTestCase {
    public static var allTests = [
        ("test1", test1),
        ("test2", test2)
    ]
    func test1() {}
    func test2() {}

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

package main

func main() {
	test1()
	test2()
}

type I interface {
	f()
	g()
	h()
}

//go:noinline
func ld[T any]() {
	var x I
	if _, ok := x.(T); ok {
	}
}

func isI(x any) {
	_ = x.(I)
}

func test1() {
	defer func() { recover() }()
	ld[bool]() // add <bool,I> itab to binary
	_ = any(false).(I)
}