*p256Element) int { var acc uint64 for i := range a { acc |= a[i] ^ b[i] } return uint64IsZero(acc) } // isInfinity returns 1 if p is the point at infinity and 0 otherwise. func (p *P256Point) isInfinity() int { return p256Equal(&p.z, &p256Zero) } // Bytes returns the uncompressed or infinity encoding of p, as specified in // SEC 1, Version 2.0, Section 2.3.3. Note that the encoding of the point at // infinity is shorter than all other encodings. func (p *P256Point) Bytes() []byte { // This function is outlined...

*p256Element) int { var acc uint64 for i := range a { acc |= a[i] ^ b[i] } return uint64IsZero(acc) } // isInfinity returns 1 if p is the point at infinity and 0 otherwise. func (p *P256Point) isInfinity() int { return p256Equal(&p.z, &p256Zero) } // Bytes returns the uncompressed or infinity encoding of p, as specified in // SEC 1, Version 2.0, Section 2.3.3. Note that the encoding of the point at // infinity is shorter than all other encodings. func (p *P256Point) Bytes() []byte { // This function is outlined...

   *
   * <p>Special cases:
   *
   * <ul>
   *   <li>If {@code x} is NaN or less than zero, the result is NaN.
   *   <li>If {@code x} is positive infinity, the result is positive infinity.
   *   <li>If {@code x} is positive or negative zero, the result is negative infinity.
   * </ul>
   *
   * <p>The computed result is within 1 ulp of the exact result.
   *

    data = {"value": Decimal("NaN")}
    assert isnan(jsonable_encoder(data)["value"])


def test_decimal_encoder_infinity():
    data = {"value": Decimal("Infinity")}
    assert isinf(jsonable_encoder(data)["value"])
    data = {"value": Decimal("-Infinity")}
    assert isinf(jsonable_encoder(data)["value"])


def test_encode_deque_encodes_child_models():
    class Model(BaseModel):
        test: str

    checkTryParse(Double.POSITIVE_INFINITY, "Infinity");
    checkTryParse(Double.POSITIVE_INFINITY, "+Infinity");
    checkTryParse(Double.NEGATIVE_INFINITY, "-Infinity");
  }

  private static final String[] BAD_TRY_PARSE_INPUTS = {
    "",
    "+-",
    "+-0",
    " 5",
    "32 ",
    " 55 ",
    "infinity",
    "POSITIVE_INFINITY",
    "0x9A",
    "0x9A.bE-5",
    ".",

        assertTrue(infinityOpt.isPresent());
        assertTrue(Double.isInfinite(infinityOpt.get()));

        OptionalEntity<Float> negInfinityOpt = OptionalUtil.ofNullable(Float.NEGATIVE_INFINITY);
        assertTrue(negInfinityOpt.isPresent());
        assertTrue(Float.isInfinite(negInfinityOpt.get()));

        // Test with very large strings

    return Double.compare(a, b);
  }

  /**
   * Returns {@code true} if {@code value} represents a real number. This is equivalent to, but not
   * necessarily implemented as, {@code !(Double.isInfinite(value) || Double.isNaN(value))}.
   *
   * <p>Prefer {@link Double#isFinite(double)} instead.
   *
   * @since 10.0
   */
  @InlineMe(replacement = "Double.isFinite(value)")

        return readShort() & 0xffff;
    }

    /**
     * Reads a Windows FILETIME value and converts it to a Date.
     * @return the Date object, or null if the time represents infinity
     * @throws IOException if an I/O error occurs
     */
    public Date readFiletime() throws IOException {
        Date date = null;

        final long last = readUnsignedInt();

  public void testIsPowerOfTwo() {
    for (double x : ALL_DOUBLE_CANDIDATES) {
      boolean expected =
          x > 0
              && !Double.isInfinite(x)
              && !Double.isNaN(x)
              && StrictMath.pow(2.0, DoubleMath.log2(x, FLOOR)) == x;
      assertEquals(expected, DoubleMath.isPowerOfTwo(x));
    }
  }

  public void testIsPowerOfTwo() {
    for (double x : ALL_DOUBLE_CANDIDATES) {
      boolean expected =
          x > 0
              && !Double.isInfinite(x)
              && !Double.isNaN(x)
              && StrictMath.pow(2.0, DoubleMath.log2(x, FLOOR)) == x;
      assertEquals(expected, DoubleMath.isPowerOfTwo(x));
    }
  }