*
   * <p>The array {@code rest} must not be longer than {@code Integer.MAX_VALUE - 1}.
   */
  // Use (first, rest) so that `of(someIntArray)` won't compile (they should use copyOf), which is
  // okay since we have to copy the just-created array anyway.
  public static ImmutableIntArray of(int first, int... rest) {
    checkArgument(
        rest.length <= Integer.MAX_VALUE - 1, "the total number of elements must fit in an int");

    long nanosPerSecond = NANOSECONDS.convert(1, SECONDS);
    assertThat(nanosPerSecond * Long.MAX_VALUE).isLessThan(0L);

    // Check that we wait long enough anyway (presumably as long as MAX_VALUE nanos):
    TimedWaiterThread waiter = new TimedWaiterThread(future, Long.MAX_VALUE, SECONDS);
    waiter.start();
    waiter.awaitWaiting();

    future.set(1);
    waiter.join();
  }

                    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);
                }

        assertNotNull(trans2SetFileInfo);

        // Test with maximum values
        trans2SetFileInfo = new Trans2SetFileInformation(config, 0xFFFF, Integer.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE);
        assertNotNull(trans2SetFileInfo);
    }

    @Test
    @DisplayName("Test attributes with OR operation")
    void testAttributesWithOrOperation() {

    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

    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);

    }

    // Test execute with large number of deleted files
    public void test_execute_largeNumberOfFiles() {
        thumbnailManager.setPurgeCallCount(Long.MAX_VALUE);

        String result = purgeThumbnailJob.execute();

        assertEquals("Deleted " + Long.MAX_VALUE + " thumbnail files.", result);
    }

    // Test method chaining with multiple expiry calls
    public void test_expiryChaining() {

    }
  }

  public static final class FloatsAsListHeadSubListGenerator extends TestFloatListGenerator {
    @Override
    protected List<Float> create(Float[] elements) {
      Float[] suffix = {Float.MIN_VALUE, Float.MAX_VALUE};
      Float[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class FloatsAsListTailSubListGenerator extends TestFloatListGenerator {

    }
  }

  public static final class FloatsAsListHeadSubListGenerator extends TestFloatListGenerator {
    @Override
    protected List<Float> create(Float[] elements) {
      Float[] suffix = {Float.MIN_VALUE, Float.MAX_VALUE};
      Float[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class FloatsAsListTailSubListGenerator extends TestFloatListGenerator {