CREATE TABLE public.log_usage (
    log_id bigint NOT NULL
);

ALTER TABLE public.log_usage ALTER COLUMN log_id ADD GENERATED BY DEFAULT AS IDENTITY (
    SEQUENCE NAME public.log_usage_log_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1
);
	`).Error; err != nil {
		t.Fatalf("failed to create table, got error %v", err)
	}

			}
			sys.hMutex.RUnlock()

			if len(eps) > 0 {
				cctx, cancel := context.WithTimeout(ctx, 30*time.Second)
				m := make(map[string]epHealth, len(eps))
				start := time.Now()

				for result := range sys.hcClient.Alive(cctx, madmin.AliveOpts{}, eps...) {
					var lastOnline time.Time
					var offline time.Duration
					//	var deploymentID string
					sys.hMutex.RLock()

                    results[index] = SystemUtil.getSearchEngineHttpAddress();
                });
            }

            // Start all threads
            for (Thread thread : threads) {
                thread.start();
            }

            // Wait for all threads to complete
            for (Thread thread : threads) {
                try {
                    thread.join();

 * #startUp} and {@link #shutDown}) will never run concurrently. Notably, if any execution of {@link
 * #runOneIteration} takes longer than its schedule defines, then subsequent executions may start
 * late. Also, all life cycle methods are executed with a lock held, so subclasses can safely modify
 * shared state without additional synchronization necessary for visibility to later executions of
 * the life cycle methods.
 *

                for (int j = 0; j < eventsPerThread; j++) {
                    logger.logAuthentication(true, "user" + threadId, "DOMAIN", "192.168.1." + threadId);
                }
            });
            threads[i].start();
        }

        for (Thread thread : threads) {
            thread.join();
        }

        Map<EventType, Long> stats = logger.getStatistics();

            return null;
        }
        int start = entryDn.toLowerCase(Locale.ROOT).indexOf("cn=");
        if (start == -1) {
            return null;
        }
        start += 3;

        final int end = entryDn.indexOf(',', start);
        final String value = end == -1 ? entryDn.substring(start) : entryDn.substring(start, end);
        if (fessConfig.isLdapGroupNameWithUnderscores()) {

        try {
            method.invoke(authenticator, null, initialGroups, initialRoles, groupIds);
            // Small wait to allow scheduled task to start
            Thread.sleep(100);
        } catch (Exception e) {
            // May throw due to null user when task executes, which is expected
        }

    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkPositionIndexes(-1, 1, 1));
    assertThat(expected).hasMessageThat().isEqualTo("start index (-1) must not be negative");
  }

  public void testCheckPositionIndexes_endTooHigh() {
    IndexOutOfBoundsException expected =

    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkPositionIndexes(-1, 1, 1));
    assertThat(expected).hasMessageThat().isEqualTo("start index (-1) must not be negative");
  }

  public void testCheckPositionIndexes_endTooHigh() {
    IndexOutOfBoundsException expected =

  /** Whether or not the background thread started successfully. */
  final boolean threadStarted;

  /** Constructs a new queue. */
  public FinalizableReferenceQueue() {
    // We could start the finalizer lazily, but I'd rather it blow up early.
    queue = new ReferenceQueue<>();
    frqRef = new PhantomReference<>(this, queue);
    boolean threadStarted = false;
    try {