val heldCertificate =
      HeldCertificate
        .Builder()
        .commonName("server name")
        .addSubjectAlternativeName("url-host.com")
        .build()
    val handshakeCertificates =
      HandshakeCertificates
        .Builder()
        .heldCertificate(heldCertificate)
        .addTrustedCertificate(heldCertificate.certificate)
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())

  @Test
  fun processResponse() {
    server.enqueue(
      MockResponse
        .Builder()
        .body(
          """
          |data: hey
          |
          |
          """.trimMargin(),
        ).setHeader("content-type", "text/event-stream")
        .build(),
    )
    val request = Request.Builder().url(server.url("/")).build()
    val response = client.newCall(request).execute()

    vararg intermediates: X509Certificate,
  ): OkHttpClient {
    val builder =
      HandshakeCertificates
        .Builder()
        .addTrustedCertificate(serverRootCa.certificate)
    if (heldCertificate != null) {
      builder.heldCertificate(heldCertificate, *intermediates)
    }
    val handshakeCertificates = builder.build()
    return clientTestRule
      .newClientBuilder()
      .sslSocketFactory(

            addCalls.incrementAndGet();
            return super.add(element, occurrences);
          }
        };
    ImmutableMultiset<String> adds =
        new ImmutableMultiset.Builder<String>().addCopies("x", 10).build();
    multiset.addAll(adds);
    assertEquals(1, addCalls.get());
  }

  public void testRemoveUnsupported() {
    Multiset<String> multiset = new NoRemoveMultiset<>();
    multiset.add("a");

func (locking Locking) Name() string {
	return "FOR"
}

// Build build where clause
func (locking Locking) Build(builder Builder) {
	builder.WriteString(locking.Strength)
	if locking.Table.Name != "" {
		builder.WriteString(" OF ")
		builder.WriteQuoted(locking.Table)
	}

	if locking.Options != "" {
		builder.WriteByte(' ')
		builder.WriteString(locking.Options)
	}
}

// MergeClause merge order by clauses

        .socketHandler(body)
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .body("this is /b")
        .build(),
    )
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .post(AsyncRequestBody())
          .build(),
      )
    call.execute().use { response ->

func (insert Insert) Name() string {
	return "INSERT"
}

// Build build insert clause
func (insert Insert) Build(builder Builder) {
	if insert.Modifier != "" {
		builder.WriteString(insert.Modifier)
		builder.WriteByte(' ')
	}

	builder.WriteString("INTO ")
	if insert.Table.Name == "" {
		builder.WriteQuoted(currentTable)
	} else {
		builder.WriteQuoted(insert.Table)
	}
}

// MergeClause merge insert clause

        if (esCb.getPreference() != null) {
            builder.setPreference(esCb.getPreference());
        }
        esCb.request().build(builder);
        final SearchResponse response = esCb.build(builder).execute().actionGet(searchTimeout);

        final EsPagingResultBean<RESULT> list = new EsPagingResultBean<>(builder);
        final SearchHits searchHits = getSearchHits(response);

    private static final String BUILD_POM_CLASSIFIER = "build";

    private final Set<Path> toDelete = new CopyOnWriteArraySet<>();

    private final PomBuilder builder;

    @Inject
    ConsumerPomArtifactTransformer(PomBuilder builder) {
        this.builder = builder;
    }

    @SuppressWarnings("deprecation")
    @Override

        builder = new DefaultMessageBuilder();
        format.formatRate(builder, 5500.0); // 5.5 kB/s
        assertEquals("5.5 kB/s", builder.build());

        // Test exact unit thresholds
        builder = new DefaultMessageBuilder();
        format.formatRate(builder, 1000.0); // 1 kB/s
        assertEquals("1.0 kB/s", builder.build());

        builder = new DefaultMessageBuilder();