private fun trailersAndCache(protocol: Protocol) {
    enableProtocol(protocol)

    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("h1", "v1")
        .addHeader("Cache-Control: max-age=30")
        .body(protocol, "Hello")
        .trailers(headersOf("t1", "v2"))
        .build(),
    )

    val call1 = client.newCall(Request(server.url("/")))
    call1.execute().use { response ->

      sink.flush()
    }
  }

  /** The maximum size of bytes that may be sent in a single call to [data]. */
  fun maxDataLength(): Int = maxFrameSize

  /**
   * `source.length` may be longer than the max length of the variant's data frame. Implementations
   * must send multiple frames as necessary.
   *
   * @param source the buffer to draw bytes from. May be null if byteCount is 0.

      checkNonnegative(distance, "distance");
      return origin.add(BigInteger.valueOf(distance));
    }

    @Override
    public long distance(BigInteger start, BigInteger end) {
      return end.subtract(start).max(MIN_LONG).min(MAX_LONG).longValue();
    }

    private Object readResolve() {
      return INSTANCE;
    }

    @Override
    public String toString() {
      return "DiscreteDomain.bigIntegers()";

        assertInstanceOf(netdfs.DfsEnumArray200.class, dfsRootEnum.info.e);

        // Verify DFS name is set to server name
        assertEquals(TEST_SERVER, dfsRootEnum.dfs_name);

        // Verify preferred max length is set to maximum
        assertEquals(0xFFFF, dfsRootEnum.prefmaxlen);

        // Verify totalentries is initialized
        assertNotNull(dfsRootEnum.totalentries);
    }

    @Test

	CLZW	X21, X22				// 1b9b0a60
	CPOP	X22, X23				// 931b2b60
	CPOPW	X23, X24				// 1b9c2b60
	CTZ	X24, X25				// 931c1c60
	CTZW	X25, X26				// 1b9d1c60
	MAX	X26, X28, X29				// b36eae0b or b32fae01b30ff041b34eae01b3fedf01b34ede01
	MAX	X26, X28				// 336eae0b or b32fcd01b30ff041334ecd0133fecf01334ecd01
	MAXU	X28, X29, X30				// 33ffce0b or b3bfce01b30ff04133cfce0133ffef0133cfee01

 */

package com.google.common.collect;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.collect.CollectPreconditions.checkNonnegative;
import static java.lang.Math.max;
import static java.util.Arrays.asList;
import static java.util.Objects.requireNonNull;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;

      checkNonnegative(distance, "distance");
      return origin.add(BigInteger.valueOf(distance));
    }

    @Override
    public long distance(BigInteger start, BigInteger end) {
      return end.subtract(start).max(MIN_LONG).min(MAX_LONG).longValue();
    }

    private Object readResolve() {
      return INSTANCE;
    }

    @Override
    public String toString() {
      return "DiscreteDomain.bigIntegers()";

	globalBucketObjectLockSys = &BucketObjectLockSys{}
	globalBucketVersioningSys = &BucketVersioningSys{}

	lcXML := `
<LifecycleConfiguration>
       <Rule>
               <ID>max-versions</ID>
               <Status>Enabled</Status>
               <NoncurrentVersionExpiration>
                       <NewerNoncurrentVersions>2</NewerNoncurrentVersions>
               </NoncurrentVersionExpiration>

        public static final String LANG_FIELD_NAME = "langFieldName";
        /** Parallel processing key. */
        public static final String PARALLEL_PROCESSING = "parallel";
        /** Max content length key. */
        public static final String MAX_CONTENT_LENGTH = "maxContextLength";

        private DefaultKeys() {
        }
    }

    val bytes = "0202ff00".decodeHex()
    assertThat(Adapters.INTEGER_AS_LONG.toDer(-256L)).isEqualTo(bytes)
    assertThat(Adapters.INTEGER_AS_LONG.fromDer(bytes)).isEqualTo(-256L)
  }

  @Test fun `max long`() {
    val bytes = "02087fffffffffffffff".decodeHex()
    assertThat(Adapters.INTEGER_AS_LONG.fromDer(bytes)).isEqualTo(Long.MAX_VALUE)
    assertThat(Adapters.INTEGER_AS_LONG.toDer(Long.MAX_VALUE)).isEqualTo(bytes)
  }