jdk-sandbox: comparison jdk/test/java/util/Collection/testlibrary/CollectionSupplier.java

equal deleted inserted replaced

-:013edb90a29d
+:221bf0e3642d
 /*
-* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 import java.lang.Exception;
 import java.lang.Integer;
 import java.lang.Iterable;
 import java.lang.Override;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Random;
 import static org.testng.Assert.assertTrue;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.function.Function;
 import java.util.function.Supplier;
 /**
 * @library
 * @summary A Supplier of test cases for Collection tests
 */
 public final class CollectionSupplier<C extends Collection<Integer>> implements Supplier<Iterable<CollectionSupplier.TestCase<C>>> {
-private final Supplier<C>[] classes;
+private final List<Function<Collection<Integer>, C>> suppliers;
 private final int size;
 /**
 * A Collection test case.
 */
 public static final class TestCase<C extends Collection<Integer>> {
 /**
 * The name of the test case.
 */
 public final String name;
+/**
+* The supplier of a collection
+*/
+public Function<Collection<Integer>, C> supplier;
 /**
 * Unmodifiable reference collection, useful for comparisons.
 */
 public final List<Integer> expected;
 /**
 * Create a Collection test case.
 *
 * @param name name of the test case
-* @param expected reference collection
 * @param collection the modifiable test collection
 */
-public TestCase(String name, C collection) {
+public TestCase(String name, Function<Collection<Integer>, C> supplier, C collection) {
 this.name = name;
+this.supplier = supplier;
 this.expected = Collections.unmodifiableList(
 Arrays.asList(collection.toArray(new Integer[0])));
 this.collection = collection;
 }
 list.set(j, e);
 }
 }
 /**
-* Create a {@code Supplier} that creates instances of specified collection
+* Create a {@code CollectionSupplier} that creates instances of specified
-* classes of specified length.
+* collection suppliers of the specified size.
 *
-* @param classNames class names that implement {@code Collection}
+* @param suppliers the suppliers names that supply {@code Collection}
+*        instances
 * @param size the desired size of each collection
 */
-public CollectionSupplier(Supplier<C>[] classes, int size) {
+public CollectionSupplier(List<Function<Collection<Integer>, C>> suppliers, int size) {
-this.classes = Arrays.copyOf(classes, classes.length);
+this.suppliers = suppliers;
 this.size = size;
 }
 @Override
 public Iterable<TestCase<C>> get() {
 final Collection<TestCase<C>> cases = new LinkedList<>();
-for (final Supplier<C> type : classes) {
+for (final Function<Collection<Integer>, C> supplier : suppliers)
 try {
-final Collection<Integer> empty = type.get();
+cases.add(new TestCase<>("empty", supplier, supplier.apply(Collections.emptyList())));
-cases.add(new TestCase("empty", empty));
+cases.add(new TestCase<>("single", supplier, supplier.apply(Arrays.asList(42))));
-final Collection<Integer> single = type.get();
-single.add(42);
+final Collection<Integer> regular = new ArrayList<>();
-cases.add(new TestCase("single", single));
-final Collection<Integer> regular = type.get();
 for (int i = 0; i < size; i++) {
 regular.add(i);
 }
-cases.add(new TestCase("regular", regular));
+cases.add(new TestCase<>("regular", supplier, supplier.apply(regular)));
-final Collection<Integer> reverse = type.get();
+final Collection<Integer> reverse = new ArrayList<>();
 for (int i = size; i >= 0; i--) {
 reverse.add(i);
 }
-cases.add(new TestCase("reverse", reverse));
+cases.add(new TestCase<>("reverse", supplier, supplier.apply(reverse)));
-final Collection<Integer> odds = type.get();
+final Collection<Integer> odds = new ArrayList<>();
 for (int i = 0; i < size; i++) {
 odds.add((i * 2) + 1);
 }
-cases.add(new TestCase("odds", odds));
+cases.add(new TestCase<>("odds", supplier, supplier.apply(odds)));
-final Collection<Integer> evens = type.get();
+final Collection<Integer> evens = new ArrayList<>();
 for (int i = 0; i < size; i++) {
 evens.add(i * 2);
 }
-cases.add(new TestCase("evens", evens));
+cases.add(new TestCase<>("evens", supplier, supplier.apply(evens)));
-final Collection<Integer> fibonacci = type.get();
+final Collection<Integer> fibonacci = new ArrayList<>();
 int prev2 = 0;
 int prev1 = 1;
 for (int i = 0; i < size; i++) {
 final int n = prev1 + prev2;
 if (n < 0) { // stop on overflow
 }
 fibonacci.add(n);
 prev2 = prev1;
 prev1 = n;
 }
-cases.add(new TestCase("fibonacci", fibonacci));
+cases.add(new TestCase<>("fibonacci", supplier, supplier.apply(fibonacci)));
-// variants where the size of the backing storage != reported size
+boolean isStructurallyModifiable = false;
+try {
+C t = supplier.apply(Collections.emptyList());
+t.add(1);
+isStructurallyModifiable = true;
+} catch (UnsupportedOperationException e) { }
+if (!isStructurallyModifiable)
+continue;
+// variants where the size of the backing storage != reported size
 // created by removing half of the elements
-final Collection<Integer> emptyWithSlack = type.get();
+final C emptyWithSlack = supplier.apply(Collections.emptyList());
 emptyWithSlack.add(42);
 assertTrue(emptyWithSlack.remove(42));
-cases.add(new TestCase("emptyWithSlack", emptyWithSlack));
+cases.add(new TestCase<>("emptyWithSlack", supplier, emptyWithSlack));
-final Collection<Integer> singleWithSlack = type.get();
+final C singleWithSlack = supplier.apply(Collections.emptyList());
 singleWithSlack.add(42);
 singleWithSlack.add(43);
 assertTrue(singleWithSlack.remove(43));
-cases.add(new TestCase("singleWithSlack", singleWithSlack));
+cases.add(new TestCase<>("singleWithSlack", supplier, singleWithSlack));
-final Collection<Integer> regularWithSlack = type.get();
+final C regularWithSlack = supplier.apply(Collections.emptyList());
 for (int i = 0; i < (2 * size); i++) {
 regularWithSlack.add(i);
 }
-assertTrue(regularWithSlack.removeIf((x) -> {
+assertTrue(regularWithSlack.removeIf(x -> x < size));
-return x >= size;
+cases.add(new TestCase<>("regularWithSlack", supplier, regularWithSlack));
-}));
-cases.add(new TestCase("regularWithSlack", regularWithSlack));
+final C reverseWithSlack = supplier.apply(Collections.emptyList());
-final Collection<Integer> reverseWithSlack = type.get();
 for (int i = 2 * size; i >= 0; i--) {
 reverseWithSlack.add(i);
 }
-assertTrue(reverseWithSlack.removeIf((x) -> {
+assertTrue(reverseWithSlack.removeIf(x -> x < size));
-return x < size;
+cases.add(new TestCase<>("reverseWithSlack", supplier, reverseWithSlack));
-}));
-cases.add(new TestCase("reverseWithSlack", reverseWithSlack));
+final C oddsWithSlack = supplier.apply(Collections.emptyList());
-final Collection<Integer> oddsWithSlack = type.get();
 for (int i = 0; i < 2 * size; i++) {
 oddsWithSlack.add((i * 2) + 1);
 }
-assertTrue(oddsWithSlack.removeIf((x) -> {
+assertTrue(oddsWithSlack.removeIf(x -> x >= size));
-return x >= size;
+cases.add(new TestCase<>("oddsWithSlack", supplier, oddsWithSlack));
-}));
-cases.add(new TestCase("oddsWithSlack", oddsWithSlack));
+final C evensWithSlack = supplier.apply(Collections.emptyList());
-final Collection<Integer> evensWithSlack = type.get();
 for (int i = 0; i < 2 * size; i++) {
 evensWithSlack.add(i * 2);
 }
-assertTrue(evensWithSlack.removeIf((x) -> {
+assertTrue(evensWithSlack.removeIf(x -> x >= size));
-return x >= size;
+cases.add(new TestCase<>("evensWithSlack", supplier, evensWithSlack));
-}));
-cases.add(new TestCase("evensWithSlack", evensWithSlack));
+final C fibonacciWithSlack = supplier.apply(Collections.emptyList());
-final Collection<Integer> fibonacciWithSlack = type.get();
 prev2 = 0;
 prev1 = 1;
 for (int i = 0; i < size; i++) {
 final int n = prev1 + prev2;
 if (n < 0) { // stop on overflow
 }
 fibonacciWithSlack.add(n);
 prev2 = prev1;
 prev1 = n;
 }
-assertTrue(fibonacciWithSlack.removeIf((x) -> {
+assertTrue(fibonacciWithSlack.removeIf(x -> x < 20));
-return x < 20;
+cases.add(new TestCase<>("fibonacciWithSlack", supplier, fibonacciWithSlack));
-}));
+}
-cases.add(new TestCase("fibonacciWithSlack",
+catch (Exception failed) {
-fibonacciWithSlack));
-} catch (Exception failed) {
 throw new TestException(failed);
 }
-}
 return cases;
 }
 }

changeset 23354	221bf0e3642d
parent 23010	6dadb192ad81