}

  public void testAddAndGet() {
    Count holder = new Count(20);
    assertEquals(21, holder.addAndGet(1));
  }

  public void testGetAndSet() {
    Count holder = new Count(10);
    assertEquals(10, holder.getAndSet(20));
    assertEquals(20, holder.get());
  }

  public void testSet() {
    Count holder = new Count(10);
    holder.set(20);
    assertEquals(20, holder.get());
  }

   * Returns the number of {@code values} that are {@code true}.
   *
   * @since 16.0
   */
  public static int countTrue(boolean... values) {
    int count = 0;
    for (boolean value : values) {
      if (value) {
        count++;
      }
    }
    return count;
  }

  /**
   * Reverses the elements of {@code array}. This is equivalent to {@code

        assertEquals(buffer, getFieldValue(write, "b"), "Buffer reference should be set");
        assertEquals(off, getFieldValue(write, "off"), "Off should match constructor arg");
        assertEquals(len, getFieldValue(write, "count"), "Count should equal len");
    }

    /**
     * Test setParam method updates the write parameters
     */
    @Test
    public void testSetParam() {
        // Arrange

  public <T> T[] toArray(T[] a) {
    E[] items = this.items;
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      if (a.length < count) a = ObjectArrays.newArray(a, count);

      int k = 0;
      int i = takeIndex;
      while (k < count) {
        // This cast is not itself safe, but the following statement
        // will fail if the runtime type of items[i] is not assignable

    protected static void waitJob(final String namePrefix) {
        Boolean isRunning = false;
        int count = 0;
        long sleepTime = 50; // Start with 50ms

        // Wait until the crawler starts (with exponential backoff)
        while (count < 1500 && !isRunning) {
            ThreadUtil.sleep(sleepTime);
            count++;
            final Map<String, Object> scheduler = getSchedulerItem(namePrefix);

import org.junit.Before;
import org.junit.Test;

/**
 * @author taedium
 */
public class ClassTraversalTest {

    private static int count = 0;

    /**
     * @throws Exception
     */
    @Before
    public void setUp() throws Exception {
        count = 0;
    }

    /**
     * @throws Exception
     */
    @Test
    public void testForEachJarFile() throws Exception {

      // The JVM will return interned values for small ints.
      Integer value = random.nextInt(1000) + 128;
      int count = min(random.nextInt(10) + 1, sizeRemaining);
      sizeRemaining -= count;
      hashMultiset.add(value, count);
      linkedHashMultiset.add(value, count);
      treeMultiset.add(value, count);
    }

    // TODO(kevinb): convert to assert once benchmark tests enable asserts by default

  @CanIgnoreReturnValue
  @Override
  public int setCount(E element, int count) {
    checkIsE(element);
    checkNonnegative(count, "count");
    int index = element.ordinal();
    int oldCount = counts[index];
    counts[index] = count;
    size += count - oldCount;
    if (oldCount == 0 && count > 0) {
      distinctElements++;
    } else if (oldCount > 0 && count == 0) {
      distinctElements--;
    }

		"Total cluster objects count")
	usageVersionsCountMD = NewGaugeMD(usageVersionsCount,
		"Total cluster object versions (including delete markers) count")
	usageDeleteMarkersCountMD = NewGaugeMD(usageDeleteMarkersCount,
		"Total cluster delete markers count")
	usageBucketsCountMD = NewGaugeMD(usageBucketsCount,
		"Total cluster buckets count")
	usageObjectsDistributionMD = NewGaugeMD(usageSizeDistribution,

	maxEntries := 1000
	if opts.count > 0 && opts.count < maxEntries {
		maxEntries = opts.count
	}

	done := false
	remaining := opts.count

	for !done {
		// Read up to max number of entries.
		fis, err := d.Readdir(maxEntries)
		if err != nil {
			if err == io.EOF {
				break
			}
			return nil, osErrToFileErr(err)
		}
		if opts.count > -1 {
			if remaining <= len(fis) {