expiresAt = Long.MIN_VALUE
      } else if (deltaSeconds != -1L) {
        val deltaMilliseconds =
          if (deltaSeconds <= Long.MAX_VALUE / 1000) {
            deltaSeconds * 1000
          } else {
            Long.MAX_VALUE
          }
        expiresAt = currentTimeMillis + deltaMilliseconds
        if (expiresAt < currentTimeMillis || expiresAt > MAX_DATE) {

      super(stripes);
      this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;
      this.locks = new AtomicReferenceArray<>(size);
      this.supplier = supplier;
    }

    @Override
    public L getAt(int index) {
      if (size != Integer.MAX_VALUE) {
        Preconditions.checkElementIndex(index, size());
      } // else no check necessary, all index values are valid

    void testDecodeWithMaxValues() throws SMBProtocolDecodingException {
        // Prepare test data with maximum values
        byte[] buffer = new byte[22];
        long maxLong = Long.MAX_VALUE;
        int maxInt = Integer.MAX_VALUE;

        // Encode test data
        int offset = 0;
        SMBUtil.writeInt8(maxLong, buffer, offset);
        offset += 8;
        SMBUtil.writeInt8(maxLong, buffer, offset);

    assertLockHeld()

    while (true) {
      if (readyQueues.isEmpty()) {
        return null // Nothing to do.
      }

      val now = backend.nanoTime()
      var minDelayNanos = Long.MAX_VALUE
      var readyTask: Task? = null
      var multipleReadyTasks = false

      // Decide what to run. This loop's goal wants to:
      //  * Find out what this thread should do (either run a task or sleep)

    if (safeMax < safeMin) {
      // If the safe range is empty, set the range limits to opposite extremes
      // to ensure the first test of either value will fail.
      safeMax = -1;
      safeMin = Integer.MAX_VALUE;
    }
    this.safeMin = safeMin;
    this.safeMax = safeMax;

    // This is a bit of a hack but lets us do quicker per-character checks in

    // We cannot read all, as the source does not close.
    // Instead, we ensure that all bytes from source have been processed by inflater.
    do {
      inflaterSource.readOrInflate(buffer, Long.MAX_VALUE)
    } while (inflater.bytesRead < totalBytesToRead && !inflater.finished())

    // The inflater data was self-terminated and there's unexpected trailing data. Tear it all down

public class DoubleMathTest extends TestCase {

  private static final BigDecimal MAX_INT_AS_BIG_DECIMAL = BigDecimal.valueOf(Integer.MAX_VALUE);
  private static final BigDecimal MIN_INT_AS_BIG_DECIMAL = BigDecimal.valueOf(Integer.MIN_VALUE);

  private static final BigDecimal MAX_LONG_AS_BIG_DECIMAL = BigDecimal.valueOf(Long.MAX_VALUE);
  private static final BigDecimal MIN_LONG_AS_BIG_DECIMAL = BigDecimal.valueOf(Long.MIN_VALUE);

        }

    val b2: Int
      get() = absoluteDelta shr 7 and 0x7f

    val b3: Int
      get() = absoluteDelta and 0x7f

    companion object {
      const val MAX_VALUE = 0x3FFFF
    }
  }

  data class External(
    override val rangeStart: Int,
    val mappedTo: ByteString,
  ) : MappedRange

                    long multiplier = 1L << safeShift;
                    // Check for potential overflow before multiplication
                    long delay = (retryDelayMs > Long.MAX_VALUE / multiplier) ? MAX_RETRY_DELAY
                            : Math.min(MAX_RETRY_DELAY, retryDelayMs * multiplier);
                    Thread.sleep(delay);
                }

    for (long value : UNSIGNED_INTS) {
      assertThat(UnsignedInts.toLong(UnsignedInts.checkedCast(value))).isEqualTo(value);
    }
    assertCastFails(1L << 32);
    assertCastFails(-1L);
    assertCastFails(Long.MAX_VALUE);
    assertCastFails(Long.MIN_VALUE);
  }

  private static void assertCastFails(long value) {
    try {
      UnsignedInts.checkedCast(value);
      fail("Cast to int should have failed: " + value);