// corresponding object, and that object's type is the (possibly generic) Named
// type. Declared Named types are identical if and only if their pointers are
// identical. On the other hand, multiple instantiated Named types may be
// identical even though their pointers are not identical. One has to use
// Identical to compare them. For instantiated named types, their obj is a
// synthetic placeholder that records their position of the corresponding

        "with an arbitrary name and no classifier"           | "optional-feature-1.9.jar"             | null               | "Invalid publication 'maven': multiple artifacts with the identical extension and classifier ('jar', 'null')"
        "with an arbitrary name and a classifier"            | "other-1.9.jar"                        | "optional-feature" | null

import org.gradle.test.fixtures.file.TestFile
import org.gradle.util.internal.TextUtil

abstract class AbstractModule implements Module {
    /**
     Last modified date for writeZipped to be able to create zipFiles with identical hashes
     */
    private static Date lmd = new Date(ZipCopyAction.CONSTANT_TIME_FOR_ZIP_ENTRIES)

    private boolean hasModuleMetadata
    private Closure<?> onEveryFile

    Map<String, String> attributes = [:]

		// CBOR supports distinct types for IEEE-754 float16, float32, and float64. Store
		// floats in the smallest width that preserves value so that equivalent float32 and
		// float64 values encode to identical bytes, as they do in a JSON
		// encoding. Satisfies one of the "Core Deterministic Encoding Requirements".
		ShortestFloat: cbor.ShortestFloat16,

		// ShortestFloat doesn't apply to NaN or Inf values. Inf values are losslessly

        registry.libraries[0].module == "group:artifact"
        registry.libraries[0].version == "1.1"
        registry.libraries[0].versionRef == "group-artifact"
    }

    def "merges multiple libraries when encountering identical coordinates"() {
        setup:
        def registry = new VersionCatalogDependencyRegistry(true)

        when:
        registry.registerLibrary("group:artifact", "1.1")

			lhs:   UnstructuredToVal([]interface{}{"a", "b"}, setListSchema),
			rhs:   UnstructuredToVal([]interface{}{"a", "b", "c"}, setListSchema),
			equal: false,
		},
		{
			name:  "identical atomic lists are equal",
			lhs:   UnstructuredToVal([]interface{}{"a", "b"}, atomicListSchema),
			rhs:   UnstructuredToVal([]interface{}{"a", "b"}, atomicListSchema),
			equal: true,
		},
		{

		return m.t&argPointer != 0

	case *types.Array:
		// Same as slice.
		if types.Identical(typ.Elem().Underlying(), types.Typ[types.Byte]) && m.t&argString != 0 {
			return true // %s matches []byte
		}
		// Recur: []int matches %d.
		return m.match(typ.Elem(), false)

	case *types.Slice:
		// Same as array.
		if types.Identical(typ.Elem().Underlying(), types.Typ[types.Byte]) && m.t&argString != 0 {

	}

	Inst := Unalias(pkg.Scope().Lookup("Inst").Type()).(*Pointer).Elem().(*Named)
	Node := firstFieldType(Inst)
	Tree := firstFieldType(Node)
	if !Identical(Inst, Tree) {
		t.Fatalf("Not a cycle: got %v, want %v", Tree, Inst)
	}
	if Inst != Tree {
		t.Errorf("Duplicate instances in cycle: %s (%p) -> %s (%p) -> %s (%p)", Inst, Inst, Node, Node, Tree, Tree)
	}
}

[versions]
com-example-group-long = "v1"

[libraries]
com-example-group-long = { module = "com.example.group:long", version.ref = "com-example-group-long" }
""")
    }

    def "merges multiple libraries when encountering identical coordinates"() {
        setup:
        versionCatalogDependencyRegistry.registerLibrary("group:artifact", "1.1")
        versionCatalogDependencyRegistry.registerLibrary("group:artifact", "1.1")

        when:

		return f(nil)
	}
	for _, t := range s.terms {
		assert(t.typ != nil)
		// x == under(x) for ~x terms
		u := t.typ
		if !t.tilde {
			u = under(u)
		}
		if debug {
			assert(Identical(u, under(u)))
		}
		if !f(u) {
			return false
		}
	}
	return true
}

// topTypeSet may be used as type set for the empty interface.
var topTypeSet = _TypeSet{terms: allTermlist}