}{
		{
			name:                          "convert nil object to unstructured should fail",
			objectToConvert:               nil,
			expectedErr:                   fmt.Errorf("unable to convert object type <nil> to Unstructured, must be a runtime.Object"),
			expectedConvertedUnstructured: &unstructured.Unstructured{},
		},
		{
			name:            "convert versioned empty object to unstructured should work",

	_ float32 = -maxFloat32
	_ float32 = maxFloat32
	_ float32 = maxFloat32 /* ERROR "overflow" */ + delta32

	_ = float32(- /* ERROR "cannot convert" */ (maxFloat32 + delta32))
	_ = float32(-maxFloat32)
	_ = float32(maxFloat32)
	_ = float32(maxFloat32 /* ERROR "cannot convert" */ + delta32)

	_ = assert(float32(smallestFloat32) == smallestFloat32)
	_ = assert(float32(smallestFloat32/2) == 0)

        assertEquals(result, duplicateHostHelper.convert(url));

        url = "http://foo.com/";
        result = "http://www.foo.com/";
        assertEquals(result, duplicateHostHelper.convert(url));

        url = "http://foo.com:8080/";
        result = "http://www.foo.com:8080/";
        assertEquals(result, duplicateHostHelper.convert(url));

        url = "http://mail.bar.com/";

    def convert(String... args) {
        converter.convert(Arrays.asList(args), new BuildLayoutParameters())
    }

    @Requires(UnitTestPreconditions.NotEC2Agent)
    @Issue('https://github.com/gradle/gradle-private/issues/2876')
    def "has reasonable defaults"() {
        expect:
        convert().currentDir == canonicalize(SystemProperties.instance.getCurrentDir())

    final def converter = new ParallelismBuildOptions().commandLineConverter()

    def "converts parallel executor"() {
        when:
        def result = convert("--parallel")

        then:
        result.parallelProjectExecutionEnabled == true

        when:
        result = convert("--no-parallel")

        then:
        result.parallelProjectExecutionEnabled == false
    }

    def "converts max workers"() {

}

func setOverhead(a admission.Attributes, pod *api.Pod, runtimeClass *nodev1.RuntimeClass) (err error) {
	if runtimeClass == nil || runtimeClass.Overhead == nil {
		return nil
	}

	// convert to internal type and assign to pod's Overhead
	nodeOverhead := &node.Overhead{}
	if err = apinodev1.Convert_v1_Overhead_To_node_Overhead(runtimeClass.Overhead, nodeOverhead, nil); err != nil {
		return err
	}

        participants.add(replacedBy);

        //We need to ensure that the conflict is orderly injected to the list of conflicts
        //Brand new conflict goes to the end
        //If we find any matching conflict we have to hook up with it

        //Find an existing matching conflict
        for (K participant : participants) {
            Conflict c = conflictsByParticipant.get(participant);
            if (c != null) {

    }

    /**
     * Resolves the conflict by delegating to the conflict resolver who selects single version from given candidates. Executes provided action against the conflict resolution result object.
     */
    @Override
    public void resolveNextConflict(Action<ConflictResolutionResult> resolutionAction) {
        assert hasConflicts();
        ConflictContainer<ModuleIdentifier, ComponentState>.Conflict conflict = conflicts.popConflict();

  namespace: ns1
spec:
  metrics:
  - providers:
    - name: prometheus
    overrides:
    - match:
        metric: ALL_METRICS
      disabled: false
---
apiVersion: telemetry.istio.io/v1alpha1
kind: Telemetry
metadata:
  name: has-selector
  namespace: ns1
spec:
  selector: # Since this has a selector, it shouldn't conflict with the other Telemetry in the namespace

        TreeFormatter formatter = new TreeFormatter();

        String plural = getPluralEnding(conflicts);
        formatter.node("Conflict" + plural + " found for the following module" + plural);
        formatter.startChildren();

        conflicts.stream().limit(MAX_SEEN_MODULE_COUNT)
            .forEach(conflict -> formatter.node(conflict.getMessage()));