BiggernYours.java revision 6073:cea72c2bf071
1/* 2 * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24/* 25 * @test 26 * @bug 6415641 6377302 27 * @summary Concurrent collections are permitted to lie about their size 28 * @author Martin Buchholz 29 */ 30 31import java.io.*; 32import java.util.*; 33import java.util.concurrent.*; 34 35@SuppressWarnings("unchecked") 36public class BiggernYours { 37 static final Random rnd = new Random(18675309); 38 39 static void compareCollections(Collection c1, Collection c2) { 40 Object[] c1Array = c1.toArray(); 41 Object[] c2Array = c2.toArray(); 42 43 check(c1Array.length == c2Array.length); 44 for(Object aC1 : c1Array) { 45 boolean found = false; 46 for(Object aC2 : c2Array) { 47 if(Objects.equals(aC1, aC2)) { 48 found = true; 49 break; 50 } 51 } 52 53 if(!found) 54 fail(aC1 + " not found in " + Arrays.toString(c2Array)); 55 } 56 } 57 58 static void compareMaps(Map m1, Map m2) { 59 compareCollections(m1.keySet(), 60 m2.keySet()); 61 compareCollections(m1.values(), 62 m2.values()); 63 compareCollections(m1.entrySet(), 64 m2.entrySet()); 65 } 66 67 static void compareNavigableMaps(NavigableMap m1, NavigableMap m2) { 68 compareMaps(m1, m2); 69 compareMaps(m1.descendingMap(), 70 m2.descendingMap()); 71 compareMaps(m1.tailMap(Integer.MIN_VALUE), 72 m2.tailMap(Integer.MIN_VALUE)); 73 compareMaps(m1.headMap(Integer.MAX_VALUE), 74 m2.headMap(Integer.MAX_VALUE)); 75 } 76 77 static void compareNavigableSets(NavigableSet s1, NavigableSet s2) { 78 compareCollections(s1, s2); 79 compareCollections(s1.descendingSet(), 80 s2.descendingSet()); 81 compareCollections(s1.tailSet(Integer.MIN_VALUE), 82 s2.tailSet(Integer.MIN_VALUE)); 83 } 84 85 static abstract class MapFrobber { abstract void frob(Map m); } 86 static abstract class SetFrobber { abstract void frob(Set s); } 87 static abstract class ColFrobber { abstract void frob(Collection c); } 88 89 static ColFrobber adder(final int i) { 90 return new ColFrobber() {void frob(Collection c) { c.add(i); }}; 91 } 92 93 static final ColFrobber[] adders = 94 { adder(1), adder(3), adder(2) }; 95 96 static MapFrobber putter(final int k, final int v) { 97 return new MapFrobber() {void frob(Map m) { m.put(k,v); }}; 98 } 99 100 static final MapFrobber[] putters = 101 { putter(1, -2), putter(3, -6), putter(2, -4) }; 102 103 static void unexpected(Throwable t, Object suspect) { 104 System.out.println(suspect.getClass()); 105 unexpected(t); 106 } 107 108 static void testCollections(Collection c1, Collection c2) { 109 try { 110 compareCollections(c1, c2); 111 for (ColFrobber adder : adders) { 112 for (Collection c : new Collection[]{c1, c2}) 113 adder.frob(c); 114 compareCollections(c1, c2); 115 } 116 } catch (Throwable t) { unexpected(t, c1); } 117 } 118 119 static void testNavigableSets(NavigableSet s1, NavigableSet s2) { 120 try { 121 compareNavigableSets(s1, s2); 122 for (ColFrobber adder : adders) { 123 for (Set s : new Set[]{s1, s2}) 124 adder.frob(s); 125 compareNavigableSets(s1, s2); 126 } 127 } catch (Throwable t) { unexpected(t, s1); } 128 } 129 130 static void testMaps(Map m1, Map m2) { 131 try { 132 compareMaps(m1, m2); 133 for (MapFrobber putter : putters) { 134 for (Map m : new Map[]{m1, m2}) 135 putter.frob(m); 136 compareMaps(m1, m2); 137 } 138 } catch (Throwable t) { unexpected(t, m1); } 139 } 140 141 static void testNavigableMaps(NavigableMap m1, NavigableMap m2) { 142 try { 143 compareNavigableMaps(m1, m2); 144 for (MapFrobber putter : putters) { 145 for (Map m : new Map[]{m1, m2}) 146 putter.frob(m); 147 compareNavigableMaps(m1, m2); 148 } 149 } catch (Throwable t) { unexpected(t, m1); } 150 } 151 152 static int randomize(int size) { return rnd.nextInt(size + 2); } 153 154 @SuppressWarnings("serial") 155 private static void realMain(String[] args) throws Throwable { 156 testNavigableMaps( 157 new ConcurrentSkipListMap(), 158 new ConcurrentSkipListMap() { 159 public int size() {return randomize(super.size());}}); 160 161 testNavigableSets( 162 new ConcurrentSkipListSet(), 163 new ConcurrentSkipListSet() { 164 public int size() {return randomize(super.size());}}); 165 166 testCollections( 167 new CopyOnWriteArraySet(), 168 new CopyOnWriteArraySet() { 169 public int size() {return randomize(super.size());}}); 170 171 testCollections( 172 new CopyOnWriteArrayList(), 173 new CopyOnWriteArrayList() { 174 public int size() {return randomize(super.size());}}); 175 176 testCollections( 177 new TreeSet(), 178 new TreeSet() { 179 public int size() {return randomize(super.size());}}); 180 181 testMaps( 182 new ConcurrentHashMap(), 183 new ConcurrentHashMap() { 184 public int size() {return randomize(super.size());}}); 185 186 testCollections( 187 new ConcurrentLinkedDeque(), 188 new ConcurrentLinkedDeque() { 189 public int size() {return randomize(super.size());}}); 190 191 testCollections( 192 new ConcurrentLinkedQueue(), 193 new ConcurrentLinkedQueue() { 194 public int size() {return randomize(super.size());}}); 195 196 testCollections( 197 new LinkedTransferQueue(), 198 new LinkedTransferQueue() { 199 public int size() {return randomize(super.size());}}); 200 201 testCollections( 202 new LinkedBlockingQueue(), 203 new LinkedBlockingQueue() { 204 public int size() {return randomize(super.size());}}); 205 206 testCollections( 207 new LinkedBlockingDeque(), 208 new LinkedBlockingDeque() { 209 public int size() {return randomize(super.size());}}); 210 211 testCollections( 212 new ArrayBlockingQueue(5), 213 new ArrayBlockingQueue(5) { 214 public int size() {return randomize(super.size());}}); 215 216 testCollections( 217 new PriorityBlockingQueue(5), 218 new PriorityBlockingQueue(5) { 219 public int size() {return randomize(super.size());}}); 220 } 221 222 //--------------------- Infrastructure --------------------------- 223 static volatile int passed = 0, failed = 0; 224 static void pass() {passed++;} 225 static void fail() {failed++; Thread.dumpStack();} 226 static void fail(String msg) {System.out.println(msg); fail();} 227 static void unexpected(Throwable t) {failed++; t.printStackTrace();} 228 static void check(boolean cond) {if (cond) pass(); else fail();} 229 static void equal(Object x, Object y) { 230 if (x == null ? y == null : x.equals(y)) pass(); 231 else fail(x + " not equal to " + y);} 232 static void arrayEqual(Object[] x, Object[] y) { 233 if (x == null ? y == null : Arrays.equals(x, y)) pass(); 234 else fail(Arrays.toString(x) + " not equal to " + Arrays.toString(y));} 235 public static void main(String[] args) throws Throwable { 236 try {realMain(args);} catch (Throwable t) {unexpected(t);} 237 System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed); 238 if (failed > 0) throw new AssertionError("Some tests failed");} 239 private static abstract class Fun {abstract void f() throws Throwable;} 240 static void THROWS(Class<? extends Throwable> k, Fun... fs) { 241 for (Fun f : fs) 242 try { f.f(); fail("Expected " + k.getName() + " not thrown"); } 243 catch (Throwable t) { 244 if (k.isAssignableFrom(t.getClass())) pass(); 245 else unexpected(t);}} 246 private static abstract class CheckedThread extends Thread { 247 abstract void realRun() throws Throwable; 248 public void run() { 249 try {realRun();} catch (Throwable t) {unexpected(t);}}} 250} 251