(end-of-line)
          (let ((endpoint (point)))
            (beginning-of-line)
            (if (re-search-forward "[ ]*);$" endpoint t) t nil))))

      (defun my/prev-line-call-with-no-args-p ()
        "Return true if the previous line is a function call with no arguments"
        (save-excursion
          (let ((start (point)))
            (forward-line -1)
            (if (re-search-forward ".($" start t) t nil))))

        @Override
        public void call(Listener listener) {
          listener.starting();
        }

        @Override
        public String toString() {
          return "starting()";
        }
      };
  private static final ListenerCallQueue.Event<Listener> RUNNING_EVENT =
      new ListenerCallQueue.Event<Listener>() {
        @Override
        public void call(Listener listener) {
          listener.running();

              .supportsTlsExtensions(false)
              .build(),
          ),
        ).eventListener(
          object : EventListener() {
            override fun connectionAcquired(
              call: Call,
              connection: Connection,
            ) {
              val sslSocket = connection.socket() as SSLSocket
              println("Requested " + sslSocket.sslParameters.applicationProtocols.joinToString())

    // (We're relying on callers to call this method only with an edge that's in the graph.)
    return requireNonNull(outEdgeMap.get(edge));
  }

  @Override
  public N removeInEdge(E edge, boolean isSelfLoop) {
    if (isSelfLoop) {
      checkNonNegative(--selfLoopCount);
    }
    N previousNode = inEdgeMap.remove(edge);
    // We're relying on callers to call this method only with an edge that's in the graph.

        // Mock close success for the first call
        doAnswer(invocation -> {
            MsrpcSamrCloseHandle rpc = invocation.getArgument(0);
            rpc.retval = 0;
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcSamrCloseHandle.class));

        // First close call
        aliasHandle.close();

        // Act: Call close again
        aliasHandle.close();

 */
@GwtCompatible
@NullUnmarked
final class UrlEscaperTesting {
  /**
   * Helper to assert common expected behaviour of uri escapers. You should call
   * assertBasicUrlEscaper() unless the escaper explicitly does not escape '%'.
   */
  @SuppressWarnings("nullness") // test of a bogus call
  static void assertBasicUrlEscaperExceptPercent(UnicodeEscaper e) {
    // URL escapers should throw null pointer exceptions for null input
    try {

import org.jspecify.annotations.Nullable;

/**
 * A simple EventSubscriber mock that records Strings.
 *
 * <p>For testing fun, also includes a landmine method that EventBus tests are required not
 * to call ({@link #methodWithoutAnnotation(String)}).
 *
 * @author Cliff Biffle
 */
@NullUnmarked
public class StringCatcher {
  private final List<String> events = new ArrayList<>();

  @Subscribe

    void testIsEstablishedShortCircuit() {
        SpnegoContext ctx = newContext();
        // The mock setup is unnecessary since we never call it
        assertFalse(ctx.isEstablished());
        verify(this.mechContext, never()).isEstablished();
    }

    @Test
    @DisplayName("getNetbiosName returns null and does not call delegate")
    void testGetNetbiosName() {

        byte[] hash = auth.getAnsiHash(challenge);
        assertNotNull(hash);
        // getAnsiHash always returns 24 bytes for all lmCompatibility levels
        // (getPreNTLMResponse, getNTLMResponse, or getLMv2Response all return 24 bytes)
        assertEquals(24, hash.length);
    }

    // Test getUnicodeHash behavior based on static LM_COMPATIBILITY setting
    @Test

  // onto its internal state after a call to `ComputeGradient`.
  using GradientTape<AbstractTensorHandle, GradientFunction,
                     TapeTensor>::IsPersistent;

  // Adds this tensor to the list of watched tensors.
  //
  // This is a no-op if the tensor is already being watched either from an
  // earlier call to `GradientTape::Watch` or being an output of an op with
  // watched inputs.