fx.WaitOrFail(t, "xds")

	sc.CreateOrUpdate(generateService("svc1", testNS, map[string]string{}, // labels
		map[string]string{}, // annotations
		[]int32{80},
		map[string]string{"app": "a"}, // selector
		"10.0.0.1",
	))
	fx.WaitOrFail(t, "xds")

	createOrUpdateNamespace(t, s, testNS, "")
	createOrUpdateNamespace(t, s, systemNS, "")

	tracker.WaitOrdered(testNS, systemNS)

						name:        "client-pod",
						namespace:   "test",
						ip:          "10.0.0.1",
						port:        80,
						clusterID:   "cluster-1",
						metaNetwork: "network-1",
					}
					// expect self
					client.ExpectWithWeight(client, "", xdstest.LocLbEpInfo{
						Weight: 1,
						LbEps: []xdstest.LbEpInfo{
							{Address: "10.0.0.1", Weight: 1},
						},
					})
					for subset, eps := range tc.expectations {

        setup:
        def customMetaDataProvider = Mock(ProcessMetaDataProvider)
        def processIdentifier = RandomStringUtils.randomAlphanumeric(1000)
        1 * customMetaDataProvider.processIdentifier >> processIdentifier
        def customManager = new DefaultFileLockManager(customMetaDataProvider, 5000, contentionHandler, generator)

        jar.manifest.mainAttributes.getValue('version') == "$expectedVersion"

        where:
        manifestContent << ["", "version: 0.0.1"]
        expectedVersion << ["1.0", "0.0.1"]
    }

    def "attribute value evaluates lazily"() {
        given:
        buildFile << """
            def versionNumber = objects.property(String)
            versionNumber.set("1.0")

			file:          "foo:x:101:bar:::\n",
			totalFields:   totalFieldsUser,
			expectedError: true,
		},
		{
			name:        "valid file for users",
			file:        "\nfoo:x:100:101:foo:/home/foo:/bin/bash\n\nbar:x:102:103:bar::\n",
			totalFields: totalFieldsUser,
			expectedEntries: []*entry{
				{name: "foo", id: 100, gid: 101, shell: "/bin/bash"},
				{name: "bar", id: 102, gid: 103},
			},

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

package shifts

func shifts0() {
	// basic constant shifts
	const (
		s = 10
		_ = 0<<0
		_ = 1<<s
		_ = 1<<- /* ERROR "negative shift count" */ 1
		// For the test below we may decide to convert to int
		// rather than uint and then report a negative shift
		// count instead, which might be a better error. The

                "sandbox": "%s"
            }
        ],
        "ips": [
            {
                "version": "4",
                "address": "10.0.0.2/24",
                "gateway": "10.0.0.1",
                "interface": 0
            }
        ],
        "routes": []

    },
    "plugin_log_level": "debug",
    "cni_event_address": "%s",
    "ambient_enabled": %t,
    "kubernetes": {

func resolverForTest(t test.Failer, xdsPort int, ns string) resolver.Builder {
	xdsresolver, err := xdsgrpc.NewXDSResolverWithConfigForTesting(
		GRPCBootstrap("foo", ns, "10.0.0.1", xdsPort))
	if err != nil {
		t.Fatal(err)
	}
	return xdsresolver
}

func init() {
	// Setup gRPC logging. Do it once in init to avoid races
	o := log.DefaultOptions()

	return reflect.ValueOf(m)
}

func (*clientKeyExchangeMsg) Generate(rand *rand.Rand, size int) reflect.Value {
	m := &clientKeyExchangeMsg{}
	m.ciphertext = randomBytes(rand.Intn(1000)+1, rand)
	return reflect.ValueOf(m)
}

func (*finishedMsg) Generate(rand *rand.Rand, size int) reflect.Value {
	m := &finishedMsg{}
	m.verifyData = randomBytes(12, rand)
	return reflect.ValueOf(m)
}

	}

	if err := r.Release(released); err != nil {
		t.Fatal(err)
	}

	err = r.Allocate(1)
	if _, ok := err.(*ErrNotInRange); !ok {
		t.Fatal(err)
	}

	if err := r.Allocate(10001); err != ErrAllocated {
		t.Fatal(err)
	}

	err = r.Allocate(20000)
	if _, ok := err.(*ErrNotInRange); !ok {
		t.Fatal(err)
	}

	err = r.Allocate(10201)
	if _, ok := err.(*ErrNotInRange); !ok {