* If an error occurs during file deletion, it is logged but not thrown to avoid
     * masking exceptions from the main operation.
     *
     * @throws IOException if an I/O error occurs during stream closure
     */
    @Override
    public void close() throws IOException {
        try {
            super.close();
        } finally {
            if (!isInMemory() && !done) {

    }

    public void test_initWithResultDataOnly() {
        // Test init method with ResultData only
        AccessResultImpl<Long> result = new AccessResultImpl<>();

        ResultData resultData = new ResultData();
        resultData.setTransformerName("TestTransformer");
        resultData.setData(new byte[0]); // Set data to avoid getData() error

        result.init(null, resultData);

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockConfig.getNetbiosScope()).thenReturn(null);
        // Configure OEM encoding to avoid NullPointerException
        when(mockConfig.getOemEncoding()).thenReturn("UTF-8");
    }

    @Test
    @DisplayName("Constructor with Configuration only should create empty Name instances")
    void testConstructorWithConfigOnly() {

    // we intercept the factory call.
    private MockedStatic<SmbTransport> smbtStatic;

    @BeforeEach
    void setUp() throws Exception {
        // Create a real NtlmPasswordAuthentication instance
        auth = new NtlmPasswordAuthentication("TESTDOMAIN", "testuser", "testpass");

        // Initialize ServerData to avoid NullPointerException
        SmbTransport.ServerData serverData = transport.new ServerData();

     *
     * We could use Suppliers.memoizingSupplier here, but I micro-optimized to this implementation
     * to avoid the extra class for the lambda (and maybe more for memoizingSupplier itself) and the
     * indirection.
     *
     * One thing to *avoid* is a change to make each Logger user use memoizingSupplier directly:
     * That may introduce an extra class for each lambda (currently a dozen).
     */

    "version" that omits the class to avoid conflicts with the copy in Guava
    itself. The idea is:

    - If users want only ListenableFuture, they depend on listenablefuture-1.0.

    - If users want all of Guava, they depend on guava, which, as of Guava
    27.0, depends on
    listenablefuture-9999.0-empty-to-avoid-conflict-with-guava. The 9999.0-...

            "requires": "1.0.3"
          }
        },
        {
          "group": "com.google.guava",
          "module": "listenablefuture",
          "version": {
            "requires": "9999.0-empty-to-avoid-conflict-with-guava"
          }
        },
        {
          "group": "org.jspecify",
          "module": "jspecify",
          "version": {
            "requires": "${jspecify.version}"
          }

   * com.google.common.testing.junit4.TearDownTestCase} for example.
   *
   * <p>A failing {@link TearDown} may or may not fail a tl4j test, depending on the version of
   * JUnit test case you are running under. To avoid failing in the face of an exception regardless
   * of JUnit version, implement a {@link SloppyTearDown} instead.
   *
   * <p>tl4j details: For backwards compatibility, {@code junit3.TearDownTestCase} currently does

  /** Returns the original request that initiated this call. */
  fun request(): Request

  /**
   * Invokes the request immediately, and blocks until the response can be processed or is in error.
   *
   * To avoid leaking resources callers should close the [Response] which in turn will close the
   * underlying [ResponseBody].
   *
   * ```java
   * // ensure the response (and underlying response body) is closed

        ObjectIdentifiers.SHA256_WITH_ECDSA -> "SHA256withECDSA"
        else -> error("unexpected signature algorithm: ${signature.algorithm}")
      }
    }

  // Avoid Long.hashCode(long) which isn't available on Android 5.
  override fun hashCode(): Int {
    var result = 0
    result = 31 * result + version.toInt()
    result = 31 * result + serialNumber.hashCode()