volumes, err := pvIndex.listByAccessModes(modes)
		if err != nil {
			return nil, err
		}

		bestVol, err := volume.FindMatchingVolume(claim, volumes, nil /* node for topology binding*/, nil /* exclusion map */, delayBinding)
		if err != nil {
			return nil, err
		}

		if bestVol != nil {
			return bestVol, nil
		}
	}
	return nil, nil
}

grep 'BUILTIN\\Guests\s+Allow' $WORK\guest-acl.txt

# The file written to the ordinary directory should not.
! grep 'BUILTIN\\Guests\s+Allow' $WORK\exe-acl.txt


-- TestACL/go.mod --
module TestACL
-- TestACL/main.go --
package main

	close(afterSubTest)
	<-afterSecondLog // Delay the "PASS: TestInterruptor" line until after "CONT  TestLog".
}

func TestLog(t *testing.T) {
	t.Parallel()

	t.Logf("this is the first TestLog log")
	close(afterFirstLog)
	<-afterSubTest
	t.Logf("this is the second TestLog log")
	close(afterSecondLog)

				InitExitCode:       126,
				InitTerminationMsg: "Died for some reason",
				LabelKey:           "testkey",
				LabelValue:         "testval",
			},
			wantLabels: map[string]string{workingPod.Name: "", workingPodDiedPreviously.Name: "", brokenPodWaiting.Name: "testkey=testval"},
			wantCount:  1,
			wantTags:   map[string]string{"result": resultSuccess, "type": labelType},
		},
		{
			name:   "With already labeled pod",

				},
				Origin: fakeOrigin{},
			},
		},
	}
	a := ValidationAnalyzer{s: testSchema}
	a.Analyze(ctx)
}

func TestSchemaValidationWrapper(t *testing.T) {
	testCol := gvk.VirtualService

	m1 := &v1alpha3.VirtualService{}
	m2 := &v1alpha3.VirtualService{}
	m3 := &v1alpha3.VirtualService{}

// expected-remark@below {{Tac filter (1) specified but not applied to any op}}
// expected-remark@below {{Tac filter (2): filter type: op filter, filter_pattern: "^test_op"}}
// expected-remark@below {{Tac filter (2) specified but not applied to any op}}
module {
  // CHECK-LABEL: testFunctionSkiped
  // expected-remark@+1 {{filtered by tac filter (0)}}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package testlog

import (
	"sync"
	_ "unsafe" // for linkname
)

// PanicOnExit0 reports whether to panic on a call to os.Exit(0).
// This is in the testlog package because, like other definitions in
// package testlog, it is a hook between the testing package and the
// os package. This is used to ensure that an early call to os.Exit(0)

	case "openbsd", "freebsd", "aix":
		t.Skipf("%v does not support reading deleted binary name", runtime.GOOS)
	}
	t.Parallel()

	dir := t.TempDir()

	src := filepath.Join(dir, "testdel.go")
	exe := filepath.Join(dir, "testdel.exe")

	err := os.WriteFile(src, []byte(testExecutableDeletion), 0666)
	if err != nil {
		t.Fatal(err)
	}

        testFile("src/main/java/Main.java") << "class Main {}"
        testFile("src/test/resources/test.resource") << "test resource"
        testFile("src/test/java/TestFoo.java") << """
        public class TestFoo {
            @org.junit.Test
            public void test() {}
        }
        """

        when:
        executer.withTasks("build").run()

        then:

    }

    void theSuiteFiles() {
        file("src/test/java/FooTest.java") << """
            ${testFrameworkImports}
            public class FooTest {
                @Test
                public void testFoo() { }
            }
        """
        file("src/test/java/FooServerTest.java") << """
            ${testFrameworkImports}
            public class FooServerTest {
                @Test