cmdStr += " -o yaml"
	}
	out, err := p.Runner.RunCmd(cmdStr, "", p.KubeConfig, p.KubeContext, p.DryRun)
	return map[string]string{
		"secrets": out,
	}, err
}

// GetCRs returns CR contents for all CRDs in the cluster.
func GetCRs(p *Params) (map[string]string, error) {
	crds, err := getCRDList(p)
	if err != nil {
		return nil, err
	}

        dest.setBbb("bbb");
        dest.setDdd("ddd");

        BeanUtil.copyBeanToBean(src, dest);
        assertThat(dest.getAaa(), is("111"));
        assertThat(dest.getBbb(), is(nullValue()));
        assertThat(dest.getDdd(), is("ddd"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testCopy_BeanToBean_ExcludeNull() throws Exception {
        final MyClass src = new MyClass();

    def setup() {
        buildFile << """
            tasks.withType(JavaCompile) {
                options.fork = true
                options.forkOptions.executable = '${TextUtil.escapeString(AvailableJavaHomes.getJdk(JavaVersion.current()).javacExecutable)}'
            }
        """
    }

    def "changing an unused non-private constant incurs full rebuild"() {

	return f.abs
}

func (f *outputdirFlag) Set(value string) (err error) {
	if value == "" {
		f.abs = ""
	} else {
		f.abs, err = filepath.Abs(value)
	}
	return err
}

func (f *outputdirFlag) getAbs() string {
	if f.abs == "" {
		return base.Cwd()
	}
	return f.abs
}

// vetFlag implements the special parsing logic for the -vet flag:
// a comma-separated list, with distinguished values "all" and

    def configureForVersion(JavaVersion javaVersion) {
        String version = javaVersion.majorVersion

        def target = AvailableJavaHomes.getJdk(javaVersion)
        Assume.assumeNotNull(target)

        file("included/src/main/java/com/example/BlankPlugin.java") << """
            package com.example;

            import org.gradle.api.Plugin;

        profile.id(modelProfile.getId());

        org.apache.maven.api.model.Activation modelActivation = modelProfile.getActivation();

        if (modelActivation != null) {
            Activation.Builder activation = Activation.newBuilder();

            activation.activeByDefault(modelActivation.isActiveByDefault());

            activation.jdk(modelActivation.getJdk());

		if version.header.VersionID != uv || version.header.Type != ObjectType {
			continue
		}
		// if uv has tiered content we add a
		// free-version to track it for asynchronous
		// deletion via scanner.
		ver, err := x.getIdx(i)
		if err != nil {
			return err
		}

		if freeVersion, toFree := ver.ObjectV2.InitFreeVersion(fi); toFree {
			return x.addVersion(freeVersion)
		}
		return nil
	}
	return nil

                        Set<String> containers = new LinkedHashSet<>();
                        containers.add("org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/" + model.getJdt().getJavaRuntimeName() + "/");
                        containers.addAll(model.getClasspath().getContainers());
                        model.getClasspath().setContainers(containers);
                    }
                });

        } else {
            dsl = BuildInitDsl.fromName(getDsl());
            if (!initializer.getDsls().contains(dsl)) {
                throw new GradleException("The requested DSL '" + getDsl() + "' is not supported for '" + initializer.getId() + "' build type");
            }
        }
        return dsl;
    }

	for i, ver := range x.versions {
		if key == ver.header.VersionID {
			obj, err := x.getIdx(i)
			return i, obj, err
		}
	}
	return -1, nil, errFileVersionNotFound
}

func (x *xlMetaV2) getIdx(idx int) (ver *xlMetaV2Version, err error) {
	if idx < 0 || idx >= len(x.versions) {
		return nil, errFileNotFound
	}
	var dst xlMetaV2Version