enable := true
	unknownPluginConfigs := append([]configv1.PluginConfig{}, pluginConfigs...)
	unknownPluginConfigs[0].Args = runtime.RawExtension{Object: &runtime.Unknown{}}

	tests := []struct {
		name     string
		config   *configv1.KubeSchedulerConfiguration
		expected *configv1.KubeSchedulerConfiguration
	}{
		{
			name:   "empty config",
			config: &configv1.KubeSchedulerConfiguration{},

	componentbaseconfig "k8s.io/component-base/config"
	"k8s.io/component-base/featuregate"
	featuregatetesting "k8s.io/component-base/featuregate/testing"
	configv1 "k8s.io/kube-scheduler/config/v1"
	"k8s.io/kubernetes/cmd/kube-scheduler/app/options"
	"k8s.io/kubernetes/pkg/features"
	"k8s.io/kubernetes/pkg/scheduler/apis/config"
	"k8s.io/kubernetes/pkg/scheduler/apis/config/testing/defaults"
	"k8s.io/kubernetes/pkg/scheduler/framework"

		Profiles: []config.KubeSchedulerProfile{{
			SchedulerName:            "me",
			PercentageOfNodesToScore: ptr.To[int32](35),
			Plugins: &config.Plugins{
				QueueSort: config.PluginSet{
					Enabled: []config.Plugin{{Name: "CustomSort"}},
				},
				Score: config.PluginSet{
					Disabled: []config.Plugin{{Name: "*"}},
				},
			},
			PluginConfig: []config.PluginConfig{{
				Name: "DefaultPreemption",

	clientset "k8s.io/client-go/kubernetes"
	restclient "k8s.io/client-go/rest"
	"k8s.io/client-go/tools/cache"
	"k8s.io/klog/v2"
	configv1 "k8s.io/kube-scheduler/config/v1"
	"k8s.io/kubernetes/pkg/features"
	schedulerapi "k8s.io/kubernetes/pkg/scheduler/apis/config"
	"k8s.io/kubernetes/pkg/scheduler/apis/config/scheme"
	"k8s.io/kubernetes/pkg/scheduler/framework"
	"k8s.io/kubernetes/pkg/scheduler/framework/parallelize"

        configB2 project(path:':a', configuration:'configA2')
    }
}
"""
        resolve.prepare {
            config("configB1")
            config("configB2")
        }

        when:
        run ":b:checkConfigB1"

        then:
        executedAndNotSkipped ":a:A1jar"
        resolve.expectGraph {
            root(":b", "test:b:") {

    }

    def "writes supplied configurations"() {
        when:
        def config1 = new DefaultIvyConfiguration("config1")
        def config2 = new DefaultIvyConfiguration("config2")
        config1.extend("foo")
        config1.extend("bar")
        descriptor.configurations.set([config1, config2])

        then:
        with (ivyXml) {
            configurations.conf.size() == 2

func TestSanitizeKubeConfig(t *testing.T) {
	cases := []struct {
		name      string
		config    api.Config
		allowlist sets.String
		want      api.Config
		wantErr   bool
	}{
		{
			name:    "empty",
			config:  api.Config{},
			want:    api.Config{},
			wantErr: false,
		},
		{
			name: "exec",
			config: api.Config{
				AuthInfos: map[string]*api.AuthInfo{
					"default": {

		t.Error("expected error posting twice")
	}

	invalid := config2.Config{
		Meta: config2.Meta{
			GroupVersionKind: mockGvk,
			Name:             "invalid",
			ResourceVersion:  revs[0],
		},
		Spec: &config.MockConfig{},
	}

	missing := config2.Config{
		Meta: config2.Meta{
			GroupVersionKind: mockGvk,
			Name:             "missing",
			ResourceVersion:  revs[0],

        child.exclude([group: "group2", module: "module2"])

        expect:
        def config = state.getConfiguration("child").metadata
        def excludes = config.excludes
        config.excludes*.moduleId.group == ["group2", "group1"]
        config.excludes*.moduleId.name == ["module2", "module1"]
        config.excludes.is(excludes)
    }

    def artifactName() {

	APISubSys: {apiReplicationWorkers, apiReplicationFailedWorkers},
	// Add future sub-system deleted keys
}

// Merge - merges a new config with all the
// missing values for default configs,
// returns a config.
func (c Config) Merge() Config {
	cp := New()
	for subSys, tgtKV := range c {
		for tgt := range tgtKV {
			ckvs := c[subSys][tgt]
			for _, kv := range cp[subSys][Default] {