def a = candidate("org", "a")
        def b = candidate("org", "b")

        expect:
        !handler.registerCandidate(a).conflictExists()
        !handler.registerCandidate(b).conflictExists()
        !handler.hasConflicts()
    }

    def "registers module with version conflict"() {
        def a = candidate("org", "a", "1", "2")
        def b = candidate("org", "b", "1")

        when:

func HasConflicts(left, right interface{}) (bool, error) {
	switch typedLeft := left.(type) {
	case map[string]interface{}:
		switch typedRight := right.(type) {
		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 {

	// Only keep deletion
	deletePatch, deletePatchObj, err := keepOrDeleteNullInJsonPatch(deletePatch, true)
	if err != nil {
		return nil, err
	}

	hasConflicts, err := mergepatch.HasConflicts(addAndChangePatchObj, deletePatchObj)
	if err != nil {
		return nil, err
	}
	if hasConflicts {
		return nil, mergepatch.NewErrConflict(mergepatch.ToYAMLOrError(addAndChangePatchObj), mergepatch.ToYAMLOrError(deletePatchObj))
	}

		testStr := fmt.Sprintf("A = %#v, B = %#v", testCase.A, testCase.B)
		// Run each test case multiple times if it passes because HasConflicts()
		// uses map iteration, which returns keys in nondeterministic order.
		for try := 0; try < 10; try++ {
			out, err := HasConflicts(testCase.A, testCase.B)
			if err != nil {
				t.Errorf("%v: unexpected error: %v", testStr, err)
				break
			}
			if out != testCase.Ret {

    }

    /**
     * Informs if there are any batched up conflicts.
     */
    @Override
    public boolean hasConflicts() {
        return !conflicts.isEmpty();
    }

    /**

     */
    PotentialConflict registerCandidate(CANDIDATE candidate);

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

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

    /**

        CapabilitiesConflictHandler capabilitiesConflictHandler = resolveState.getConflictTracker().getCapabilitiesConflictHandler();

        while (resolveState.peek() != null || moduleConflictHandler.hasConflicts() || capabilitiesConflictHandler.hasConflicts()) {
            if (resolveState.peek() != null) {
                final NodeState node = resolveState.pop();
                LOGGER.debug("Visiting configuration {}.", node);

					if err != nil {
						return true, err
					}
				}

				if hasConflicts, err := mergingMapFieldsHaveConflicts(leftValue, rightValue,
					subschema, patchStrategy, patchMeta.GetPatchMergeKey()); hasConflicts {
					return true, err
				}
			}
		}
	}

	return false, nil
}

func slicesHaveConflicts(

        String capabilityId = capability.getCapabilityId();

        return capabilityWithoutVersionToNodes.computeIfAbsent(capabilityId, k -> new LinkedHashSet<>());
    }

    @Override
    public boolean hasConflicts() {
        return !conflicts.isEmpty();
    }

    @Override
    public void resolveNextConflict(Action<ConflictResolutionResult> resolutionAction) {
        CapabilityConflict conflict = conflicts.poll();

        barInsight[0].resolvable == 'RESOLVED'
        barInsight[0].hasConflict == false
        barInsight[0].description == null
        barInsight[0].children.size() == 0

        barInsight[1].name == 'foo:bar:2.0'
        barInsight[1].resolvable == 'RESOLVED'
        barInsight[1].hasConflict == false
        barInsight[1].description == null
        barInsight[1].children.size() == 1