case 14:
          k2 ^= (long) toUnsignedInt(bb.get(13)) << 40; // fall through
        case 13:
          k2 ^= (long) toUnsignedInt(bb.get(12)) << 32; // fall through
        case 12:
          k2 ^= (long) toUnsignedInt(bb.get(11)) << 24; // fall through
        case 11:
          k2 ^= (long) toUnsignedInt(bb.get(10)) << 16; // fall through
        case 10:

    Route(
      address = address,
      proxy = proxy,
      socketAddress = socketAddress,
    )

  fun newChain(call: RealCall): RealInterceptorChain =
    RealInterceptorChain(
      call = call,
      interceptors = listOf(),
      index = 0,
      exchange = null,
      request = call.request(),
      connectTimeoutMillis = 10_000,
      readTimeoutMillis = 10_000,
      writeTimeoutMillis = 10_000,
    )

 * creation methods appear to adhere doggedly to the original intent of the "mapped" address: all
 * "mapped" addresses return {@link Inet4Address} objects.
 *
 * <p>For added safety, it is common for IPv6 network operators to filter all packets where either
 * the source or destination address appears to be a "compat" or "mapped" address. Filtering

            // The implementation doesn't check for null in constructor
            buffer = new DfsReferralRequestBuffer(path, maxReferralLevel);
            assertNotNull(buffer);

            // Will throw NPE when trying to call size() or encode()
            assertThrows(NullPointerException.class, () -> {
                buffer.size();
            });
        }

        @ParameterizedTest

	return c.call(ctx, lockRPCRLock, &args)
}

// Lock calls lock REST API.
func (c *lockRESTClient) Lock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCLock, &args)
}

// RUnlock calls read unlock REST API.
func (c *lockRESTClient) RUnlock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCRUnlock, &args)
}

    server.enqueue(MockResponse())

    val url =
      server
        .url("/")
        .newBuilder()
        .host("localhost.localdomain")
        .build()
    val call = client.newCall(Request(url = url))
    val response = call.execute()
    assertThat(response.isSuccessful).isTrue()

    val recordedRequest = server.takeRequest()
    // https://github.com/bcgit/bc-java/issues/1773
    if (!platform.isBouncyCastle()) {

              @Override
              public ClosingFuture<TestCloseable> call(DeferredCloser closer) {
                closer.eventuallyClose(closeable1, closingExecutor);
                return ClosingFuture.submit(
                    new ClosingCallable<TestCloseable>() {
                      @Override
                      public TestCloseable call(DeferredCloser deferredCloser) throws Exception {

    compressed file (like a JAR or APK), so compressing its internal data was redundant.

 *  Fix: Call `ProxySelector.connectFailed()` when a connection's initial TCP handshake fails.

 *  Fix: Change the signature of `Dispatcher` to accept a nullable `ExecutorService`. Changing this
    parameter to be non-null was an unintended signature change in OkHttp 4.0.

  final class KeySet extends View<K, V, K> {
    KeySet() {
      super(HashBiMap.this);
    }

    @Override
    @ParametricNullness
    K forEntry(int entry) {
      // The cast is safe because we call forEntry only for indexes that contain entries.
      return uncheckedCastNullableTToT(keys[entry]);
    }

    @Override
    public boolean contains(@Nullable Object o) {
      return HashBiMap.this.containsKey(o);

          }
        }

        @Override
        public void remove() {
          if (toRemove == null) {
            throw new IllegalStateException("no calls to next() since the last call to remove()");
          }
          forward().remove(toRemove.getKey());
          toRemove = null;
        }
      };
    }
  }

  @Override
  public NavigableSet<K> navigableKeySet() {