actual = Arrays.asList(KuromojiCSVUtil.parse(value));
        assertThat(actual, is(expected));

        value = "\"Fess,FESS\"";
        expected = Arrays.asList("\"Fess,FESS\"");
        actual = Arrays.asList(KuromojiCSVUtil.parse(value));
        assertThat(actual, is(expected));

        value = " ";
        expected = Arrays.asList(" ");

  // Test all creation paths very lazily: by assuming asList() works

  public void testOf0() {
    assertThat(ImmutableDoubleArray.of().asList()).isEmpty();
  }

  public void testOf1() {
    assertThat(ImmutableDoubleArray.of(0).asList()).containsExactly(0.0);
  }

  public void testOf2() {
    assertThat(ImmutableDoubleArray.of(0, 1).asList()).containsExactly(0.0, 1.0).inOrder();
  }

    }
    return Longs.asList(temp);
  }

  @J2ktIncompatible
  @GwtIncompatible // suite
  public static Test suite() {
    List<ListTestSuiteBuilder<Long>> builders =
        ImmutableList.of(
            ListTestSuiteBuilder.using(new LongsAsListGenerator()).named("Longs.asList"),
            ListTestSuiteBuilder.using(new LongsAsListHeadSubListGenerator())
                .named("Longs.asList, head subList"),

            ListTestSuiteBuilder.using(new ShortsAsListTailSubListGenerator())
                .named("Shorts.asList, tail subList"),
            ListTestSuiteBuilder.using(new ShortsAsListMiddleSubListGenerator())
                .named("Shorts.asList, middle subList"));

    TestSuite suite = new TestSuite();
    for (ListTestSuiteBuilder<Short> builder : builders) {
      suite.addTest(
          builder

        executionResult.setTopologicallySortedProjects(asList(projectA, projectB));

        Optional<BuildResumptionData> result = analyzer.determineBuildResumptionData(executionResult);

        assertThat(result.isPresent(), is(true));
        assertThat(result.get().getRemainingProjects(), is(asList("test:B")));
    }

    @Test
    void resumeFromIsIgnoredWhenFirstProjectFails() {

  // Test all creation paths very lazily: by assuming asList() works

  public void testOf0() {
    assertThat(ImmutableLongArray.of().asList()).isEmpty();
  }

  public void testOf1() {
    assertThat(ImmutableLongArray.of(0).asList()).containsExactly(0L);
  }

  public void testOf2() {
    assertThat(ImmutableLongArray.of(0, 1).asList()).containsExactly(0L, 1L).inOrder();
  }

  public void testOf3() {

    }
    return Bytes.asList(temp);
  }

  @J2ktIncompatible
  @GwtIncompatible // suite
  public static Test suite() {
    List<ListTestSuiteBuilder<Byte>> builders =
        ImmutableList.of(
            ListTestSuiteBuilder.using(new BytesAsListGenerator()).named("Bytes.asList"),
            ListTestSuiteBuilder.using(new BytesAsListHeadSubListGenerator())
                .named("Bytes.asList, head subList"),

            ListTestSuiteBuilder.using(new CharsAsListTailSubListGenerator())
                .named("Chars.asList, tail subList"),
            ListTestSuiteBuilder.using(new CharsAsListMiddleSubListGenerator())
                .named("Chars.asList, middle subList"));

    TestSuite suite = new TestSuite();
    for (ListTestSuiteBuilder<Character> builder : builders) {
      suite.addTest(
          builder

            ListTestSuiteBuilder.using(new DoublesAsListTailSubListGenerator())
                .named("Doubles.asList, tail subList"),
            ListTestSuiteBuilder.using(new DoublesAsListMiddleSubListGenerator())
                .named("Doubles.asList, middle subList"));

    TestSuite suite = new TestSuite();
    for (ListTestSuiteBuilder<Double> builder : builders) {
      suite.addTest(
          builder

            ListTestSuiteBuilder.using(new DoublesAsListTailSubListGenerator())
                .named("Doubles.asList, tail subList"),
            ListTestSuiteBuilder.using(new DoublesAsListMiddleSubListGenerator())
                .named("Doubles.asList, middle subList"));

    TestSuite suite = new TestSuite();
    for (ListTestSuiteBuilder<Double> builder : builders) {
      suite.addTest(
          builder