},
	},
	{
		name:       "conflicting gateways detect",
		inputFiles: []string{"testdata/conflicting-gateways.yaml"},
		analyzer:   &gateway.ConflictingGatewayAnalyzer{},
		expected: []message{
			{msg.ConflictingGateways, "Gateway alpha"},
			{msg.ConflictingGateways, "Gateway beta"},
		},
	},
	{
		name:       "conflicting gateways detect: no port",

        resolutionAction.execute(result);
        if (selected != null) {
            maybeSetReason(conflict.participants, selected);
        }
        LOGGER.debug("Selected {} from conflicting modules {}.", selected, conflict.candidates);
    }

    private void maybeSetReason(Set<ModuleIdentifier> partifipants, ComponentResolutionState selected) {
        for (ModuleIdentifier identifier : partifipants) {

                                Version.V40,
                                "Ignored POM import for: " + toString(dependency) + " as already imported "
                                        + toString(present) + ". Add the conflicting managed dependency directly "
                                        + "to the dependencyManagement section of the POM.");
                    }
                }
            }

                                .setMessage("Ignored POM import for: " + toString(dependency) + " as already imported "
                                        + toString(present) + ". Add the conflicting managed dependency directly "
                                        + "to the dependencyManagement section of the POM."));
                    }
                }
            }

        'validation:property-validation:cannot-write-to-reserved-location' : 'Cannot write to reserved location',
        'validation:property-validation:conflicting-annotations' : 'Type has conflicting annotation',
        'validation:property-validation:ignored-property-must-not-be-annotated' : 'Has wrong combination of annotations',
        'validation:property-validation:implicit-dependency' : 'Property has implicit dependency',

var poolRaceHash [128]uint64

// poolRaceAddr returns an address to use as the synchronization point
// for race detector logic. We don't use the actual pointer stored in x
// directly, for fear of conflicting with other synchronization on that address.
// Instead, we hash the pointer to get an index into poolRaceHash.
// See discussion on golang.org/cl/31589.
func poolRaceAddr(x any) unsafe.Pointer {

  return matching_devices;
}

// Create error message for a conflicting attribute of a device.
template <typename T>
absl::Status MismatchedTPUSystemAttributeErr(absl::string_view attribute, T a,
                                             T b) {
  return absl::InvalidArgumentError(
      absl::StrCat("found ", kDeviceTPUSystem, " devices with conflicting ",
                   attribute, "s '", a, "' and '", b, "'"));
}

		return true
	}

	if hasUnexpectedController(claim, set, pod) {
		if hasOwnerRef(claim, set) || hasOwnerRef(claim, pod) {
			return false // Need to clean up the conflicting controllers
		}
		// The claim refs are good, we don't want to add any controllers on top of the unexpected one.
		return true
	}

	if hasNonControllerOwner(claim, set, pod) {

		default:
			if hasUnexpectedController(claim, set, pod) {
				// Add an event so the user knows they're in a strange configuration. The claim will be cleaned up below.
				msg := fmt.Sprintf("PersistentVolumeClaim %s has a conflicting OwnerReference that acts as a manging controller, the retention policy is ignored for this claim", claimName)
				spc.recorder.Event(set, v1.EventTypeWarning, "ConflictingController", msg)
			}

        PotentialConflict c = resolveState.getConflictTracker().getModuleConflictHandler().registerCandidate(module);
        if (c.conflictExists()) {
            // We have a conflict
            LOGGER.debug("Found new conflicting module {}", module);

            // For each module participating in the conflict, deselect the currently selection, and remove all outgoing edges from the version.