/**
 * Tests {@code ReportSet}.
 *
 */
class ReportSetTest {

    @Test
    void testHashCodeNullSafe() {
        new ReportSet().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new ReportSet().equals(null));

        new ReportSet().equals(new ReportSet());
    }

    @Test
    void testEqualsIdentity() {
        ReportSet thing = new ReportSet();

/**
 * Tests {@code Repository}.
 *
 */
class RepositoryTest {

    @Test
    void testHashCodeNullSafe() {
        new Repository().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new Repository().equals(null));

        new Repository().equals(new Repository());
    }

    @Test
    void testEqualsIdentity() {
        Repository thing = new Repository();

        Suggest.createSuggestFromContent();
        Logger.info("Finished setup suggest.");
    }

    @Override
    public void onStop(Application var1) {
        ComponentsUtil.runner.close();
        ComponentsUtil.runner.clean();
    }

    private void esRun() {
        ElasticsearchClusterRunner runner = new ElasticsearchClusterRunner();
        runner.onBuild((number, settingsBuilder) -> {

    protected long reloadInterval = 1000L;

    public void update() {
        CommonPoolUtil.execute(this::load);
    }

    protected void waitForNext() {
        if (reloadInterval > 0) {
            ThreadUtil.sleep(reloadInterval);
        }
    }

    public abstract int load();

    public void setReloadInterval(final long reloadInterval) {
        this.reloadInterval = reloadInterval;

    public abstract PagingList<T> selectList(int offset, int size);

    public abstract OptionalEntity<T> get(long id);

    public abstract void insert(T item);

    public abstract void update(T item);

    public abstract void delete(T item);

    public static class PagingList<E> implements List<E> {
        private final List<E> parent;

        protected int allPageCount;

  protected CountDownLatch latch;
  protected ListenableFuture<Boolean> future;

  @Override
  protected void setUp() throws Exception {

    // Create a latch and a future that waits on the latch.
    latch = new CountDownLatch(1);
    future = createListenableFuture(Boolean.TRUE, null, latch);
  }

  @Override
  protected void tearDown() throws Exception {

    // Make sure we have no waiting threads.
    latch.countDown();
  }

/**
 * Tests for {@link CharSequenceReader}.
 *
 * @author Colin Decker
 */
public class CharSequenceReaderTest extends TestCase {

  public void testReadEmptyString() throws IOException {
    assertReadsCorrectly("");
  }

  public void testReadsStringsCorrectly() throws IOException {
    assertReadsCorrectly("abc");
    assertReadsCorrectly("abcde");
    assertReadsCorrectly("abcdefghijkl");

    }

    public void setDataBuffer(byte[] dataBuffer) {
        this.dataBuffer = dataBuffer;
    }

    public int getDataOffset() {
        return dataOffset;
    }

    public void setDataOffset(int dataOffset) {
        this.dataOffset = dataOffset;
    }

    public int getDataLength() {
        return dataLength;
    }

    public void setDataLength(int dataLength) {

  }

  public void testStringsConsistency() {
    for (String s : Arrays.asList("", "some", "test", "strings", "to", "try")) {
      assertEquals(HASH_FN.newHasher().putUnencodedChars(s).hash(), HASH_FN.hashUnencodedChars(s));
    }
  }

  public void testUtf8() {
    char[] charsA = new char[128];
    char[] charsB = new char[128];

    private static final Logger logger = LogManager.getLogger(GsaConfigParserTest.class);

    @Override
    public void setUp() throws Exception {
        super.setUp();
        ComponentUtil.register(new SystemHelper(), "systemHelper");
    }

    public void test_parse() throws IOException {
        GsaConfigParser parser = new GsaConfigParser();