1 /*
2 * Copyright (c) 2016, 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 package java.lang.reflect;
25
26 import java.util.ArrayList;
27 import java.util.List;
28 import java.util.Objects;
29 import java.util.concurrent.ExecutionException;
30 import java.util.concurrent.ExecutorService;
31 import java.util.concurrent.Executors;
32 import java.util.concurrent.Future;
33 import java.util.concurrent.TimeUnit;
34 import java.util.concurrent.atomic.AtomicBoolean;
35
36 /**
37 * Functional and concurrency test for ClassLoaderValue
38 *
39 * @author Peter Levart
40 */
41 public class ClassLoaderValueTest {
42
43 @SuppressWarnings("unchecked")
44 public static void main(String[] args) throws Exception {
45
46 ClassLoaderValue[] clvs = {new ClassLoaderValue<>(),
47 new ClassLoaderValue<>()};
48
49 ClassLoader[] lds = {ClassLoader.getSystemClassLoader(),
50 ClassLoader.getPlatformClassLoader(),
51 null /* bootstrap class loader */};
52
53 Integer[] keys = new Integer[32];
54 for (int i = 0; i < keys.length; i++) {
55 keys[i] = i + 128;
56 }
57
58 try (AutoCloseable cleanup = () -> {
59 for (ClassLoaderValue<Integer> clv : clvs) {
60 for (ClassLoader ld : lds) {
61 clv.removeAll(ld);
62 }
63 }
64 }) {
65 // 1st just one sequential pass of single-threaded validation
66 // which is easier to debug if it fails...
67 for (ClassLoaderValue<Integer> clv : clvs) {
68 for (ClassLoader ld : lds) {
69 writeValidateOps(clv, ld, keys);
70 }
71 }
72 for (ClassLoaderValue<Integer> clv : clvs) {
73 for (ClassLoader ld : lds) {
74 readValidateOps(clv, ld, keys);
75 }
76 }
77
78 // 2nd the same in concurrent setting that also validates
79 // failure-isolation between threads and data-isolation between
80 // regions - (ClassLoader, ClassLoaderValue) pairs - of the storage
81 testConcurrentIsolation(clvs, lds, keys, TimeUnit.SECONDS.toMillis(3));
82 }
83 }
84
85 static void writeValidateOps(ClassLoaderValue<Integer> clv,
86 ClassLoader ld,
87 Object[] keys) {
88 for (int i = 0; i < keys.length; i++) {
89 Object k = keys[i];
90 Integer v1 = i;
91 Integer v2 = i + 333;
92 Integer pv;
93 boolean success;
94
95 pv = clv.sub(k).putIfAbsent(ld, v1);
96 assertEquals(pv, null);
97 assertEquals(clv.sub(k).get(ld), v1);
98
99 pv = clv.sub(k).putIfAbsent(ld, v2);
100 assertEquals(pv, v1);
101 assertEquals(clv.sub(k).get(ld), v1);
102
103 success = clv.sub(k).remove(ld, v2);
104 assertEquals(success, false);
105 assertEquals(clv.sub(k).get(ld), v1);
106
107 success = clv.sub(k).remove(ld, v1);
108 assertEquals(success, true);
109 assertEquals(clv.sub(k).get(ld), null);
110
111 pv = clv.sub(k).putIfAbsent(ld, v2);
112 assertEquals(pv, null);
113 assertEquals(clv.sub(k).get(ld), v2);
114
115 pv = clv.sub(k).computeIfAbsent(ld, (_ld, _clv) -> v1);
116 assertEquals(pv, v2);
117 assertEquals(clv.sub(k).get(ld), v2);
118
119 success = clv.sub(k).remove(ld, v1);
120 assertEquals(success, false);
121 assertEquals(clv.sub(k).get(ld), v2);
122
123 success = clv.sub(k).remove(ld, v2);
124 assertEquals(success, true);
125 assertEquals(clv.sub(k).get(ld), null);
126
127 pv = clv.sub(k).computeIfAbsent(ld, (_ld, clv_k) -> {
128 try {
129 // nested get for same key should throw
130 clv_k.get(_ld);
131 throw new AssertionError("Unexpected code path");
132 } catch (IllegalStateException e) {
133 // expected
134 }
135 try {
136 // nested putIfAbsent for same key should throw
137 clv_k.putIfAbsent(_ld, v1);
138 throw new AssertionError("Unexpected code path");
139 } catch (IllegalStateException e) {
140 // expected
141 }
142 // nested remove for for same key and any value (even null)
143 // should return false
144 assertEquals(clv_k.remove(_ld, null), false);
145 assertEquals(clv_k.remove(_ld, v1), false);
146 assertEquals(clv_k.remove(_ld, v2), false);
147 try {
148 // nested computeIfAbsent for same key should throw
149 clv_k.computeIfAbsent(_ld, (__ld, _clv_k) -> v1);
150 throw new AssertionError("Unexpected code path");
151 } catch (IllegalStateException e) {
152 // expected
153 }
154 // if everything above has been handled, we should succeed...
155 return v2;
156 });
157 // ... and the result should be reflected in the CLV
158 assertEquals(pv, v2);
159 assertEquals(clv.sub(k).get(ld), v2);
160
161 success = clv.sub(k).remove(ld, v2);
162 assertEquals(success, true);
163 assertEquals(clv.sub(k).get(ld), null);
164
165 try {
166 clv.sub(k).computeIfAbsent(ld, (_ld, clv_k) -> {
167 throw new UnsupportedOperationException();
168 });
169 throw new AssertionError("Unexpected code path");
170 } catch (UnsupportedOperationException e) {
171 // expected
172 }
173 assertEquals(clv.sub(k).get(ld), null);
174 }
175 }
176
177 static void readValidateOps(ClassLoaderValue<Integer> clv,
178 ClassLoader ld,
179 Object[] keys) {
180 for (int i = 0; i < keys.length; i++) {
181 Object k = keys[i];
182 Integer v1 = i;
183 Integer v2 = i + 333;
184 Integer rv = clv.sub(k).get(ld);
185 if (!(rv == null || rv.equals(v1) || rv.equals(v2))) {
186 throw new AssertionError("Unexpected value: " + rv +
187 ", expected one of: null, " + v1 + ", " + v2);
188 }
189 }
190 }
191
192 static void testConcurrentIsolation(ClassLoaderValue<Integer>[] clvs,
193 ClassLoader[] lds,
194 Object[] keys,
195 long millisRuntime) {
196 ExecutorService exe = Executors.newCachedThreadPool();
197 List<Future<?>> futures = new ArrayList<>();
198 AtomicBoolean stop = new AtomicBoolean();
199 for (ClassLoaderValue<Integer> clv : clvs) {
200 for (ClassLoader ld : lds) {
201 // submit a task that exercises a mix of modifying
202 // and reading-validating operations in an isolated
203 // part of the storage. If isolation is violated,
204 // validation operations are expected to fail.
205 futures.add(exe.submit(() -> {
206 do {
207 writeValidateOps(clv, ld, keys);
208 } while (!stop.get());
209 }));
210 // submit a task that just reads from the same part of
211 // the storage as above task. It should not disturb
212 // above task in any way and this task should never
213 // exhibit any failure although above task produces
214 // regular failures during lazy computation
215 futures.add(exe.submit(() -> {
216 do {
217 readValidateOps(clv, ld, keys);
218 } while (!stop.get());
219 }));
220 }
221 }
222 // wait for some time
223 try {
224 Thread.sleep(millisRuntime);
225 } catch (InterruptedException e) {
226 throw new AssertionError(e);
227 }
228 // stop tasks
229 stop.set(true);
230 // collect results
231 AssertionError error = null;
232 for (Future<?> future : futures) {
233 try {
234 future.get();
235 } catch (InterruptedException | ExecutionException e) {
236 if (error == null) error = new AssertionError("Failure");
237 error.addSuppressed(e);
238 }
239 }
240 exe.shutdown();
241 if (error != null) throw error;
242 }
243
244 static void assertEquals(Object actual, Object expected) {
245 if (!Objects.equals(actual, expected)) {
246 throw new AssertionError("Expected: " + expected + ", actual: " + actual);
247 }
248 }
249 }