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

            boolean hasConflict = !childName.equals(childDependency.getName());
            String name = leaf ? configurationName : childName;

            LinkedHashMap<String, Object> map = new LinkedHashMap<>(6);
            map.put("name", name);
            map.put("resolvable", childDependency.getResolutionState());
            map.put("hasConflict", hasConflict);

            return NO_CONFLICT;
        }
        return new HasConflict(conflict.participants);
    }

    static PotentialConflict noConflict() {
        return NO_CONFLICT;
    }

    private static class HasConflict implements PotentialConflict {

        private final Set<ModuleIdentifier> participants;

        private HasConflict(Set<ModuleIdentifier> participants) {
            this.participants = participants;

            };
            var classes = [];
            if (dependency.alreadyRendered) {
                classes.push('alreadyRendered');
            }
            if (dependency.hasConflict) {
                classes.push('hasConflict');
            }
            if (!dependency.resolvable) {
                classes.push('unresolvable');
            }
            if (classes.length > 0) {

		return "", errNotFound
	}

	rev := time.Now().String()
	cfg.ResourceVersion = rev
	ns[cfg.Name] = cfg

	return rev, nil
}

// hasConflict checks if the two resources have a conflict, which will block Update calls
func hasConflict(existing, replacement config.Config) bool {
	if replacement.ResourceVersion == "" {
		// We don't care about resource version, so just always overwrite
		return false
	}

    background-color: #FFFFEE
}
.alreadyRendered > a, .unresolvable > a {
    border-radius: 4px;
}
.alreadyRendered > a {
    border: solid 1px #EEEEEE;
    background-color: #EEEEEE !IMPORTANT;
}
.hasConflict > a {
    font-weight: bold !IMPORTANT;
    color: #FAA732 !IMPORTANT;
}
.unresolvable > a {
    border: solid 1px #DD514C;
    background-color: #DD514C !IMPORTANT;
    color: white !IMPORTANT;
}
.leaf a {

	}

	// each HTTPMatchRequest of delegate must find a superset in root.
	// otherwise it conflicts
	for _, subMatch := range delegate {
		foundMatch := false
		for _, rootMatch := range root {
			if hasConflict(rootMatch, subMatch) {
				log.Warnf("HTTPMatchRequests conflict: root %v, delegate %v", rootMatch, subMatch)
				continue
			}
			// merge HTTPMatchRequest

				Gateways: []string{"ingress-gateway", "mesh"},
			},
			expected: true,
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			got := hasConflict(tc.root, tc.leaf)
			if got != tc.expected {
				t.Errorf("got %v, expected %v", got, tc.expected)
			}
		})
	}
}

// Note: this is to prevent missing merge new added HTTPRoute fields