return errHealStopSignalled

			// Timeout if no results consumed for too long.
			case <-unconsumedTimer.C:
				h.mutex.Unlock()
				return errHealIdleTimeout
			}
		}
		break
	}

	// Set the correct result index for the new result item
	if itemsLen > 0 {
		r.ResultIndex = 1 + h.currentStatus.Items[itemsLen-1].ResultIndex
	} else {
		r.ResultIndex = 1 + h.lastSentResultIndex
	}

        }

        long margin = 5000000L;
        System.gc();
        for (int i = 0; i < 300; i++) {
            if (MemoryUtil.getUsedMemory() < current + margin) {
                break;
            }
            System.gc();
            Thread.sleep(100L);
        }
        final long usedMemory = MemoryUtil.getUsedMemory();

   * compares, using {@link #compare(byte, byte)}), the first pair of values that follow any common
   * prefix, or when one array is a prefix of the other, treats the shorter array as the lesser. For
   * example, {@code [] < [0x01] < [0x01, 0x7F] < [0x01, 0x80] < [0x02]}. Values are treated as
   * unsigned.
   *

   * transitionService in the wrong order due to a race. Due to the fact that it is a race this test
   * isn't guaranteed to expose the issue, but it is at least likely to become flaky if the race
   * sneaks back in, and in this case flaky means something is definitely wrong.
   *
   * <p>Before the bug was fixed this test would fail at least 30% of the time.
   */
  public void testTransitionRace() throws TimeoutException {

        for (int i = 0; i < 20; i++) {
            if (!indexUpdater.isAlive() || indexUpdater.getState() == Thread.State.WAITING
                    || indexUpdater.getState() == Thread.State.TIMED_WAITING) {
                break;
            }
            Thread.sleep(100);
        }

        // Clean up the thread
        indexUpdater.setFinishCrawling(true);
        indexUpdater.interrupt();
        indexUpdater.join(2000);

				continue
			}

			// Print the error
			t.Errorf("%s", err)
		}

		var found bool
		for _, fi := range files {
			if fi.Name() == ".trash" {
				continue
			}
			found = true
			break
		}

		if found {
			t.Fatalf("%s: expected: empty, got: non-empty. content: %#v", tmpMetaDir, files)
		}
	}
}

// Benchmarks for ObjectLayer.PutObject().

	for r := range resp {
		if r.Err != nil {
			return r.Err
		}
		if len(r.Msg) > 0 {
			err := cb(r.Msg)
			if err != nil {
				if errors.Is(err, ErrDone) {
					break
				}
				return err
			}
		}
	}
	return nil
}
*/

// shouldConnect returns a deterministic bool whether the local should initiate the connection.

	}
	if len(volInfos) != 2 {
		t.Fatalf("expected: 2, got: %d", len(volInfos))
	}
	volFound := false
	for _, info := range volInfos {
		if info.Name == "success-vol" {
			volFound = true
			break
		}
	}
	if !volFound {
		t.Errorf("expected: success-vol to be created")
	}

	// removing the path and simulating disk failure
	os.RemoveAll(path)
	// should fail with errDiskNotFound.

 *
 * Disclaimer: Part of the reason that callers are so well adapted to `Function<A, B>` may be that
 * that is how the signature looked even prior to this comment! So naturally any change can break
 * existing users, but it can't *fix* existing users because any users who needed
 * `Function<@Nullable A, @Nullable B>` already had to find a workaround. Still, there is a *ton* of

    protected int leaseTimeout = 30000;
    /** Maximum number of concurrent leases */
    protected int maxLeases = 1000;
    /** Preferred lease version (1 or 2) */
    protected int leaseVersion = 2;
    /** Lease break timeout in seconds (per MS-SMB2 spec) */
    protected int leaseBreakTimeout = 60;
    /** Whether to use NT status codes instead of DOS error codes */
    protected boolean useNtStatus = true;