return EventListener.NONE;
      }
    }
  };

  ...
}
```

### Events with Failures

When an operation fails, a failure method is called. This is `connectFailed()` for failures while building a connection to the server, and `callFailed()` when the HTTP call fails permanently. When a failure happens it is possible that a `start` event won’t have a corresponding `end` event.

internal fun BufferedSource.skipAll() {
  while (!exhausted()) {
    skip(buffer.size)
  }
}

/**
 * Attempts to exhaust this, returning true if successful. This is useful when reading a complete
 * source is helpful, such as when doing so completes a cache body or frees a socket connection for
 * reuse.
 */
internal fun Source.discard(
  timeout: Int,
  timeUnit: TimeUnit,
): Boolean =
  try {

     * When a term starts with this prefix, it is treated as a regular expression
     * pattern rather than an exact match term.
     */
    protected String regexPrefix = "regex:";

    /**
     * Placeholder string used in regex-based related content templates.
     * This placeholder is replaced with the actual search query when
     * a regex pattern matches the query.
     */

        long decodedValue = 112233445566778L;
        NdrHyper ndrHyper = new NdrHyper(0); // Initialize with a dummy value

        // Configure the mock NdrBuffer to return a specific value when dec_ndr_hyper is called
        when(mockNdrBuffer.dec_ndr_hyper()).thenReturn(decodedValue);

        // Call the decode method with the mocked NdrBuffer
        ndrHyper.decode(mockNdrBuffer);

 * <strong>Performance</strong>).
 *
 * <p><strong>Cycle Detection</strong>
 *
 * <p>Deadlocks can arise when locks are acquired in an order that forms a cycle. In a simple
 * example involving two locks and two threads, deadlock occurs when one thread acquires Lock A, and
 * then Lock B, while another thread acquires Lock B, and then Lock A:
 *
 * <pre>
 * Thread1: acquire(LockA) --X acquire(LockB)
 * Thread2: acquire(LockB) --X acquire(LockA)

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockConfig.getMaximumBufferSize()).thenReturn(65535);
        when(mockConfig.getTransactionBufferSize()).thenReturn(65535);
        when(mockConfig.isUseUnicode()).thenReturn(true);
        when(mockConfig.isForceUnicode()).thenReturn(false);
        when(mockConfig.getOemEncoding()).thenReturn("ASCII");
    }

    @Test

   * convenient. It is invoked exactly once on service shutdown, even when {@link #stopAsync} is
   * called multiple times.
   *
   * <p>When this method is called {@link #state()} will return {@link State#STOPPING}, which is the
   * external state observable by the caller of {@link #stopAsync}.
   *
   * @since 27.0
   */
  @ForOverride
  protected void doCancelStart() {}

  @CanIgnoreReturnValue
  @Override

    }

    @Test
    void testHasDefaultCredentials_withNonAnonymous() {
        when(mockCredentials.isAnonymous()).thenReturn(false);
        assertTrue(context.hasDefaultCredentials());
    }

    @Test
    void testHasDefaultCredentials_withAnonymous() {
        when(mockCredentials.isAnonymous()).thenReturn(true);
        assertFalse(context.hasDefaultCredentials());
    }

        byte[] data = { 0x01, 0x02 };
        // This constructor call itself should not throw an error, as it's just storing the values.
        // The error should occur when System.arraycopy is called.
        ByteEncodable encodable = new ByteEncodable(data, 1, 2); // off=1, len=2, data.length=2. 1+2 > 2

        byte[] dest = new byte[5];

        Mockito.when(mockContext.getConfig()).thenReturn(mockConfig);
        Mockito.when(mockContext.getCredentials()).thenReturn(mockCredentials);

        // Mock CredentialsInternal for session tests
        jcifs.smb.CredentialsInternal mockCredentialsInternal = Mockito.mock(jcifs.smb.CredentialsInternal.class);