/**
     * Create new RDMA error handler
     *
     * @param statistics statistics tracker
     * @param maxRetries maximum number of retries for recoverable errors
     * @param retryDelayMs delay between retries in milliseconds
     */
    public RdmaErrorHandler(RdmaStatistics statistics, int maxRetries, long retryDelayMs) {
        this.statistics = statistics;
        this.maxRetries = maxRetries;
        this.retryDelayMs = retryDelayMs;

import jcifs.internal.SMBProtocolDecodingException;

/**
 * Test class for FileBasicInfo
 */
class FileBasicInfoTest {

    private FileBasicInfo fileBasicInfo;
    // Use realistic time values in milliseconds since 1970 (Unix epoch)
    private static final long TEST_CREATE_TIME = System.currentTimeMillis() - 86400000L; // 1 day ago

	return nil
}

func (target ExampleTarget) send(eventData Event) error {
	b := make([]byte, 1)
	if _, err := rand.Read(b); err != nil {
		panic(err)
	}

	time.Sleep(time.Duration(b[0]) * time.Millisecond)

	if target.sendErr {
		return errors.New("send error")
	}

	return nil
}

// SendFromStore - interface compatible method does no-op.
func (target *ExampleTarget) SendFromStore(_ store.Key) error {

    serverIpv6.enqueue(
      MockResponse(body = "hello from IPv6"),
    )

    client =
      client
        .newBuilder()
        .fastFallback(false)
        .callTimeout(1_000, TimeUnit.MILLISECONDS)
        .build()
    val call = client.newCall(Request(url))
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected).hasMessage("timeout")
    }
  }

import static com.google.common.util.concurrent.Service.State.STOPPING;
import static com.google.common.util.concurrent.Service.State.TERMINATED;
import static java.util.Collections.sort;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.base.MoreObjects;

 */
@ExtendWith(MockitoExtension.class)
class BasicFileInformationTest {

    @Mock
    private BasicFileInformation mockBasicFileInfo;

    private FileBasicInfo fileBasicInfo;

    // Use Unix timestamps (milliseconds since 1970) for test values
    private static final long TEST_CREATE_TIME = System.currentTimeMillis() - 10000;
    private static final long TEST_LAST_ACCESS_TIME = System.currentTimeMillis() - 8000;

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static java.util.concurrent.Executors.newFixedThreadPool;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static java.util.concurrent.Executors.newFixedThreadPool;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;

    public void awaitTermination() {
        awaitTermination(0);
    }

    /**
     * Waits for the crawling process to terminate for a specified duration.
     * @param millis The maximum time to wait in milliseconds. A value of 0 means wait indefinitely.
     */
    public void awaitTermination(final long millis) {
        if (parentThread != null) {
            try {
                if (logger.isDebugEnabled()) {

			return
		}
		t := time.NewTicker(time.Duration(pingInterval) * time.Second)
		defer t.Stop()
		emptyEventTicker = t.C
	} else {
		// Deprecated Apr 2023
		t := time.NewTicker(500 * time.Millisecond)
		defer t.Stop()
		keepAliveTicker = t.C
	}

	enc := json.NewEncoder(w)
	for {
		select {
		case ev := <-mergeCh:
			_, err := w.Write(ev)
			if err != nil {
				return
			}