util/Collection/BiggernYours.java

/*
 * Copyright (c) 2006, 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.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @bug 6415641 6377302
 * @summary Concurrent collections are permitted to lie about their size
 * @author Martin Buchholz
 */

import java.io.*;
import java.util.*;
import java.util.concurrent.*;

@SuppressWarnings("unchecked")
public class BiggernYours {
    static final Random rnd = new Random(18675309);

    static void compareCollections(Collection c1, Collection c2) {
        Object[] c1Array = c1.toArray();
        Object[] c2Array = c2.toArray();

        check(c1Array.length == c2Array.length);
        for (Object aC1 : c1Array) {
            boolean found = false;
            for (Object aC2 : c2Array) {
                if (Objects.equals(aC1, aC2)) {
                    found = true;
                    break;
                }
            }

            if (!found)
                fail(aC1 + " not found in " + Arrays.toString(c2Array));
        }
    }

    static void compareMaps(Map m1, Map m2) {
        compareCollections(m1.keySet(),
                           m2.keySet());
        compareCollections(m1.values(),
                           m2.values());
        compareCollections(m1.entrySet(),
                           m2.entrySet());
    }

    static void compareNavigableMaps(NavigableMap m1, NavigableMap m2) {
        compareMaps(m1, m2);
        compareMaps(m1.descendingMap(),
                    m2.descendingMap());
        compareMaps(m1.tailMap(Integer.MIN_VALUE),
                    m2.tailMap(Integer.MIN_VALUE));
        compareMaps(m1.headMap(Integer.MAX_VALUE),
                    m2.headMap(Integer.MAX_VALUE));
    }

    static void compareNavigableSets(NavigableSet s1, NavigableSet s2) {
        compareCollections(s1, s2);
        compareCollections(s1.descendingSet(),
                           s2.descendingSet());
        compareCollections(s1.tailSet(Integer.MIN_VALUE),
                           s2.tailSet(Integer.MIN_VALUE));
    }

    abstract static class MapFrobber { abstract void frob(Map m); }
    abstract static class SetFrobber { abstract void frob(Set s); }
    abstract static class ColFrobber { abstract void frob(Collection c); }

    static ColFrobber adder(final int i) {
        return new ColFrobber() {void frob(Collection c) { c.add(i); }};
    }

    static final ColFrobber[] adders =
    { adder(1), adder(3), adder(2) };

    static MapFrobber putter(final int k, final int v) {
        return new MapFrobber() {void frob(Map m) { m.put(k,v); }};
    }

    static final MapFrobber[] putters =
    { putter(1, -2), putter(3, -6), putter(2, -4) };

    static void unexpected(Throwable t, Object suspect) {
        System.out.println(suspect.getClass());
        unexpected(t);
    }

    static void testCollections(Collection c1, Collection c2) {
        try {
            compareCollections(c1, c2);
            for (ColFrobber adder : adders) {
                for (Collection c : new Collection[]{c1, c2})
                    adder.frob(c);
                compareCollections(c1, c2);
            }
        } catch (Throwable t) { unexpected(t, c1); }
    }

    static void testNavigableSets(NavigableSet s1, NavigableSet s2) {
        try {
            compareNavigableSets(s1, s2);
            for (ColFrobber adder : adders) {
                for (Set s : new Set[]{s1, s2})
                    adder.frob(s);
                compareNavigableSets(s1, s2);
            }
        } catch (Throwable t) { unexpected(t, s1); }
    }

    static void testMaps(Map m1, Map m2) {
        try {
            compareMaps(m1, m2);
            for (MapFrobber putter : putters) {
                for (Map m : new Map[]{m1, m2})
                    putter.frob(m);
                compareMaps(m1, m2);
            }
        } catch (Throwable t) { unexpected(t, m1); }
    }

    static void testNavigableMaps(NavigableMap m1, NavigableMap m2) {
        try {
            compareNavigableMaps(m1, m2);
            for (MapFrobber putter : putters) {
                for (Map m : new Map[]{m1, m2})
                    putter.frob(m);
                compareNavigableMaps(m1, m2);
            }
        } catch (Throwable t) { unexpected(t, m1); }
    }

