mtu, _, ok := dtoi(mtustr)
	if !ok {
		return nil, errors.New("invalid status file of interface: " + ifcstat)
	}
	ifc.MTU = mtu

	// Not a loopback device ("/dev/null") or packet interface (e.g. "pkt2")
	if stringslite.HasPrefix(device, netdir+"/") {
		deviceaddrf, err := open(device + "/addr")
		if err != nil {
			return nil, err
		}
		defer deviceaddrf.close()

		line, ok = deviceaddrf.readLine()

go test -c -o $devnull ./...

rm pkg1.test$GOEXE
rm pkg2.test$GOEXE
go test -o . ./pkg/...
exists -exec pkg1.test$GOEXE
exists -exec pkg2.test$GOEXE

-- go.mod --
module example

-- pkg/pkg1/pkg1_test.go --
package pkg1

-- pkg/pkg2/pkg2_test.go --
package pkg2

-- anotherpkg/pkg1/pkg1_test.go --

-- go.mod --
module m

go 1.16
-- pkg1/a.go --
package pkg1

import "fmt"

func F() {
	fmt.Println("pkg1")
}
-- pkg2/a.go --
package pkg2

import "fmt"

func F() {
	fmt.Println("pkg2")
}
-- pkg2/a_test.go --
package pkg2
-- pkg3/a.go --
package pkg3

import "fmt"

func F() {
	fmt.Println("pkg3")
}
-- pkg3/a_test.go --
package pkg3

	}

	CheckPet(t, pet, pet)

	// Find
	var pet2 Pet
	DB.Find(&pet2, "id = ?", pet.ID)
	DB.Model(&pet2).Association("Toy").Find(&pet2.Toy)
	CheckPet(t, pet2, pet)

	// Count
	AssertAssociationCount(t, pet, "Toy", 1, "")

	// Append
	toy := Toy{Name: "toy-has-one-append"}

	if err := DB.Model(&pet2).Association("Toy").Append(&toy); err != nil {

		{"GET", "", "/a/b/c/d", "", nil},
	})

	// A pattern ending in a single wildcard should not match a trailing slash URL.
	pat2 := "/a/b/{w}"
	test(buildTree(pat2), []testCase{
		{"GET", "", "/a/b", "", nil},
		{"GET", "", "/a/b/", "", nil},
		{"GET", "", "/a/b/c", pat2, []string{"c"}},
		{"GET", "", "/a/b/c/d", "", nil},
	})

	// A pattern ending in a multi wildcard should match both URLs.

	const src = "package p; type T[P any] int"
	pkg1 := mustTypecheck(src, nil, nil)
	pkg2 := mustTypecheck(src, nil, nil)
	// We consider T1 and T2 to be distinct types, so their instances should not
	// be deduplicated by the context.
	T1 := pkg1.Scope().Lookup("T").Type().(*Named)
	T2 := pkg2.Scope().Lookup("T").Type().(*Named)
	ctxt := NewContext()
	res1, err := Instantiate(ctxt, T1, []Type{Typ[Int]}, false)

        def packagePrefixes = [ 'allowed.pkgprefix1.', 'allowed.pkgprefix2' ]
        def disallowedPackagePrefixes = [ 'disallowed.pkgprefix1.', 'disallowed.pkgprefix2.' ]
        def packageNames = [ 'allowed.pkg1', 'allowed.pkg2' ]
        def resourceNames = [ 'allowed.resource1', 'allowed.resource2' ]
        def resourcePrefixes = [ 'allowed.resourcePrefix1.', 'allowed.resourcePrefix2.' ]

var testResetConfig = fmt.Sprintf(`apiVersion: %s
kind: ResetConfiguration
force: true
dryRun: true
cleanupTmpDir: true
criSocket: %s:///var/run/fake.sock
certificatesDir: /etc/kubernetes/pki2
ignorePreflightErrors:
- a
- b
`, kubeadmapiv1.SchemeGroupVersion.String(), defaultURLScheme)

func TestNewResetData(t *testing.T) {
	// create temp directory
	tmpDir, err := os.MkdirTemp("", "kubeadm-reset-test")

        then:
        executedAndNotSkipped(":lib:compileScala", ":compileScala")

        when:
        file("lib/src/main/scala/pkg1/Other.scala").delete()
        file("lib/src/main/scala/pkg2/Other.scala") << """
            package pkg2

            class Other
        """
        fails ':build'

        then:
        executedAndNotSkipped(":lib:compileScala", ":compileScala")

        def packagePrefixes = [ 'allowed.pkgprefix1.', 'allowed.pkgprefix2' ]
        def disallowedPackagePrefixes = [ 'disallowed.pkgprefix1.', 'disallowed.pkgprefix2.' ]
        def packageNames = [ 'allowed.pkg1', 'allowed.pkg2' ]
        def resourceNames = [ 'allowed.resource1', 'allowed.resource2' ]
        def resourcePrefixes = [ 'allowed.resourcePrefix1.', 'allowed.resourcePrefix2.' ]