}

        @Override
        public String getName() {
            return name;
        }

        @Override
        public int getType() {
            return 0;
        }

        @Override
        public int getAttributes() {
            return 0;
        }

        @Override
        public long createTime() {
            return 0;
        }

      extends ForwardingList<E> {
    final List<E> delegate;
    final int delta;

    MisleadingSizeList(List<E> delegate, int delta) {
      this.delegate = delegate;
      this.delta = delta;
    }

    @Override
    protected List<E> delegate() {
      return delegate;
    }

    @Override
    public int size() {
      return delegate.size() + delta;
    }
  }

     *
     * @param inputBuf
     * @param offset
     * @param len
     * @return response token
     */
    @Override
    public byte[] initSecContext(final byte[] inputBuf, final int offset, final int len) throws CIFSException {
        SpnegoToken resp;
        if (this.completed) {
            throw new CIFSException("Already complete");
        }
        if (len == 0) {

    void testConcurrentAccess() throws InterruptedException {
        // Given
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];
        final boolean[] results = new boolean[threadCount];

        // When
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                try {

    assertFalse(a1[0].equals(a2[0]));
  }

  public void testPrimitiveArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    int[] a1 = generator.generateFresh(int[].class);
    int[] a2 = generator.generateFresh(int[].class);
    assertTrue(a1[0] != a2[0]);
  }

  public void testRange() {
    assertFreshInstance(new TypeToken<Range<String>>() {});
  }

            throw new RuntimeException(uee.getMessage());
        }
    }

    static byte[] computeResponse(final byte[] responseKey, final byte[] serverChallenge, final byte[] clientData, final int offset,
            final int length) {
        final HMACT64 hmac = new HMACT64(responseKey);
        hmac.update(serverChallenge);
        hmac.update(clientData, offset, length);
        final byte[] mac = hmac.digest();

    private static final long BASE_POLL_INTERVAL = 1000;
    private static final long BASE_ERROR_DELAY = 1000;
    private static final int MAX_FAILURE_LIMIT = 5; // Limit failures for backoff calculation

    private final InetAddress witnessServer;
    private final int port;
    private final CIFSContext context;
    private final ConcurrentHashMap<String, WitnessRegistration> registrations;

    return new RegularImmutableMap<>(entries);
  }

  public static <K, V> Builder<K, V> builder() {
    return new Builder<K, V>();
  }

  public static <K, V> Builder<K, V> builderWithExpectedSize(int expectedSize) {
    return new Builder<K, V>(expectedSize);
  }

  static <K, V> Entry<K, V> entryOf(K key, V value) {
    checkEntryNotNull(key, value);
    return Maps.immutableEntry(key, value);
  }

 * returning more-or-less the same answers.
 */
@NullUnmarked
public class QuantilesAlgorithmTest extends TestCase {

  private static final Random rng = new Random(82674067L);
  private static final int DATASET_SIZE = 1000;
  private static final double ALLOWED_ERROR = 1.0e-10;
  private static final QuantilesAlgorithm REFERENCE_ALGORITHM = QuantilesAlgorithm.SORTING;

  }

  /**
   * @return an array of the proper size with {@code null} as the key of the middle element.
   */
  protected Entry<K, V>[] createArrayWithNullKey() {
    Entry<K, V>[] array = createSamplesArray();
    int nullKeyLocation = getNullLocation();
    Entry<K, V> oldEntry = array[nullKeyLocation];
    array[nullKeyLocation] = mapEntry(null, oldEntry.getValue());
    return array;
  }

  /**