// processing. A [Reader] that does not implement  ByteReader
// can be wrapped using bufio.NewReader to add this method.
type ByteReader interface {
	ReadByte() (byte, error)
}

// ByteScanner is the interface that adds the UnreadByte method to the
// basic ReadByte method.
//
// UnreadByte causes the next call to ReadByte to return the last byte read.

        then:
        sources.assertClass('Libs')
    }

    def "generates an accessor for #name as method #method"() {
        when:
        generate {
            library(name, 'g:a:v')
        }

        then:
        sources.hasDependencyAlias(name, method)

        where:
        name                  | method
        'groovy'              | 'getGroovy'
        'groovy-json'         | 'getJson'

  QuantizationResult result{};
  QuantizableUnit& quantizable_unit = *result.mutable_quantizable_unit();
  quantizable_unit.set_name("quantized_my_function");

  Method& method = *result.mutable_method();
  method.mutable_no_quantization();

  QuantizationReport report{};
  report.AddQuantizationResult(std::move(result));

  const QuantizationResults& results = report.GetQuantizationResults();

            throw createHttpRequestException(method, wrapWithExplanation(e), request.getURI());
        }
    }

    @Nonnull
    private static HttpRequestException createHttpRequestException(String method, Throwable cause, URI uri) {
        return new HttpRequestException(String.format("Could not %s '%s'.", method, stripUserCredentials(uri)), cause);
    }

    private Exception wrapWithExplanation(IOException e) {

    The HistogramMseSymmetric method starts from the center bin and expands the
    range to both sides. This works better when the data is well-centered.

    Returns:
      (min_value, max_value): Min and max calculated using the method starting
      from center and expanding.
    """

    # This function is currently only called in this method, but will be used in
    # other methods in the future.

        final Lock lock;
        final Condition condition;
        final String method;
        final String url;
        Throwable failure;
        boolean completed;

        public RequestOutcome(Lock lock, String method, String url) {
            this.lock = lock;
            this.condition = lock.newCondition();
            this.method = method;
            this.url = url;
        }

        String getDisplayName() {

   * this method has no effect and returns zero.
   */
  @CanIgnoreReturnValue
  public long remove(K key) {
    Long result = map.remove(key);
    return (result == null) ? 0L : result.longValue();
  }

  /**
   * If {@code (key, value)} is currently in the map, this method removes it and returns true;
   * otherwise, this method returns false.
   */

   * invocation of finalize methods) and waits for it to complete. Ensures that at least one weak
   * reference has been cleared and one {@code finalize} method has been run before this method
   * returns. This method may be useful when testing the garbage collection mechanism itself, or
   * inhibiting a spontaneous GC initiation in subsequent code.
   *

}

// urlErrorOp returns the (*url.Error).Op value to use for the
// provided (*Request).Method value.
func urlErrorOp(method string) string {
	if method == "" {
		return "Get"
	}
	if lowerMethod, ok := ascii.ToLower(method); ok {
		return method[:1] + lowerMethod[1:]
	}
	return method
}

// Do sends an HTTP request and returns an HTTP response, following

 * {@code Iterable}. Except as noted, each method has a corresponding {@link Iterator}-based method
 * in the {@link Iterators} class.
 *
 * <p><b>Java 8+ users:</b> several common uses for this class are now more comprehensively
 * addressed by the new {@link java.util.stream.Stream} library. Read the method documentation below