.body("A")
        .build(),
    )
    server.enqueue(
      MockResponse.Builder()
        .body("B")
        .build(),
    )
    val url = server.url("/")
    val request =
      Request.Builder()
        .url(url)
        .header("Accept-Language", "fr-CA")
        .header("Accept-Charset", "UTF-8")
        .header("Accept-Encoding", "identity")
        .build()

      public void forEach(Consumer<? super T> action) {
        checkNotNull(action);
        new Consumer<T>() {
          @Override
          public void accept(T t) {
            action.accept(t);
            children(t).forEach(this);
          }
        }.accept(root);
      }
    };
  }

  UnmodifiableIterator<T> preOrderIterator(T root) {
    return new PreOrderIterator(root);
  }

            final RequestProcessor processor = new RequestProcessor(encoding, threshold);
            processor.accept(con);
            try (final CurlResponse res = processor.getResponse()) {
                actionListener.accept(res);
            } catch (final IOException e) {
                exceptionListener.accept(e);
            }
        }, exceptionListener);
    }

    public CurlResponse execute() {

import junit.framework.TestCase;

/**
 * Tests for {@code AbstractBiMap}.
 *
 * @author Mike Bostock
 */
public class AbstractBiMapTest extends TestCase {

  // The next two tests verify that map entries are not accessed after they're
  // removed, since IdentityHashMap throws an exception when that occurs.
  @SuppressWarnings("IdentityHashMapBoxing") // explicitly testing IdentityHashMap
  public void testIdentityKeySetIteratorRemove() {

import junit.framework.TestCase;

/**
 * Tests for {@code AbstractBiMap}.
 *
 * @author Mike Bostock
 */
public class AbstractBiMapTest extends TestCase {

  // The next two tests verify that map entries are not accessed after they're
  // removed, since IdentityHashMap throws an exception when that occurs.
  @SuppressWarnings("IdentityHashMapBoxing") // explicitly testing IdentityHashMap
  public void testIdentityKeySetIteratorRemove() {

        .url(server.url("/"))
        .header("Accept", "text/plain")
        .build()
    val response = client.newCall(request).execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("hello, OkHttp")

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isEqualTo("gzip")

 */
package jcifs.smb;


import java.util.Objects;

import org.bouncycastle.asn1.ASN1ObjectIdentifier;


/**
 * This class is used to parse the name of context initiator and
 * context acceptor which are retrieved from GSSContext.
 * 
 * @author Shun
 *
 */
class MIEName {

    private static byte[] TOK_ID = {
        04, 01
    };
    private static int TOK_ID_SIZE = 2;

    if (streamA.isParallel() || streamB.isParallel()) {
      zip(streamA, streamB, TemporaryPair::new).forEach(pair -> consumer.accept(pair.a, pair.b));
    } else {
      Iterator<A> iterA = streamA.iterator();
      Iterator<B> iterB = streamB.iterator();
      while (iterA.hasNext() && iterB.hasNext()) {
        consumer.accept(iterA.next(), iterB.next());
      }
    }
  }

   * network interceptors return.
   */
  internal var interceptorScopedExchange: Exchange? = null
    private set

  // These properties are guarded by [lock]. They are typically only accessed by the thread executing
  // the call, but they may be accessed by other threads for duplex requests.

  /** True if this call still has a request body open. */
  private var requestBodyOpen = false

      .assertNoMoreLogs()
    networkLogs
      .assertLogEqual("--> GET $url http/1.1")
      .assertLogEqual("Host: $host")
      .assertLogEqual("Connection: Keep-Alive")
      .assertLogEqual("Accept-Encoding: gzip")
      .assertLogMatch(Regex("""User-Agent: okhttp/.+"""))
      .assertLogEqual("--> END GET")
      .assertLogMatch(Regex("""<-- 200 OK $url \(\d+ms\)"""))
      .assertLogEqual("Content-Length: 0")