assertEquals("Converter.identity()", stringIdentityConverter.toString());

    assertSame(Converter.identity(), Converter.identity());
  }

  public void testFrom() {
    Function<String, Integer> forward =
        new Function<String, Integer>() {
          @Override
          public Integer apply(String input) {
            return Integer.parseInt(input);
          }

    FluentIterable<TimeUnit> units = FluentIterable.from(TimeUnit.values());
    assertThrows(UnsupportedOperationException.class, () -> removeIf(units, equalTo(SECONDS)));
  }

  public void testFrom() {
    assertEquals(
        ImmutableList.of(1, 2, 3, 4),
        Lists.newArrayList(FluentIterable.from(ImmutableList.of(1, 2, 3, 4))));
  }

  @SuppressWarnings("deprecation") // test of deprecated method

    assertThrows(NullPointerException.class, () -> comparator.compare(null, null));
    assertSame(comparator, reserialize(comparator));
    assertEquals("Ordering.natural()", comparator.toString());
  }

  public void testFrom() {
    Ordering<String> caseInsensitiveOrdering = Ordering.from(String.CASE_INSENSITIVE_ORDER);
    assertEquals(0, caseInsensitiveOrdering.compare("A", "a"));
    assertTrue(caseInsensitiveOrdering.compare("a", "B") < 0);

    assertThrows(NullPointerException.class, () -> comparator.compare(null, null));
    assertSame(comparator, reserialize(comparator));
    assertEquals("Ordering.natural()", comparator.toString());
  }

  public void testFrom() {
    Ordering<String> caseInsensitiveOrdering = Ordering.from(String.CASE_INSENSITIVE_ORDER);
    assertEquals(0, caseInsensitiveOrdering.compare("A", "a"));
    assertTrue(caseInsensitiveOrdering.compare("a", "B") < 0);

    assertEquals(ImmutableSet.of(1), testTable.columnKeySet());
  }

  public void testColumnMap() {
    assertEquals(ImmutableMap.of(1, ImmutableMap.of('a', "blah")), testTable.columnMap());
  }

  public void testRow() {
    assertEquals(ImmutableMap.of(), testTable.row('A'));
    assertEquals(ImmutableMap.of(1, "blah"), testTable.row('a'));
  }

  public void testRowKeySet() {

  }

  public void testContainsRow() {
    assertFalse(INSTANCE.containsRow('a'));
  }

  public void testContainsValue() {
    assertFalse(INSTANCE.containsValue("blah"));
  }

  public void testRow() {
    assertEquals(ImmutableMap.of(), INSTANCE.row('a'));
  }

  public void testRowKeySet() {
    assertEquals(ImmutableSet.of(), INSTANCE.rowKeySet());
  }

  public void testRowMap() {

      assertTrue(testInstance.containsRow('a'));
      assertTrue(testInstance.containsRow('b'));
      assertFalse(testInstance.containsRow('c'));
    }
  }

  public void testRow() {
    for (ImmutableTable<Character, Integer, String> testInstance : getTestInstances()) {
      assertEquals(ImmutableMap.of(1, "foo", 2, "baz"), testInstance.row('a'));

    assertEquals(expected, table.hashCode());
  }

  public void testToStringSize1() {
    table = create("foo", 1, 'a');
    assertEquals("{foo={1=a}}", table.toString());
  }

  public void testRow() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertEquals(ImmutableMap.of(1, 'a', 3, 'c'), table.row("foo"));
  }

  // This test assumes that the implementation does not support null keys.

        assertFalse(file.exists());
        assertNotNull(
                updateCheckManager.readLastUpdated(touchFile, updateCheckManager.getRepositoryKey(remoteRepository)));
    }

    @Test
    void testPom() throws Exception {
        ArtifactRepository remoteRepository = remoteRepository();

        ArtifactRepository localRepository = localRepository();

        Artifact a = createArtifact("a", "0.0.1", "pom");

    assertEquals(expected, table.hashCode());
  }

  public void testToStringSize1() {
    table = create("foo", 1, 'a');
    assertEquals("{foo={1=a}}", table.toString());
  }

  public void testRow() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertEquals(ImmutableMap.of(1, 'a', 3, 'c'), table.row("foo"));
  }

  // This test assumes that the implementation does not support null keys.