// P256 returns a [Curve] which implements NIST P-256 (FIPS 186-3, section D.2.3),
// also known as secp256r1 or prime256v1.
//
// Multiple invocations of this function will return the same value, which can
// be used for equality checks and switch statements.
func P256() Curve { return p256 }

var p256 = &nistCurve[*nistec.P256Point]{
	name:        "P-256",
	newPoint:    nistec.NewP256Point,
	scalarOrder: p256Order,
}

// also known as secp224r1. The CurveParams.Name of this [Curve] is "P-224".
//
// Multiple invocations of this function will return the same value, so it can
// be used for equality checks and switch statements.
//
// The cryptographic operations are implemented using constant-time algorithms.
func P224() Curve {
	initonce.Do(initAll)
	return p224
}

        when:
        createWbResource().appendNode(rootNode)

        then:
        new WbResource(rootNode.'wb-resource'[0]) == createWbResource()
    }

    def equality() {
        WbResource wbResource = createWbResource()
        wbResource.sourcePath += 'x'

        expect:
        wbResource != createWbResource()
    }

    private WbResource createWbResource() {

    }

    def "rule action has no inputs"() {
        when:
        def action = ruleAction({ String val -> } as Action<String>)

        then:
        action.inputTypes.empty
    }

    def "equality"() {
        def baseAction = {String val -> } as Action<String>
        def noInputsAction = ruleAction(baseAction)

        expect:
        Matchers.strictlyEquals(noInputsAction, ruleAction(baseAction))

        when:
        createProjectDependency().appendNode(rootNode)

        then:
        new ProjectDependency(rootNode.classpathentry[0]) == createProjectDependency()
    }

    def equality() {
        ProjectDependency projectDependency = createProjectDependency()
        projectDependency.nativeLibraryLocation += 'x'

        expect:
        projectDependency != createProjectDependency()
    }

        when:
        createWbDependentModule().appendNode(rootNode)

        then:
        new WbDependentModule(rootNode.'dependent-module'[0]) == createWbDependentModule()
    }

    def equality() {
        WbDependentModule wbDependentModule = createWbDependentModule()
        wbDependentModule.handle += 'x'

        expect:
        wbDependentModule != createWbDependentModule()
    }

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

        when:
        createFixedFacet().appendNode(rootNode)

        then:
        new Facet(rootNode.fixed[0]) == createFixedFacet()
    }

    def equality() {
        Facet facet = createFacet()
        facet.name += 'x'

        expect:
        facet != createFacet()
    }

    def fixedEquality() {
        Facet facet = createFixedFacet()

import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEqual
import static org.hamcrest.MatcherAssert.assertThat

class MethodInvocationTest extends Specification {

    def "equality"() {
        def invocation = new MethodInvocation(String.class.getMethod("length"), ["param"] as Object[])
        def equalInvocation = new MethodInvocation(String.class.getMethod("length"), ["param"] as Object[])

 * limitations under the License.
 */
package org.gradle.plugins.ide.idea.model

import spock.lang.Specification

class ModuleLibraryTest extends Specification {
    def equality() {
        expect:
        createModuleLibraryWithScope(null).equals(createModuleLibraryWithScope("COMPILE"))
        createModuleLibraryWithScope("").equals(createModuleLibraryWithScope("COMPILE"))

			// Since we've encountered an unknown field, fallback to unstructured equality checking.
			ouMap, ok := other.(*unstructuredMap)
			if !ok {
				// The compiler ensures equality is against the same type of object, so this should be unreachable
				return types.MaybeNoSuchOverloadErr(other)
			}
			if oValue, ok := ouMap.value[key]; ok {
				if !equality.Semantic.DeepEqual(value, oValue) {
					return types.False
				}
			}