* value is <a href="#bitEquals">bitwise equal</a> to the expected value.
   *
   * @param i the index
   * @param expect the expected value
   * @param update the new value
   * @return true if successful. False return indicates that the actual value was not equal to the
   *     expected value.
   */
  public final boolean compareAndSet(int i, double expect, double update) {

      }
    }
  }

  public void testFactorial() {
    BigInteger expected = BigInteger.ONE;
    for (int i = 1; i <= 200; i++) {
      expected = expected.multiply(BigInteger.valueOf(i));
      assertEquals(expected, BigIntegerMath.factorial(i));
    }
  }

  public void testFactorial0() {
    assertEquals(BigInteger.ONE, BigIntegerMath.factorial(0));

  }

  /**
   * Verify that the listener completes in a reasonable amount of time, and Asserts that the future
   * returns the expected data.
   *
   * @throws Throwable if the listener isn't called or if it resulted in a throwable or if the
   *     result doesn't match the expected value.
   */
  public void assertSuccess(Object expectedData) throws Throwable {

    private void assertArrayEquals(String[] expected, String[] actual) {
        if (expected == null && actual == null) {
            return;
        }
        assertNotNull(expected, "Expected array is null but actual is not");
        assertNotNull(actual, "Actual array is null but expected is not");
        assertEquals("Array lengths differ", expected.length, actual.length);

        FileModelSource instance = new FileModelSource(tempFile);

        assertFalse(instance.equals(null), "Expected " + instance + " to not equal " + null);
        assertFalse(instance.equals(new Object()));
        assertTrue(instance.equals(instance), "Expected " + instance + " to equal " + instance);
        assertTrue(instance.equals(new FileModelSource(tempFile)));
    }

    @Test

    @MethodSource("sizeWithScaleUnitTestData")
    void testSizeWithSelectedScaleUnit(long input, ScaleUnit unit, String expected) {
        FileSizeFormat format = new FileSizeFormat();
        if (unit == null) {
            assertEquals(expected, format.format(input));
        } else {
            assertEquals(expected, format.format(input, unit));
        }
    }

    @Test
    void testNegativeProgressedSize() {

  public void testEquals() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = new HashMap<>();
    expected.put(k0(), Lists.newArrayList(v0(), v3()));
    expected.put(k1(), Lists.newArrayList(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

  @CollectionSize.Require(SEVERAL)
  public void testEntrySetEquals() {

  public void testEquals() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = new HashMap<>();
    expected.put(k0(), Lists.newArrayList(v0(), v3()));
    expected.put(k1(), Lists.newArrayList(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

  @CollectionSize.Require(SEVERAL)
  public void testEntrySetEquals() {

    for (int n = 0; n < replacementArray.length; n++) {
      char c = (char) n;
      String expected = map.get(c);
      if (expected == null) {
        assertThat(replacementArray[n]).isNull();
      } else {
        assertThat(new String(replacementArray[n])).isEqualTo(expected);
      }
    }
  }

    assertThat(factory.getSinkContents()).isEqualTo(expected);
  }

  private void assertContainsExpectedLines(String separator) throws IOException {
    String expected = expectedLines.isEmpty() ? "" : Joiner.on(separator).join(expectedLines);
    if (!lines.isEmpty()) {
      // if we wrote any lines in writeLines(), there will be a trailing newline
      expected += separator;
    }