logging.captureStandardOutput(LogLevel.ERROR)
println 'error message'
assert gradle != null
assert initscript.classLoader == getClass().classLoader.parent
assert initscript.classLoader == Thread.currentThread().contextClassLoader
Gradle.class.classLoader.loadClass('${implClassName}')
try {
    initscript.classLoader.loadClass('${implClassName}')
    assert false: 'should fail'
} catch (ClassNotFoundException e) {
    // expected

        def receivedCommand = receivedCommand()
        assert receivedCommand instanceof ForwardInput
        assert receivedCommand.bytes == expected.bytes
        true
    }

    def receiveUserResponse(String expected) {
        def receivedCommand = receivedCommand()
        assert receivedCommand instanceof UserResponse
        assert receivedCommand.response == expected
        true
    }

        def executor = unwrapExecutor(runnable)
        assert executor instanceof SingleUseDaemonClient
    }

    private Runnable unwrapAction(Action<?> action) {
        assert action instanceof Actions.RunnableActionAdapter
        return action.runnable
    }

    private BuildActionExecutor unwrapExecutor(Runnable runnable) {
        assert runnable instanceof RunBuildAction
        return runnable.executor
    }

		}),
	}

	client := kube.NewFakeClient(nss...)
	expected := sets.New[string]("default", "no-ambient")
	actual, err := getNamespaces(context.TODO(), client, "istio-system")
	assert.NoError(t, err)
	for _, ns := range actual {
		assert.Equal(t, true, expected.Contains(ns.Name))
	}
}

func Test_injectionDisabled(t *testing.T) {
	cases := []struct {
		name     string
		pod      *corev1.Pod
		expected bool

        this.errForwarder = new Forwarder(processor, TestOutputEvent.Destination.StdErr);
    }

    public void startRedirecting() {
        assert outForwarder.outputOwner != null;
        assert errForwarder.outputOwner != null;

        redirector.redirectStandardOutputTo(outForwarder);
        redirector.redirectStandardErrorTo(errForwarder);
        redirector.start();
    }

		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			jsonPatch, err := jsonpatch.DecodePatch(tc.patch)
			assert.NoError(t, err, "unexpected error decode patch")
			actual, err := jsonPatchAnnotationValue(tc.config, tc.webhook, jsonPatch)
			assert.NoError(t, err, "unexpected error getting json patch annotation")
			if actual != tc.expected {

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

package com.example;

import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class LumberJackTest {
    @Test
    public void singsTheSong() {
        LumberJack jack = new LumberJack();
        jack.sing();
    }

                                        assert testFramework instanceof ${JUnitTestFramework.canonicalName}
                                        // .collect() is intentional for a better error message on failure
                                        // The 6 elements are: junit, hamcrest, test classes and resources, main classes and resources
                                        assert classpath.collect().size() == 6

                def compileClasspathNames = displayNamesOf(configurations.compileClasspath)
                doLast {
                    assert runtimeClasspathNames.get().find { it == 'io.reactivex:rxjava:1.0.1' }
                    assert !compileClasspathNames.get().find { it == 'io.reactivex:rxjava:1.0.1' }
                }
            }
        """

        when:

            public class IncludedTest {
                @org.junit.Test
                public void foo() {
                     org.junit.Assert.assertEquals(1, 1);
                }
                @org.junit.Test
                public void foo2() {
                     org.junit.Assert.assertEquals(1, 1);
                }
            }
        """
        file("included-build/src/test/java/example/IncludedTest2.java").text = """