27 import java.util.Comparator;
28 import java.util.List;
29 import java.util.LinkedList;
30 import java.util.Stack;
31 import java.util.TreeMap;
32 import java.util.TreeSet;
33 import java.util.Vector;
34 import java.util.concurrent.CopyOnWriteArrayList;
35 import java.util.concurrent.atomic.AtomicBoolean;
36 import java.util.concurrent.atomic.AtomicInteger;
37
38 import org.testng.annotations.DataProvider;
39 import org.testng.annotations.Test;
40
41 import static org.testng.Assert.assertEquals;
42 import static org.testng.Assert.assertFalse;
43 import static org.testng.Assert.assertTrue;
44 import static org.testng.Assert.fail;
45
46 import java.lang.reflect.Constructor;
47 import java.util.ConcurrentModificationException;
48 import java.util.function.Predicate;
49
50 /**
51 * @test
52 * @library testlibrary
53 * @build CollectionAsserts CollectionSupplier
54 * @run testng ListDefaults
55 * @summary Unit tests for extension methods on List
56 */
57 public class ListDefaults {
58
59 private static final String[] LIST_CLASSES = {
60 "java.util.ArrayList",
61 "java.util.LinkedList",
62 "java.util.Vector",
63 "java.util.concurrent.CopyOnWriteArrayList"
64 };
65
66 private static final String[] LIST_CME_CLASSES = {
67 "java.util.ArrayList",
68 "java.util.Vector"
69 };
70
71 private static final Predicate<Integer> pEven = x -> 0 == x % 2;
72 private static final Predicate<Integer> pOdd = x -> 1 == x % 2;
73
74 private static final Comparator<Integer> BIT_COUNT_COMPARATOR =
75 (x, y) -> Integer.bitCount(x) - Integer.bitCount(y);
76
77 private static final Comparator<AtomicInteger> ATOMIC_INTEGER_COMPARATOR =
78 (x, y) -> x.intValue() - y.intValue();
79
80 private static final int SIZE = 100;
81 private static final int SUBLIST_FROM = 20;
82 private static final int SUBLIST_TO = SIZE - 5;
83 private static final int SUBLIST_SIZE = SUBLIST_TO - SUBLIST_FROM;
496 } catch (ConcurrentModificationException cme) {
497 gotException = true;
498 }
499 if (!gotException) {
500 fail("expected CME was not thrown from " + test);
501 }
502 }
503 }
504
505 private static final List<Integer> SLICED_EXPECTED = Arrays.asList(0, 1, 2, 3, 5, 6, 7, 8, 9);
506 private static final List<Integer> SLICED_EXPECTED2 = Arrays.asList(0, 1, 2, 5, 6, 7, 8, 9);
507
508 @DataProvider(name="shortIntListProvider", parallel=true)
509 public static Object[][] intListCases() {
510 final Integer[] DATA = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
511 final List<Object[]> cases = new LinkedList<>();
512 cases.add(new Object[] { new ArrayList<>(Arrays.asList(DATA)) });
513 cases.add(new Object[] { new LinkedList<>(Arrays.asList(DATA)) });
514 cases.add(new Object[] { new Vector<>(Arrays.asList(DATA)) });
515 cases.add(new Object[] { new CopyOnWriteArrayList<>(Arrays.asList(DATA)) });
516 return cases.toArray(new Object[0][cases.size()]);
517 }
518
519 @Test(dataProvider = "shortIntListProvider")
520 public void testRemoveIfFromSlice(final List<Integer> list) throws Exception {
521 final List<Integer> sublist = list.subList(3, 6);
522 assertTrue(sublist.removeIf(x -> x == 4));
523 CollectionAsserts.assertContents(list, SLICED_EXPECTED);
524
525 final List<Integer> sublist2 = list.subList(2, 5);
526 assertTrue(sublist2.removeIf(x -> x == 3));
527 CollectionAsserts.assertContents(list, SLICED_EXPECTED2);
528 }
529 }
|
27 import java.util.Comparator;
28 import java.util.List;
29 import java.util.LinkedList;
30 import java.util.Stack;
31 import java.util.TreeMap;
32 import java.util.TreeSet;
33 import java.util.Vector;
34 import java.util.concurrent.CopyOnWriteArrayList;
35 import java.util.concurrent.atomic.AtomicBoolean;
36 import java.util.concurrent.atomic.AtomicInteger;
37
38 import org.testng.annotations.DataProvider;
39 import org.testng.annotations.Test;
40
41 import static org.testng.Assert.assertEquals;
42 import static org.testng.Assert.assertFalse;
43 import static org.testng.Assert.assertTrue;
44 import static org.testng.Assert.fail;
45
46 import java.lang.reflect.Constructor;
47 import java.util.Collection;
48 import java.util.ConcurrentModificationException;
49 import java.util.function.Predicate;
50
51 /**
52 * @test
53 * @summary Unit tests for extension methods on List
54 * @library ../Collection/testlibrary
55 * @build CollectionAsserts CollectionSupplier ExtendsAbstractList
56 * @run testng ListDefaults
57 */
58 public class ListDefaults {
59
60 private static final String[] LIST_CLASSES = {
61 "java.util.ArrayList",
62 "java.util.LinkedList",
63 "java.util.Vector",
64 "java.util.concurrent.CopyOnWriteArrayList",
65 "ExtendsAbstractList"
66 };
67
68 private static final String[] LIST_CME_CLASSES = {
69 "java.util.ArrayList",
70 "java.util.Vector"
71 };
72
73 private static final Predicate<Integer> pEven = x -> 0 == x % 2;
74 private static final Predicate<Integer> pOdd = x -> 1 == x % 2;
75
76 private static final Comparator<Integer> BIT_COUNT_COMPARATOR =
77 (x, y) -> Integer.bitCount(x) - Integer.bitCount(y);
78
79 private static final Comparator<AtomicInteger> ATOMIC_INTEGER_COMPARATOR =
80 (x, y) -> x.intValue() - y.intValue();
81
82 private static final int SIZE = 100;
83 private static final int SUBLIST_FROM = 20;
84 private static final int SUBLIST_TO = SIZE - 5;
85 private static final int SUBLIST_SIZE = SUBLIST_TO - SUBLIST_FROM;
498 } catch (ConcurrentModificationException cme) {
499 gotException = true;
500 }
501 if (!gotException) {
502 fail("expected CME was not thrown from " + test);
503 }
504 }
505 }
506
507 private static final List<Integer> SLICED_EXPECTED = Arrays.asList(0, 1, 2, 3, 5, 6, 7, 8, 9);
508 private static final List<Integer> SLICED_EXPECTED2 = Arrays.asList(0, 1, 2, 5, 6, 7, 8, 9);
509
510 @DataProvider(name="shortIntListProvider", parallel=true)
511 public static Object[][] intListCases() {
512 final Integer[] DATA = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
513 final List<Object[]> cases = new LinkedList<>();
514 cases.add(new Object[] { new ArrayList<>(Arrays.asList(DATA)) });
515 cases.add(new Object[] { new LinkedList<>(Arrays.asList(DATA)) });
516 cases.add(new Object[] { new Vector<>(Arrays.asList(DATA)) });
517 cases.add(new Object[] { new CopyOnWriteArrayList<>(Arrays.asList(DATA)) });
518 cases.add(new Object[] { new ExtendsAbstractList<>(Arrays.asList(DATA)) });
519 return cases.toArray(new Object[0][cases.size()]);
520 }
521
522 @Test(dataProvider = "shortIntListProvider")
523 public void testRemoveIfFromSlice(final List<Integer> list) throws Exception {
524 final List<Integer> sublist = list.subList(3, 6);
525 assertTrue(sublist.removeIf(x -> x == 4));
526 CollectionAsserts.assertContents(list, SLICED_EXPECTED);
527
528 final List<Integer> sublist2 = list.subList(2, 5);
529 assertTrue(sublist2.removeIf(x -> x == 3));
530 CollectionAsserts.assertContents(list, SLICED_EXPECTED2);
531 }
532 }
|