*/
    @Test
    void testClose_throwsException() {
        doThrow(new RuntimeException("Failed to close")).when(smbTree).close();

        assertThrows(RuntimeException.class, () -> smbTree.close(), "Should propagate exception when close fails");
    }

    /**
     * Test for AutoCloseable functionality.
     * Verifies that SmbTree can be used in try-with-resources.
     */
    @Test
    void testAutoCloseable() {

  // At least, I assume that's why. TODO(cpovirk): Check, and maybe add a test for this.
  @SuppressWarnings("ThreadPriorityCheck") // We only propagate user requests (which we discourage).
  private static ThreadFactory doBuild(ThreadFactoryBuilder builder) {
    String nameFormat = builder.nameFormat;
    Boolean daemon = builder.daemon;

   *       of a task are ignored.
   * </ol>
   *
   * <p>{@code RuntimeException}s thrown by tasks are simply logged and the executor keeps trucking.
   * If an {@code Error} is thrown, the error will propagate and execution will stop until the next
   * time a task is submitted.
   *
   * <p>When an {@code Error} is thrown by an executed task, previously submitted tasks may never

        verify(transport).isSigningOptional();
        verify(transport).isSigningEnforced();
    }

    // Error propagation: signing checks may throw SmbException
    @Test
    @DisplayName("signing checks propagate SmbException")
    void signingChecks_throw() throws Exception {
        doThrow(new SmbException("opt error")).when(transport).isSigningOptional();

 * continues. See {@link QueueWorker#workOnQueue} for details.
 *
 * <p>{@code RuntimeException}s thrown by tasks are simply logged and the executor keeps trucking.
 * If an {@code Error} is thrown, the error will propagate and execution will stop until it is
 * restarted by a call to {@link #execute}.
 */
@J2ktIncompatible
@GwtIncompatible
final class SequentialExecutor implements Executor {

 * continues. See {@link QueueWorker#workOnQueue} for details.
 *
 * <p>{@code RuntimeException}s thrown by tasks are simply logged and the executor keeps trucking.
 * If an {@code Error} is thrown, the error will propagate and execution will stop until it is
 * restarted by a call to {@link #execute}.
 */
@J2ktIncompatible
@GwtIncompatible
final class SequentialExecutor implements Executor {

            assertEquals("S-1-5-10-20", domSidCap.getValue().toString());
        }

        @Test
        @DisplayName("initContext then accessors propagate resolver CIFSException as log-only (no throw)")
        void testResolveWeakCIFSExceptionIsIgnored() throws Exception {
            SID sid = new SID("S-1-5-21-1-2-3");

	QueryFields bool
	// CreateBatchSize default create batch size
	CreateBatchSize int
	// TranslateError enabling error translation
	TranslateError bool
	// PropagateUnscoped propagate Unscoped to every other nested statement
	PropagateUnscoped bool

	// ClauseBuilders clause builder
	ClauseBuilders map[string]clause.ClauseBuilder
	// ConnPool db conn pool
	ConnPool ConnPool

            this.reactorContext = reactorContext;
            this.threads = Math.min(
                    session.getRequest().getDegreeOfConcurrency(),
                    session.getProjects().size());
            // Propagate the parallel flag to the root session
            session.setParallel(threads > 1);
            this.executor = new PhasingExecutor(Executors.newFixedThreadPool(threads, new BuildThreadFactory()));

        RuntimeException thrownException = assertThrows(RuntimeException.class, () -> {
            delegatingConfig.getResponseTimeout();
        });

        assertSame(testException, thrownException, "Should propagate exception from delegate");
        verify(mockDelegate).getResponseTimeout();
    }

    @Test
    @DisplayName("Multiple method calls should result in multiple delegate calls")