"invalid interval: $notBefore..$notAfter"
      }
      this.notBefore = notBefore
      this.notAfter = notAfter
    }

    /**
     * Sets the certificate to be valid immediately and until the specified duration has elapsed.
     * The precision of this field is seconds; further precision will be truncated.
     */
    fun duration(
      duration: Long,
      unit: TimeUnit,

		// Break if the local endpoint is found already Or all the endpoints are resolved.

		// Retry infinitely on Kubernetes and Docker swarm.
		// This is needed as the remote hosts are sometime
		// not available immediately.
		select {
		case <-globalOSSignalCh:
			return fmt.Errorf("The endpoint resolution got interrupted")
		default:
			for i, resolved := range resolvedList {
				if resolved {

        });
    assertThat(orig.toString())
        .contains("Exception thrown from implementation: class java.lang.StackOverflowError");
  }

  // Regression test for a case where we would fail to execute listeners immediately on done futures
  // this would be observable from an afterDone callback
  public void testListenersExecuteImmediately_fromAfterDone() {
    AbstractFuture<String> f =
        new AbstractFuture<String>() {

            // original recommended version
            version = restriction.recommendedVersion;
        }
        /* TODO should throw this immediately, but need artifact
                else
                {
                    throw new OverConstrainedVersionException( "Restricting incompatible version ranges" );
                }
        */

  override fun clone(): Call = RealCall(client, originalRequest, forWebSocket)

  override fun request(): Request = originalRequest

  /**
   * Immediately closes the socket connection if it's currently held. Use this to interrupt an
   * in-flight request from any thread. It's the caller's responsibility to close the request body

            return null;
        }
        if (list.size() >= 2) {
            String msg = "The size of selected list is over 1: " + list.size();
            throw new FetchingOverSafetySizeException(msg, 1); // immediately caught by caller and translated
        }
        return list.get(0);
    }

    @Override

    assertThat(inputStream.read()).isEqualTo('B'.code)
    assertThat(inputStream.read()).isEqualTo('C'.code)
    try {
      inputStream.read() // if Content-Length was accurate, this would return -1 immediately
      fail<Any>()
    } catch (expected: SocketTimeoutException) {
    }
    val urlConnection2 = server.url("/").toUrl().openConnection()
    val in2 = urlConnection2.getInputStream()

func close(c chan<- Type)

// The panic built-in function stops normal execution of the current
// goroutine. When a function F calls panic, normal execution of F stops
// immediately. Any functions whose execution was deferred by F are run in
// the usual way, and then F returns to its caller. To the caller G, the
// invocation of F then behaves like a call to panic, terminating G's

// the input may be discarded. If that error is [ErrFinalToken], scanning
// stops with no error. A non-nil token delivered with [ErrFinalToken]
// will be the last token, and a nil token with [ErrFinalToken]
// immediately stops the scanning.
//
// Otherwise, the [Scanner] advances the input. If the token is not nil,
// the [Scanner] returns it to the user. If the token is nil, the

    static <K, V> PopulatableMapAsMultimap<K, V> create() {
      return new PopulatableMapAsMultimap<>();
    }

    @SuppressWarnings("unchecked") // all methods throw immediately
    PopulatableMapAsMultimap() {
      this.map = new HashMap<>();
      this.unusableDelegate =
          (SetMultimap<K, V>)
              newProxy(
                  SetMultimap.class,