@Test
    @DisplayName("Should handle multiple close() calls gracefully")
    void testMultipleCloseCallsSafe() {
        // Given
        Smb2EncryptionContext closeableContext = new Smb2EncryptionContext(EncryptionNegotiateContext.CIPHER_AES128_CCM,
                DialectVersion.SMB302, testEncryptionKey, testDecryptionKey);

        // When/Then - Multiple close calls should not throw
        assertDoesNotThrow(() -> {

   *   <li>If {@code equivalent(x, y)} and {@code equivalent(y, z)} are both true, then {@code
   *       equivalent(x, z)} is also true (<i>transitive</i> property)
   * </ul>
   *
   * <p>Note that all calls to {@code equivalent(x, y)} are expected to return the same result as
   * long as neither {@code x} nor {@code y} is modified.
   */
  public final boolean equivalent(@Nullable T a, @Nullable T b) {
    if (a == b) {

        assertEquals("/test/uri", webApiRequest.getRequestURI());
        assertEquals(testHeaderValue, webApiRequest.getHeader(testHeader));
    }

    // Test multiple calls to getServletPath
    public void test_getServletPath_multipleCallsReturnSameResult() {
        final String customPath = "/api/v1/consistent";
        mockRequest.setQueryString("query=test");

    return new JavaIoCreator();
  }

  /**
   * Creates the permissions normally used for Windows filesystems, looking up the user afresh, even
   * if previous calls have initialized the {@code PermissionSupplier} fields.
   *
   * <p>This lets us test the effects of different values of the {@code user.name} system property
   * without needing a separate VM or classloader.
   */

        String retrievedMessage = exception.getMessage();
        assertEquals(testMessage, retrievedMessage);

        // Test that multiple calls return the same message
        assertEquals(retrievedMessage, exception.getMessage());
        assertEquals(retrievedMessage, exception.getMessage());
    }

    public void test_fillInStackTrace() {

      next = next.next;
      nextIndex++;
      return current;
    }

    @Override
    public void remove() {
      checkForConcurrentModification();
      checkState(current != null, "no calls to next() since the last call to remove()");
      if (current != next) { // after call to next()
        previous = current.previous;
        nextIndex--;
      } else { // after call to previous()

      // For each listener we add a task that submits it to the executor directly for the blocking
      // get use case and another task that adds it as a listener to the future to exercise both
      // racing addListener calls and addListener calls completing after the future completes.
      Runnable listener = k % 2 == 0 ? collectResultsRunnable : collectResultsTimedGetRunnable;
      allTasks.add(callable(listener));
      allTasks.add(

        long actualSize = MemoryUtil.sizeOf(complexMap);
        assertEquals(689L, actualSize);
    }

    public void test_getUsedMemory_variations() {
        // Test multiple calls to ensure consistency
        long memory1 = MemoryUtil.getUsedMemory();
        assertTrue(memory1 >= 0);

        // Create some objects to change memory usage
        @SuppressWarnings("unused")

            } catch (final IOException ioe) {}
        }
    }

    @Override
    public void destroy() {
    }

    /**
     * This method simply calls {@code negotiate( req, resp, false )}
     * and then {@code chain.doFilter}. You can override and call
     * negotiate manually to achive a variety of different behavior.
     */
    @Override

import java.net.URL;
import java.net.UnknownHostException;

/**
 * This class will allow a Java program to read and write data to Named
 * Pipes and Transact NamedPipes.
 *
 * <p>There are three Win32 function calls provided by the Windows SDK
 * that are important in the context of using jCIFS. They are:
 *
 * <ul>
 * <li> <code>CallNamedPipe</code> A message-type pipe call that opens,