1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/*
* Copyright (C) 2015 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.common.util.concurrent;
import com.google.common.collect.ImmutableSet;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URLClassLoader;
import java.util.Set;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Tests our AtomicHelper fallback strategy in AggregateFutureState.
*
* <p>On different platforms AggregateFutureState uses different strategies for its core
* synchronization primitives. The strategies are all implemented as subtypes of AtomicHelper and
* the strategy is selected in the static initializer of AggregateFutureState. This is convenient
* and performant but introduces some testing difficulties. This test exercises the two fallback
* strategies.
*
* <ul>
* <li>SafeAtomicHelper: uses Atomic FieldsUpdaters to implement synchronization
* <li>SynchronizedHelper: uses {@code synchronized} blocks for synchronization
* </ul>
*
* To force selection of our fallback strategies we load {@link AggregateFutureState} (and all of
* {@code com.google.common.util.concurrent} in degenerate class loaders which make certain platform
* classes unavailable. Then we construct a test suite so we can run the normal FuturesTest test
* methods in these degenerate classloaders.
*/
public class AggregateFutureStateFallbackAtomicHelperTest extends TestCase {
/**
* This classloader disallows AtomicReferenceFieldUpdater and AtomicIntegerFieldUpdate which will
* prevent us from selecting our {@code SafeAtomicHelper} strategy.
*
* <p>Stashing this in a static field avoids loading it over and over again and speeds up test
* execution significantly.
*/
private static final ClassLoader NO_ATOMIC_FIELD_UPDATER =
getClassLoader(
ImmutableSet.of(
AtomicIntegerFieldUpdater.class.getName(),
AtomicReferenceFieldUpdater.class.getName()));
public static TestSuite suite() {
// we create a test suite containing a test for every FuturesTest test method and we
// set it as the name of the test. Then in runTest we can reflectively load and invoke the
// corresponding method on FuturesTest in the correct classloader.
TestSuite suite = new TestSuite(AggregateFutureStateFallbackAtomicHelperTest.class.getName());
for (Method method : FuturesTest.class.getDeclaredMethods()) {
if (Modifier.isPublic(method.getModifiers()) && method.getName().startsWith("test")) {
suite.addTest(
TestSuite.createTest(
AggregateFutureStateFallbackAtomicHelperTest.class, method.getName()));
}
}
return suite;
}
@Override
public void runTest() throws Exception {
// First ensure that our classloaders are initializing the correct helper versions
checkHelperVersion(getClass().getClassLoader(), "SafeAtomicHelper");
checkHelperVersion(NO_ATOMIC_FIELD_UPDATER, "SynchronizedAtomicHelper");
// Run the corresponding FuturesTest test method in a new classloader that disallows
// certain core jdk classes.
ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(NO_ATOMIC_FIELD_UPDATER);
try {
runTestMethod(NO_ATOMIC_FIELD_UPDATER);
// TODO(lukes): assert that the logs are full of errors
} finally {
Thread.currentThread().setContextClassLoader(oldClassLoader);
}
}
private void runTestMethod(ClassLoader classLoader) throws Exception {
Class<?> test = classLoader.loadClass(FuturesTest.class.getName());
Object testInstance = test.getDeclaredConstructor().newInstance();
test.getMethod("setUp").invoke(testInstance);
test.getMethod(getName()).invoke(testInstance);
test.getMethod("tearDown").invoke(testInstance);
}
private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)
throws Exception {
// Make sure we are actually running with the expected helper implementation
Class<?> abstractFutureClass = classLoader.loadClass(AggregateFutureState.class.getName());
Field helperField = abstractFutureClass.getDeclaredField("ATOMIC_HELPER");
helperField.setAccessible(true);
assertEquals(expectedHelperClassName, helperField.get(null).getClass().getSimpleName());
}
private static ClassLoader getClassLoader(final Set<String> blocklist) {
final String concurrentPackage = SettableFuture.class.getPackage().getName();
ClassLoader classLoader = AggregateFutureStateFallbackAtomicHelperTest.class.getClassLoader();
// we delegate to the current classloader so both loaders agree on classes like TestCase
return new URLClassLoader(ClassPathUtil.getClassPathUrls(), classLoader) {
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
if (blocklist.contains(name)) {
throw new ClassNotFoundException("I'm sorry Dave, I'm afraid I can't do that.");
}
if (name.startsWith(concurrentPackage)) {
Class<?> c = findLoadedClass(name);
if (c == null) {
return super.findClass(name);
}
return c;
}
return super.loadClass(name);
}
};
}
}
|
