import com.google.common.annotations.Beta;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;

/**
 * An object which can receive a stream of primitive values.
 *
 * @author Kevin Bourrillion
 * @since 12.0 (in 11.0 as {@code Sink})
 */
@Beta
@ElementTypesAreNonnullByDefault
public interface PrimitiveSink {
  /**
   * Puts a byte into this sink.
   *

    .build()
}

val Response.commonIsSuccessful: Boolean
  get() = code in 200..299

fun Response.commonHeaders(name: String): List<String> = headers.values(name)

@JvmOverloads
fun Response.commonHeader(
  name: String,
  defaultValue: String?,
): String? = headers[name] ?: defaultValue

@Throws(IOException::class)

  @CollectionSize.Require(SEVERAL)
  public void testRemovePresentConcurrentWithValuesIteration() {
    assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<V> iterator = getMap().values().iterator();
          getMap().remove(k0());
          iterator.next();
        });
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_notPresent() {

      dummy ^= JOINER_ON_CHARACTER.join(components).length();
    }
    return dummy;
  }

  /**
   * Mimics what the {@link Joiner} class does internally when no extra options like ignoring {@code
   * null} values are used.
   */
  @Benchmark
  int joinerInlined(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      StringBuilder sb = new StringBuilder();

 * to the provided {@code standardEquals} method.
 *
 * <p>Each of the {@code standard} methods, where appropriate, use {@link Objects#equal} to test
 * equality for both keys and values. This may not be the desired behavior for map implementations
 * that use non-standard notions of key equality, such as the entry of a {@code SortedMap} whose
 * comparator is not consistent with {@code equals}.
 *

 * returns a {@link SortedMap}, instead of the {@link Set} and {@link Map} specified by the {@link
 * Table} interface.
 *
 * <p>Null keys and values are not supported.
 *
 * <p>See the {@link StandardTable} superclass for more information about the behavior of this
 * class.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault

	buf, err := args.MarshalMsg(nil)
	if err != nil {
		return false, err
	}
	body := bytes.NewReader(buf)
	respBody, err := restClient.rest.Call(context.Background(), method,
		url.Values{}, body, body.Size())
	defer xhttp.DrainBody(respBody)

	switch toLockError(err) {
	case nil:
		return true, nil
	case errLockConflict, errLockNotFound:
		return false, nil
	default:

      doExpectCollects(expectedResult, list);
    }
    return this;
  }

  private void doExpectCollects(R expectedResult, List<T> inputs) {
    for (CollectStrategy scheme : CollectStrategy.values()) {
      A finalAccum = scheme.result(collector, inputs);
      if (collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {

                    .getLifecyclePhases()
                    .forEach((phase, lifecyclePhase) -> parseLifecyclePhaseDefinitions(plugins, phase, lifecyclePhase));
            lfs.put(id, PluginContainer.newBuilder().plugins(plugins.values()).build());
        });
        return lfs;
    }

    static void parseLifecyclePhaseDefinitions(Map<String, Plugin> plugins, String phase, LifecyclePhase goals) {

        if use_type is None:
            use_type = create_model(original_type.__name__, __base__=original_type)
            cloned_types[original_type] = use_type
            for f in original_type.__fields__.values():
                use_type.__fields__[f.name] = create_cloned_field(
                    f, cloned_types=cloned_types
                )
    new_field = create_model_field(name=field.name, type_=use_type)