verify(configuration, atLeastOnce()).getOemEncoding();
        verifyNoMoreInteractions(cifsContext, configuration);
    }

    @Test
    @DisplayName("getPreNTLMResponse: unsupported OEM encoding propagates as runtime exception")
    void testGetPreNTLMResponse_invalidEncoding() {
        // Arrange
        when(cifsContext.getConfig()).thenReturn(configuration);

        when(nego.isSigningNegotiated()).thenReturn(false);
        assertFalse(session.isSignatureSetupRequired());
    }

    @Test
    @DisplayName("reauthenticate propagates transport failures")
    void testReauthenticatePropagates() throws Exception {
        SmbSessionImpl session = newSession();
        // Cause the inner reauthenticate to fail at first transport call

          executionThread.start();
        }
      };

  @Override
  protected final void tearDown() {
    tearDownStack.runTearDown();
    assertWithMessage("exceptions should not be propagated to uncaught exception handlers")
        .that(thrownByExecutionThread)
        .isNull();
  }

  public void testServiceStartStop() throws Exception {
    WaitOnRunService service = new WaitOnRunService();

    /**
     * Indicates whether plugin executions and configurations should be processed. If enabled, lifecycle-induced plugin
     * executions will be injected into the model and common plugin configuration will be propagated to individual
     * executions.
     *
     * @return {@code true} if plugins should be processed, {@code false} otherwise.
     */
    boolean isProcessPlugins();

    /**

        verify(resp, atLeastOnce()).reset();
        // Verify disconnect was called on retry
        verify(c, atLeastOnce()).disconnect(eq(true));
    }

    @Test
    @DisplayName("send honors NO_RETRY and propagates error immediately")
    void send_noRetry_param() throws Exception {
        SmbTreeConnection c = newConn();
        SmbTreeImpl tree = mock(SmbTreeImpl.class);
        when(tree.acquire(false)).thenReturn(tree);

                List.class);
        method.setAccessible(true);

        // Should not throw - errors should be logged but not propagated
        try {
            method.invoke(authenticator, null, groups, roles, groupIds);
            Thread.sleep(200); // Wait for async execution
        } catch (Exception e) {

        // After close, report stale
        handle.close();
        assertTrue(handle.isStale(), "Closed handle reports stale");
    }

    @Test
    @DisplayName("getSessionKey propagates CIFSException from session acquisition")
    void getSessionKey_exception_propagates() throws Exception {
        SmbPipeHandleImpl handle = newHandleWithBasicStubs(0, "\\\\pipe\\\\sess");

            // Should catch the exception and return EXIT_FAIL
            assertEquals(Constants.EXIT_FAIL, result);
        } catch (RuntimeException e) {
            // Expected behavior - test exception propagates
            assertEquals("Test exception", e.getMessage());
        }
    }

    // Test writeTimeToSessionInfo method
    @Test
    public void test_writeTimeToSessionInfo_withValidHelper() {

        assertNotNull(groovyEngine.evaluate("return container", null));
    }

    // ===== Exception Handling Tests =====

    /**
     * Test that JobProcessingException is propagated
     */
    @Test
    public void test_evaluate_jobProcessingExceptionPropagates() {
        final Map<String, Object> params = new HashMap<>();
        try {

        });
        try {
            systemHelper.destroy();
            assertTrue(true);
        } catch (Exception e) {
            fail("Exception should be caught and not propagated");
        }
    }

    @Test
    public void test_getHelpUrl() {
        getMockRequest().setLocale(Locale.ENGLISH);