Comparable[] c = new Comparable[versions.length];
        for (int i = 0; i < versions.length; i++) {
            c[i] = newComparable(versions[i]);
        }

        for (int i = 1; i < versions.length; i++) {
            Comparable low = c[i - 1];
            for (int j = i; j < versions.length; j++) {
                Comparable high = c[j];

    assertEquals(2 * entries.size(), alternatingKeysAndValues.length);
    assertEquals(2 * keys.size(), alternatingKeysAndValues.length);
    assertEquals(2 * values.size(), alternatingKeysAndValues.length);
    for (int i = 0; i < map.size(); i++) {
      Object expectedKey = alternatingKeysAndValues[2 * i];
      Object expectedValue = alternatingKeysAndValues[2 * i + 1];

    public Iterator<Entry<K, V>> iterator() {
      return entryIterator();
    }
  }

  @WeakOuter
  final class EntrySet extends Entries implements Set<Entry<K, V>> {
    @Override
    public int hashCode() {
      return Sets.hashCodeImpl(this);
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      return Sets.equalsImpl(this, obj);
    }
  }

    private void writeLittleEndianInt(ByteArrayOutputStream baos, int value) {
        baos.write(value & 0xFF);
        baos.write((value >> 8) & 0xFF);
        baos.write((value >> 16) & 0xFF);
        baos.write((value >> 24) & 0xFF);
    }

    private void writeLittleEndianLong(ByteArrayOutputStream baos, long value) {
        for (int i = 0; i < 8; i++) {
            baos.write((int) ((value >> (i * 8)) & 0xFF));
        }
    }

    }

    @Override
    public int count(@Nullable Object element) {
      return standardCount(element);
    }

    @Override
    public boolean equals(@Nullable Object object) {
      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override

            Handler.factory = factory;
        }
    }

    /**
     * Returns the default HTTP port.
     *
     * @return An <code>int</code> containing the default HTTP port.
     */
    @Override
    protected int getDefaultPort() {
        return DEFAULT_HTTP_PORT;
    }

    @Override
    protected URLConnection openConnection(URL url) throws IOException {

        buffer[5] = 0x00;
        // eaErrorOffset (2 bytes)
        buffer[6] = 0x00;
        buffer[7] = 0x00;
        // lastNameOffset (2 bytes)
        buffer[8] = 0x10;
        buffer[9] = 0x00;

        int result = response.readParametersWireFormat(buffer, 0, 10);

        // Should read 10 bytes
        assertEquals(10, result);
        // Check the values were parsed correctly
        assertEquals(1, response.getSid());

            snapshot.setTimestamp(getDeploymentTimestamp());

            // we update the build number anyway so that it doesn't get lost. It requires the timestamp to take effect
            try {
                int buildNumber = resolveLatestSnapshotBuildNumber(artifact, localRepository, remoteRepository);

                snapshot.setBuildNumber(buildNumber + 1);
            } catch (RepositoryMetadataResolutionException e) {

    }

    @Test
    @DisplayName("Should format with specific offset and length")
    void testHexdumpWithOffsetAndLength() {
        // Given
        byte[] data = createTestData(64);
        int offset = 16;
        int length = 32;

        // When
        String result = Hexdump.toHexString(data, offset, length);

        // Then
        assertNotNull(result);
        assertFalse(result.isEmpty());

  fun clear(hostname: String): FakeDns {
    hostAddresses.remove(hostname)
    return this
  }

  @Throws(UnknownHostException::class)
  fun lookup(
    hostname: String,
    index: Int,
  ): InetAddress = hostAddresses[hostname]!![index]

  @Throws(UnknownHostException::class)
  override fun lookup(hostname: String): List<InetAddress> {
    requestedHosts.add(hostname)