sign(jar)
            }
        """

        when:
        executer.withEnvironmentVars([
            ORG_GRADLE_PROJECT_secretKey: secretKeyWithPassword,
            ORG_GRADLE_PROJECT_password: password
        ])
        succeeds("signJar")

        then:
        executed(":signJar")
        file("build", "libs", "sign-1.0.jar.asc").exists()
    }

func zForAffine(x, y *big.Int) *big.Int {
	z := new(big.Int)
	if x.Sign() != 0 || y.Sign() != 0 {
		z.SetInt64(1)
	}
	return z
}

// affineFromJacobian reverses the Jacobian transform. See the comment at the
// top of the file. If the point is ∞ it returns 0, 0.
func (curve *CurveParams) affineFromJacobian(x, y, z *big.Int) (xOut, yOut *big.Int) {
	if z.Sign() == 0 {
		return new(big.Int), new(big.Int)
	}

project['signing.keyId'] = "24875D73"
project['signing.password'] = "gradle"
project['signing.secretKeyRingFile'] = file("secKeyRingFile.gpg").absolutePath

// tag::sign-runtime-elements[]
signing {
    sign configurations.runtimeElements
}

		return
	}

	if x == nil {
		fmt.Fprint(s, "<nil>")
		return
	}

	// determine sign character
	sign := ""
	switch {
	case x.neg:
		sign = "-"
	case s.Flag('+'): // supersedes ' ' when both specified
		sign = "+"
	case s.Flag(' '):
		sign = " "
	}

	// determine prefix characters for indicating output base
	prefix := ""
	if s.Flag('#') {
		switch ch {

   * or the least double greater than or equal to the precise value of x.
   */
  abstract double roundToDoubleArbitrarily(X x);

  /** Returns the sign of x: either -1, 0, or 1. */
  abstract int sign(X x);

  /** Returns d's value as an X, rounded with the specified mode. */
  abstract X toX(double d, RoundingMode mode);

  /** Returns a - b, guaranteed that both arguments are nonnegative. */

    }

    TestFile pom(String name = "sign-1.0") {
        m2RepoFile("${name}.pom")
    }

    TestFile pomSignature(String name = "sign-1.0") {
        m2RepoFile("${name}.pom.asc")
    }

    TestFile module(String name = "sign-1.0") {
        m2RepoFile("${name}.module")
    }

    TestFile moduleSignature(String name = "sign-1.0") {
        m2RepoFile("${name}.module.asc")
    }

// Sign signs a hash (which should be the result of hashing a larger message)
// using the private key, priv. If the hash is longer than the bit-length of the
// private key's curve order, the hash will be truncated to that length. It
// returns the signature as a pair of integers. Most applications should use
// [SignASN1] instead of dealing directly with r, s.

   * or the least double greater than or equal to the precise value of x.
   */
  abstract double roundToDoubleArbitrarily(X x);

  /** Returns the sign of x: either -1, 0, or 1. */
  abstract int sign(X x);

  /** Returns d's value as an X, rounded with the specified mode. */
  abstract X toX(double d, RoundingMode mode);

  /** Returns a - b, guaranteed that both arguments are nonnegative. */

The [Kubernetes community repo](https://github.com/kubernetes/community) contains information about how to get started, how the community organizes, and more.

## Sign the CLA

        signing {
            signTasks = sign publishing.publications
        }

        when:
        publishing.publications.clear()

        then:
        !tasks.findByName('signMavenPublication').enabled

        and:
        signTasks.isEmpty()
    }

    def "sign task has description"() {
        when:
        signing {
            sign publishing.publications
        }

        then: