PluginExecution existing = merged.get(key);
                    if (existing != null) {
                        element = mergePluginExecution(element, existing, sourceDominant, context);
                    }
                    merged.put(key, element);
                }

                builder.executions(merged.values());
            }
        }
    }

	}

	merged, err := strategicpatch.StrategicMergePatch(mainYaml, overlayYaml, &deploymentMerge)
	if err != nil {
		return "", fmt.Errorf("json merge error (%s) for base object: \n%s\n override object: \n%s", err, mainYaml, overlayYaml)
	}

	resYaml, err := yaml.JSONToYAML(merged)
	if err != nil {
		return "", fmt.Errorf("jsonToYAML error (%s) for merged object: \n%s", err, merged)
	}

                List<Plugin> tgt = target.getPlugins();

                Map<Object, Plugin> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);

                for (Plugin element : tgt) {
                    Object key = getPluginKey().apply(element);
                    merged.put(key, element);
                }

                Map<Object, Plugin> added = new LinkedHashMap<>();

        file("output/merged.txt").text == 'file1'

        when:
        run("merge")

        then:
        result.assertTasksNotSkipped()

        when:
        file("file-source.txt").text = "new-file1"
        run("merge")

        then:
        result.assertTasksExecuted(":createFile", ":merge")
        file("output/merged.txt").text == 'new-file1'
    }

            List<ComponentSelectionDescriptorInternal> merged = Lists.newArrayListWithCapacity(descriptors.size()-1);
            boolean added = false;
            for (ComponentSelectionDescriptorInternal descriptor : descriptors) {
                if (isByVersionConflict(descriptor)) {
                    if (!added) {

                            ExcludeSpec merged = unions.tryUnion(left, right);
                            if (merged != null) {
                                if (merged instanceof ExcludeEverything) {
                                    return merged;
                                }
                                left = merged;
                                asArray[i] = merged;
                                asArray[j] = null;

  // merged execute.
  Operation* new_parallel_execute_op = new_parallel_execute.getOperation();
  for (int i = 0; i < num_results_before_region; ++i)
    parallel_execute_op->getResult(i).replaceAllUsesWith(
        new_parallel_execute_op->getResult(i));

  // Replace the uses of the original parallel_execute after region containing

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 38082
releaseNotes:
  - |
    **Fixed** xDS may not be updated when there are multiple destinationRules for a service are merged.
    In this case the merged rule does only record one name/namespace pair of all the destinationRules.
    however this meta is used to record config dependencies of a sidecar.

        Model source = Model.newBuilder().artifactId("SOURCE").build();

        Model merged = mavenMerger.merge(target, source, true, null);
        assertThat(merged.getArtifactId(), is("SOURCE"));

        merged = mavenMerger.merge(target, source, false, null);
        assertThat(merged.getArtifactId(), is("TARGET"));
    }

    @Test
    void mergeSameContributors() {
        Contributor contributor =

 *         //but before gradle build information is merged
 *         beforeMerged { wtpFacet ->
 *           //tinker with {@link WtpFacet} here
 *         }
 *
 *         //closure executed after wtp facet file content is loaded from existing file
 *         //and after gradle build information is merged
 *         whenMerged { wtpFacet ->
 *           //you can tinker with the {@link WtpFacet} here