    static int randomize(int size) { return rnd.nextInt(size + 2); }

    @SuppressWarnings("serial")
    private static void realMain(String[] args) throws Throwable {
        testNavigableMaps(
            new ConcurrentSkipListMap(),
            new ConcurrentSkipListMap() {
                public int size() {return randomize(super.size());}});

        testNavigableSets(
            new ConcurrentSkipListSet(),
            new ConcurrentSkipListSet() {
                public int size() {return randomize(super.size());}});

        testCollections(
            new CopyOnWriteArraySet(),
            new CopyOnWriteArraySet() {
                public int size() {return randomize(super.size());}});

        testCollections(
            new CopyOnWriteArrayList(),
            new CopyOnWriteArrayList() {
                public int size() {return randomize(super.size());}});

        testCollections(
            new TreeSet(),
            new TreeSet() {
                public int size() {return randomize(super.size());}});

        testMaps(
            new ConcurrentHashMap(),
            new ConcurrentHashMap() {
                public int size() {return randomize(super.size());}});

        testCollections(
            new ConcurrentLinkedDeque(),
            new ConcurrentLinkedDeque() {
                public int size() {return randomize(super.size());}});

        testCollections(
            new ConcurrentLinkedQueue(),
            new ConcurrentLinkedQueue() {
                public int size() {return randomize(super.size());}});

        testCollections(
            new LinkedTransferQueue(),
            new LinkedTransferQueue() {
                public int size() {return randomize(super.size());}});

        testCollections(
            new LinkedBlockingQueue(),
            new LinkedBlockingQueue() {
                public int size() {return randomize(super.size());}});

        testCollections(
            new LinkedBlockingDeque(),
            new LinkedBlockingDeque() {
                public int size() {return randomize(super.size());}});

        testCollections(
            new ArrayBlockingQueue(5),
            new ArrayBlockingQueue(5) {
                public int size() {return randomize(super.size());}});

        testCollections(
            new PriorityBlockingQueue(5),
            new PriorityBlockingQueue(5) {
                public int size() {return randomize(super.size());}});
    }

    //--------------------- Infrastructure ---------------------------
    static volatile int passed = 0, failed = 0;
    static void pass() {passed++;}
    static void fail() {failed++; Thread.dumpStack();}
    static void fail(String msg) {System.out.println(msg); fail();}
    static void unexpected(Throwable t) {failed++; t.printStackTrace();}
    static void check(boolean cond) {if (cond) pass(); else fail();}
    static void equal(Object x, Object y) {
        if (x == null ? y == null : x.equals(y)) pass();
        else fail(x + " not equal to " + y);}
    static void arrayEqual(Object[] x, Object[] y) {
        if (x == null ? y == null : Arrays.equals(x, y)) pass();
        else fail(Arrays.toString(x) + " not equal to " + Arrays.toString(y));}
    public static void main(String[] args) throws Throwable {
        try {realMain(args);} catch (Throwable t) {unexpected(t);}
        System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
        if (failed > 0) throw new AssertionError("Some tests failed");}
    private abstract static class CheckedThread extends Thread {
        abstract void realRun() throws Throwable;
        public void run() {
            try {realRun();} catch (Throwable t) {unexpected(t);}}}
}
Revision:	1.5
Committed:	Tue Sep 15 07:09:51 2015 UTC (8 years, 8 months ago) by jsr166
Branch:	MAIN
Changes since 1.4:	+18 -15 lines
Log Message:	merge upstream changes
#	Content
1	/*
2	* Copyright (c) 2006, 2014, 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
31	import java.io.*;
32	import java.util.*;
33	import java.util.concurrent.*;
34
35	@SuppressWarnings("unchecked")
36	public 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	abstract static class MapFrobber { abstract void frob(Map m); }
86	abstract static class SetFrobber { abstract void frob(Set s); }
87	abstract static 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 abstract static class CheckedThread extends Thread {
240	abstract void realRun() throws Throwable;
241	public void run() {
242	try {realRun();} catch (Throwable t) {unexpected(t);}}}
243	}