if err := p.loadResync(ctx, buckets, objAPI); err == nil {
			<-ctx.Done()
			return
		}
		duration := max(time.Duration(r.Float64()*float64(time.Minute)),
			// Make sure to sleep at least a second to avoid high CPU ticks.
			time.Second)
		time.Sleep(duration)
	}
}

// Loads bucket replication resync statuses into memory.

            when(mockEntry.getName()).thenReturn(null, "", " ");

            // Act & Assert
            assertNull(mockEntry.getName(), "first call returns null");
            assertEquals("", mockEntry.getName(), "second call returns empty");
            assertEquals(" ", mockEntry.getName(), "third call returns space");

            verify(mockEntry, times(3)).getName();
        }
    }

            assertEquals(100L, SMBUtil.readInt8(buffer, 0));
            assertEquals(200L, SMBUtil.readInt8(buffer, 8));
            assertEquals(1, SMBUtil.readInt4(buffer, 16));

            // Verify second lock
            assertEquals(300L, SMBUtil.readInt8(buffer, 24));
            assertEquals(400L, SMBUtil.readInt8(buffer, 32));
            assertEquals(2, SMBUtil.readInt4(buffer, 40));

            this.channelId = channelId;
            this.failureTime = System.currentTimeMillis();
            this.retryCount = 0;
            this.nextRetryTime = failureTime + 1000; // Initial 1 second delay
        }

        /**
         * Get channel ID
         *
         * @return channel identifier
         */
        public String getChannelId() {
            return channelId;
        }

						}
						return
					}
					if configRetriableErrors(err) {
						decomLogIf(ctx, fmt.Errorf("Unable to resume decommission of pools %v: %w: retrying..", pools, err))
						time.Sleep(time.Second + time.Duration(r.Float64()*float64(5*time.Second)))
						continue
					}
					decomLogIf(ctx, fmt.Errorf("Unable to resume decommission of pool %v: %w", pools, err))
					return
				}
			}
		}()
	}

	return nil
}

        // First call without SAStruts.method
        mockRequest.setQueryString("query=test");
        assertEquals(customPath, webApiRequest.getServletPath());

        // Second call with SAStruts.method
        mockRequest.setQueryString("SAStruts.method=execute");
        assertEquals(originalPath, webApiRequest.getServletPath());

        // Third call without SAStruts.method again

            response.readBytesWireFormat(buffer1, 0);
            assertEquals(1024, response.getCount());
            assertEquals(512, response.getRemaining());

            // Second read - should update values
            byte[] buffer2 = createValidWriteResponse(2048, 1024);
            response.readBytesWireFormat(buffer2, 0);
            assertEquals(2048, response.getCount());

        request.writeBytesWireFormat(buffer1, 0);

        // Update values
        request.setNotifyFlags(Smb2ChangeNotifyRequest.SMB2_WATCH_TREE);
        request.setCompletionFilter(0xFFF);

        // Second write
        byte[] buffer2 = new byte[512];
        request.writeBytesWireFormat(buffer2, 0);

        // Then
        assertEquals(0, SMBUtil.readInt2(buffer1, 2));

        } catch (Exception e) {
            // Expected
        }
        long duration = System.currentTimeMillis() - startTime;

        // Test should complete in under 1 second (much less than the original 25+ seconds)
        assertTrue("Test should complete quickly (duration: " + duration + "ms)", duration < 1000);
    }

    // Fast mock implementations to minimize overhead

    private final long retryDelay;
    
    public HandleReconnector(PersistentHandleManager manager) {
        this.handleManager = manager;
        this.maxRetries = 3;
        this.retryDelay = 1000;  // 1 second
    }
    
    public CompletableFuture<SmbFile> reconnectHandle(SmbFile file, Exception cause) {
        String path = file.getPath();
        HandleInfo info = handleManager.getHandleForReconnect(path);