(defaultModuleComponentIdentifier1.hashCode() == defaultModuleComponentIdentifier2.hashCode()) == hashCode
        (defaultModuleComponentIdentifier1.toString() == defaultModuleComponentIdentifier2.toString()) == stringRepresentation

        where:
        group         | name         | version | equality | hashCode | stringRepresentation

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Deep equality test via reflection

package reflect

import (
	"internal/bytealg"
	"unsafe"
)

// During deepValueEqual, must keep track of checks that are
// in progress. The comparison algorithm assumes that all
// checks in progress are true when it reencounters them.

        genericCallLikeComparison * zeroOrMore(comparisonOperator * genericCallLikeComparison)
    }

    val equality by debug {
        comparison * zeroOrMore(equalityOperator * comparison)
    }

    val conjunction by debug {
        equality * zeroOrMore(token(ANDAND) * equality)
    }

    val disjunction =
        conjunction * zeroOrMore(token(OROR) * conjunction)

        expect:
        with(library) {
            name == null
            classes == [] as Set
            sources == [] as Set
            javadoc == [] as Set
        }
    }

    def "defines equality as deep equality of all its properties"() {
        expect:
        new ProjectLibrary() == new ProjectLibrary()
        new ProjectLibrary(name: "lib1") == new ProjectLibrary(name: "lib1")

import (
	"context"
	"fmt"
	"sort"
	"time"

	rbacv1ac "k8s.io/client-go/applyconfigurations/rbac/v1"
	"k8s.io/klog/v2"

	rbacv1 "k8s.io/api/rbac/v1"
	"k8s.io/apimachinery/pkg/api/equality"
	"k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/labels"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
	"k8s.io/apimachinery/pkg/util/wait"

 * 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}.
 *

        } catch (RuntimeException e) {
            // in-process Groovy compilation throws a CompilationFailedException from another classloader, hence testing class name equality
            // TODO:pm Prefer class over class name for equality check once using WorkerExecutor for in-process groovy compilation
            if ((spec.getCompileOptions().isFailOnError() && spec.getGroovyCompileOptions().isFailOnError())

        (defaultBuildComponentSelector1.hashCode() == defaultBuildComponentSelector2.hashCode()) == hashCode
        (defaultBuildComponentSelector1.toString() == defaultBuildComponentSelector2.toString()) == stringRepresentation

        where:
        projectPath1      | libraryName1 | projectPath2      | libraryName2 | equality | hashCode | stringRepresentation

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

        when:
        createWbProperty().appendNode(rootNode)

        then:
        new WbProperty(rootNode.property[0]) == createWbProperty()
    }

    def equality() {
        WbProperty wbProperty = createWbProperty()
        wbProperty.name += 'x'

        expect:
        wbProperty != createWbProperty()
    }

    private WbProperty createWbProperty() {

    }

    def "hashCode and equals determine equality" () {
        given:
        NamespaceId id1 = new NamespaceId("some-namespace", "some-name")
        NamespaceId id2 = new NamespaceId("some-namespace", "some-name")

        expect:
        id1 Matchers.strictlyEqual(id2)
    }

    def "hashCode and equals determine inequality" () {
        given: