configurationContainer.newConf.is(configuration)
    }

    def addsNewConfigurationWithClosureWhenConfiguringSelf() {
        when:
        String someDesc = 'desc1'
        configurationContainer.configure {
            newConf {
                description = someDesc
            }
        }

        then:

    SDS/kubernetes://test:
LDS/:
`,
		},
	}
	for _, item := range descs {
		desc := item // avoid refer to on-stack-var
		expected := make(map[string]*discovery.DeltaDiscoveryResponse)
		for _, response := range item.serverResponses {
			expected[response.TypeUrl] = response
		}
		tc := testCase{
			desc:     desc.desc,
			inClient: NewDeltaWithBackoffPolicy("", &DeltaADSConfig{}, nil),

		// todo tests for listeners, clusters, eds, and routes, not sure how to do this.
	}

	for _, item := range descs {
		desc := item // avoid refer to on-stack-var
		expected := map[string]*discovery.DiscoveryResponse{}
		for _, request := range desc.initialRequests {
			if desc.excludedResource != "" && request.TypeUrl == desc.excludedResource {
				continue
			}
			expected[request.TypeUrl] = &discovery.DiscoveryResponse{

        String field1

        @Option(description = "Descr Field2")
        String field2

        @Option(description = "Descr Field3")
        TestEnum field3

        @Option(description = "Descr Field4")
        boolean field4

        @Option(description = "Descr Field5")
        Integer field5

        @Option(description = "Descr Field6")
        List<TestEnum> field6

			}
		})
	}
}

func hollowPodsWithIndexPhase(descs []indexPhase) []*v1.Pod {
	pods := make([]*v1.Pod, 0, len(descs))
	for _, desc := range descs {
		p := &v1.Pod{
			Status: v1.PodStatus{
				Phase: desc.Phase,
			},
		}
		if desc.Index != noIndex {
			p.Annotations = map[string]string{
				batch.JobCompletionIndexAnnotation: desc.Index,
			}
		}
		pods = append(pods, p)
	}

        when:
        run "help", "--task", "hello"

        then:
        output.contains """
Options
     --valueA     descA

     --no-valueA     Disables option --valueA.

     --valueB     descB

     --no-valueB     Disables option --valueB.

     --valueC     descC

     --no-valueC     Disables option --valueC."""
    }

	testCases := []struct {
		desc string
		in   *apiserver.KMSConfiguration
		want field.ErrorList
	}{{
		desc: "valid v1 api version",
		in:   &apiserver.KMSConfiguration{APIVersion: "v1"},
		want: field.ErrorList{},
	}, {
		desc: "valid v2 api version",
		in:   &apiserver.KMSConfiguration{APIVersion: "v2"},
		want: field.ErrorList{},
	}, {
		desc: "invalid api version",

a:
  nk1:
    nk2: nv2
`,
		},
		{
			desc:      "DeleteMapEntry",
			path:      `a.b`,
			wantFound: true,
			want: `
a: {}
`,
		},
		{
			desc:      "path not found",
			path:      `a.c.[name:n2].list.[:v3]`,
			wantFound: false,
			wantErr:   `path not found at element c in path a.c.[name:n2].list.[:v3]`,
		},
		{
			desc:      "error key",
			path:      `a.b.[].list`,

                .desc("Define a user property")
                .build());
        options.addOption(Option.builder(Character.toString(OFFLINE))
                .longOpt("offline")
                .desc("Work offline")
                .build());
        options.addOption(Option.builder(Character.toString(VERSION))
                .longOpt("version")
                .desc("Display version information")

	testCases := []struct {
		desc              string
		src               io.Reader
		size              int64
		actualSize        int64
		md5hex, sha256hex string
		err               error
	}{
		0: {
			desc:       "Success, no checksum verification provided.",
			src:        bytes.NewReader([]byte("abcd")),
			size:       4,
			actualSize: 4,
		},
		{
			desc:       "Failure md5 mismatch.",