if (file != null) {
                lastPath = file.getPath();
            }
            return true;
        }
    }

    @Nested
    @DisplayName("Happy path – accept is called and returns true")
    class HappyPath {
        @Test
        void acceptWithMockedFile() throws Exception {
            SmbFile mockFile = mock(SmbFile.class);

 * It also uses an AtomicBoolean to track whether the thread is running.
 * </p>
 *
 * <p>
 * The expired method is called when a timeout occurs.
 * It interrupts the running thread up to a maximum number of times.
 * The stop method is called to stop the timeout target.
 * </p>
 */
public class AccessTimeoutTarget implements TimeoutTarget {

import okio.IOException

interface Callback {
  /**
   * Called when the request could not be executed due to cancellation, a connectivity problem or
   * timeout. Because networks can fail during an exchange, it is possible that the remote server
   * accepted the request before the failure.
   */
  fun onFailure(
    call: Call,
    e: IOException,
  )

  /**

     * We mock a simple 200 OK response to test the handshake is called.
     * @throws IOException
     */
    @Test
    void testGettersTriggerHandshake() throws IOException {
        // Arrange
        // Spy on the connection to verify handshake() is called
        NtlmHttpURLConnection spiedConnection = spy(ntlmConnection);
        doNothing().when(spiedConnection).connect();

      /*
       * requireNonNull is safe because we don't null out `sequencer` except:
       *
       * - after the requireNonNull call below. (And this object has its Runnable.run override
       *   called only once, just as it has its Executor.execute override called only once.)
       *
       * - if we return immediately from `execute` (in which case we never get here)
       *

        // Verify that writeQuestionSectionWireFormat was called
        verify((NameServicePacket) request, times(1)).writeQuestionSectionWireFormat(dst, dstIndex);
        assertEquals(10, result);
    }

    @Test
    void testReadBodyWireFormat() {
        // Test that readBodyWireFormat calls readQuestionSectionWireFormat

    try {
      future.get();
      Assert.fail("This call was supposed to throw an ExecutionException");
    } catch (ExecutionException expected) {
      Assert.assertSame(expectedCause, expected.getCause());
    }
  }

  public void assertTimeout() throws Exception {
    // Verify that the listener does not get called in a reasonable amount of
    // time.

// A create function. This will never actually get called in this test, it's
// just nice to know that it compiles.
void* create(TF_OpKernelConstruction* ctx) {
  TF_DataType type;
  TF_Status* s = TF_NewStatus();
  TF_OpKernelConstruction_GetAttrType(ctx, "foobar", &type, s);
  TF_DeleteStatus(s);
  return NULL;
}

// A compute function. This will never actually get called in this test, it's
// just nice to know that it compiles.

    protected CrawlerContainer crawlerContainer;

    /**
     * The name of the component to be retrieved from the CrawlerContainer.
     */
    protected String componentName;

    /**
     * The listener that is called when a pooled object is destroyed.
     */
    protected OnDestroyListener<T> onDestroyListener;

    /**
     * Constructs a new CrawlerPooledObjectFactory.
     */
    public CrawlerPooledObjectFactory() {

 *
 * <p>{@code CharSource} provides two kinds of methods:
 *
 * <ul>
 *   <li><b>Methods that return a reader:</b> These methods should return a <i>new</i>, independent
 *       instance each time they are called. The caller is responsible for ensuring that the
 *       returned reader is closed.
 *   <li><b>Convenience methods:</b> These are implementations of common operations that are