* @return a new, empty {@code CompactLinkedHashMap} with enough capacity to hold {@code
   *     expectedSize} elements without resizing
   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactLinkedHashMap<K, V> createWithExpectedSize(int expectedSize) {
    return new CompactLinkedHashMap<>(expectedSize);
  }

            throw new IllegalArgumentException("Data buffer cannot be null");
        }
        if (offset < 0 || length < 0) {
            throw new IllegalArgumentException("Offset and length must be non-negative");
        }
        if (offset + length > data.length) {
            throw new IllegalArgumentException("Offset + length exceeds data buffer size");
        }

            assertNotNull(e);
        }
    }

    // Test various numeric values for time adjust
    public void xtest_getTimeAdjustTimeMillisAsLong_variousValues() {
        // Test negative value
        FessEnv.SimpleImpl negativeEnv = new FessEnv.SimpleImpl() {
            protected Properties prepareProperties() {
                Properties props = new Properties();

import okio.Buffer
import okio.BufferedSource
import okio.ByteString
import okio.ForwardingSource
import okio.Source
import okio.buffer

/**
 * Streaming decoder of data encoded following Abstract Syntax Notation One (ASN.1). There are
 * multiple variants of ASN.1, including:
 *
 *  * DER: Distinguished Encoding Rules. This further constrains ASN.1 for deterministic encoding.
 *  * BER: Basic Encoding Rules.
 *

 * This is either a mapping decision or the length of the mapped output, according to this table:
 *
 * ```
 *  0..63 : Length of the UTF-16 sequence that this range maps to. The offset is b2b3.
 * 64..79 : Offset by a fixed negative offset. The bottom 4 bits of b1 are the top 4 bits of the offset.
 * 80..95 : Offset by a fixed positive offset. The bottom 4 bits of b1 are the top 4 bits of the offset.
 *    119 : Ignored.
 *    120 : Valid.

      fail();
    } catch (NumberFormatException expected) {
    } catch (IllegalArgumentException expected) {
      // Kotlin native, see above
    }

    // The radix is used as an array index, so try a negative value.
    try {
      UnsignedInts.parseUnsignedInt("0", -1);
      fail();
    } catch (NumberFormatException expected) {
    } catch (IllegalArgumentException expected) {
      // Kotlin native, see above

    assertThrows(
        NumberFormatException.class,
        () -> UnsignedLongs.parseUnsignedLong("0", Character.MAX_RADIX + 1));

    // The radix is used as an array index, so try a negative value.
    assertThrows(NumberFormatException.class, () -> UnsignedLongs.parseUnsignedLong("0", -1));
  }

  public void testToString() {
    String[] tests = {
      "0",
      "ffffffffffffffff",

   *
   * <p><b>Note:</b> this method behaves identically to {@link Byte#compare}.
   *
   * @param a the first {@code byte} to compare
   * @param b the second {@code byte} to compare
   * @return a negative value if {@code a} is less than {@code b}; a positive value if {@code a} is
   *     greater than {@code b}; or zero if they are equal
   */
  public static int compare(byte a, byte b) {
    return Byte.compare(a, b);
  }

    if (localInputFuture != null) {
      String message = "inputFuture=[" + localInputFuture + "]";
      if (localTimer != null) {
        long delay = localTimer.getDelay(MILLISECONDS);
        // Negative delays look confusing in an error message
        if (delay > 0) {
          message += ", remaining delay=[" + delay + " ms]";
        }
      }
      return message;
    }
    return null;
  }

    void testTimeReadWriteZero() {
        byte[] buffer = new byte[8];
        ServerMessageBlock.writeTime(0, buffer, 0);
        // When zero is written, it stays as zero in buffer
        // When read back, it converts to negative Unix time due to Windows FileTime conversion
        long expectedTime = -SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601;
        assertEquals(expectedTime, ServerMessageBlock.readTime(buffer, 0));
    }

    @Test