func (update Update) Name() string {
	return "UPDATE"
}

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

	if update.Table.Name == "" {
		builder.WriteQuoted(currentTable)
	} else {
		builder.WriteQuoted(update.Table)
	}
}

// MergeClause merge update clause

    val cacheControl =
      CacheControl
        .Builder()
        .maxAge(365 * 100, TimeUnit.DAYS) // Longer than Integer.MAX_VALUE seconds.
        .build()
    assertThat(cacheControl.maxAgeSeconds).isEqualTo(Int.MAX_VALUE)
  }

  @Test
  @Throws(Exception::class)
  fun secondsMustBeNonNegative() {
    val builder = CacheControl.Builder()
    assertFailsWith<IllegalArgumentException> {

  @Test
  fun ecdsaSignedByRsa() {
    val root =
      HeldCertificate
        .Builder()
        .certificateAuthority(0)
        .rsa2048()
        .build()
    val leaf =
      HeldCertificate
        .Builder()
        .certificateAuthority(0)
        .ecdsa256()
        .signedBy(root)
        .build()
    assertThat(root.certificate.sigAlgName).isEqualTo("SHA256WITHRSA", ignoreCase = true)

   *         .addNode(REYKJAVIK)
   *         .build();
   * }
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build
   * multiple graphs in series. Each new graph contains all the elements of the ones created before
   * it.
   *
   * @since 28.0
   */
  public static class Builder<N, V> {

    private final MutableValueGraph<N, V> mutableValueGraph;

        return read(XmlReaderRequest.builder().reader(reader).strict(strict).build());
    }

    @Nonnull
    T read(@Nonnull XmlReaderRequest request) throws XmlReaderException;

    default void write(@Nonnull T content, @Nonnull Path path) throws XmlWriterException {
        write(XmlWriterRequest.<T>builder().content(content).path(path).build());
    }

  public void testBuilder_presize_zero() {
    ImmutableLongArray.Builder builder = ImmutableLongArray.builder(0);
    builder.add(5L);
    ImmutableLongArray array = builder.build();
    assertThat(array.asList()).containsExactly(5L);
  }

  public void testBuilder_presize_negative() {
    assertThrows(IllegalArgumentException.class, () -> ImmutableLongArray.builder(-1));
  }

  /**

docker-hotfix: hotfix-push checks ## builds minio docker container with hotfix tags
	@echo "Building minio docker image '$(TAG)'"
	@docker build -q --no-cache -t $(TAG) --build-arg RELEASE=$(VERSION) . -f Dockerfile.hotfix

docker: build ## builds minio docker container
	@echo "Building minio docker image '$(TAG)'"
	@docker build -q --no-cache -t $(TAG) . -f Dockerfile

test-resiliency: build
	@echo "Running resiliency tests"

    val request =
      Request
        .Builder()
        .url("https://server/robots.txt")
        .build()
    val response =
      Response
        .Builder()
        .request(request)
        .code(401)
        .header("WWW-Authenticate", "Basic realm=\"User Visible Realm\"")
        .protocol(HTTP_2)
        .message("Unauthorized")
        .build()

  private val handshakeCertificates = localhost()

  private var client: OkHttpClient =
    OkHttpClient
      .Builder()
      .sslSocketFactory(
        handshakeCertificates.sslSocketFactory(),
        handshakeCertificates.trustManager,
      ).connectionPool(ConnectionPool(0, 1, TimeUnit.SECONDS))
      .build()

  private val server =
    MockWebServer()

  @Test
  fun testHttpsRequest() {

        ImmutableMultiset.Builder<Object> builder = ImmutableMultiset.builder();
        for (Object o : keys) {
          builder.add(o);
        }
        return builder.build();
      }
    },
    BUILDER_ADD_ALL_COLLECTION {
      @Override
      public ImmutableMultiset<Object> create(List<?> keys) {
        ImmutableMultiset.Builder<Object> builder = ImmutableMultiset.builder();
        builder.addAll(keys);