assertEquals(0, freshData.getCurrentPageNumber());
        assertEquals(0L, freshData.getAllRecordCount());
        assertEquals(0, freshData.getAllPageCount());
        assertFalse(freshData.isExistNextPage());
        assertFalse(freshData.isExistPrevPage());
        assertEquals(0L, freshData.getCurrentStartRecordNumber());
        assertEquals(0L, freshData.getCurrentEndRecordNumber());
        assertFalse(freshData.isPartialResults());

    assertThat(max(8L, 6L, 7L, 5L, 3L, 0L, 9L)).isEqualTo(9L);
  }

  public void testMin_noArgs() {
    assertThrows(IllegalArgumentException.class, () -> min());
  }

  public void testMin() {
    assertThat(min(MIN_VALUE)).isEqualTo(MIN_VALUE);
    assertThat(min(MAX_VALUE)).isEqualTo(MAX_VALUE);
    assertThat(min(8L, 6L, 7L, 5L, 3L, 0L, 9L)).isEqualTo(0L);
  }

  public void testConstrainToRange() {

    }

    @Test
    public void test_sizeOf_arrayVariations() {
        // Empty array
        assertEquals(0L, MemoryUtil.sizeOf(new String[0]));
        assertEquals(0L, MemoryUtil.sizeOf(new Object[0]));

        // Array with null elements
        assertEquals(0L, MemoryUtil.sizeOf(new String[] { null, null }));

        // Mixed content array

        assertEquals("0", mockConfig.getTimeAdjustTimeMillis());
        assertEquals(Long.valueOf(0L), mockConfig.getTimeAdjustTimeMillisAsLong());

        // Test multiple calls return same values
        for (int i = 0; i < 10; i++) {
            assertEquals("0", mockConfig.getTimeAdjustTimeMillis());
            assertEquals(Long.valueOf(0L), mockConfig.getTimeAdjustTimeMillisAsLong());
        }
    }

        final MockSearchRequestParams params = new MockSearchRequestParams();
        final LocalDateTime now = LocalDateTime.now();
        final QueryResponseList queryResponseList = new QueryResponseList(Collections.emptyList(), 0L, "eq", 0L, false, null, 0, 10, 0);

        searchLogHelper.createSearchLog(params, now, "test-query-id", "test query", 0, 10, queryResponseList, context);

        assertFalse(searchLogHelper.searchLogQueue.isEmpty());

        TestSearchLogEvent event = new TestSearchLogEvent("id", 0L, "type");

        // Test minimum value
        event.setVersionNo(Long.MIN_VALUE);
        assertEquals(Long.valueOf(Long.MIN_VALUE), event.getVersionNo());

        // Test zero
        event.setVersionNo(0L);
        assertEquals(Long.valueOf(0L), event.getVersionNo());

        // Test maximum value

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

        indexingHelper.setRequestInterval(0L);
        assertEquals(0L, indexingHelper.requestInterval);
    }

    @Test
    public void test_deleteBySessionId_withClient() {
        final Map<String, String> resultMap = new HashMap<>();

                    java.util.function.BiFunction<org.opensearch.action.update.UpdateRequestBuilder, org.opensearch.search.SearchHit, org.opensearch.action.update.UpdateRequestBuilder> processor) {
                return 0L;
            }
        };
        ComponentUtil.register(zeroClient, "searchEngineClient");

        String result = updateLabelJob.execute();
        assertNotNull(result);

        }
    }

    @Test
    public void test_interval_boundary_values() {
        // Test interval boundary values quickly
        dataIndexHelper.setCrawlingExecutionInterval(0L);
        dataIndexHelper.setCrawlingExecutionInterval(1L);
        dataIndexHelper.setCrawlingExecutionInterval(Long.MAX_VALUE);
        assertTrue("Boundary value tests should be fast", true);
    }

    @Test

        return new ChatSearchResult(Collections.emptyList(), null, 0L);
    }

    /**
     * Validates a query and returns an empty result if invalid, or null if validation passed.
     */
    private ChatSearchResult validateQuery(final String query) {
        if (StringUtil.isBlank(query)) {
            return new ChatSearchResult(Collections.emptyList(), null, 0L);
        }
        if (query.length() > MAX_QUERY_LENGTH) {