@BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
        response = new Smb2TreeDisconnectResponse(mockConfig);
    }

    @Test
    @DisplayName("Should create response with configuration")
    void testConstructorWithConfiguration() {
        // Given & When
        Smb2TreeDisconnectResponse resp = new Smb2TreeDisconnectResponse(mockConfig);

        // Then

        mocks = MockitoAnnotations.openMocks(this);

        when(context.getConfig()).thenReturn(config);
        when(config.isDirectoryNotificationsEnabled()).thenReturn(false);

        // Create real lease manager for integration testing
        baseLeaseManager = new LeaseManager(context);
        directoryLeaseManager = new DirectoryLeaseManager(context, baseLeaseManager);
    }

    @AfterEach

	dirAbs, err := filepath.Abs(dir)
	if err != nil {
		return nil, err
	}
	err = mkdirAllIgnorePerm(dirAbs)
	if err != nil {
		return nil, fmt.Errorf("unable to create the directory `%s`: %w", dirAbs, err)
	}

	return &ConfigDir{path: dirAbs}, nil
}

func buildServerCtxt(ctx *cli.Context, ctxt *serverCtxt) (err error) {
	// Get "json" flag from command line argument and

  taskRunner: TaskRunner,
) : Closeable,
  Flushable {
  /** Create a cache of at most [maxSize] bytes in [directory]. */
  constructor(
    fileSystem: FileSystem,
    directory: Path,
    maxSize: Long,
  ) : this(
    directory,
    maxSize,
    fileSystem,
    TaskRunner.INSTANCE,
  )

  /** Create a cache of at most [maxSize] bytes in [directory]. */

    public static final String ERRORS_crud_invalid_mode = "{errors.crud_invalid_mode}";

    /** The key of the message: Failed to create a new data. */
    public static final String ERRORS_crud_failed_to_create_instance = "{errors.crud_failed_to_create_instance}";

    /** The key of the message: Failed to create a new data. ({0}) */
    public static final String ERRORS_crud_failed_to_create_crud_table = "{errors.crud_failed_to_create_crud_table}";

public class ScriptEngineTest extends UnitFessTestCase {

    private ScriptEngine scriptEngine;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        // Create a test implementation of ScriptEngine
        scriptEngine = new TestScriptEngine();
    }

    // Test evaluate method with valid template and parameters
    public void test_evaluate_withValidTemplateAndParams() {

    WaitOnRunService service = new WaitOnRunService();
    service.startAsync().awaitRunning();
    enterRun.await();
    service.stopAsync().awaitTerminated();
  }

  public void testTimeout() {
    // Create a service whose executor will never run its commands
    Service service =
        new AbstractExecutionThreadService() {
          @Override
          protected void run() throws Exception {}

          @Override

                }
            } catch (final IOException ioe) {
                log.debug("DS enumeration failed", ioe);
            }
        }

        final SmbTreeConnection treeConn = SmbTreeConnection.create(tc);
        try (SmbTreeHandleImpl th = treeConn.connectHost(locator, locator.getServerWithDfs());
                SmbSessionImpl session = th.getSession();
                SmbTransportImpl transport = session.getTransport()) {

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
        mockContext = mock(CIFSContext.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);

        // Create a test file ID (16 bytes)
        testFileId = new byte[16];
        for (int i = 0; i < 16; i++) {
            testFileId[i] = (byte) (i + 1);
        }

        request = new Smb2FlushRequest(mockConfig, testFileId);

        assertNull(emptyIterator.next(), "Final next call");
    }

    @Test
    @DisplayName("EmptyIterator should be lightweight and efficient")
    void testPerformanceCharacteristics() {
        // When - create many instances quickly
        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {
            EmptyIterator iterator = new EmptyIterator();
            iterator.hasNext();