@Test
  fun emptyNameForbidden() {
    val builder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      builder.header("", "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      builder.addHeader("", "Value")
    }
  }

  @Test
  fun headerAllowsTabOnlyInValues() {
    val builder = Request.Builder()
    builder.header("key", "sample\tvalue")

	return "SET"
}

func (set Set) Build(builder Builder) {
	if len(set) > 0 {
		for idx, assignment := range set {
			if idx > 0 {
				builder.WriteByte(',')
			}
			builder.WriteQuoted(assignment.Column)
			builder.WriteByte('=')
			builder.AddVar(builder, assignment.Value)
		}
	} else {
		builder.WriteQuoted(Column{Name: PrimaryKey})
		builder.WriteByte('=')
		builder.WriteQuoted(Column{Name: PrimaryKey})
	}
}

      HeldCertificate
        .Builder()
        .signedBy(intermediateCa)
        .serialNumber(3L)
        .commonName(server.hostName)
        .build()
    val certificatePinner =
      CertificatePinner
        .Builder()
        .add(server.hostName, pin(rootCa.certificate))
        .build()
    val handshakeCertificates =
      HandshakeCertificates
        .Builder()

            builder.field(STORE_NAME.getPreferredName(), storeName);
        }
        if (this.params != null && !this.params.isEmpty()) {
            builder.field(PARAMS.getPreferredName(), this.params);
        }
        if (activeFeatures != null && !activeFeatures.isEmpty()) {
            builder.field(ACTIVE_FEATURES.getPreferredName(), activeFeatures);
        }
        printBoostAndQueryName(builder);
        builder.endObject();

    Escapers.Builder builder = Escapers.builder();
    builder.setSafeRange('a', 'z');
    builder.setUnsafeReplacement("X");
    assertThat(builder.build().escape("The Quick Brown Fox!")).isEqualTo("XheXXuickXXrownXXoxX");
    // Explicit replacements take priority over unsafe characters.
    builder.addEscape(' ', "_");
    builder.addEscape('!', "_");

        ScriptedMetricAggregationBuilder builder = regScriptedMetricA(name);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void topHits(String name, ConditionOptionCall<TopHitsAggregationBuilder> opLambda) {
        TopHitsAggregationBuilder builder = regTopHitsA(name);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

        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();

                    .longOpt("verbose")
                    .desc("Produce execution verbose output")
                    .get());
            options.addOption(Option.builder(SHOW_ERRORS)
                    .longOpt("errors")
                    .desc("Produce execution error messages")
                    .get());
            options.addOption(Option.builder(BATCH_MODE)
                    .longOpt("batch-mode")

    assertFalse(pin.matchesCertificate(certB1.certificate))
  }

  @Test fun pinList() {
    val builder =
      CertificatePinner
        .Builder()
        .add("example.com", CertificatePinnerTest.certA1Sha256Pin)
        .add("www.example.com", CertificatePinnerTest.certA1Sha256Pin)
    val certificatePinner = builder.build()

    val expectedPins =
      listOf(

                .build());
        options.addOption(Option.builder(THREADS)
                .longOpt("threads")
                .hasArg()
                .desc("Thread count, for instance 4 (int) or 2C/2.5C (int/float) where C is core multiplied")
                .build());
        options.addOption(Option.builder(BUILDER)
                .longOpt("builder")
                .hasArg()