conflict: false,
		},
		{
			labels1:  map[string]string{"env": "test"},
			labels2:  map[string]string{"env": "dev"},
			conflict: true,
		},
		{
			labels1:  map[string]string{"env": "test", "infra": "false"},
			labels2:  map[string]string{"infra": "true", "color": "blue"},
			conflict: true,
		},
	}
	for _, test := range tests {
		conflict := Conflicts(Set(test.labels1), Set(test.labels2))

	T4 ~int | ~string,
]() {
	_ = T1(0 /* ERRORx `cannot convert 0 .* to type T1: T1 does not contain specific types` */)
	_ = T2(1 /* ERRORx `cannot convert 1 .* to type T2: T2 does not contain specific types` */)
	_ = T3(2 /* ERRORx `cannot convert 2 .* to type T3: cannot convert 2 .* to type bool \(in T3\)` */)
	_ = T4(3.14 /* ERRORx `cannot convert 3.14 .* to type T4: cannot convert 3.14 .* to type int \(in T4\)` */)
}

// "x is assignable to T"

    private static class Details implements ResolutionDetails {
        private final CapabilityConflict conflict;
        private final Set<NodeState> evicted = new HashSet<>();
        private NodeState selected;
        private Describable reason;

        private Details(CapabilityConflict conflict) {
            this.conflict = conflict;
        }

        @Override

        def converter1 = Mock(NotationConverter)
        def converter2 = Mock(NotationConverter)

        given:
        _ * converter1.convert(12, _) >> { Object n, NotationConvertResult result -> result.converted("[12]") }
        converter2.convert(true, _) >> { Object n, NotationConvertResult result -> result.converted("True") }

        and:

	return c.unsafe.ConvertFieldLabel(gvk, label, value)
}

// Convert makes a copy of in object and then delegate the call to the unsafe converter.
func (c *safeConverterWrapper) Convert(in, out, context interface{}) error {
	inObject, ok := in.(runtime.Object)
	if !ok {
		return fmt.Errorf("input type %T in not valid for object conversion", in)
	}
	return c.unsafe.Convert(inObject.DeepCopyObject(), out, context)
}

    /**
     * Registers new module and returns information about any potential conflict
     */
    PotentialConflict registerCandidate(CANDIDATE candidate);

    /**
     * Informs whether there is any conflict at present
     */
    boolean hasConflicts();

    /**
     * Resolves next conflict and trigger provided action after the resolution
     */

        loggingConfigurationCommandLineConverter.convert(parsedCommandLine, properties.getProperties(), startParameter);
        parallelConfigurationCommandLineConverter.convert(parsedCommandLine, properties.getProperties(), startParameter);

        startParameter.getSystemPropertiesArgs().putAll(properties.getRequestedSystemProperties());

        projectPropertiesCommandLineConverter.convert(parsedCommandLine, startParameter.getProjectProperties());

kind: Sidecar
metadata:
  name: has-conflict-1 # Both Sidecars in this namespace omit workload selector, so they are in conflict
  namespace: ns2
spec:
  egress:
  - hosts:
    - "./*"
---
apiVersion: networking.istio.io/v1alpha3
kind: Sidecar
metadata:
  name: has-conflict-2 # Both Sidecars in this namespace omit workload selector, so they are in conflict
  namespace: ns2
spec:
  egress:
  - hosts:

        return create(targetBuild);
    }

    @Override
    public DefaultGradleBuild create(BuildState target) {
        target.ensureProjectsLoaded();
        return convert(target, new LinkedHashMap<>());
    }

    private DefaultGradleBuild convert(BuildState targetBuild, Map<BuildState, DefaultGradleBuild> all) {
        DefaultGradleBuild model = all.get(targetBuild);
        if (model != null) {
            return model;

			file:          "../../../../test/fixtures/pkg/kubectl/cmd/convert/appsdeployment.yaml",
			outputVersion: "extensions/v1beta1",
			fields: []checkField{
				{
					expected: "apiVersion: extensions/v1beta1",
				},
			},
		},
		{
			name:          "extensions deployment to apps deployment",
			file:          "../../../../test/fixtures/pkg/kubectl/cmd/convert/extensionsdeployment.yaml",
			outputVersion: "apps/v1beta2",