*/
        public JvmThreadsObj() {
            // Default constructor
        }

        /** Current number of threads */
        public int count;
        /** Peak number of threads */
        public int peak;
    }

    /**
     * Data transfer object representing JVM class loading statistics.
     */
    public static class JvmClassesObj {
        /**
         * Default constructor.

        buf.append("},");
        final Threads threads = jvmStats.getThreads();
        buf.append("\"threads\":{");
        append(buf, "count", () -> threads.getCount()).append(',');
        append(buf, "peak", () -> threads.getPeakCount());
        buf.append("},");
        final Classes classes = jvmStats.getClasses();
        buf.append("\"classes\":{");

            }
          }
        };

    assertEquals(0, (int) iter.peek());
    assertEquals(0, (int) iter.peek());
    assertTrue(iter.hasNext());
    assertEquals(0, (int) iter.peek());
    assertEquals(0, (int) iter.next());

    assertEquals(1, (int) iter.peek());
    assertEquals(1, (int) iter.next());

    /*
     * We test peek() after various calls to make sure that one bad call doesn't interfere with its

    assertSame(EntryFactory.WEAK, EntryFactory.getFactory(Strength.WEAK, false, false));
    assertSame(EntryFactory.WEAK_ACCESS, EntryFactory.getFactory(Strength.WEAK, true, false));
    assertSame(EntryFactory.WEAK_WRITE, EntryFactory.getFactory(Strength.WEAK, false, true));
    assertSame(EntryFactory.WEAK_ACCESS_WRITE, EntryFactory.getFactory(Strength.WEAK, true, true));
  }

  // computation tests

    assertEquals(
        "next() should still return first element after peeking", "A", peekingIterator.next());

    assertEquals("Should be able to peek() at middle element", "B", peekingIterator.peek());
    assertEquals(
        "Should be able to peek() middle element multiple times", "B", peekingIterator.peek());
    assertEquals(

          chunked = true
        }
      }

      val peek = dispatcher.peek()
      for (response in peek.informationalResponses) {
        writeHttpResponse(socket, response)
      }

      val requestBodySink =
        requestBody
          .withThrottlingAndSocketEffect(
            policy = peek,
            socketEffect = peek.onRequestBody,
            expectedByteCount = contentLength,

@Throws(EOFException::class)
private fun Buffer.readChallengeHeader(result: MutableList<Challenge>) {
  var peek: String? = null

  while (true) {
    // Read a scheme name for this challenge if we don't have one already.
    if (peek == null) {
      skipCommasAndWhitespace()
      peek = readToken()
      if (peek == null) return
    }

    val schemeName = peek

    // Read a token68, a sequence of parameters, or nothing.

    }
    if (builder.getKeyStrength() == Strength.WEAK
        && builder.getValueStrength() == Strength.STRONG) {
      return new MapMakerInternalMap<>(builder, WeakKeyDummyValueEntry.Helper.<K>instance());
    }
    if (builder.getValueStrength() == Strength.WEAK) {
      throw new IllegalArgumentException("Map cannot have both weak and dummy values");
    }
    throw new AssertionError();
  }

   *   <li>clearing weak references to unreachable referents
   *   <li>enqueuing weak references to unreachable referents in their reference queue
   * </ul>
   */
  @DoNotMock("Implement with a lambda")
  public interface FinalizationPredicate {
    boolean isDone();
  }

  /**
   * Waits until the given weak reference is cleared, invoking the garbage collector as necessary to

   *   <li>clearing weak references to unreachable referents
   *   <li>enqueuing weak references to unreachable referents in their reference queue
   * </ul>
   */
  @DoNotMock("Implement with a lambda")
  public interface FinalizationPredicate {
    boolean isDone();
  }

  /**
   * Waits until the given weak reference is cleared, invoking the garbage collector as necessary to