top.offer(2);
    assertThat(top.topK()).containsExactly(2, 3, 5).inOrder();
  }

  public void testOfferedKPlusOne() {
    for (List<Integer> list : Collections2.permutations(Ints.asList(1, 2, 3, 4, 5))) {
      TopKSelector<Integer> top = TopKSelector.least(4);
      top.offerAll(list);
      assertThat(top.topK()).containsExactly(1, 2, 3, 4).inOrder();
    }
  }

  public void testOfferedThreeK() {

            EndpointPair.unordered(4, 5))
        .inOrder();
  }

  @Test
  public void stableIncidentEdgeOrder_adjacentNodes_returnsInConnectingEdgeInsertionOrder() {
    assume().that(graph.incidentEdgeOrder().type()).isEqualTo(ElementOrder.Type.STABLE);

    populateTShapedGraph();

    assertThat(graph.adjacentNodes(1)).containsExactly(2, 4, 3).inOrder();
  }

  @Test

    assertThat(ms.elementSet()).containsExactly("a", "b", "c").inOrder();
    ms.remove("b");
    assertThat(ms.elementSet()).containsExactly("a", "b", "c").inOrder();
    ms.add("b");
    assertThat(ms.elementSet()).containsExactly("a", "b", "c").inOrder();
    ms.remove("b", 2);
    ms.add("b");
    assertThat(ms.elementSet()).containsExactly("a", "c", "b").inOrder();
  }

    assertThat(actual.getLowerBounds())
        .asList()
        .containsExactlyElementsIn(asList(expected.getLowerBounds()))
        .inOrder();
    assertThat(actual.getUpperBounds())
        .asList()
        .containsExactlyElementsIn(asList(expected.getUpperBounds()))
        .inOrder();
  }

  private static class WithTypeVariable {

    @SuppressWarnings("unused")
    <T> void withoutBound(List<T> list) {}

            EndpointPair.ordered(5, 1))
        .inOrder();
  }

  @Test
  public void stableIncidentEdgeOrder_adjacentNodes_returnsInConnectingEdgeInsertionOrder() {
    assume().that(graph.incidentEdgeOrder().type()).isEqualTo(ElementOrder.Type.STABLE);

    populateStarShapedGraph();

    assertThat(graph.adjacentNodes(1)).containsExactly(2, 4, 3, 5).inOrder();
  }

  @Test

        new Iterable<Integer>() {
          @Override
          public Iterator<Integer> iterator() {
            return newDoubler(2, 32);
          }
        };
    assertThat(doubled).containsExactly(2, 4, 8, 16, 32).inOrder();
  }

  public void testSampleCode() {
    Iterable<Integer> actual =
        new Iterable<Integer>() {
          @Override
          public Iterator<Integer> iterator() {

        .containsExactly(4, 3, 2, 1)
        .inOrder();
  }

  public void testToSortedSet_removeDuplicates() {
    assertThat(fluent(1, 4, 1, 3).toSortedSet(Ordering.<Integer>natural().reverse()))
        .containsExactly(4, 3, 1)
        .inOrder();
  }

  public void testToMultiset() {
    assertThat(fluent(1, 2, 1, 3, 2, 4).toMultiset()).containsExactly(1, 1, 2, 2, 3, 4).inOrder();
  }

        .inOrder();
    assertThat(map.tailMap("onea").entrySet())
        .containsExactly(mapEntry("three", 5), mapEntry("two", 3))
        .inOrder();
    assertThat(map.subMap("one", "two").entrySet())
        .containsExactly(mapEntry("one", 3), mapEntry("three", 5))
        .inOrder();
  }

  public void testAsMapSortedReadsThrough() {

        .inOrder();
    assertThat(map.tailMap("onea").entrySet())
        .containsExactly(mapEntry("three", 5), mapEntry("two", 3))
        .inOrder();
    assertThat(map.subMap("one", "two").entrySet())
        .containsExactly(mapEntry("one", 3), mapEntry("three", 5))
        .inOrder();
  }

  public void testAsMapSortedReadsThrough() {

        new Iterable<Integer>() {
          @Override
          public Iterator<Integer> iterator() {
            return newDoubler(2, 32);
          }
        };
    assertThat(doubled).containsExactly(2, 4, 8, 16, 32).inOrder();
  }

  public void testSampleCode() {
    Iterable<Integer> actual =
        new Iterable<Integer>() {
          @Override
          public Iterator<Integer> iterator() {