*/
package org.codelibs.fess.suggest.entity;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.junit.Before;
import org.junit.Test;

        RangeQueryBuilder rangeQuery = (RangeQueryBuilder) deleteQuery;
        assertEquals(expiresFieldName, rangeQuery.fieldName());
        assertEquals("now", rangeQuery.to());
        assertNull(rangeQuery.from());
    }

    public void test_execute_multipleExecutions() {
        // Execute the job multiple times
        String result1 = purgeDocJob.execute();

        // Reset the flag

    }

    public void test_constructor_withNullServletPath() {
        final String servletPath = null;
        webApiRequest = new WebApiRequest(mockRequest, servletPath);
        assertNotNull(webApiRequest);
        assertNull(webApiRequest.servletPath);
    }

    public void test_constructor_withSpecialCharactersInPath() {
        final String servletPath = "/api/v1/search?query=test&page=1";

    if (chunk1 > 0) {
      write(out, data, 0, chunk1, singleByte);
      assertTrue(ByteSource.wrap(data).slice(0, chunk1).contentEquals(source));
    }
    File file = out.getFile();
    assertNull(file);

    // Write data to go over the threshold
    if (chunk2 > 0) {
      if (JAVA_IO_TMPDIR.value().equals("/sdcard")) {
        assertThrows(IOException.class, () -> write(out, data, chunk1, chunk2, singleByte));

    assertEquals("bar", getOnlyElement(iterator, "bar"));
  }

  public void testGetOnlyElement_withDefault_empty_null() {
    Iterator<String> iterator = emptyIterator();
    assertNull(Iterators.<@Nullable String>getOnlyElement(iterator, null));
  }

  public void testGetOnlyElement_withDefault_two() {
    Iterator<String> iterator = asList("foo", "bar").iterator();

        }
    }

    public void test_addShutdownListener_null() {
        // Test adding null listener
        jobExecutor.addShutdownListener(null);
        assertNull(jobExecutor.shutdownListener);

        // Shutdown with null listener should throw NullPointerException
        try {
            jobExecutor.shutdown();
            fail("Expected NullPointerException");

        ProtwordsFile.ProtwordsUpdater updater = protwordsFile.new ProtwordsUpdater(item);

        // Write the same item (should delete)
        ProtwordsItem result = updater.write(item);

        assertNull(result);

        updater.close();
    }

    public void test_ProtwordsUpdater_write_mismatchException() {
        protwordsFile.reload(null);

        // Create an item for update

        result = (String) method.invoke(keyMatchHelper, "Mixed_Case");
        assertEquals("mixed_case", result);

        result = (String) method.invoke(keyMatchHelper, (String) null);
        assertNull(result);

        result = (String) method.invoke(keyMatchHelper, "");
        assertEquals("", result);

        result = (String) method.invoke(keyMatchHelper, "Test123");

        QueryBuilder builder = queryCommand.convertTermQuery(queryContext, (TermQuery) query, 1.0f);
        if (text.startsWith("sort:")) {
            assertNull(builder);
        } else {
            logger.info("{} => {}", text, builder.toString());
            assertEquals(expectedClass, builder.getClass());

      assertFalse(name, domain.isPublicSuffix());
      assertFalse(name, domain.hasPublicSuffix());
      assertFalse(name, domain.isUnderPublicSuffix());
      assertFalse(name, domain.isTopPrivateDomain());
      assertNull(domain.publicSuffix());
    }

    for (String name : NON_PS) {
      InternetDomainName domain = InternetDomainName.from(name);
      assertFalse(name, domain.isPublicSuffix());