* put duplicate dependencies on the classpath. The order will always be arbitrary and break one
     * use case or another.
     */
    @Test
    @ToBeFixedForConfigurationCache
    void "conflicting versions of the same library for compile and compile-only mapped to classpath"() {
        // given
        mavenRepo.module('org.gradle.test', 'conflictingDependency', '1.0').publish()

    return TableCollectors.<T, R, C, V, I>toTable(
        rowFunction,
        columnFunction,
        valueFunction,
        (v1, v2) -> {
          throw new IllegalStateException("Conflicting values " + v1 + " and " + v2);
        },
        tableSupplier);
  }

  static <
          T extends @Nullable Object,
          R extends @Nullable Object,
          C extends @Nullable Object,

var (
	errNotFound      = errors.New("item not found")
	errAlreadyExists = errors.New("item already exists")
	// TODO: can we make this compatible with kerror.IsConflict without imports the library?
	errConflict = errors.New("conflicting resource version, try again")
)

const ResourceVersion string = "ResourceVersion"

// Make creates an in-memory config store from a config schemas
// It is with validation

        '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',

     *
     * The preferred version of a module provides a hint when resolving the version,
     * but will not be honored in the presence of conflicting constraints.
     *
     * @return the preferred version, or empty string if no preferred version specified. Never null.
     */
    String getPreferredVersion();

    /**

}

// renameTop renames all references to the top-level name old.
// It reports whether it makes any changes.
func renameTop(f *ast.File, old, new string) bool {
	var fixed bool

	// Rename any conflicting imports
	// (assuming package name is last element of path).
	for _, s := range f.Imports {
		if s.Name != nil {
			if s.Name.Name == old {
				s.Name.Name = new
				fixed = true
			}
		} else {

        }

        where:
        mapping << [false, true]
    }

    def "reports failure when project dependency references a project with multiple conflicting publications"() {
        createBuildScripts("""
project(":project2") {
    publishing {
        publications {
            extraComp(MavenPublication) {
                from components.java

		return
	}
	l := log.Warnf
	if features.EnableUnsafeAssertions && !allowedOverlap(resource) {
		l = log.Fatalf
	}
	l("for type %v, registered conflicting ObjectTransform. Stack: %v", resource, string(debug.Stack()))
}

func (f *informerFactory) makeStartableInformer(informer cache.SharedIndexInformer, key informerKey) StartableInformer {
	return StartableInformer{

  JAVA_OPTS          Environment variable, if unset uses ""
  SBT_OPTS           Environment variable, if unset uses ""
  ACTIVATOR_OPTS     Environment variable, if unset uses ""

In the case of duplicated or conflicting options, the order above
shows precedence: environment variables lowest, command line options highest.
EOM
}

###  ------------------------------- ###
###  Main script                     ###

        }

        then:
        outputEquals """
Type 'Whatever' property 'prop' has conflicting type annotations declared: @Input, @Output.

Reason: The different annotations have different semantics and Gradle cannot determine which one to pick.

Possible solution: Choose between one of the conflicting annotations.

${validationMessage("conflicting_annotations")}
"""
    }