def result2 = new DefaultTestResult(FAILURE, 250, 300, 1, 0, 1, asList(org.gradle.api.tasks.testing.TestFailure.fromTestFrameworkFailure(new RuntimeException("Boo!"))))

        when:
        //simulating TestNG, where we don't receive beforeSuite for classes
        collector.beforeSuite(root)

        collector.beforeTest(test1)
        collector.beforeTest(test2)

    }

    def "handler can be closed and contended action does not run"() {
        when:
        int port = handler.reservePort();
        handler.start(10, { throw new RuntimeException("Boo!") })
        handler.stop()

        client.maybePingOwner(port, 10, "lock 1", 50000, null)

        then:
        noExceptionThrown()
    }

		{
			Meta: config.Meta{
				Namespace:       "default",
				Name:            "bar",
				ResourceVersion: "1",
			},
		},
		{
			Meta: config.Meta{
				Namespace:       "alternate",
				Name:            "boo",
				ResourceVersion: "1",
			},
		},
	}
	// cast our model.Configs to Resource because these types aren't compatible
	var myResources []status.Resource
	col := collections.VirtualService

		{
			versions:                        []string{"v1.2.3", "boo", "v0.3.0", "2.0.1"},
			expectedHighestSupportedVersion: "1.2.3",
			shouldFail:                      false,
		},
		{
			versions:                        []string{},
			expectedHighestSupportedVersion: "",
			shouldFail:                      true,
		},
		{
			versions:                        []string{"var", "boo", "foo"},
			expectedHighestSupportedVersion: "",

		urlNormalizer("http://example.com:80/foo?q=bar%20&baz=x+y#frag")
	}
}

func BenchmarkSrcsetFilter(b *testing.B) {
	for i := 0; i < b.N; i++ {
		srcsetFilterAndEscaper(" /foo/bar.png 200w, /baz/boo(1).png")
	}
}

func BenchmarkSrcsetFilterNoSpecials(b *testing.B) {
	for i := 0; i < b.N; i++ {
		srcsetFilterAndEscaper("http://example.com:80/foo?q=bar%20&baz=x+y#frag")
	}

    @Test public void pass() {}
    @Test public void pass2() {}
    @Test public void passSlowly() {}
    @Test public void passSlowly2() {}
    @Test public void fail() { throw new RuntimeException("Boo!") }
}
public class ATestClassWithSlowMethods {
    @Test public void pass() {}
    @Test public void passSlowly() {}
}

@RunWith(Suite.class)
@Suite.SuiteClasses([ATestClass.class, BTestClass.class])

                // but since integration tests are pretty slow we do both in one go, knowing that
                // configuration-level already has its own test
                conf.attributes.attribute(quality, 'boo')
            }

            dependencies {
                attributesSchema {
                    attribute(quality)
                }
                conf('org.test:module:$requested') {

			manifestShouldChange: true,
		},
		{
			description: "any wait error should result in a rollback and an abort 1",
			waitErrsToReturn: map[string]error{
				waitForHashes:        errors.New("boo! failed"),
				waitForHashChange:    nil,
				waitForPodsWithLabel: nil,
			},
			moveFileFunc:         os.Rename,
			expectedErr:          true,
			manifestShouldChange: false,
		},
		{

        node("c", ComponentSelectionReasons.of(ComponentSelectionReasons.CONFLICT_RESOLUTION))
        node("d")
        resolvedConf("a", [dep("a", "b"), dep("a", "c"), dep("a", "d", new RuntimeException("Boo!"))])
        resolvedConf("b", [])
        resolvedConf("c", [])
        resolvedConf("d", [])

        when:
        def deps = builder.getRoot(id("a")).dependencies

        then:

        def dep1 = node(2, "org", "dep1", "2.0", of(CONFLICT_RESOLUTION))
        root.outgoingEdges >> [
                dep(selector1, 1, 2),
                dep(selector2, 1, new RuntimeException("Boo!"))
        ]

        builder.start(root)

        builder.visitNode(root)
        builder.visitNode(dep1)
        builder.visitSelector(selector1)
        builder.visitSelector(selector2)