{
			name: "create slice from endpoints with labels and annotations",
			tweakEndpoint: func(ep *v1.Endpoints) {
				labels := map[string]string{"foo": "bar"}
				ep.Labels = labels
				annotations := map[string]string{"foo2": "bar2"}
				ep.Annotations = annotations
			},
			expectedSlice: discovery.EndpointSlice{
				ObjectMeta: metav1.ObjectMeta{
					Labels: map[string]string{
						"foo":                      "bar",

				{
					"foo": {Mode: 0644, Data: []byte("foo")},
					"bar": {Mode: 0644, Data: []byte("bar")},
				},
				{
					"foo": {Mode: 0400, Data: []byte("foo2")},
					"bar": {Mode: 0400, Data: []byte("bar2")},
				},
				{
					"foo": {Mode: 0600, Data: []byte("foo3")},
					"bar": {Mode: 0600, Data: []byte("bar3")},
				},
			},
		},
		{
			name: "update 2",
			payloads: []map[string]FileProjection{
				{

	testLabels := map[string]string{"key": "value"}

	foo3 := obj.DeepCopyObject()
	t.setObjectMeta(foo3, "foo3")
	foo4 := obj.DeepCopyObject()
	foo4Meta := t.getObjectMetaOrFail(foo4)
	foo4Meta.SetName("foo4")
	foo4Meta.SetNamespace(genericapirequest.NamespaceValue(ctx))
	foo4Meta.SetLabels(testLabels)

	objs := ([]runtime.Object{foo3, foo4})

	assignFn(objs)
	filtered := []runtime.Object{objs[1]}

          - backend:
              service:
                name: service1
                port:
                  number: 4200
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: foo2
  namespace: ns
spec:
  rules:
    - host: foohost.bar.com
      http:
        paths:
          - path: /second
            backend:
              service:
                name: service2

        launchTests { TestLauncher launcher ->
            launcher.withTaskAndTestMethods(':secondTest', "example.MyTest", ["foo2"])
        }
        then:
        assertTaskNotExecuted(":test")
        assertTaskExecuted(":secondTest")
        assertTestExecuted(className: "example.MyTest", methodName: "foo2", task: ":secondTest")
        assertTestNotExecuted(className: "example.MyTest", methodName: "foo")
    }

        then:
        events.testClassesAndMethods.size() == 5
        assertTestExecuted(className: 'example.MyTest', methodName: 'foo', task: ':secondTest')
        assertTestExecuted(className: 'example.MyTest', methodName: 'foo2', task: ':secondTest')
        assertTestExecuted(className: 'example2.MyOtherTest2', methodName: 'baz', task: ':secondTest')
    }

    def "can select test methods"() {
        when:

			expectedValue: "a1",
			expectedIdx:   0,
			startIdx:      0,
		},
		{
			testName:      "argument exists with empty value",
			args:          []Arg{{Name: "foo1", Value: ""}, {Name: "foo2", Value: ""}},
			name:          "foo2",
			expectedValue: "",
			expectedIdx:   1,
			startIdx:      -1,
		},
		{
			testName:      "argument does not exists",
			args:          []Arg{{Name: "foo", Value: "bar"}},

			Namespace: "foo-ns",
		},
		Spec: v1.PodSpec{
			Containers: []v1.Container{
				{
					Name:  "foo1",
					Image: "busybox",
				},
				{
					Name:  "foo2",
					Image: "busybox",
				},
				{
					Name:  "foo3",
					Image: "busybox",
				},
			},
		},
		Status: v1.PodStatus{
			ContainerStatuses: []v1.ContainerStatus{
				{
					ContainerID: "://id1",

                if ( trans.isSMB2() ) {
                    Smb2CreateRequest create = new Smb2CreateRequest(sess.getConfig(), "\\foocc");
                    create.setCreateDisposition(Smb2CreateRequest.FILE_OPEN_IF);
                    create.setRequestedOplockLevel(Smb2CreateRequest.SMB2_OPLOCK_LEVEL_BATCH);



                    try {

                fflush(stdout);
                return 0;
            }

            """),
            sourceFile("asm", "foo1/sum.s", getAsmSource("sum1")),
            sourceFile("asm", "foo2/sum.s", getAsmSource("sum2"))
        ]
    }

    @Override
    List<SourceFile> getHeaderFiles() {
        []
    }

    protected def getAsmSource(String methodName) {