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;

    /**
     * Creates a new object instance from the crawler container.

    // If a clear() happens close to the end of computation, one of two things should happen:
    // - computation ends first: the removal listener is called, and the cache does not contain the
    //   key/value pair
    // - clear() happens first: the removal listener is not called, and the cache contains the pair
    AtomicBoolean computationShouldWait = new AtomicBoolean();
    CountDownLatch computationLatch = new CountDownLatch(1);

        // When
        String firstName = mockAddress.firstCalledName();

        // Then
        assertEquals(expectedFirstName, firstName, "Should return first called name");
        assertNotNull(firstName, "First called name should not be null");
    }

    @Test
    @DisplayName("nextCalledName should return valid name for fallback attempts")
    void testNextCalledNameContract() {
        // Given

### Other utility functions { #other-utility-functions }

Any other utility function that you call directly can be created with normal `def` or `async def` and FastAPI won't affect the way you call it.

This is in contrast to the functions that FastAPI calls for you: *path operation functions* and dependencies.

    /**
     * Creates a new messages instance for handling validation and user messages.
     * This method can be called by the application to create message containers.
     *
     * @return a new FessMessages instance
     */
    @Override
    public FessMessages createMessages() { // application may call
        return new FessMessages(); // overriding to change return type to concrete-class
    }

    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Finish the task by unblocking the task latch.  Then wait for the
    // listener to be called by blocking on the listener latch.
    taskLatch.countDown();
    assertEquals(25, task.get().intValue());
    assertTrue(listenerLatch.await(5, SECONDS));
    assertTrue(task.isDone());

   * of response body by the caller.
   *
   * This method is always invoked after [callStart].
   */
  open fun callEnd(call: Call) {
  }

  /**
   * Invoked when a call fails permanently.
   *
   * This method is always invoked after [callStart].
   */
  open fun callFailed(
    call: Call,
    ioe: IOException,
  ) {
  }

        // 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();

        MsrpcLsarOpenPolicy2 msrpcLsarOpenPolicy2 = new MsrpcLsarOpenPolicy2(server, access, mockPolicyHandle);

        // Then
        // Verify that the super constructor is called with correct arguments
        // Note: Directly verifying super constructor calls is not straightforward in JUnit/Mockito.
        // We verify the effects of the super constructor by checking the fields of the created object.

        // Assert object_attributes fields

	// "SCHILY.xattr." namespace.
	//
	// The following are semantically equivalent:
	//  h.Xattrs[key] = value
	//  h.PAXRecords["SCHILY.xattr."+key] = value
	//
	// When Writer.WriteHeader is called, the contents of Xattrs will take
	// precedence over those in PAXRecords.
	//
	// Deprecated: Use PAXRecords instead.
	Xattrs map[string]string

	// PAXRecords is a map of PAX extended header records.
	//