Object o = cl.newInstance(new Object[0])

        when:
        def r = serialize(o, serializer)

        then:
        cl.isInstance(r)
    }

    def "returns true when testing equality between two serializer with the same classloader"() {
        DefaultSerializer rhsSerializer = new DefaultSerializer(getClass().classLoader)
        DefaultSerializer lhsSerializer = new DefaultSerializer(getClass().classLoader)

 * to the provided {@code standardEquals} method.
 *
 * <p>Each of the {@code standard} methods, where appropriate, use {@link Objects#equal} to test
 * equality for both keys and values. This may not be the desired behavior for map implementations
 * that use non-standard notions of key equality, such as the entry of a {@code SortedMap} whose
 * comparator is not consistent with {@code equals}.
 *

   */
  @Override
  Map<K, Collection<V>> asMap();

  /**
   * Compares the specified object to this multimap for equality.
   *
   * <p>Two {@code SetMultimap} instances are equal if, for each key, they contain the same values.
   * Equality does not depend on the ordering of keys or values.
   *
   * <p>An empty {@code SetMultimap} is equal to any other empty {@code Multimap}, including an

   */
  @Override
  Map<K, Collection<V>> asMap();

  /**
   * Compares the specified object to this multimap for equality.
   *
   * <p>Two {@code SetMultimap} instances are equal if, for each key, they contain the same values.
   * Equality does not depend on the ordering of keys or values.
   *
   * <p>An empty {@code SetMultimap} is equal to any other empty {@code Multimap}, including an

			if (flags&identIgnoreTags) == 0 && f1.Note != f2.Note {
				return false
			}
		}
		return true

	case TFUNC:
		// Check parameters and result parameters for type equality.
		// We intentionally ignore receiver parameters for type
		// equality, because they're never relevant.
		if t1.NumParams() != t2.NumParams() ||
			t1.NumResults() != t2.NumResults() ||
			t1.IsVariadic() != t2.IsVariadic() {
			return false
		}

        "taskReport"            | []
        "propertyReport"        | []
        "htmlDependencyReport"  | []
        // projectReport depends on the other ones, and task order may not be preserved,
        // causing equality comparison between first and second outputs to fail
        //"projectReport"         | []
    }

        Node rootNode = new Node(null, 'root')

        when:
        createContainer().appendNode(rootNode)

        then:
        new Container(rootNode.classpathentry[0]) == createContainer()
    }

    def equality() {
        Container container = createContainer()
        container.nativeLibraryLocation += 'x'

        expect:
        container != createContainer()
    }

    private Container createContainer() {

        Node rootNode = new Node(null, 'root')

        when:
        createOutput().appendNode(rootNode)

        then:
        new Output(rootNode.classpathentry[0]) == createOutput()
    }

    def equality() {
        Output output = createOutput()
        output.path += 'x'

        expect:
        output != createOutput()
    }

    private Output createOutput() {
        return new Output('somePath')

import static org.gradle.api.internal.initialization.ClassLoaderIds.testTaskClasspath
import static org.gradle.util.Matchers.strictlyEquals

class ClassLoaderIdsTest extends Specification {

    def "equality"() {
        expect:
        strictlyEquals(buildScript("x", "x"), buildScript("x", "x"))
        buildScript("x", "x") != buildScript("x", "y")
        buildScript("x", "x") != buildScript("y", "y")

//  2. s1: first string used in the comparison
//  3. s2: second string used in the comparison
//  4. result: an integer representing the comparison result. 0 indicates
//     equality (comparison will ignored by libfuzzer), non-zero indicates a
//     difference (comparison will be taken into consideration).
//
//go:nosplit
func libfuzzerHookStrCmp(s1, s2 string, fakePC int) {
	if s1 != s2 {