}
        }
        """
        settingsFile << """
        rootProject.name = 'root'
        include ':a', ':b'
        """
    }

    def "externally used project names can be supplied and are deduplicated"() {
        when:
        EclipseProject model = withConnection { connection ->
            return connection.action(new LoadEclipseModel(eclipseWorkspace([
                gradleProject("a"),

            }
        }
        """
        settingsFile << """
        rootProject.name = 'root'
        include ':a', ':b'
        """
    }

    def "Included builds are deduplicated"() {
        given:
        settingsFile << """
                includeBuild 'includedBuild1'
                includeBuild 'includedBuild2'
            """

`Make[T]` function, which produces a reference to a canonical copy of
the value in the form of a `Handle[T]`.
Two `Handle[T]` are equal if and only if the values used to produce the
handles are equal, allowing programs to deduplicate values and reduce
their memory footprint.
Comparing two `Handle[T]` values is efficient, reducing down to a simple

	// related to the primary diagnostic.
	Related []RelatedInformation
}

// RelatedInformation contains information related to a diagnostic.
// For example, a diagnostic that flags duplicated declarations of a
// variable may include one RelatedInformation per existing
// declaration.
type RelatedInformation struct {
	Pos     token.Pos
	End     token.Pos // optional
	Message string
}

        }
    }

    private Collection<WeakMojoExecutionListener> getProvidedListeners() {
        // the same instance can be provided multiple times under different Key's
        // deduplicate instances to avoid redundant beforeXXX/afterXXX callbacks
        IdentityHashMap<WeakMojoExecutionListener, Object> listeners = new IdentityHashMap<>();
        for (Object provided : getScopeState().provided.values()) {

		})
	}
}

// removeDups removes duplicate replace directives.
//
// Later replace directives take priority.
//
// require directives are not de-duplicated. That's left up to higher-level
// logic (MVS).
//
// retract directives are not de-duplicated since comments are
// meaningful, and versions may be retracted multiple times.
func (f *WorkFile) removeDups() {
	removeDups(f.Syntax, nil, &f.Replace)

  pm.addPass(createReplaceStablehloOpsInMainFunctionWithXlaCallModuleOpsPass());
  // ReplaceStablehloOpsInMainFunctionWithXlaCallModuleOpsPass may create
  // duplicate constants. Add canonicalizer to deduplicate.
  pm.addNestedPass<func::FuncOp>(mlir::createCanonicalizerPass());
  pm.addPass(TF::CreateXlaCallModuleSerializationPass());
}

void AddProcessNchwTensorPasses(OpPassManager& pm) {

                } else if (logger.isWarnEnabled()) {
                    Lifecycle original = phaseToLifecycleMap.get(phase);
                    logger.warn(
                            "Duplicated lifecycle phase {}. Defined in {} but also in {}",
                            phase,
                            original.getId(),
                            lifecycle.getId());
                }
            }

			// traffic policies if they already exist
			for _, subset := range rule.Subsets {
				if !existingSubset.Contains(subset.Name) {
					// if not duplicated, append
					mergedRule.Subsets = append(mergedRule.Subsets, subset)
				} else {
					// duplicate subset
					ps.AddMetric(DuplicatedSubsets, string(resolvedHost), "",

		},

		// scenario 6: set valid `--disable-admission-plugins`
		{
			setDisablePlugins: []string{"pluginA"},
			expectedResult:    true,
		},

		// scenario 7: RecommendedPluginOrder has duplicated plugin
		{
			setRecommendedPluginsOrder: []string{"pluginA", "pluginB", "pluginB", "pluginC"},
			expectedResult:             false,
		},

		// scenario 8: RecommendedPluginOrder not equal to registered
		{