searchRenderData.setRequestedTime(timestamp);
        assertEquals(timestamp, searchRenderData.getRequestedTime());

        // Test with negative value
        searchRenderData.setRequestedTime(-1000L);
        assertEquals(-1000L, searchRenderData.getRequestedTime());
    }

    public void test_setAndGetQueryId() {
        // Test with null
        searchRenderData.setQueryId(null);

     */
    public PurgeThumbnailJob() {
        // Default constructor
    }

    /** Expiration time for thumbnails in milliseconds (default: 30 days) */
    private long expiry = 30 * 24 * 60 * 60 * 1000L;

    /**
     * Executes the thumbnail purging job.
     * Removes thumbnail files that have exceeded the configured expiration time.
     *

            if (logger.isDebugEnabled()) {
                logger.debug("Interrupt {}", runningThread);
            }
            runningThread.interrupt();
            ThreadUtil.sleepQuietly(1000L);
            count++;
        }
    }

    /**
     * Stops the timeout target by setting the running flag to false.
     */
    public void stop() {
        if (logger.isDebugEnabled()) {

        // Prepare test data with sectPerAlloc = 1
        byte[] buffer = new byte[22];
        int idFileSystem = 0x11111111;
        int sectPerAlloc = 1;
        long alloc = 1000L;
        long free = 500L;
        int bytesPerSect = 512;

        // Encode test data
        int offset = 0;
        SMBUtil.writeInt4(idFileSystem, buffer, offset);
        offset += 4;

            int chunkCount = 50;
            SrvCopychunk[] chunks = new SrvCopychunk[chunkCount];

            for (int i = 0; i < chunkCount; i++) {
                chunks[i] = new SrvCopychunk(i * 1000L, i * 2000L, i * 100);
            }

            SrvCopychunkCopy copy = new SrvCopychunkCopy(sourceKey, chunks);
            byte[] buffer = new byte[HEADER_SIZE + (chunkCount * CHUNK_SIZE)];

            // When

        SearchResult result = SearchResult.create()
                .allRecordCount(1000L)
                .allRecordCountRelation("eq")
                .queryTime(150L)
                .partialResults(true)
                .addDocument(doc)
                .facetResponse(facetResponse)
                .build();

        assertEquals(1000L, result.getAllRecordCount());
        assertEquals("eq", result.getAllRecordCountRelation());

        assertEquals(50, indexingHelper.defaultRowSize);

        indexingHelper.setDefaultRowSize(1000);
        assertEquals(1000, indexingHelper.defaultRowSize);
    }

    public void test_setRequestInterval() {
        indexingHelper.setRequestInterval(1000L);
        assertEquals(1000L, indexingHelper.requestInterval);

        indexingHelper.setRequestInterval(0L);

    @Override
    public void setUp() throws Exception {
        super.setUp();
        configHelper = new TestConfigHelper();
    }

    public void test_setReloadInterval() {
        assertEquals(1000L, configHelper.reloadInterval);

        configHelper.setReloadInterval(5000L);
        assertEquals(5000L, configHelper.reloadInterval);

        configHelper.setReloadInterval(0L);

        @DisplayName("Should verify all interface methods can be mocked")
        void testAllMethodsCanBeMocked() {
            // Setup all mock behaviors
            when(mockReferralData.getExpiration()).thenReturn(1000L);
            when(mockReferralData.getPathConsumed()).thenReturn(10);
            when(mockReferralData.getDomain()).thenReturn("domain");
            when(mockReferralData.getLink()).thenReturn("link");

                for (final TimeoutTask task : getExpiredTask()) {
                    processTask(executorService, task);
                }
                Thread.sleep(1000L);
            }
        } catch (final InterruptedException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Interrupted.", e);
            }
        } finally {