new Foo("b", 1, null));
    for (Foo a : instances) {
      for (Foo b : instances) {
        int comparedUsingComparisonChain = signum(comparatorUsingComparisonChain.compare(a, b));
        int comparedUsingComparatorMethods = signum(comparatorUsingComparatorMethods.compare(a, b));
        assertWithMessage("%s vs %s", a, b)
            .that(comparedUsingComparatorMethods)

            assertEquals(1, Integer.signum(v1.compareTo(v2)), "expected " + v1 + " > " + v2);
            assertEquals(-1, Integer.signum(v2.compareTo(v1)), "expected " + v2 + " < " + v1);
            assertNotEquals(v1, v2, "expected " + v1 + " != " + v2);
            assertNotEquals(v2, v1, "expected " + v2 + " != " + v1);
        } else if (expected < 0) {
            assertEquals(-1, Integer.signum(v1.compareTo(v2)), "expected " + v1 + " < " + v2);

		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "OrgNum":
			z.OrgNum, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "OrgNum")
				return
			}
		case "OrgString":
			z.OrgString, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "OrgString")
				return

     * deal with the cases where rounding towards 0 is wrong, which typically depends on the sign of
     * p / q.
     *
     * signum is 1 if p and q are both nonnegative or both negative, and -1 otherwise.
     */
    int signum = 1 | (int) ((p ^ q) >> (Long.SIZE - 1));
    boolean increment;
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(rem == 0);

package cmd

// SetupType - enum for setup type.
type SetupType int

const (
	// UnknownSetupType - starts with unknown setup type.
	UnknownSetupType SetupType = iota

	// FSSetupType - FS setup type enum.
	FSSetupType

	// ErasureSDSetupType - Erasure single drive setup enum.
	ErasureSDSetupType

	// ErasureSetupType - Erasure setup type enum.
	ErasureSetupType

		const wantString = testPayload + testPayload
		if resp.OrgString != testPayload+testPayload {
			t.Errorf("want %q, got %q", wantString, resp.OrgString)
		}
		if resp.OrgNum != n+1 {
			t.Errorf("want %d, got %d", n+1, resp.OrgNum)
		}
		handler.PutResponse(resp)
		n++
		return nil
	})
	errFatal(err)
	t.Log("EOF.", payloads, " Roundtrips:", time.Since(start))
}

    int exponent = absX.bitLength() - 1;
    // exponent == floor(log2(abs(x)))
    if (exponent < Long.SIZE - 1) {
      return x.longValue();
    } else if (exponent > MAX_EXPONENT) {
      return x.signum() * POSITIVE_INFINITY;
    }

    /*
     * We need the top SIGNIFICAND_BITS + 1 bits, including the "implicit" one bit. To make rounding

   * {@code enumClass} using {@link Enum#valueOf(Class, String)} and {@link Enum#name()}. The
   * converter will throw an {@code IllegalArgumentException} if the argument is not the name of any
   * enum constant in the specified enum.
   *
   * @since 16.0
   */
  @GwtIncompatible
  public static <T extends Enum<T>> Converter<String, T> stringConverter(Class<T> enumClass) {

        byte[] sk = this.signKey;
        if ( sk == null ) {
            throw new CIFSException("Signing is not initialized");
        }

        int seqNum = this.signSequence.getAndIncrement();
        byte[] seqBytes = new byte[4];
        SMBUtil.writeInt4(seqNum, seqBytes, 0);

        MessageDigest mac = Crypto.getHMACT64(sk);
        mac.update(seqBytes); // sequence
        mac.update(data); // data

   */
  static BigInteger randomPositiveBigInteger(int numBits) {
    BigInteger result;
    do {
      result = randomNonNegativeBigInteger(numBits);
    } while (result.signum() == 0);
    return result;
  }

  /**
   * Generates a number in [0, 2^numBits) with an exponential distribution. The floor of the log2 of