util/Collections/WrappedNull.java

/*
 * Copyright (c) 1999, 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 4189641
 * @summary Wrapping a null collection/array should blow up sooner
 *          rather than later
 */

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;

public class WrappedNull {
    public static void main(String[] args) throws Exception {
        boolean testSucceeded = false;
        try {
            List l = Arrays.asList(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("Arrays.asList");

        testSucceeded = false;
        try {
            Collection c = Collections.unmodifiableCollection(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("unmodifiableCollection");

        testSucceeded = false;
        try {
            Set c = Collections.unmodifiableSet(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("unmodifiableSet");

        testSucceeded = false;
        try {
            List c = Collections.unmodifiableList(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("unmodifiableList");

        testSucceeded = false;
        try {
            Map c = Collections.unmodifiableMap(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("unmodifiableMap");

        testSucceeded = false;
        try {
            SortedSet c = Collections.unmodifiableSortedSet(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("unmodifiableSortedSet");

        testSucceeded = false;
        try {
            SortedMap c = Collections.unmodifiableSortedMap(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("unmodifiableSortedMap");

        testSucceeded = false;
        try {
            Collection c = Collections.synchronizedCollection(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("synchronizedCollection");

        testSucceeded = false;
        try {
            Set c = Collections.synchronizedSet(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("synchronizedSet");

        testSucceeded = false;
        try {
            List c = Collections.synchronizedList(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("synchronizedList");

        testSucceeded = false;
        try {
            Map c = Collections.synchronizedMap(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("synchronizedMap");

        testSucceeded = false;
        try {
            SortedSet c = Collections.synchronizedSortedSet(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("synchronizedSortedSet");

        testSucceeded = false;
        try {
            SortedMap c = Collections.synchronizedSortedMap(null);
        }
        catch (NullPointerException e) {
            testSucceeded = true;
        }
        if (!testSucceeded)
            throw new Exception("synchronizedSortedMap");

        // Make sure that non-null arguments don't throw exc.
        List l = Arrays.asList(new Object[0]);
        Collection c = Collections.unmodifiableCollection(
                Collections.EMPTY_SET);
        Set s = Collections.unmodifiableSet(Collections.EMPTY_SET);
        l = Collections.unmodifiableList(Collections.EMPTY_LIST);
        Map m = Collections.unmodifiableMap(Collections.EMPTY_MAP);
        SortedSet ss = Collections.unmodifiableSortedSet(new TreeSet());
        SortedMap sm = Collections.unmodifiableSortedMap(new TreeMap());

        c = Collections.synchronizedCollection(Collections.EMPTY_SET);
        s = Collections.synchronizedSet(Collections.EMPTY_SET);
        l = Collections.synchronizedList(Collections.EMPTY_LIST);
        m = Collections.synchronizedMap(Collections.EMPTY_MAP);
        ss = Collections.synchronizedSortedSet(new TreeSet());
        sm = Collections.synchronizedSortedMap(new TreeMap());
    }
}
Revision:	1.7
Committed:	Mon Jan 8 03:12:03 2018 UTC (6 years, 3 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.6:	+10 -1 lines
Log Message:	organize imports
#	Content
1	/*
2	* Copyright (c) 1999, 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 4189641
27	* @summary Wrapping a null collection/array should blow up sooner
28	* rather than later
29	*/
30
31	import java.util.Arrays;
32	import java.util.Collection;
33	import java.util.Collections;
34	import java.util.List;
35	import java.util.Map;
36	import java.util.Set;
37	import java.util.SortedMap;
38	import java.util.SortedSet;
39	import java.util.TreeMap;
40	import java.util.TreeSet;
41
42	public class WrappedNull {
43	public static void main(String[] args) throws Exception {
44	boolean testSucceeded = false;
45	try {
46	List l = Arrays.asList(null);
47	}
48	catch (NullPointerException e) {
49	testSucceeded = true;
50	}
51	if (!testSucceeded)
52	throw new Exception("Arrays.asList");
53
54	testSucceeded = false;
55	try {
56	Collection c = Collections.unmodifiableCollection(null);
57	}
58	catch (NullPointerException e) {
59	testSucceeded = true;
60	}
61	if (!testSucceeded)
62	throw new Exception("unmodifiableCollection");
63
64	testSucceeded = false;
65	try {
66	Set c = Collections.unmodifiableSet(null);
67	}
68	catch (NullPointerException e) {
69	testSucceeded = true;
70	}
71	if (!testSucceeded)
72	throw new Exception("unmodifiableSet");
73
74	testSucceeded = false;
75	try {
76	List c = Collections.unmodifiableList(null);
77	}
78	catch (NullPointerException e) {
79	testSucceeded = true;
80	}
81	if (!testSucceeded)
82	throw new Exception("unmodifiableList");
83
84	testSucceeded = false;
85	try {
86	Map c = Collections.unmodifiableMap(null);
87	}
88	catch (NullPointerException e) {
89	testSucceeded = true;
90	}
91	if (!testSucceeded)
92	throw new Exception("unmodifiableMap");
93
94	testSucceeded = false;
95	try {
96	SortedSet c = Collections.unmodifiableSortedSet(null);
97	}
98	catch (NullPointerException e) {
99	testSucceeded = true;
100	}
101	if (!testSucceeded)
102	throw new Exception("unmodifiableSortedSet");
103
104	testSucceeded = false;
105	try {
106	SortedMap c = Collections.unmodifiableSortedMap(null);
107	}
108	catch (NullPointerException e) {
109	testSucceeded = true;
110	}
111	if (!testSucceeded)
112	throw new Exception("unmodifiableSortedMap");
113
114	testSucceeded = false;
115	try {
116	Collection c = Collections.synchronizedCollection(null);
117	}
118	catch (NullPointerException e) {
119	testSucceeded = true;
120	}
121	if (!testSucceeded)
122	throw new Exception("synchronizedCollection");
123
124	testSucceeded = false;
125	try {
126	Set c = Collections.synchronizedSet(null);
127	}
128	catch (NullPointerException e) {
129	testSucceeded = true;
130	}
131	if (!testSucceeded)
132	throw new Exception("synchronizedSet");
133
134	testSucceeded = false;
135	try {
136	List c = Collections.synchronizedList(null);
137	}
138	catch (NullPointerException e) {
139	testSucceeded = true;
140	}
141	if (!testSucceeded)
142	throw new Exception("synchronizedList");
143
144	testSucceeded = false;
145	try {
146	Map c = Collections.synchronizedMap(null);
147	}
148	catch (NullPointerException e) {
149	testSucceeded = true;
150	}
151	if (!testSucceeded)
152	throw new Exception("synchronizedMap");
153
154	testSucceeded = false;
155	try {
156	SortedSet c = Collections.synchronizedSortedSet(null);
157	}
158	catch (NullPointerException e) {
159	testSucceeded = true;
160	}
161	if (!testSucceeded)
162	throw new Exception("synchronizedSortedSet");
163
164	testSucceeded = false;
165	try {
166	SortedMap c = Collections.synchronizedSortedMap(null);
167	}
168	catch (NullPointerException e) {
169	testSucceeded = true;
170	}
171	if (!testSucceeded)
172	throw new Exception("synchronizedSortedMap");
173
174	// Make sure that non-null arguments don't throw exc.
175	List l = Arrays.asList(new Object[0]);
176	Collection c = Collections.unmodifiableCollection(
177	Collections.EMPTY_SET);
178	Set s = Collections.unmodifiableSet(Collections.EMPTY_SET);
179	l = Collections.unmodifiableList(Collections.EMPTY_LIST);
180	Map m = Collections.unmodifiableMap(Collections.EMPTY_MAP);
181	SortedSet ss = Collections.unmodifiableSortedSet(new TreeSet());
182	SortedMap sm = Collections.unmodifiableSortedMap(new TreeMap());
183
184	c = Collections.synchronizedCollection(Collections.EMPTY_SET);
185	s = Collections.synchronizedSet(Collections.EMPTY_SET);
186	l = Collections.synchronizedList(Collections.EMPTY_LIST);
187	m = Collections.synchronizedMap(Collections.EMPTY_MAP);
188	ss = Collections.synchronizedSortedSet(new TreeSet());
189	sm = Collections.synchronizedSortedMap(new TreeMap());
190	}
191	}