}
  }

  public void testCheckRoundingUnnecessary_success() {
    MathPreconditions.checkRoundingUnnecessary(true);
  }

  public void testCheckRoundingUnnecessary_failure() {
    try {
      MathPreconditions.checkRoundingUnnecessary(false);
      fail();
    } catch (ArithmeticException expected) {
    }
  }

  public void testCheckInRange_success() {

      getMap().remove(k0());
      iterator.next();
      fail("Expected ConcurrentModificationException");
    } catch (ConcurrentModificationException expected) {
      // success
    }
  }

  @MapFeature.Require({FAILS_FAST_ON_CONCURRENT_MODIFICATION, SUPPORTS_REMOVE})
  @CollectionSize.Require(SEVERAL)
  public void testRemovePresentConcurrentWithKeySetIteration() {
    try {

      put(e3());
      iterator.next();
      fail("Expected ConcurrentModificationException");
    } catch (ConcurrentModificationException expected) {
      // success
    }
  }

  @MapFeature.Require({FAILS_FAST_ON_CONCURRENT_MODIFICATION, SUPPORTS_PUT})
  @CollectionSize.Require(absent = ZERO)
  public void testPutAbsentConcurrentWithKeySetIteration() {
    try {

       * and LinkedList will notably return true on hasNext here!
       */
      fail("Expected ConcurrentModificationException");
    } catch (ConcurrentModificationException expected) {
      // success
    }
  }

      assertTrue(collection.remove(e0()));
      iterator.next();
      fail("Expected ConcurrentModificationException");
    } catch (ConcurrentModificationException expected) {
      // success
    }
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_notPresent() {
    assertFalse("remove(notPresent) should return false", collection.remove(e3()));
    expectUnchanged();
  }

      getList().add(0, e3());
      iterator.next();
      fail("Expected ConcurrentModificationException");
    } catch (ConcurrentModificationException expected) {
      // success
    }
  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  public void testAddAtIndex_unsupportedNotPresent() {
    try {
      getList().add(0, e3());
      fail("add(n, notPresent) should throw");

      assertTrue(collection.removeAll(MinimalCollection.of(e0(), e3())));
      iterator.next();
      fail("Expected ConcurrentModificationException");
    } catch (ConcurrentModificationException expected) {
      // success
    }
  }

  /** Trigger the {@code other.size() >= this.size()} case in {@link AbstractSet#removeAll}. */
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)

      assertTrue(collection.addAll(MinimalCollection.of(e3(), e0())));
      iterator.next();
      fail("Expected ConcurrentModificationException");
    } catch (ConcurrentModificationException expected) {
      // success
    }
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAll_unsupportedAllPresent() {
    try {
      assertFalse(

                    || actualOsName.contains("98")
                    || actualOsName.contains("me")
                    // wince isn't really 9x, but crippled enough to
                    // be a muchness. Maven doesnt run on CE, anyway.
                    || actualOsName.contains("ce"));
            isNT = !is9x;
        }
        switch (family) {
            case FAMILY_WINDOWS:
                return isWindows;

@GwtCompatible(emulated = true)
public class VerifyTest extends TestCase {
  public void testVerify_simple_success() {
    verify(true);
  }

  public void testVerify_simple_failure() {
    try {
      verify(false);
      fail();
    } catch (VerifyException expected) {
    }
  }

  public void testVerify_simpleMessage_success() {
    verify(true, "message");
  }

  public void testVerify_simpleMessage_failure() {