}

  public void testToString() {
    // We can easily afford to test this exhaustively.
    for (int i = 0; i <= 0xff; i++) {
      assertThat(UnsignedBytes.toString((byte) i)).isEqualTo(Integer.toString(i));
    }
  }

  public void testToStringWithRadix() {
    // We can easily afford to test this exhaustively.
    for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; radix++) {

/*
 * Copyright (C) 2011 The Guava Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License

        private final CtBehavior behavior
        private final String behaviorName

        NullableMethodVisitor(CtBehavior behavior) {
            super(AsmConstants.ASM_LEVEL)
            this.behavior = behavior
            this.behaviorName = behavior instanceof CtConstructor ? "<init>" : behavior.getName()
        }

        @Override
        AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {

OkHttp perseveres when the network is troublesome: it will silently recover from common connection
problems. If your service has multiple IP addresses, OkHttp will attempt alternate addresses if the
first connect fails. This is necessary for IPv4+IPv6 and services hosted in redundant data
centers. OkHttp supports modern TLS features (TLS 1.3, ALPN, certificate pinning). It can be
configured to fall back for broad connectivity.

   * implementations are permitted to throw IAE if a hole is requested, and we could update
   * test*Hole to permit IAE. (But might this ignore genuine bugs?) But see the TODO above
   * testLower, which could make this all unnecessary
   */
  public static Method[] getHoleMethods() {
    return new Method[] {
      getMethod(NavigableSetNavigationTester.class, "testLowerHole"),

    /**
     * Get the number of currently blocked IPs.
     * Note: This may include expired entries not yet evicted.
     * @return the count of blocked IPs
     */
    public int getBlockedIpCount() {
        blockedIps.cleanUp();
        return (int) blockedIps.size();
    }

    /**
     * Get the number of tracked IP counters.
     * Note: This may include expired entries not yet evicted.

        private static List<Integer> executionOrder = new ArrayList<>();
        private final long returnValue;

        public PriorityTrackingBooster(int priority, long returnValue) {
            this.priority = priority;
            this.returnValue = returnValue;
        }

        @Override
        public long process() {
            executionOrder.add(priority);
            return returnValue;
        }

  private final class Target {
    private final Collection<E> toRetain;
    private final String description;

    private Target(Collection<E> toRetain, String description) {
      this.toRetain = toRetain;
      this.description = description;
    }

    @Override
    public String toString() {
      return description;
    }
  }

  private Target empty;
  private Target disjoint;

/*
 * Copyright (C) 2007 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License

/**
 * Signifies that a public API (public class, method or field) is subject to incompatible changes,
 * or even removal, in a future release. An API bearing this annotation is exempt from any
 * compatibility guarantees made by its containing library. Note that the presence of this
 * annotation implies nothing about the quality or performance of the API in question, only the fact
 * that it is not "API-frozen."
 *