}
  }

  class FakeSSLSession(
    private val protocol: String,
    private val cipherSuite: String,
    private val peerCertificates: Array<Certificate>?,
    private val localCertificates: Array<Certificate>?,
  ) : DelegatingSSLSession(null) {
    override fun getProtocol() = protocol

    override fun getCipherSuite() = cipherSuite

        char[] dst2 = new char[4];
        Hexdump.toHexChars(0xABCD, dst2, 0, 4);
        assertEquals("ABCD", new String(dst2));

        // Test with offset
        char[] dst3 = new char[10];
        java.util.Arrays.fill(dst3, 'X');
        Hexdump.toHexChars(0xFF, dst3, 2, 2);
        assertEquals("XXFFXXXXXX", new String(dst3));

        // Test long conversion
        char[] dst4 = new char[16];

  }

  private static final class ArrayItr<T extends @Nullable Object>
      extends AbstractIndexedListIterator<T> {
    static final UnmodifiableListIterator<Object> EMPTY = new ArrayItr<>(new Object[0], 0);

    private final T[] array;

    ArrayItr(T[] array, int position) {
      super(array.length, position);
      this.array = array;
    }

    @Override

/**
 * Helper class for language detection.
 */
public class LanguageHelper {
    private static final Logger logger = LogManager.getLogger(LanguageHelper.class);

    /** An array of language fields. */
    protected String[] langFields;

    /** An array of supported languages. */
    protected String[] supportedLanguages;

    /** The language detector. */
    protected LanguageDetector detector;

      }
    }
  }

  /**
   * Resizes the internal entries array to the specified capacity, which may be greater or less than
   * the current capacity.
   */
  void resizeEntries(int newCapacity) {
    this.entries = Arrays.copyOf(requireEntries(), newCapacity);
    this.keys = Arrays.copyOf(requireKeys(), newCapacity);
    this.values = Arrays.copyOf(requireValues(), newCapacity);
  }

  @CanIgnoreReturnValue

        assertEquals("00FF7F80", result);
    }

    @Test
    @DisplayName("Should handle large byte arrays efficiently")
    void testLargeByteArray() {
        // Create a larger test array
        byte[] data = createTestData(1024);

        // Test full array conversion
        String result = Hexdump.toHexString(data);
        assertEquals(2048, result.length()); // 1024 bytes * 2 chars

        verify(consumer, times(3)).accept(dosCaptor.capture(), ntCaptor.capture());
        assertIterableEquals(Arrays.asList(0x00000000, 0x00050001, 0x007b0001), dosCaptor.getAllValues());
        assertIterableEquals(Arrays.asList(0x00000000, 0xc0000022, 0xc0000033), ntCaptor.getAllValues());

        // And ensure no further interactions happened
        verifyNoMoreInteractions(consumer);

   * lies outside the stated safe range. Subclasses should override this method to provide
   * generalized escaping for characters.
   *
   * <p>Note that arrays returned by this method must not be modified once they have been returned.
   * However it is acceptable to return the same array multiple times (even for different input
   * characters).
   *

    // In GWT array access never throws IndexOutOfBoundsException.
    checkElementIndex(rowIndex, rowList.size());
    checkElementIndex(columnIndex, columnList.size());
    V oldValue = array[rowIndex][columnIndex];
    array[rowIndex][columnIndex] = value;
    return oldValue;
  }

  /**
   * Returns a two-dimensional array with the table contents. The row and column indices correspond

  }

  /** Convenience method to compute a fingerprint on a full bytes array. */
  private static long fingerprint(byte[] bytes) {
    return fingerprint(bytes, bytes.length);
  }

  /** Convenience method to compute a fingerprint on a subset of a byte array. */
  private static long fingerprint(byte[] bytes, int length) {
    return HASH_FN.hashBytes(bytes, 0, length).asLong();
  }