// implied by expression z, or if sign < 0, by expression !z.
func minVersion(z Expr, sign int) int {
	switch z := z.(type) {
	default:
		return -1
	case *AndExpr:
		op := andVersion
		if sign < 0 {
			op = orVersion
		}
		return op(minVersion(z.X, sign), minVersion(z.Y, sign))
	case *OrExpr:
		op := orVersion
		if sign < 0 {
			op = andVersion
		}

            ${keyInfo.addAsPropertiesScript()}

            signing {
                sign {
                    sign(tasks.jar)
                }
            }
        """

        when:
        run "sign"

        then:
        executedAndNotSkipped ":signJar"

        and:
        file("build", "libs", "sign-1.0.jar.asc").text
    }

    def "use kotlin action when signing"() {
        given:

                sign jar, javadocJar, sourcesJar
            }
        """

        when:
        run "signJar", "signJavadocJar", "signSourcesJar"

        then:
        executedAndNotSkipped(":signJar", ":signJavadocJar", ":signSourcesJar")

        and:
        file("build", "libs", "sign-1.0.jar.asc").text
        file("build", "libs", "sign-1.0-javadoc.jar.asc").text

    def setup() {
        applyPlugin()
    }

    def "sign jar with defaults"() {
        given:
        useJavadocAndSourceJars()
        createJarTaskOutputFile('jar', 'sourcesJar', 'javadocJar')

        when:
        signing {
            sign jar
            sign sourcesJar, javadocJar
        }

        then:

TEXT ·archCeil(SB),NOSPLIT,$0
	MOVQ	x+0(FP), AX
	MOVQ	$~(1<<63), DX // sign bit mask
	MOVQ	AX, BX // BX = copy of x
	ANDQ    DX, BX // BX = |x|
	MOVQ    $Big, CX // if |x| >= 2**52 or IsNaN(x), return x
	CMPQ    BX, CX
	JAE     isBig_ceil
	MOVQ	AX, X0 // X0 = x
	MOVQ	DX, X2 // X2 = sign bit mask
	CVTTSD2SQ	X0, AX
	ANDNPD	X0, X2 // X2 = sign
	CVTSQ2SD	AX, X1	// X1 = float(int(x))

    }
    
    def "sign single file with defaults"() {
        when:
        def operation = signing.sign(input1)
        
        then:
        output1.exists()
        output1 == operation.singleSignature.file
    }
    
    def "sign single artifact with defaults"() {
        when:
        def operation = signing.sign(input1Artifact)
        
        then:
        output1.exists()

    }

    def "sign configuration with inherited artifacts"() {
        when:
        signing {
            sign configurations.produced
        }

        then:
        configurations.signatures.artifacts.size() == 3
        signProduced.signatures.every { it in configurations.signatures.artifacts }
    }

    def "sign configuration with custom type"() {
        def signingTasks

In some cases the artifact that you need to sign may not be part of a configuration.
In this case you can directly sign the task that produces the artifact to sign.

.Signing a task output
====
include::sample[dir="snippets/signing/tasks/kotlin",files="build.gradle.kts[tags=sign-task]"]
include::sample[dir="snippets/signing/tasks/groovy",files="build.gradle[tags=sign-task]"]
====

	}

	message := []byte("message")
	var noHash crypto.Hash
	signature, err := signer.Sign(zero, message, noHash)
	if err != nil {
		t.Fatalf("error from Sign(): %s", err)
	}

	signature2, err := signer.Sign(zero, message, &Options{Hash: noHash})
	if err != nil {
		t.Fatalf("error from Sign(): %s", err)
	}
	if !bytes.Equal(signature, signature2) {
		t.Errorf("signatures keys do not match")
	}

//
//	abs(±Inf) = +Inf
//	abs(NaN) = NaN
func abs(x float64) float64 {
	const sign = 1 << 63
	return float64frombits(float64bits(x) &^ sign)
}

// copysign returns a value with the magnitude
// of x and the sign of y.
func copysign(x, y float64) float64 {
	const sign = 1 << 63
	return float64frombits(float64bits(x)&^sign | float64bits(y)&sign)
}

// float64bits returns the IEEE 754 binary representation of f.