assertThat(MoreFiles.equal(fooPath, barPath)).isFalse();
      assertThat(MoreFiles.equal(fooPath, fooPath)).isTrue();
      assertThat(MoreFiles.asByteSource(fooPath).contentEquals(MoreFiles.asByteSource(fooPath)))
          .isTrue();

      Path fooCopy = Files.copy(fooPath, fs.getPath("fooCopy"));
      assertThat(Files.isSameFile(fooPath, fooCopy)).isFalse();

  public void testCount() {
    assertThat(EMPTY_STATS_VARARGS.count()).isEqualTo(0);
    assertThat(EMPTY_STATS_ITERABLE.count()).isEqualTo(0);
    assertThat(ONE_VALUE_STATS.count()).isEqualTo(1);
    assertThat(TWO_VALUES_STATS.count()).isEqualTo(2);
    assertThat(MANY_VALUES_STATS_VARARGS.count()).isEqualTo(MANY_VALUES_COUNT);
    assertThat(MANY_VALUES_STATS_ITERABLE.count()).isEqualTo(MANY_VALUES_COUNT);

    assertThat(Bytes.indexOf(EMPTY, ARRAY234)).isEqualTo(-1);
    assertThat(Bytes.indexOf(ARRAY234, ARRAY1)).isEqualTo(-1);
    assertThat(Bytes.indexOf(ARRAY1, ARRAY234)).isEqualTo(-1);
    assertThat(Bytes.indexOf(ARRAY1, ARRAY1)).isEqualTo(0);
    assertThat(Bytes.indexOf(ARRAY234, ARRAY234)).isEqualTo(0);
    assertThat(Bytes.indexOf(ARRAY234, new byte[] {(byte) 2, (byte) 3})).isEqualTo(0);

    ImmutableDoubleArray iia = ImmutableDoubleArray.of(1, 1, 2, 3, 5, 8);
    assertThat(iia.indexOf(1)).isEqualTo(0);
    assertThat(iia.indexOf(8)).isEqualTo(5);
    assertThat(iia.indexOf(4)).isEqualTo(-1);
    assertThat(ImmutableDoubleArray.of(13).indexOf(13)).isEqualTo(0);
    assertThat(ImmutableDoubleArray.of().indexOf(21)).isEqualTo(-1);
    assertThat(iia.subArray(1, 5).indexOf(1)).isEqualTo(0);
  }

    Set<Feature<?>> features = newHashSet(FOO);
    assertThat(addImpliedFeatures(features)).isSameInstanceAs(features);
  }

  public void testAddImpliedFeatures_addsImpliedFeatures() {
    assertThat(addImpliedFeatures(newHashSet(FOO))).containsExactly(FOO);

    assertThat(addImpliedFeatures(newHashSet(IMPLIES_IMPLIES_FOO)))
        .containsExactly(IMPLIES_IMPLIES_FOO, IMPLIES_FOO, FOO);

    assertThat(future.isDone()).isFalse();
    assertThat(future.set(1)).isTrue();
    assertSuccessful(future, 1);
  }

  public void testSetFutureNull() throws Exception {
    assertThrows(NullPointerException.class, () -> future.setFuture(null));

    assertThat(future.isDone()).isFalse();
    assertThat(future.set(1)).isTrue();
    assertSuccessful(future, 1);
  }

  }

  public void testCount() {
    assertThat(emptyAccumulator.count()).isEqualTo(0);
    assertThat(emptyAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(0);
    assertThat(oneValueAccumulator.count()).isEqualTo(1);
    assertThat(oneValueAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(1);
    assertThat(twoValuesAccumulator.count()).isEqualTo(2);

    assertEquals(I18N, Resources.toString(resource, UTF_8));
    assertThat(Resources.toString(resource, US_ASCII)).isNotEqualTo(I18N);
  }

  public void testToByteArray() throws IOException {
    URL resource = getClass().getResource("testdata/i18n.txt");
    assertThat(Resources.toByteArray(resource)).isEqualTo(I18N.getBytes(UTF_8));
  }

  public void testReadLines() throws IOException {

      assertThat(urls.get(0).getProtocol()).isEqualTo("file");
      assertThat(urls.get(0).getAuthority()).isNull();
      assertThat(urls.get(0).getPath()).endsWith("/relative/path/to/some.jar");

      assertThat(urls.get(1)).isEqualTo(new URL("file:///absolute/path/to/some.jar"));

      assertThat(urls.get(2).getProtocol()).isEqualTo("file");
      assertThat(urls.get(2).getAuthority()).isNull();

    ImmutableListMultimap<String, Integer> multimap = zis.combine(zat).build();
    assertThat(multimap.keySet()).containsExactly("a", "b", "c").inOrder();
    assertThat(multimap.values()).containsExactly(1, 3, 2, 4).inOrder();
    assertThat(multimap.get("a")).containsExactly(1, 3).inOrder();
    assertThat(multimap.get("b")).containsExactly(2);
    assertThat(multimap.get("c")).containsExactly(4);
  }