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);

    SingleCallListener singleCallListener = new SingleCallListener();
    singleCallListener.expectCall();

    assertFalse(spy.wasExecuted);
    assertFalse(singleCallListener.wasCalled());
    assertFalse(listenableFuture.isDone());

    listenableFuture.addListener(singleCallListener, executorService);
    abstractFuture.set(DATA1);

    Predicate<Object> predicate = Predicates.or(array);
    assertFalse(predicate.apply(1));
    array[0] = Predicates.alwaysTrue();
    assertFalse(predicate.apply(1));
  }

  public void testOr_listDefensivelyCopied() {
    List<Predicate<Object>> list = newArrayList();
    Predicate<Object> predicate = Predicates.or(list);
    assertFalse(predicate.apply(1));
    list.add(Predicates.alwaysTrue());

  }

  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() {

    assertEquals(Integer.valueOf(2), map.get("foo"));
    assertFalse(map.containsKey("bar"));
  }

  public void testReplaceConditional() {
    TestMap map = new TestMap();
    map.put("foo", 1);
    assertFalse(map.replace("foo", 2, 3));
    assertFalse(map.replace("bar", 1, 2));
    assertEquals(Integer.valueOf(1), map.get("foo"));
    assertFalse(map.containsKey("bar"));
    assertTrue(map.replace("foo", 1, 4));

    assertTrue(map.isEmpty());
    assertEquals(0, map.size());
    assertFalse(map.containsKey("1"));
    assertFalse(map.containsKey("2"));
    assertFalse(map.containsKey("3"));
    assertEquals(0L, map.get("1"));
    assertEquals(0L, map.get("2"));
    assertEquals(0L, map.get("3"));

    map.putAll(in);
    assertFalse(map.isEmpty());
    assertEquals(3, map.size());
    assertTrue(map.containsKey("1"));

        ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);
        cos.write(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 });
        assertFalse(cos.done);
        assertFalse(cos.isInMemory());
        cos.close();
        assertFalse(cos.done);
        assertFalse(cos.getFile().exists());
    }

    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));

    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("");

    assertFalse(rangeSet.intersects(Range.closed(3, 4)));
    assertTrue(rangeSet.intersects(Range.greaterThan(5)));
    assertFalse(rangeSet.intersects(Range.greaterThan(8)));

    assertTrue(rangeSet.encloses(Range.closed(1, 2)));
    assertTrue(rangeSet.encloses(Range.open(5, 8)));
    assertFalse(rangeSet.encloses(Range.closed(1, 8)));
    assertFalse(rangeSet.encloses(Range.greaterThan(5)));