jdk-sandbox: comparison jdk/test/java/util/Collection/MOAT.java

equal deleted inserted replaced

-:f96e172a6ce8
+:268fbc344d53
 /*
-* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2005, 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.
 // Empty collections
 final List<Integer> emptyArray = Arrays.asList(new Integer[]{});
 testCollection(emptyArray);
 testEmptyList(emptyArray);
-THROWS(IndexOutOfBoundsException.class,
+THROWS(IndexOutOfBoundsException.class, () -> emptyArray.set(0,1));
-new Fun(){void f(){ emptyArray.set(0,1); }});
+THROWS(UnsupportedOperationException.class, () -> emptyArray.add(0,1));
-THROWS(UnsupportedOperationException.class,
-new Fun(){void f(){ emptyArray.add(0,1); }});
 List<Integer> noOne = nCopies(0,1);
 testCollection(noOne);
 testEmptyList(noOne);
 testImmutableList(noOne);
 static <T> void testEmptyIterator(final Iterator<T> it) {
 if (rnd.nextBoolean())
 check(! it.hasNext());
-THROWS(NoSuchElementException.class,
+THROWS(NoSuchElementException.class, () -> it.next());
-new Fun(){void f(){ it.next(); }});
 try { it.remove(); }
 catch (IllegalStateException ignored) { pass(); }
 catch (UnsupportedOperationException ignored) { pass(); }
 catch (Throwable t) { unexpected(t); }
 testEmptyIterator(((NavigableSet<T>)c).descendingIterator());
 }
 private static void testImmutableCollection(final Collection<Integer> c) {
 THROWS(UnsupportedOperationException.class,
-new Fun(){void f(){ c.add(99); }},
+() -> c.add(99),
-new Fun(){void f(){ c.addAll(singleton(99)); }});
+() -> c.addAll(singleton(99)));
 if (! c.isEmpty()) {
 final Integer first = c.iterator().next();
 THROWS(UnsupportedOperationException.class,
-new Fun(){void f(){ c.clear(); }},
+() -> c.clear(),
-new Fun(){void f(){ c.remove(first); }},
+() -> c.remove(first),
-new Fun(){void f(){ c.removeAll(singleton(first)); }},
+() -> c.removeAll(singleton(first)),
-new Fun(){void f(){ c.retainAll(emptyList()); }}
+() -> c.retainAll(emptyList()));
-);
 }
 }
 private static void testImmutableSet(final Set<Integer> c) {
 testImmutableCollection(c);
 private static void testImmutableList(final List<Integer> c) {
 testList(c);
 testImmutableCollection(c);
 THROWS(UnsupportedOperationException.class,
-new Fun(){void f(){ c.set(0,42); }},
+() -> c.set(0,42),
-new Fun(){void f(){ c.add(0,42); }},
+() -> c.add(0,42),
-new Fun(){void f(){ c.addAll(0,singleton(86)); }});
+() -> c.addAll(0,singleton(86)));
 if (! c.isEmpty())
 THROWS(UnsupportedOperationException.class,
-new Fun(){void f(){
+() -> { Iterator<Integer> it = c.iterator();
-Iterator<Integer> it = c.iterator();
+it.next();
-it.next(); it.remove();}},
+it.remove(); },
-new Fun(){void f(){
+() -> { ListIterator<Integer> it = c.listIterator();
-ListIterator<Integer> it = c.listIterator();
+it.next();
-it.next(); it.remove();}});
+it.remove(); });
 }
 private static void clear(Collection<Integer> c) {
 try { c.clear(); }
 catch (Throwable t) { unexpected(t); }
 check(! m.containsKey(1));
 }
 private static void testImmutableMap(final Map<Integer,Integer> m) {
 THROWS(UnsupportedOperationException.class,
-new Fun(){void f(){ m.put(1,1); }},
+() -> m.put(1,1),
-new Fun(){void f(){ m.putAll(singletonMap(1,1)); }});
+() -> m.putAll(singletonMap(1,1)));
 if (! m.isEmpty()) {
 final Integer first = m.keySet().iterator().next();
 THROWS(UnsupportedOperationException.class,
-new Fun(){void f(){ m.remove(first); }},
+() -> m.remove(first),
-new Fun(){void f(){ m.clear(); }});
+() -> m.clear());
 final Map.Entry<Integer,Integer> me
 = m.entrySet().iterator().next();
 Integer key = me.getKey();
 Integer val = me.getValue();
 THROWS(UnsupportedOperationException.class,
-new Fun(){void f(){ me.setValue(3); }});
+() -> me.setValue(3));
 equal(key, me.getKey());
 equal(val, me.getValue());
 }
 testImmutableSet(m.keySet());
 testImmutableCollection(m.values());
 final List<Integer> singleton = Collections.singletonList(e);
 // insert, query, remove element at head
 if (isEmpty) {
 THROWS(NoSuchElementException.class,
-new Fun(){void f(){ deq.getFirst(); }},
+() -> deq.getFirst(),
-new Fun(){void f(){ deq.element(); }},
+() -> deq.element(),
-new Fun(){void f(){ deq.iterator().next(); }});
+() -> deq.iterator().next());
 check(deq.peekFirst() == null);
 check(deq.peek() == null);
 } else {
 check(deq.getFirst() != e);
 check(deq.element() != e);
 case 10: asList.subList(0, 1).clear(); break;
 default: throw new AssertionError();
 }
 if (isEmpty) {
 THROWS(NoSuchElementException.class,
-new Fun(){void f(){ deq.getFirst(); }},
+() -> deq.getFirst(),
-new Fun(){void f(){ deq.element(); }},
+() -> deq.element(),
-new Fun(){void f(){ deq.iterator().next(); }});
+() -> deq.iterator().next());
 check(deq.peekFirst() == null);
 check(deq.peek() == null);
 } else {
 check(deq.getFirst() != e);
 check(deq.element() != e);
 equal(new ArrayList<Integer>(deq), originalContents);
 // insert, query, remove element at tail
 if (isEmpty) {
 check(deq.peekLast() == null);
-THROWS(NoSuchElementException.class,
+THROWS(NoSuchElementException.class, () -> deq.getLast());
-new Fun(){void f(){ deq.getLast(); }});
 } else {
 check(deq.peekLast() != e);
 check(deq.getLast() != e);
 }
 switch (rnd.nextInt(isList ? 6 : 4)) {
 break;
 default: throw new AssertionError();
 }
 if (isEmpty) {
 check(deq.peekLast() == null);
-THROWS(NoSuchElementException.class,
+THROWS(NoSuchElementException.class, () -> deq.getLast());
-new Fun(){void f(){ deq.getLast(); }});
 } else {
 check(deq.peekLast() != e);
 check(deq.getLast() != e);
 }
 check(!deq.contains(e));
 testEmptyCollection(deq);
 check(!deq.iterator().hasNext());
 if (isList) {
 check(!asList.listIterator().hasPrevious());
 THROWS(NoSuchElementException.class,
-new Fun(){void f(){ asList.listIterator().previous(); }});
+() -> asList.listIterator().previous());
 }
 THROWS(NoSuchElementException.class,
-new Fun(){void f(){ deq.iterator().next(); }},
+() -> deq.iterator().next(),
-new Fun(){void f(){ deq.element(); }},
+() -> deq.element(),
-new Fun(){void f(){ deq.getFirst(); }},
+() -> deq.getFirst(),
-new Fun(){void f(){ deq.getLast(); }},
+() -> deq.getLast(),
-new Fun(){void f(){ deq.pop(); }},
+() -> deq.pop(),
-new Fun(){void f(){ deq.remove(); }},
+() -> deq.remove(),
-new Fun(){void f(){ deq.removeFirst(); }},
+() -> deq.removeFirst(),
-new Fun(){void f(){ deq.removeLast(); }});
+() -> deq.removeLast());
 check(deq.poll() == null);
 check(deq.pollFirst() == null);
 check(deq.pollLast() == null);
 check(deq.peek() == null);
 l.iterator();
 l.listIterator();
 l.listIterator(0);
 l.listIterator(l.size());
 THROWS(IndexOutOfBoundsException.class,
-new Fun(){void f(){l.listIterator(-1);}},
+() -> l.listIterator(-1),
-new Fun(){void f(){l.listIterator(l.size() + 1);}});
+() -> l.listIterator(l.size() + 1));
 if (l instanceof AbstractList) {
 try {
 int size = l.size();
 AbstractList<Integer> abList = (AbstractList<Integer>) l;
 m.clear();
 final ConcurrentMap<T,Integer> cm = (m instanceof ConcurrentMap)
 ? (ConcurrentMap<T,Integer>) m
 : null;
 List<Fun> fs = new ArrayList<Fun>();
-fs.add(new Fun(){void f(){ check(! m.containsKey(null));}});
+fs.add(() -> check(! m.containsKey(null)));
-fs.add(new Fun(){void f(){ equal(m.remove(null), null);}});
+fs.add(() -> equal(m.remove(null), null));
-fs.add(new Fun(){void f(){ equal(m.get(null), null);}});
+fs.add(() -> equal(m.get(null), null));
-if (cm != null) {
+if (cm != null)
-fs.add(new Fun(){void f(){ check(! cm.remove(null,null));}});}
+fs.add(() -> check(! cm.remove(null,null)));
 throwsConsistently(NullPointerException.class, fs);
 fs.clear();
 final Map<T,Integer> sm = singletonMap(null,1);
-fs.add(new Fun(){void f(){ equal(m.put(null,1), null); m.clear();}});
+fs.add(() -> { equal(m.put(null,1), null); m.clear();});
-fs.add(new Fun(){void f(){ m.putAll(sm); m.clear();}});
+fs.add(() -> { m.putAll(sm); m.clear();});
 if (cm != null) {
-fs.add(new Fun(){void f(){ check(! cm.remove(null,null));}});
+fs.add(() -> check(! cm.remove(null,null)));
-fs.add(new Fun(){void f(){ equal(cm.putIfAbsent(null,1), 1);}});
+fs.add(() -> equal(cm.putIfAbsent(null,1), 1));
-fs.add(new Fun(){void f(){ equal(cm.replace(null,1), null);}});
+fs.add(() -> equal(cm.replace(null,1), null));
-fs.add(new Fun(){void f(){ equal(cm.replace(null,1, 1), 1);}});
+fs.add(() -> equal(cm.replace(null,1, 1), 1));
 }
 throwsConsistently(NullPointerException.class, fs);
 }
 //----------------------------------------------------------------
 m.navigableKeySet().descendingIterator()}) {
 equalNext(it, 5);
 equalNext(it, 3);
 equalNext(it, 1);
 check(! it.hasNext());
-THROWS(NoSuchElementException.class,
+THROWS(NoSuchElementException.class, () -> it.next());
-new Fun(){void f(){it.next();}});
 }
 {
 final Iterator<Map.Entry<Integer,Integer>> it
 = m.descendingMap().entrySet().iterator();
 check(it.hasNext()); equal(it.next().getKey(), 5);
 check(it.hasNext()); equal(it.next().getKey(), 3);
 check(it.hasNext()); equal(it.next().getKey(), 1);
 check(! it.hasNext());
-THROWS(NoSuchElementException.class,
+THROWS(NoSuchElementException.class, () -> it.next());
-new Fun(){void f(){it.next();}});
 }
 prepMapForDescItrTests(m);
 checkDescItrRmFirst(m.keySet(), m.navigableKeySet().descendingIterator());
 prepMapForDescItrTests(m);
 s.descendingSet().iterator()}) {
 equalNext(it, 5);
 equalNext(it, 3);
 equalNext(it, 1);
 check(! it.hasNext());
-THROWS(NoSuchElementException.class,
+THROWS(NoSuchElementException.class, () -> it.next());
-new Fun(){void f(){it.next();}});
 }
 prepSetForDescItrTests(s);
 checkDescItrRmFirst(s, s.descendingIterator());
 prepSetForDescItrTests(s);
 try { realMain(args); } catch (Throwable t) { unexpected(t); }
 System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
 if (failed > 0) throw new Exception("Some tests failed");
 }
-private static abstract class Fun {abstract void f() throws Throwable;}
+interface Fun {void f() throws Throwable;}
 private static void THROWS(Class<? extends Throwable> k, Fun... fs) {
 for (Fun f : fs)
 try { f.f(); fail("Expected " + k.getName() + " not thrown"); }
 catch (Throwable t) {
 if (k.isAssignableFrom(t.getClass())) pass();

changeset 24692	268fbc344d53
parent 23580	1055a611c69b
child 30046	cf2c86e1819e