}

	for _, test := range tests {
		err := v.Validate(getPodWithProfile(test.profile))
		if test.expectValid {
			assert.NoError(t, err, "Pod with profile %q should be valid", test.profile)
		} else {
			assert.Error(t, err, fmt.Sprintf("Pod with profile %q should trigger a validation error", test.profile))
		}
	}

	// Test multi-container pod.
	pod := &v1.Pod{

        assertEquals("test.sh", list.get(0));
        assertEquals("test1 ' test2", list.get(1));

        cmd = "test.sh 'test1 \" test2'";
        params.clear();
        list = extractor.parseCommand(cmd, params);
        assertEquals(2, list.size());
        assertEquals("test.sh", list.get(0));
        assertEquals("test1 \" test2", list.get(1));

        cmd = "test.sh $INPUT_FILE";
        params.clear();

		fmt.Sprintf(DestinationHost, "test", 0, 0),
		fmt.Sprintf(MirrorHost, 0),
		fmt.Sprintf(VSGateway, 0),
		fmt.Sprintf(URISchemeMethodAuthorityRegexMatch, 0, 0, "test"),
		fmt.Sprintf(HeaderAndQueryParamsRegexMatch, 0, 0, "test", "test"),
		fmt.Sprintf(AllowOriginsRegexMatch, 0, 0),
		fmt.Sprintf(WorkloadSelector, "test"),
		fmt.Sprintf(PortInPorts, 0),
		fmt.Sprintf(FromRegistry, "test", 0),
		fmt.Sprintf(ImageInContainer, 0),

	for _, test := range tests {
		t.Run("", func(t *testing.T) {
			args := []string{"operator", "init", "--dry-run"}
			if test.operatorNamespace != "" {
				args = append(args, "--operatorNamespace", test.operatorNamespace)
			}
			if test.watchedNamespaces != "" {
				args = append(args, "--watchedNamespaces", test.watchedNamespaces)
			}

			kubeClientFunc = func() (kube.CLIClient, error) {
				return nil, nil
			}

[short] skip

# test fail fast
! go test ./failfast_test.go -run='TestFailingA' -failfast=true
stdout -count=1 'FAIL - '
! go test ./failfast_test.go -run='TestFailing[AB]' -failfast=true
stdout -count=1 'FAIL - '
! go test ./failfast_test.go -run='TestFailing[AB]' -failfast=false
stdout -count=2 'FAIL - '

# mix with non-failing tests
! go test ./failfast_test.go -run='TestA|TestFailing[AB]' -failfast=true
stdout -count=1 'FAIL - '

        where:
        path1    | path2    | test1   | test2   | expectedEntries
        '/pathA' | '/pathA' | 'false' | 'false' | [[path: '/pathA', test: 'false']]
        '/pathA' | '/pathA' | 'false' | 'true'  | [[path: '/pathA', test: 'false']]
        '/pathA' | '/pathA' | 'true'  | 'false' | [[path: '/pathA', test: 'false']]

svn propset svn:date 2017-09-27T17:48:18.350817Z --revprop -r4

cd git-README-only
git remote set-url origin https://vcs-test.golang.org/git/README-only
cd ..
replace 'vcs-test.swtch.com' 'vcs-test.golang.org' other/pkg.go
replace 'vcs-test.swtch.com' 'vcs-test.golang.org' pkg.go
svn commit -m 'move from vcs-test.swtch.com to vcs-test.golang.org'
svn propset svn:author rsc --revprop -r5
svn propset svn:date 2017-10-04T15:08:26.291877Z --revprop -r5

        executer.withRepositoryMirrors()
    }

    def "uses test filter"() {
        when:
        inDirectory(sample.dir)
        run("test")

        then:
        def result = new DefaultTestExecutionResult(sample.dir)
        result.assertTestClassesExecuted("SomeIntegTest", "SomeOtherTest")
        result.testClass("SomeIntegTest").assertTestsExecuted("test1", "test2")

	go func() {
		if err := http.Serve(unixListener, mux); err != nil {
			t.Error(err)
		}
	}()

	{
		t.Log("test sending normal log")

		WithLabels("k", "v").Info("test")
		Warn("test2")
		Sync()

		// There should be two messages received at server
		// {"msg":"test","k":"v"}
		// {"msg":"test2"}
		if got, want := len(srv.messages), 2; got != want {
			t.Fatalf("number received log messages got %v want %v", got, want)

    private static final String TESTNG_VERSION = '6.3.1'
    private static final String TESTNG_ANNOTATION = 'org.testng.annotations.Test'
    private static final String TEST_CLASS_1 = 'Test1'
    private static final String TEST_CLASS_2 = 'Test2'

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    def setup() {
        executer.withConsole(ConsoleOutput.Rich)