final BigInteger lastBigInt = BigInteger.valueOf(last);
            final BigInteger firstBigInt = BigInteger.valueOf(first);
            BigInteger completeBigInt = lastBigInt.add(firstBigInt.shiftLeft(32));
            completeBigInt = completeBigInt.divide(BigInteger.valueOf(10000L));
            completeBigInt = completeBigInt.add(BigInteger.valueOf(-SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601));

  }

  /**
   * Does a CPU intensive operation on Integer and returns a BigInteger Used to implement an
   * ordering that spends a lot of cpu.
   */
  static class ExpensiveComputation implements Function<Integer, BigInteger> {
    @Override
    public BigInteger apply(Integer from) {
      BigInteger v = BigInteger.valueOf(from);
      // Math.sin is very slow for values outside 4*pi

  }

  /**
   * Does a CPU intensive operation on Integer and returns a BigInteger Used to implement an
   * ordering that spends a lot of cpu.
   */
  static class ExpensiveComputation implements Function<Integer, BigInteger> {
    @Override
    public BigInteger apply(Integer from) {
      BigInteger v = BigInteger.valueOf(from);
      // Math.sin is very slow for values outside 4*pi

    }

    @Test
    void testConstructorWithBigIntegerVersion() throws IOException {
        // Test with a BigInteger Kerberos version
        byte[] validToken = createTestTicketBytes(new BigInteger(KerberosConstants.KERBEROS_VERSION), SERVER_REALM, SERVER_PRINCIPAL_NAME,
                ENCRYPTION_TYPE, ENCRYPTED_DATA, null);

    return (double) ((value >>> 1) | (value & 1)) * 2.0;
  }

  /** Returns the value of this {@code UnsignedLong} as a {@link BigInteger}. */
  public BigInteger bigIntegerValue() {
    BigInteger bigInt = BigInteger.valueOf(value & UNSIGNED_MASK);
    if (value < 0) {
      bigInt = bigInt.setBit(Long.SIZE - 1);
    }
    return bigInt;
  }

  @Override

   * Returns the {@code Inet4Address} corresponding to a given {@code BigInteger}.
   *
   * @param address BigInteger representing the IPv4 address
   * @return Inet4Address representation of the given BigInteger
   * @throws IllegalArgumentException if the BigInteger is not between 0 and 2^32-1
   * @since 28.2
   */
  public static Inet4Address fromIPv4BigInteger(BigInteger address) {

      tagClass = DerHeader.TAG_CLASS_UNIVERSAL,
      tag = 2L,
      codec =
        object : BasicDerAdapter.Codec<BigInteger> {
          override fun decode(reader: DerReader): BigInteger = reader.readBigInteger()

          override fun encode(
            writer: DerWriter,
            value: BigInteger,
          ) = writer.writeBigInteger(value)
        },
    )

  val BIT_STRING =
    BasicDerAdapter(

   */
  @Override
  public double doubleValue() {
    return longValue();
  }

  /** Returns the value of this {@code UnsignedInteger} as a {@link BigInteger}. */
  public BigInteger bigIntegerValue() {
    return BigInteger.valueOf(longValue());
  }

  /**
   * Compares this unsigned integer to another unsigned integer. Returns {@code 0} if they are

import static com.google.common.truth.Truth.assertThat;
import static java.math.BigInteger.ONE;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.collect.testing.Helpers;
import com.google.common.testing.NullPointerTester;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Comparator;

import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;

import com.google.common.annotations.GwtIncompatible;
import com.google.errorprone.annotations.FormatMethod;
import java.math.BigInteger;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@link DoubleUtils}.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
@NullUnmarked