}

// Empty asserts the tracker is empty
func (t *Tracker[T]) Empty() {
	t.t.Helper()
	t.mu.Lock()
	defer t.mu.Unlock()
	if len(t.events) != 0 {
		t.t.Fatalf("unexpected events: %v", t.events)
	}
}

// WaitOrdered waits for an event to happen, in order
func (t *Tracker[T]) WaitOrdered(events ...T) {
	t.t.Helper()
	for i, event := range events {
		var err error
		retry.UntilSuccessOrFail(t.t, func() error {

)

func ValidateListeners(t testing.TB, ls []*listener.Listener) {
	t.Helper()
	found := sets.New[string]()
	for _, l := range ls {
		if found.InsertContains(l.Name) {
			t.Errorf("duplicate listener name %v", l.Name)
		}
		ValidateListener(t, l)
	}
}

func ValidateListener(t testing.TB, l *listener.Listener) {
	t.Helper()
	if err := l.Validate(); err != nil {

  private static final AtomicHelper ATOMIC_HELPER;

  private static final LazyLogger log = new LazyLogger(AggregateFutureState.class);

  static {
    AtomicHelper helper;
    Throwable thrownReflectionFailure = null;
    try {
      helper =
          new SafeAtomicHelper(
              newUpdater(AggregateFutureState.class, Set.class, "seenExceptions"),
              newUpdater(AggregateFutureState.class, "remaining"));

}

func mktemp(dir, prefix string, t *testing.T) string {
	t.Helper()
	tempDir, err := os.MkdirTemp(dir, prefix)
	if err != nil {
		t.Fatalf("Couldn't get current working directory, err: %v", err)
	}
	t.Logf("Created temporary dir: %v", tempDir)
	return tempDir
}

func ls(dir string, t *testing.T) []string {
	files, err := os.ReadDir(dir)
	t.Helper()
	if err != nil {
		t.Fatalf("Failed to list files, err: %v", err)
	}

import javax.annotation.Resource;
import javax.servlet.ServletContext;

import org.codelibs.core.lang.StringUtil;
import org.codelibs.fess.exception.UserRoleLoginException;
import org.codelibs.fess.helper.CrawlingConfigHelper;
import org.dbflute.optional.OptionalThing;
import org.lastaflute.di.util.LdiFileUtil;
import org.lastaflute.web.login.LoginManager;
import org.lastaflute.web.response.ActionResponse;

	t.Helper()
	if _, err := client.CoreV1().Namespaces().Create(context.TODO(), &v1.Namespace{
		ObjectMeta: metav1.ObjectMeta{Name: ns, Labels: labels},
	}, metav1.CreateOptions{}); err != nil {
		t.Fatal(err)
	}
}

func updateNamespace(t *testing.T, client kubernetes.Interface, ns string, labels map[string]string) {
	t.Helper()

	t.Helper()
	fx.matchOrFail(t, false, events...)
}

// StrictMatchOrFail expects the provided events to arrive, and nothing else
func (fx *Updater) StrictMatchOrFail(t test.Failer, events ...Event) {
	t.Helper()
	fx.matchOrFail(t, true, events...)
}

func (fx *Updater) matchOrFail(t test.Failer, strict bool, events ...Event) {
	t.Helper()
	delay := time.NewTimer(time.Second * 5)

  private static final AtomicHelper ATOMIC_HELPER;

  private static final LazyLogger log = new LazyLogger(AggregateFutureState.class);

  static {
    AtomicHelper helper;
    Throwable thrownReflectionFailure = null;
    try {
      helper =
          new SafeAtomicHelper(
              newUpdater(AggregateFutureState.class, Set.class, "seenExceptions"),
              newUpdater(AggregateFutureState.class, "remaining"));

	case 1:
		lc = lcOpt[0]
	default:
		t.Helper()
		t.Fatal("too many ListenConfigs passed to newLocalListener: want 0 or 1")
	}

	listenPacket := func(net, addr string) PacketConn {
		c, err := lc.ListenPacket(context.Background(), net, addr)
		if err != nil {
			t.Helper()
			t.Fatal(err)
		}
		return c
	}

	t.Helper()
	switch network {
	case "udp":
		if supportsIPv4() {

import org.codelibs.fess.es.client.SearchEngineClient;
import org.codelibs.fess.exception.DataStoreException;
import org.codelibs.fess.helper.CrawlingInfoHelper;
import org.codelibs.fess.helper.IndexingHelper;
import org.codelibs.fess.helper.SearchLogHelper;
import org.codelibs.fess.helper.SystemHelper;
import org.codelibs.fess.ingest.IngestFactory;
import org.codelibs.fess.ingest.Ingester;