Thread.sleep(20);
    assertFalse(taskDone);
    assertFalse(future.isDone());
  }

  public void testNoOpScheduledExecutorShutdown() {
    ListeningScheduledExecutorService executor = TestingExecutors.noOpScheduledExecutor();
    assertFalse(executor.isShutdown());
    assertFalse(executor.isTerminated());
    executor.shutdown();
    assertTrue(executor.isShutdown());

    public void testIsNumver() throws Exception {
        assertFalse(StringUtil.isNumber(null));
        assertTrue(StringUtil.isNumber("0123456789"));
        assertFalse(StringUtil.isNumber("aaaBBBccc"));
        assertFalse(StringUtil.isNumber("０１２３４５６７８９"));
        assertFalse(StringUtil.isNumber(""));
        assertFalse(StringUtil.isNumber("01234abcdef"));
        assertFalse(StringUtil.isNumber("abcdef01234"));
    }

    /**

    Iterator<Subscriber> empty = registry.getSubscribers("");
    assertFalse(empty.hasNext());

    empty = registry.getSubscribers("");

    registry.register(s1);
    assertFalse(empty.hasNext());

    Iterator<Subscriber> one = registry.getSubscribers("");
    assertEquals(s1, one.next().target);
    assertFalse(one.hasNext());

    one = registry.getSubscribers("");

    try {
      assertFalse(entrySet.contains(nullKeyEntry));
    } catch (NullPointerException e) {
      assertFalse(allowsNullKeys);
    }
    Entry<@Nullable K, @Nullable V> nullKeyValueEntry = mapEntry(null, null);
    try {
      assertFalse(entrySet.contains(nullKeyValueEntry));
    } catch (NullPointerException e) {
      assertFalse(allowsNullKeys && allowsNullValues);
    }
  }

        AndArtifactFilter filter2 = new AndArtifactFilter(Arrays.asList(newSubFilter()));

        assertFalse(filter1.equals(null));
        assertTrue(filter1.equals(filter1));
        assertEquals(filter1.hashCode(), filter1.hashCode());

        assertFalse(filter1.equals(filter2));
        assertFalse(filter2.equals(filter1));
    }

            functionalTests.forEach { assertTrue(it.getGradleTasks().startsWith("clean $subProjectName")) }
            if (functionalTests.size == 1) {
                assertFalse(functionalTests[0].getGradleParams().contains("-PincludeTestClasses"))
                assertFalse(functionalTests[0].getGradleParams().contains("-PexcludeTestClasses"))
            } else {
                functionalTests.forEachIndexed { index, it ->

  @CollectionSize.Require(absent = ZERO)
  public void testReplaceEntry_supportedWrongValue() {
    assertFalse(getMap().replace(k0(), v3(), v4()));
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testReplaceEntry_supportedAbsentKey() {
    assertFalse(getMap().replace(k3(), v3(), v4()));
    expectUnchanged();
  }

    assertFalse(TypeToken.of(wildcardType).isSupertypeOf(wildcardType));
    assertFalse(TypeToken.of(int[].class).isSupertypeOf(wildcardType));
  }

  public void testAssignableWildcardTypeParameterToClassTypeParameter() {
    TypeToken<?> wildcardType = new TypeToken<Iterable<? extends Object[]>>() {};
    assertFalse(new TypeToken<Iterable<Object[]>>() {}.isSupertypeOf(wildcardType));

    assertFalse(task.isDone());
    task.run();
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
    assertEquals(2, getDone(task).intValue());
  }

  public void testCancelled() throws Exception {
    TrustedListenableFutureTask<Integer> task = TrustedListenableFutureTask.create(returning(2));
    assertFalse(task.isDone());
    task.cancel(false);

  }

  public void testContains() {
    assertTrue(testTable.contains('a', 1));
    assertFalse(testTable.contains('a', 2));
    assertFalse(testTable.contains('A', 1));
    assertFalse(testTable.contains('A', 2));
  }

  public void testContainsColumn() {
    assertTrue(testTable.containsColumn(1));
    assertFalse(testTable.containsColumn(2));
  }

  public void testContainsRow() {