// don't merge
    }

    @Override
    protected void mergeBuildBase_Resources(
            BuildBase.Builder builder,
            BuildBase target,
            BuildBase source,
            boolean sourceDominant,
            Map<Object, Object> context) {
        // don't merge
    }

    @Override
    protected void mergeBuildBase_TestResources(

}

// TODO: replace with merge.Conflicts.ToSet()
func conflictsToSet(conflicts merge.Conflicts) *fieldpath.Set {
	conflictSet := fieldpath.NewSet()
	for _, conflict := range []merge.Conflict(conflicts) {
		conflictSet.Insert(conflict.Path)
	}
	return conflictSet
}

func conflictsDifference(conflicts merge.Conflicts, s *fieldpath.Set) merge.Conflicts {
	newConflicts := []merge.Conflict{}

     */
    String getMergeValue();

    /**
     * Returns the value for the key of the manifest after the merge takes place. By default this is the value
     * of the source for the merge.
     */
    String getValue();

    /**
     * Set's the value for the key of the manifest after the merge takes place.
     */
    void setValue(String value);

    /**

    @Test
    void mergeEmptyMetadata() throws Exception {
        Metadata metadata = new Metadata();
        assertFalse(metadata.merge(new Metadata()));
    }

    @Test
    void mergeDifferentGAV() throws Exception {
        // merge implicitly assumes that merge is only called on the same GAV and does not perform any validation here!
        Metadata source = new Metadata();
        source.setArtifactId("source-artifact");

    %Merge:2, %ctl_2 = Merge(%Enter, %NextIteration) name("while/Merge") {N = 2 : i64, T = i32} : (tensor<*xi32>, tensor<*xi32>) -> (tensor<*xi32>, tensor<*xi32>)
    %Const_3, %ctl_4 = Const [%ctl_2] name("while/Less/y") {dtype = i32, value = dense<10> : tensor<i32>} : () -> (tensor<i32>)

        when:
        run("merge")

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

        when:
        run("merge")

        then:
        result.assertTasksNotSkipped()

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

        then:

      i: 10
    }
  }
}
node {
  name: "while/Merge"
  op: "Merge"
  input: "while/Enter"
  input: "while/NextIteration"
  attr {
    key: "N"
    value {
      i: 2
    }
  }
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
}
node {
  name: "while/Less/y"
  op: "Const"
  input: "^while/Merge"
  attr {
    key: "dtype"
    value {
      type: DT_INT32

    %NextIteration, %ctl_1 = NextIteration(%Const) [%arg.ctl] name("while/NextIteration") {T = i32} : (tensor<i32>) -> (tensor<*xi32>)
    %Merge:2, %ctl_2 = Merge(%Enter, %NextIteration) [%arg.ctl] name("while/Merge") {N = 2 : i64, T = i32} : (tensor<*xi32>, tensor<*xi32>) -> (tensor<*xi32>, tensor<i32>)
    %Less, %ctl_5 = Less(%Merge#0, %Const) [%arg.ctl] name("while/Less") {T = i32} : (tensor<*xi32>, tensor<i32>) -> (tensor<*xi1>)

        ConstantToDependentsMapping mapping = merger.merge(newMapping, oldMapping, ["a", "b"] as Set)

        then:
        mapping.getConstantDependentsForClass("a").accessibleDependentClasses == ["1"] as Set
        mapping.getConstantDependentsForClass("b").accessibleDependentClasses == [] as Set
    }

    def "does not remove classes that are not in new mapping from mapping on merge"() {
        given:

			if err != nil {
				log.Debugf("Merge of transport socket failed for cluster: %v", err)
				continue
			}
			applied = true
			if !tsMerged {
				merge.Merge(c, cp.Value)
			}
		}
		IncrementEnvoyFilterMetric(cp.Key(), Cluster, applied)
	}
	return c
}

// Test if the patch contains a config for TransportSocket