return new CheckedCallable<String>() {
      @Override
      protected String realCall() {
        try {
          latch.await();
        } catch (InterruptedException quittingTime) {
        }
        return TEST_STRING;
      }
    };
  }

  public Runnable awaiter(final CountDownLatch latch) {
    return new CheckedRunnable() {

    }

    private static class FlushOperationsCommand implements Runnable {
        private CountDownLatch latch = new CountDownLatch(1);

        @Override
        public void run() {
        }

        public void await() {
            try {
                latch.await();
            } catch (InterruptedException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }

    Map<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }

    if (supportsClear) {
      map.clear();
      assertTrue(map.isEmpty());
    } else {
      try {
        map.clear();
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException expected) {
      }
    }

      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testCheckPositive_maxInt() {
    MathPreconditions.checkPositive("int", Integer.MAX_VALUE);
  }

  public void testCheckPositive_minInt() {
    try {
      MathPreconditions.checkPositive("int", Integer.MIN_VALUE);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

    try {
      iterator.remove();
      fail();
    } catch (UnsupportedOperationException expected) {
    }
    assertFalse(iterator.hasNext());
    try {
      iterator.next();
      fail();
    } catch (NoSuchElementException expected) {
    }
    try {
      iterable.iterator();
      fail();
    } catch (IllegalStateException expected) {
    }
  }

      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      Helpers.assertContentsInOrder(list, "a", "c", "b");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      Helpers.assertContentsInOrder(list, "a", "B", "c");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
  }

      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      Helpers.assertContentsInOrder(list, "a", "c", "b");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      Helpers.assertContentsInOrder(list, "a", "B", "c");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
  }

    Map<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }

    if (supportsClear) {
      map.clear();
      assertTrue(map.isEmpty());
    } else {
      try {
        map.clear();
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException expected) {
      }
    }

    try {
      iterator.remove();
      fail();
    } catch (UnsupportedOperationException expected) {
    }
    assertFalse(iterator.hasNext());
    try {
      iterator.next();
      fail();
    } catch (NoSuchElementException expected) {
    }
    try {
      iterable.iterator();
      fail();
    } catch (IllegalStateException expected) {
    }
  }

                cipher.init(Cipher.ENCRYPT_MODE, sksSpec);
            } catch (final InvalidKeyException e) {
                throw new InvalidKeyRuntimeException(e);
            } catch (final NoSuchAlgorithmException e) {
                throw new NoSuchAlgorithmRuntimeException(e);
            } catch (final NoSuchPaddingException e) {
                throw new NoSuchPaddingRuntimeException(e);
            }
        }