override fun secureConnectEnd(
                  call: Call,
                  handshake: Handshake?,
                ) {
                  if (first) {
                    first = false
                    throw SSLException("")
                  }
                }
              },
            ).build()

        overrideBadImplementation(

    assertThat(fooReference1).isNotSameInstanceAs(fooReference2);

    assertThat(mapCache.put(fooReference1, "bar")).isNull();
    assertThat(mapCache.get(fooReference1)).isEqualTo("bar"); // ensure first reference is cached
    assertThat(mapCache.remove(fooReference2)).isEqualTo("bar");
    assertThat(mapCache.get(fooReference1)).isNull();
  }

//
// Usage:
//
//	go tool addr2line binary
//
// Addr2line reads hexadecimal addresses, one per line and with optional 0x prefix,
// from standard input. For each input address, addr2line prints two output lines,
// first the name of the function containing the address and second the file:line
// of the source code corresponding to that address.
//
// This tool is intended for use only by pprof; its interface may change or

    }

    return true
  }

  /** Returns a new bias. */
  private fun adapt(
    delta: Int,
    numpoints: Int,
    first: Boolean,
  ): Int {
    var delta =
      when {
        first -> delta / DAMP
        else -> delta / 2
      }
    delta += (delta / numpoints)
    var k = 0
    while (delta > ((BASE - TMIN) * TMAX) / 2) {
      delta /= (BASE - TMIN)

  private static final long LONG_DELAY_MS = 10000;

  /** The first exception encountered if any threadAssertXXX method fails. */
  private final AtomicReference<Throwable> threadFailure = new AtomicReference<>(null);

  /**
   * Records an exception so that it can be rethrown later in the test harness thread, triggering a
   * test case failure. Only the first failure is recorded; subsequent calls to this method from

                assertFalse(iterator1.hasNext(), "First instance should have no elements");
                assertFalse(iterator2.hasNext(), "Second instance should have no elements");
                assertFalse(iterator3.hasNext(), "Third instance should have no elements");

                assertNull(iterator1.next(), "First instance next() should return null");

        SmbComTransactionResponse r1 = (SmbComTransactionResponse) d.nextElement();
        assertSame(d, r1, "nextElement should return the same instance");
        // After first call isPrimary should be false
        assertFalse(d.getIsPrimary(), "isPrimary should be cleared after first call");
        // Second call keeps the same state
        SmbComTransactionResponse r2 = (SmbComTransactionResponse) d.nextElement();

func (b *Buffer) Cap() int { return cap(b.buf) }

// Available returns how many bytes are unused in the buffer.
func (b *Buffer) Available() int { return cap(b.buf) - len(b.buf) }

// Truncate discards all but the first n unread bytes from the buffer
// but continues to use the same allocated storage.
// It panics if n is negative or greater than the length of the buffer.
func (b *Buffer) Truncate(n int) {
	if n == 0 {
		b.Reset()

        assertFalse(item.isUpdated());
        assertFalse(item.isDeleted());

        item.setNewInput("first");
        assertTrue(item.isUpdated());
        assertFalse(item.isDeleted());
        assertEquals("first", item.toLineString());

        item.setNewInput("second");
        assertTrue(item.isUpdated());
        assertFalse(item.isDeleted());

 * {@snippet :
 *        h
 *      / | \
 *     /  e  \
 *    d       g
 *   /|\      |
 *  / | \     f
 * a  b  c
 * }
 *
 * <p>can be iterated over in preorder (hdabcegf), postorder (abcdefgh), or breadth-first order
 * (hdegabcf).
 *
 * <p>Null nodes are strictly forbidden.
 *
 * <p>Because this is an abstract class, not an interface, you can't use a lambda expression to
 * implement it:
 *
 * {@snippet :