// (Unicode code points above \uFFFF are represented via surrogate pairs
    // which means they are treated as pairs of safe characters).
    builder.setSafeRange(Character.MIN_VALUE, '\uFFFD');
    // Unsafe characters are replaced with the Unicode replacement character.
    builder.setUnsafeReplacement("\uFFFD");

    /*

            assertDoesNotThrow(() -> impl.fixupDomain(domain));
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, -1, Integer.MIN_VALUE, Integer.MAX_VALUE })
        @DisplayName("Should handle various values in stripPathConsumed")
        void testStripPathConsumedWithVariousValues(int value) {
            // Test with mock

      return null;
    }
    long accum = -digit;

    long cap = Long.MIN_VALUE / radix;

    while (index < string.length()) {
      digit = AsciiDigits.digit(string.charAt(index++));
      if (digit < 0 || digit >= radix || accum < cap) {
        return null;
      }
      accum *= radix;
      if (accum < Long.MIN_VALUE + digit) {
        return null;
      }
      accum -= digit;
    }

                Arguments.of(0xFFFFFFFF, false), Arguments.of(0x80000000, false), Arguments.of(Integer.MAX_VALUE, false),
                Arguments.of(Integer.MIN_VALUE, false));
    }

    // Concrete implementation for testing abstract class
    private static class TestSessionServicePacket extends SessionServicePacket {

        int result = SMBUtil.readInt4(buffer, 0);
        assertEquals((int) (input & 0xFFFFFFFFL), result);
    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 0x123456789ABCDEF0L })
    void testWriteReadInt8RoundTrip(long input) {
        byte[] buffer = new byte[8];
        SMBUtil.writeInt8(input, buffer, 0);
        long result = SMBUtil.readInt8(buffer, 0);

        // Assert
        assertNotNull(transPeekNamedPipe);
        assertNull(transPeekNamedPipe.name);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, -1, Integer.MAX_VALUE, Integer.MIN_VALUE, 0xFFFF })
    @DisplayName("Constructor should handle various FID values")
    void testConstructorWithVariousFids(int fid) {
        // Act
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, fid);

  private static final byte[] EMPTY = {};
  private static final byte[] ARRAY1 = {(byte) 1};
  private static final byte[] ARRAY234 = {(byte) 2, (byte) 3, (byte) 4};

  private static final byte[] VALUES = {Byte.MIN_VALUE, -1, 0, 1, Byte.MAX_VALUE};

  // We need to test that our method behaves like the JDK method.
  @SuppressWarnings("InlineMeInliner")
  public void testHashCode() {
    for (byte value : VALUES) {

    frame.writeByte(Http2.TYPE_SETTINGS)
    frame.writeByte(FLAG_NONE)
    frame.writeInt(0) // Settings are always on the connection stream 0.
    frame.writeShort(4) // SETTINGS_INITIAL_WINDOW_SIZE
    frame.writeInt(Int.MIN_VALUE)
    assertFailsWith<IOException> {
      reader.nextFrame(requireSettings = false, BaseTestHandler())
    }.also { expected ->
      assertThat(expected.message).isEqualTo(

   */
  public CharMatcher precomputed() {
    return Platform.precomputeCharMatcher(this);
  }

  private static final int DISTINCT_CHARS = Character.MAX_VALUE - Character.MIN_VALUE + 1;

  /**
   * This is the actual implementation of {@link #precomputed}, but we bounce calls through a method
   * on {@link Platform} so that we can have different behavior in GWT.
   *

    @Test
    @DisplayName("Should handle different previous session IDs")
    void testDifferentPreviousSessionIds() throws Exception {
        // Given
        long[] sessionIds = { 0L, 1L, Long.MAX_VALUE, Long.MIN_VALUE, 0xFFFFFFFFFFFFFFFFL };

        for (long sessionId : sessionIds) {
            Smb2SessionSetupRequest req = new Smb2SessionSetupRequest(mockContext, TEST_SECURITY_MODE, TEST_CAPABILITIES, sessionId, null);