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))

        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()));

}

// 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{}

    static <T> PotentialConflict potentialConflict(@Nullable final ConflictContainer<ModuleIdentifier, T>.Conflict conflict) {
        if (conflict == null) {
            return NO_CONFLICT;
        }
        return new HasConflict(conflict.participants);
    }

    static PotentialConflict noConflict() {
        return NO_CONFLICT;
    }

            allConflicts.add(buildConflict(owner, selectionReason));
        }
    }

    private static Conflict buildConflict(DependencyGraphComponent owner, ComponentSelectionReason selectionReason) {
        ModuleIdentifier module = owner.getModuleVersion().getModule();
        return new Conflict(ImmutableList.copyOf(owner.getAllVersions()), buildConflictMessage(module, selectionReason));
    }

If the module you want to select is not part of the conflict, you can abstain from performing a selection, effectively not resolving _this_ conflict.
It might be that another conflict exists in the graph for the same capability and will have the module you want to select.

		case map[string]interface{}:
			for key, leftValue := range typedLeft {
				rightValue, ok := typedRight[key]
				if !ok {
					continue
				}
				if conflict, err := HasConflicts(leftValue, rightValue); err != nil || conflict {
					return conflict, err
				}
			}

			return false, nil
		default:
			return true, nil
		}
	case []interface{}:
		switch typedRight := right.(type) {

        registerError(output -> {
            Collection<Conflict> conflicts = conflict.getConflicts();
            String plural = getPluralEnding(conflicts);
            output.text("Dependency resolution failed because of conflict" + plural + " on the following module"+ plural + ":");
            output.println();
            conflicts.stream()

     */
    boolean hasConflicts();

    /**
     * Resolves next conflict and trigger provided action after the resolution
     */
    void resolveNextConflict(Action<RESULT> resolutionAction);

    /**
     * Indicates if the identifier is a known participant in a conflict
     *
     * @param id the identifier to check

If you are experiencing or witnessing conflict, we ask you to use the following escalation strategy to address the conflict:

1.  Address the perceived conflict directly with those involved, preferably in a
    real-time medium.