@get:JvmName("connectTimeoutMillis")
  val connectTimeoutMillis: Int = builder.connectTimeout

  /** Default read timeout (in milliseconds). The default is 10 seconds. */
  @get:JvmName("readTimeoutMillis")
  val readTimeoutMillis: Int = builder.readTimeout

  /** Default write timeout (in milliseconds). The default is 10 seconds. */
  @get:JvmName("writeTimeoutMillis")

    // causing the thread to be suspended for 3.5 seconds, and then park itself for 2 seconds after
    // being resumed. To avoid a flake in this scenario, calculate how long that thread actually
    // waited and assert based on that time. Empirically, the race where the thread ends up waiting
    // for 5.5 seconds happens about 2% of the time.

    }
  }

  /** Returns once all stream actions complete successfully. */
  fun awaitSuccess() {
    val futureTask =
      results.poll(5, TimeUnit.SECONDS)
        ?: throw AssertionError("no onRequest call received")
    futureTask.get(5, TimeUnit.SECONDS)
  }

        scriptExecutor.addShutdownListener(listener1);

        // Add second listener (should replace first)
        TestShutdownListener listener2 = new TestShutdownListener();
        scriptExecutor.addShutdownListener(listener2);

        // Call shutdown
        scriptExecutor.shutdown();

        // Verify only second listener was called
        assertFalse(listener1.wasShutdownCalled());

        createCacheBuilder().expireAfterWrite(99999, SECONDS),
        createCacheBuilder().maximumSize(SMALL_MAX_SIZE).expireAfterAccess(SMALL_MAX_SIZE, SECONDS),
        createCacheBuilder().maximumSize(SMALL_MAX_SIZE).expireAfterWrite(SMALL_MAX_SIZE, SECONDS));
  }

  /** Returns an iterable containing all combinations weakKeys and weak/softValues. */

    future.set(1);
    assertEquals(1, future.get(-1, SECONDS).intValue());
  }

  @J2ktIncompatible
  @GwtIncompatible // threads
  public void testOverflowTimeout() throws Exception {
    // First, sanity check that naive multiplication would really overflow to a negative number:
    long nanosPerSecond = NANOSECONDS.convert(1, SECONDS);
    assertThat(nanosPerSecond * Long.MAX_VALUE).isLessThan(0L);

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
@file:Suppress("ktlint:standard:filename")

package okhttp3.internal

import kotlin.time.Duration.Companion.seconds
import okhttp3.CacheControl
import okhttp3.Headers

internal fun CacheControl.commonToString(): String {
  var result = headerValue
  if (result == null) {
    result =
      buildString {

 *   protected void visitWildcardType(WildcardType t) {
 *     throw new IllegalArgumentException("Cannot contain wildcard type.");
 *   }
 * }.visit(type);
 * }
 *
 * <p>One {@code Type} is visited at most once. The second time the same type is visited, it's
 * ignored by {@link #visit}. This avoids infinite recursion caused by recursive type bounds.
 *
 * <p>This class is not thread safe.
 *
 * @author Ben Yu
 */

        assertEquals("Second group should be AnotherTestGroup", AnotherTestGroup.class, multiAnnotation.groups()[1]);

        assertEquals("Should have 2 payloads", 2, multiAnnotation.payload().length);
        assertEquals("First payload should be TestPayload", TestPayload.class, multiAnnotation.payload()[0]);

 * limitations under the License.
 */
package okhttp3.internal.duplex

import java.util.concurrent.BlockingQueue
import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.TimeUnit.SECONDS
import okhttp3.MediaType
import okhttp3.RequestBody
import okio.BufferedSink
import org.junit.jupiter.api.Assertions.assertTrue

/** A duplex request body that keeps the provided sinks so they can be written to later.  */