* This is typically invoked immediately before bytes are returned to the application. If the
   * response body is empty this is invoked immediately before returning that to the application.
   *
   * If the application closes the response body before attempting a read, this is invoked at the
   * time it is closed.
   *
   * The connection is implicit, and will generally relate to the last [connectionAcquired] event.
   *

        if (root instanceof InterruptedException) {
            ioe = new InterruptedIOException(root.getMessage());
            ioe.initCause(root);
        }
        return ioe;
    }

    /**
     * Closes this input stream and releases any system resources associated with the stream.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override

    }

    @Test
    @DisplayName("Should handle multiple closes gracefully")
    void testMultipleCloses() {
        // Given
        Smb2EncryptionContext context = new Smb2EncryptionContext(EncryptionNegotiateContext.CIPHER_AES128_CCM, DialectVersion.SMB300,
                testEncryptionKey, testDecryptionKey);

        // When/Then - Multiple closes should be safe
        assertDoesNotThrow(() -> {

    assertFailsWith<ProtocolException> {
      CertificateAdapters.subjectPublicKeyInfo.fromDer(bytes)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("enclosed object too large")
    }
  }

  /** Object identifiers are nominally self-delimiting. Outrun the limit with one. */
  @Test fun `variable length long outruns limit`() {
    val bytes = "060229ffffff7f".decodeHex()

    }
    assertWithMessage("Hex string and dec parm").that(Ints.tryParse("FFFF", 10)).isNull();
    assertWithMessage("Mixed hex case").that((int) Ints.tryParse("ffFF", 16)).isEqualTo(65535);
  }

  /**
   * Encodes an integer as a string with given radix, then uses {@link Ints#tryParse(String, int)}
   * to parse the result. Asserts the result is the same as what we started with.
   */

        src[3] = 'E';
        src[4] = 'C'; // B

        // Use 'X' (0x58) instead of space for padding
        for (int i = 5; i < 31; i += 2) {
            src[i] = 'E';
            src[i + 1] = 'I'; // Encodes to 'X'
        }

        src[31] = 'C';
        src[32] = 'A';
        src[33] = 0x00;

        Name name = new Name(mockConfig);
        name.readWireFormat(src, 0);

        // Cannot check password after closing as it now throws IllegalStateException
        // This is actually good security practice - closed authenticators cannot be accessed

        // Verify multiple closes don't cause issues
        auth.close(); // Should be safe to call again
        assertTrue(auth.isClosed());
    }

    /**
     * Test AutoCloseable implementation
     */
    @Test

                holder.add(smbAuthentication);
            }
        }
        smbAuthenticationHolder = holder;
    }

    /**
     * Closes the SMB client, releasing resources.
     */
    @Override
    public void close() {
        smbAuthenticationHolder = null;
    }

    /*
     * (non-Javadoc)
     *

  override fun clone(): Call = RealCall(client, originalRequest, forWebSocket)

  override fun request(): Request = originalRequest

  /**
   * Immediately closes the socket connection if it's currently held. Use this to interrupt an
   * in-flight request from any thread. It's the caller's responsibility to close the request body

   * - Both request discover no existing connection. They both make a connection.
   * - The first request "wins the race".
   * - The second request discovers it "lost the race" and closes the connection it just opened.
   * - The second request uses the coalesced connection from request1.
   * - The coalesced connection is violently closed after servicing the first request.