{
		merged: `
yaml: foo
---
bar: boo
`,
		split: []string{
			`
yaml: foo
`,
			`bar: boo
`,
		},
	},
	{
		merged: `
yaml: foo
---
bar: boo
`,
		split: []string{
			`
yaml: foo
`,
			``,
			`bar: boo
`,
		},
	},
	{
		merged: `
yaml: foo
---
bar: boo`,
		split: []string{
			`
yaml: foo`,
			`bar: boo`,
		},
	},
}

                        throw new RuntimeException("Boo!")
                    }
                    outFile << "xxx"
                }
            }
        """

        expect:
        succeeds "foo"

        when:
        file("out.txt") << "force rerun"
        fails "foo"
        then:
        failureHasCause "Boo!"

        when:
        fails "foo", "--info"
        then:

        withExtension("/some/path/to/foo.baz", ".bar") == "/some/path/to/foo.bar"
        withExtension("\\some\\path\\to\\foo.baz", ".bar") == "\\some\\path\\to\\foo.bar"
        withExtension("/some/path/to/foo.boo.baz", ".bar") == "/some/path/to/foo.boo.bar"
        withExtension("/some/path/to/foo.bar", ".bar") == "/some/path/to/foo.bar"
    }

    def "can determine if one path start with another"(String path, String startsWithPath, boolean result) {

                    throw new RuntimeException("Boo!");
                }
            }
        """
        file("src/test/java/org/gradle/OtherTest.java") << """
            package org.gradle;
            ${testFrameworkImports}
            public class OtherTest {
                @Test public void pass() {}
                @Test public void fail() { throw new RuntimeException("Boo!"); }
            }
        """

				Proto:        "google.protobuf.Empty",
			},
			expectError: true,
		},
		{
			name: "invalid proto",
			b: Builder{
				Kind:         "Boo",
				Plural:       "Boos",
				ProtoPackage: "github.com/gogo/protobuf/types",
				Proto:        "boo",
			},
			expectError: true,
		},
	}

	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			g := NewWithT(t)

        }
        generator.xmlWriter.write(fooTest, _) >> { throw new IOException("Boo!") }

        when:
        generator.generate()

        then:
        def ex = thrown(MultipleBuildOperationFailures)
        ex.causes.size() == 1
        ex.causes[0].message.startsWith('Could not write XML test results for FooTest')
        ex.causes[0].cause.message == "Boo!"
    }

        file("src/test/java/FooTest.java") << """
            public class FooTest {
                @org.junit.Test public void passes() {}
                @org.junit.Test public void fails() { throw new RuntimeException("Boo!"); }
            }
        """

        when:
        withConnection { it.newBuild().withArguments('test', '--tests', 'FooTest.passes').run() }

        then:
        noExceptionThrown()
    }

        def requested = DefaultModuleComponentSelector.newSelector(mid, new DefaultMutableVersionConstraint("1.0"))
        def failure = new ModuleVersionResolveException(newSelector(mid, "1.2"), new RuntimeException("Boo!"))

        def failed = Mock(DependencyGraphEdge) {
            getSelector() >> Stub(DependencyGraphSelector) {
                getResultId() >> 4L
                getRequested() >> requested
            }

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    foo: boo
  name: scale-3
spec:
  replicas: 1
  selector:
    matchLabels:
      run: hello
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      labels:
        run: hello
    spec:
      containers:
      - image: aronchick/hello-node:2.0

        1 * clientsManager.reserveIdleClient(options) >> client

        then:
        1 * buildOperationRunner.call(_) >> { args -> args[0].call() }
        1 * client.execute(spec) >> { throw new RuntimeException("Boo!") }

        then:
        thrown(RuntimeException)
        1 * clientsManager.release(client)
    }

    def "build operation is started and finished when client is executed"() {
        when: