test/jdk/java/util/List/ListFactories.java

rev 48077 : 8193128: Reduce number of implementation classes returned by List/Set/Map.of()
Reviewed-by: smarks

*** 24,33 ****
--- 24,34 ----
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
+ import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
*** 70,80 ****
      }
  
      @DataProvider(name="empty")
      public Iterator<Object[]> empty() {
          return Collections.singletonList(
!             a(List.of(), Collections.emptyList())
          ).iterator();
      }
  
      @DataProvider(name="nonempty")
      public Iterator<Object[]> nonempty() {
--- 71,81 ----
      }
  
      @DataProvider(name="empty")
      public Iterator<Object[]> empty() {
          return Collections.singletonList(
!             a(List.of(), asList())
          ).iterator();
      }
  
      @DataProvider(name="nonempty")
      public Iterator<Object[]> nonempty() {
*** 102,116 ****
--- 103,156 ----
              a(List.of(stringArray),
                 asList(stringArray))
          ).iterator();
      }
  
+     @DataProvider(name="sublists")
+     public Iterator<Object[]> sublists() {
+         return asList(
+             a(List.<String>of().subList(0,0),
+                asList()),
+             a(List.of("a").subList(0,0),
+                asList("a").subList(0,0)),
+             a(List.of("a", "b").subList(0,1),
+                asList("a", "b").subList(0,1)),
+             a(List.of("a", "b", "c").subList(1,3),
+                asList("a", "b", "c").subList(1,3)),
+             a(List.of("a", "b", "c", "d").subList(0,4),
+                asList("a", "b", "c", "d").subList(0,4)),
+             a(List.of("a", "b", "c", "d", "e").subList(0,3),
+                asList("a", "b", "c", "d", "e").subList(0,3)),
+             a(List.of("a", "b", "c", "d", "e", "f").subList(3, 5),
+                asList("a", "b", "c", "d", "e", "f").subList(3, 5)),
+             a(List.of("a", "b", "c", "d", "e", "f", "g").subList(0, 7),
+                asList("a", "b", "c", "d", "e", "f", "g").subList(0, 7)),
+             a(List.of("a", "b", "c", "d", "e", "f", "g", "h").subList(0, 0),
+                asList("a", "b", "c", "d", "e", "f", "g", "h").subList(0, 0)),
+             a(List.of("a", "b", "c", "d", "e", "f", "g", "h", "i").subList(4, 5),
+                asList("a", "b", "c", "d", "e", "f", "g", "h", "i").subList(4, 5)),
+             a(List.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "j").subList(1,10),
+                asList("a", "b", "c", "d", "e", "f", "g", "h", "i", "j").subList(1,10)),
+             a(List.of(stringArray).subList(5, NUM_STRINGS),
+                asList(Arrays.copyOfRange(stringArray, 5, NUM_STRINGS)))
+                 ).iterator();
+     }
+ 
      @DataProvider(name="all")
      public Iterator<Object[]> all() {
          List<Object[]> all = new ArrayList<>();
          empty().forEachRemaining(all::add);
          nonempty().forEachRemaining(all::add);
+         sublists().forEachRemaining(all::add);
+         return all.iterator();
+     }
+ 
+     @DataProvider(name="nonsublists")
+     public Iterator<Object[]> nonsublists() {
+         List<Object[]> all = new ArrayList<>();
+         empty().forEachRemaining(all::add);
+         nonempty().forEachRemaining(all::add);
          return all.iterator();
      }
  
      @Test(dataProvider="all", expectedExceptions=UnsupportedOperationException.class)
      public void cannotAddLast(List<String> act, List<String> exp) {
*** 210,220 ****
          List<String> list = List.of(array);
          array[0] = "xyzzy";
          assertEquals(list, Arrays.asList(stringArray));
      }
  
!     @Test(dataProvider="all")
      public void serialEquality(List<String> act, List<String> exp) {
          // assume that act.equals(exp) tested elsewhere
          List<String> copy = serialClone(act);
          assertEquals(act, copy);
          assertEquals(copy, exp);
--- 250,267 ----
          List<String> list = List.of(array);
          array[0] = "xyzzy";
          assertEquals(list, Arrays.asList(stringArray));
      }
  
!     // List.of().subList views should not be Serializable
!     @Test(dataProvider="sublists")
!     public void isNotSerializable(List<String> act, List<String> exp) {
!         assertFalse(act instanceof Serializable);
!     }
! 
!     // ... but List.of() should be
!     @Test(dataProvider="nonsublists")
      public void serialEquality(List<String> act, List<String> exp) {
          // assume that act.equals(exp) tested elsewhere
          List<String> copy = serialClone(act);
          assertEquals(act, copy);
          assertEquals(copy, exp);