void testConcurrentAccess() throws InterruptedException {
        // Given
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];
        final boolean[] results = new boolean[threadCount];

        // When
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                try {

func getListQuorum(quorum string, driveCount int) int {
	switch quorum {
	case "disk":
		return 1
	case "reduced":
		return 2
	case "optimal":
		return (driveCount + 1) / 2
	case "auto":
		return -1
	}
	// defaults to 'strict'
	return driveCount
}

func calcCommonWritesDeletes(infos []DiskInfo, readQuorum int) (commonWrite, commonDelete uint64) {

    assertFalse(a1[0].equals(a2[0]));
  }

  public void testPrimitiveArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    int[] a1 = generator.generateFresh(int[].class);
    int[] a2 = generator.generateFresh(int[].class);
    assertTrue(a1[0] != a2[0]);
  }

  public void testRange() {
    assertFreshInstance(new TypeToken<Range<String>>() {});
  }

 * returning more-or-less the same answers.
 */
@NullUnmarked
public class QuantilesAlgorithmTest extends TestCase {

  private static final Random rng = new Random(82674067L);
  private static final int DATASET_SIZE = 1000;
  private static final double ALLOWED_ERROR = 1.0e-10;
  private static final QuantilesAlgorithm REFERENCE_ALGORITHM = QuantilesAlgorithm.SORTING;

        }

        @Override
        public String getName() {
            return name;
        }

        @Override
        public int getType() {
            return 0;
        }

        @Override
        public int getAttributes() {
            return 0;
        }

        @Override
        public long createTime() {
            return 0;
        }

  @Override
  void setCountCheckReturnValue(E element, int count) {
    assertTrue(
        "setCount() with the correct expected present count should return true",
        setCount(element, count));
  }

  @Override
  void setCountNoCheckReturnValue(E element, int count) {
    setCount(element, count);
  }

  @CanIgnoreReturnValue
  private boolean setCount(E element, int count) {

    private final ByteArrayOutputStream out = new ByteArrayOutputStream();

    @Override
    protected void update(byte b) {
      out.write(b);
    }

    @Override
    protected void update(byte[] b, int off, int len) {
      out.write(b, off, len);
    }

    byte[] bytes() {
      return out.toByteArray();
    }

    void assertBytes(byte[] expected) {
      assertArrayEquals(expected, bytes());

  }

  @Override
  public C first() {
    throw new NoSuchElementException();
  }

  @Override
  public C last() {
    throw new NoSuchElementException();
  }

  @Override
  public int size() {
    return 0;
  }

  @Override
  public ContiguousSet<C> intersection(ContiguousSet<C> other) {
    return this;
  }

  @Override
  public Range<C> range() {

  public void testSize() {
    int expectedSize = getNumElements();
    Multimap<K, V> multimap = multimap();
    assertEquals(expectedSize, multimap.size());

    int size = 0;
    for (Entry<K, V> entry : multimap.entries()) {
      assertTrue(multimap.containsEntry(entry.getKey(), entry.getValue()));
      size++;
    }
    assertEquals(expectedSize, size);

    int size2 = 0;

/**
 * @author y-komori
 *
 */
public class FieldUtilTest {

    /** */
    public Object objectField;

    /** */
    public int intField;

    /** */
    public String stringField;

    /** */
    public static final int INT_DATA = 987654321;

    /** */
    public static final String STRING_DATA = "Hello World!";

    /**
     * @throws Exception
     */
    @Test