@Test
    public void test_FilePurgeVisitor_visitFileFailed() throws IOException {
        // Test that visitFileFailed doesn't throw exception
        // This is primarily a logging method, so we just verify no exception
        assertTrue(true);
    }

    // Test FilePurgeVisitor postVisitDirectory
    @Test
    public void test_FilePurgeVisitor_postVisitDirectory() throws IOException {
        // Test empty directory deletion logic

   */
  @Override
  protected void tearDown() throws Exception {
    Throwable t = threadFailure.getAndSet(null);
    if (t != null) {
      if (t instanceof Error) {
        throw (Error) t;
      } else if (t instanceof RuntimeException) {
        throw (RuntimeException) t;
      } else if (t instanceof Exception) {
        throw (Exception) t;
      } else {

            @Override
            protected URLConnection openConnection(URL u) throws IOException {
                return mock(HttpURLConnection.class);
            }
        };

        // Create mock HTTPS handler
        URLStreamHandler httpsHandler = new URLStreamHandler() {
            @Override
            protected URLConnection openConnection(URL u) throws IOException {
                return mock(HttpURLConnection.class);

      notifyAll()
    }
  }

  @Throws(IOException::class)
  internal fun checkOutNotClosed() {
    when {
      sink.closed -> throw IOException("stream closed")
      sink.finished -> throw IOException("stream finished")
      errorCode != null -> throw errorException ?: StreamResetException(errorCode!!)
    }
  }

  /**

   *
   * @throws ParseException if the specifier is not valid.
   */
  @CanIgnoreReturnValue // TODO(b/219820829): consider removing
  public static HostSpecifier from(String specifier) throws ParseException {
    try {
      return fromValid(specifier);
    } catch (IllegalArgumentException e) {
      // Since the IAE can originate at several different points inside

  }

  /**
   * Guaranteed to throw an exception and leave the set unmodified.
   *
   * @since 12.0
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @GwtIncompatible // NavigableSet
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")

      putIndex = 0;
      takeIndex = 0;
    } finally {
      monitor.leave();
    }
  }

  /**
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws ClassCastException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   * @throws IllegalArgumentException {@inheritDoc}
   */
  @CanIgnoreReturnValue
  @Override
  public int drainTo(Collection<? super E> c) {

            statement.setQueryTimeout(queryTimeout);
        } catch (final SQLException ex) {
            throw new SQLRuntimeException(ex);
        }
    }

    /**
     * Closes the {@link Statement}.
     * <p>
     * If {@link Statement#close()} throws an exception, an error message is logged. The exception is not rethrown.
     * </p>
     *
     * @param statement
     *            {@link Statement}

        @Override
        public int getFileIndex() {
            return 0;
        }
    }

    @Test
    @DisplayName("open(): invalid URL path without trailing slash throws SmbException")
    void invalidUrlPathThrows() throws Exception {
        // Override the default setup for this specific test
        URL invalidUrl = new URL("smb://server/share/dir"); // no trailing '/'

        when(delegate.next()).thenReturn(entry1, entry2);

        // Adapter that always throws
        FileEntryAdapterIterator iterator = new FileEntryAdapterIterator(parent, delegate, null) {
            @Override
            protected SmbResource adapt(FileEntry e) throws MalformedURLException {
                throw new MalformedURLException("Always fails");
            }
        };