assertEquals("Store2", names[1]);
        assertEquals(1, loadCount[0]);

        // Second immediate call should use cache
        names = testFactory.getDataStoreNames();
        assertEquals(2, names.length);
        assertEquals(1, loadCount[0]); // Should not increment

        // Simulate time passing (more than 60 seconds)
        testFactory.lastLoadedTime = System.currentTimeMillis() - 61000L;

    /** List of JVM options to apply when executing the job */
    protected List<String> jvmOptions = new ArrayList<>();

    /** Lasta environment configuration */
    protected String lastaEnv;

    /** Timeout in seconds for job execution (-1 means no timeout) */
    protected int timeout = -1; // sec

    /** Flag indicating whether the process has timed out */
    protected boolean processTimeout = false;

    /**

         */
        public int hunds;
        /**
         * The time zone offset from UTC in minutes.
         */
        public int timezone;
        /**
         * The time interval for each tick of the clock in 0.0001 seconds.
         */
        public int tinterval;
        /**
         * The current day of the month (1-31).
         */
        public int day;
        /**

//	sub-second times  |     no |       yes |        no
//	sparse files      |     no |       yes |       yes
//
// The table's upper portion shows the [Header] fields, where each format reports
// the maximum number of bytes allowed for each string field and
// the integer type used to store each numeric field
// (where timestamps are stored as the number of seconds since the Unix epoch).
//

                    }
                });
            }

            startLatch.countDown(); // Start all threads
            boolean completed = endLatch.await(10, TimeUnit.SECONDS);
            executor.shutdown();

            assertTrue(completed, "All threads should complete without deadlock");

    }

    @Test
    void testUTimeReadWrite() {
        byte[] buffer = new byte[4];
        long time = System.currentTimeMillis();
        // UTime is seconds since epoch, so divide by 1000
        long unixTime = time / 1000L;

        // Mocking date for timezone consistency
        TimeZone original = TimeZone.getDefault();
        try {

});
```

## Troubleshooting

### Common Issues

#### Connection Timeouts
```java
// Increase timeout values
client.setConnectionTimeout(60000);  // 60 seconds
client.setSocketTimeout(120000);     // 120 seconds
```

#### Memory Issues
```java
// Reduce concurrent threads and batch sizes
crawler.crawlerContext.setNumOfThread(5);
crawler.crawlerContext.setMaxAccessCount(1000);
```

	if result.Error != nil {
		return RemoteTargetConnectionErr{Bucket: tgt.TargetBucket, Err: result.Error, AccessKey: tgt.Credentials.AccessKey}
	}
	if !result.Online {
		err := errors.New("Health check timed out after 3 seconds")
		return RemoteTargetConnectionErr{Err: err}
	}

	sys.Lock()
	defer sys.Unlock()

	tgts := sys.targetsMap[bucket]
	newtgts := make([]madmin.BucketTarget, len(tgts))
	found := false

        super();
        setLeaseKey(key);
        setLeaseState(leaseState);
        this.cacheScope = scope;
        this.maxCacheAge = 30000;  // 30 seconds default
        this.notificationEnabled = true;
    }
    
    @Override
    public void encode(byte[] buffer, int offset) {
        super.encode(buffer, offset);
        

public class RdmaErrorHandler {

    private static final Logger log = LoggerFactory.getLogger(RdmaErrorHandler.class);

    // Retry and timing constants (in ms)
    private static final long MAX_RETRY_DELAY = 10000; // 10 seconds maximum delay
    private static final int MAX_BACKOFF_SHIFT = 4; // Maximum 16x multiplier

    private final RdmaStatistics statistics;
    private final int maxRetries;
    private final long retryDelayMs;

    /**