T invoke(ANY object, String methodName, V... args) {
39 | return console.invoke(object, methodName, args);
40 | }
41 |
42 | /**
43 | * Returns the index of the first method with the specified name.
44 | */
45 | public int getIndex(String methodName) {
46 | return console.indexOfMethod(methodName);
47 | }
48 |
49 | public int getIndex(Method method) {
50 | return console.indexOfMethod(method);
51 | }
52 |
53 | /**
54 | * Returns the index of the first method with the specified name and param types.
55 | */
56 | public int getIndex(String methodName, Class... paramTypes) {
57 | return console.indexOfMethod(null, methodName, paramTypes);
58 | }
59 |
60 | /**
61 | * Returns the index of the first method with the specified name and the specified number of arguments.
62 | */
63 | public int getIndex(String methodName, int paramsCount) {
64 | return console.indexOfMethod(methodName, paramsCount);
65 | }
66 |
67 | public String[] getMethodNames() {
68 | return classInfo.methodNames;
69 | }
70 |
71 | public Class[][] getParameterTypes() {
72 | return classInfo.methodParamTypes;
73 | }
74 |
75 | public Class[] getReturnTypes() {
76 | return classInfo.returnTypes;
77 | }
78 |
79 | public Integer[] getModifiers() {
80 | return classInfo.constructorModifiers;
81 | }
82 |
83 | public int getMethodCount() {
84 | return classInfo.methodCount;
85 | }
86 | }
--------------------------------------------------------------------------------
/src/com/esotericsoftware/reflectasm/util/NumberUtils.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm.util;
2 |
3 | /*
4 | * Copyright 2002-2016 the original author or authors.
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | import java.lang.reflect.Array;
20 | import java.math.BigDecimal;
21 | import java.math.BigInteger;
22 | import java.util.*;
23 |
24 | /**
25 | * Miscellaneous utility methods for number conversion and parsing.
26 | * Mainly for internal use within the framework; consider Apache's
27 | * Commons Lang for a more comprehensive suite of number utilities.
28 | *
29 | * @author Juergen Hoeller
30 | * @author Rob Harrop
31 | * @since 1.1.2
32 | */
33 | public abstract class NumberUtils {
34 | /**
35 | * Standard number types (all immutable):
36 | * Byte, Short, Integer, Long, BigInteger, Float, Double, BigDecimal.
37 | */
38 | public static final Set> STANDARD_NUMBER_TYPES;
39 | public static final Map> namePrimitiveMap = new HashMap<>();
40 | private static final BigInteger LONG_MIN = BigInteger.valueOf(Long.MIN_VALUE);
41 | private static final BigInteger LONG_MAX = BigInteger.valueOf(Long.MAX_VALUE);
42 |
43 | static {
44 | namePrimitiveMap.put("boolean", Boolean.class);
45 | namePrimitiveMap.put("byte", Byte.class);
46 | namePrimitiveMap.put("char", Character.class);
47 | namePrimitiveMap.put("short", Short.class);
48 | namePrimitiveMap.put("int", Integer.class);
49 | namePrimitiveMap.put("long", Long.class);
50 | namePrimitiveMap.put("double", Double.class);
51 | namePrimitiveMap.put("float", Float.class);
52 | namePrimitiveMap.put("void", Void.class);
53 |
54 | Set> numberTypes = new HashSet<>(8);
55 | numberTypes.add(Byte.class);
56 | numberTypes.add(Byte.TYPE);
57 | numberTypes.add(Short.class);
58 | numberTypes.add(Short.TYPE);
59 | numberTypes.add(Integer.class);
60 | numberTypes.add(Integer.TYPE);
61 | numberTypes.add(Long.class);
62 | numberTypes.add(Long.TYPE);
63 | numberTypes.add(BigInteger.class);
64 | numberTypes.add(Float.class);
65 | numberTypes.add(Float.TYPE);
66 | numberTypes.add(Double.class);
67 | numberTypes.add(Double.TYPE);
68 | numberTypes.add(BigDecimal.class);
69 | STANDARD_NUMBER_TYPES = Collections.unmodifiableSet(numberTypes);
70 | }
71 |
72 | private static T convertOrGetDistance(V from, Class toClass, final boolean isGetDistance) {
73 | //return (T) (isGetDistance ? Integer.valueOf(5) : from);
74 | if (toClass == null) return (T) (isGetDistance ? 5 : null);
75 | if (from == null) return (T) (isGetDistance ? (toClass.isPrimitive() ? -1 : 5) : null);
76 | Class clz;
77 | boolean isClass = false;
78 |
79 | if (!(from instanceof Class)) clz = from.getClass();
80 | else {
81 | clz = (Class) from;
82 | isClass = true;
83 | }
84 |
85 | if (clz == String.class && toClass == byte[].class)
86 | return (T) (isGetDistance ? 5 : isClass ? toClass : ((String) from).getBytes());
87 |
88 | if (clz == byte[].class && toClass == String.class)
89 | return (T) (isGetDistance ? 5 : isClass ? toClass : new String((byte[]) from));
90 |
91 | if (clz == toClass || toClass.isAssignableFrom(clz)) return (T) (isGetDistance ? 5 : from);
92 | if (toClass.isArray() && clz.isArray()) {
93 | int distance = 5;
94 | toClass = toClass.getComponentType();
95 | if (isClass) return convertOrGetDistance(clz.getComponentType(), toClass, isGetDistance);
96 | Object objects = isGetDistance ? null : Array.newInstance(toClass, Array.getLength(from));
97 | for (int i = 0; i < Array.getLength(from); i++) {
98 | if (isGetDistance)
99 | distance = Math.min(distance, (int) convertOrGetDistance(Array.get(from, i), toClass, true));
100 | else Array.set(objects, i, convertOrGetDistance(Array.get(from, i), toClass, false));
101 | }
102 | return (T) (isGetDistance ? distance : objects);
103 | }
104 | if (toClass == String.class) return (T) (isGetDistance ? 2 : isClass ? toClass : String.valueOf(from));
105 | if (STANDARD_NUMBER_TYPES.contains(toClass)) {
106 | Class to = (Class) toClass;
107 | if (STANDARD_NUMBER_TYPES.contains(clz)) {
108 | return (T) (isGetDistance ? 4 : isClass ? toClass : convertNumberToTargetClass((Number) from, to));
109 | }
110 | if (clz == String.class) return (T) (isGetDistance ? 1 : isClass ? clz : parseNumber((String) from, to));
111 | if (clz == Character.class || clz == char.class)
112 | return (T) (isGetDistance ? 3 : isClass ? toClass : convertNumberToTargetClass((int) ((Character) from).charValue(), to));
113 | }
114 | if ((toClass == Character.class || toClass == char.class)) {
115 | if (STANDARD_NUMBER_TYPES.contains(clz))
116 | return (T) (isGetDistance ? 3 : isClass ? toClass : Character.valueOf((char) ((Number) from).intValue()));
117 | if (clz == String.class) {
118 | if (isClass) return (T) (isGetDistance ? 3 : isClass ? clz : toClass);
119 | if (((String) from).length() == 1)
120 | return (T) (isGetDistance ? 3 : isClass ? toClass : ((String) from).charAt(0));
121 | }
122 | }
123 | if (namePrimitiveMap.containsKey(toClass.getName()) && namePrimitiveMap.get(toClass.getName()) == clz) {
124 | return (T) (isGetDistance ? 5 : isClass ? toClass : from);
125 | }
126 | if (namePrimitiveMap.containsKey(clz.getName()) && namePrimitiveMap.get(clz.getName()) == toClass) {
127 | return (T) (isGetDistance ? 5 : isClass ? toClass : from);
128 | }
129 | return (T) (isGetDistance ? 0 : isClass ? clz : toClass.cast(from));
130 | }
131 |
132 | public static T convert(V from, Class toClass) {
133 | return convertOrGetDistance(from, toClass, false);
134 | }
135 |
136 | public static int getDistance(V from, Class toClass) {
137 | return (Integer) convertOrGetDistance(from, toClass, true);
138 | }
139 |
140 | /**
141 | * Convert the given number into an instance of the given target class.
142 | *
143 | * @param number the number to convert
144 | * @param targetClass the target class to convert to
145 | * @return the converted number
146 | * @throws IllegalArgumentException if the target class is not supported
147 | * (i.e. not a standard Number subclass as included in the JDK)
148 | * @see Byte
149 | * @see Short
150 | * @see Integer
151 | * @see Long
152 | * @see BigInteger
153 | * @see Float
154 | * @see Double
155 | * @see BigDecimal
156 | */
157 | @SuppressWarnings("unchecked")
158 | public static T convertNumberToTargetClass(Number number, Class targetClass) throws IllegalArgumentException {
159 | if (number == null) return null;
160 | Number to = null;
161 | if (targetClass.isInstance(number)) {
162 | return (T) number;
163 | }
164 | Class clz = targetClass;
165 | if (clz.isPrimitive() && STANDARD_NUMBER_TYPES.contains(clz)) clz = namePrimitiveMap.get(clz.getName());
166 | if (Byte.class == clz) {
167 | long value = checkedLongValue(number, clz);
168 | if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
169 | raiseOverflowException(number, clz);
170 | }
171 | to = Byte.valueOf(number.byteValue());
172 | } else if (Short.class == clz) {
173 | long value = checkedLongValue(number, clz);
174 | if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
175 | raiseOverflowException(number, clz);
176 | }
177 | to = Short.valueOf(number.shortValue());
178 | } else if (Integer.class == clz) {
179 | long value = checkedLongValue(number, clz);
180 | if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
181 | raiseOverflowException(number, clz);
182 | }
183 | to = Integer.valueOf(number.intValue());
184 | } else if (Long.class == clz) {
185 | long value = checkedLongValue(number, clz);
186 | to = Long.valueOf(value);
187 | } else if (BigInteger.class == clz) {
188 | if (number instanceof BigDecimal) {
189 | // do not lose precision - use BigDecimal's own conversion
190 | to = ((BigDecimal) number).toBigInteger();
191 | } else {
192 | // original value is not a Big* number - use standard long conversion
193 | to = BigInteger.valueOf(number.longValue());
194 | }
195 | } else if (Float.class == clz) {
196 | to = Float.valueOf(number.floatValue());
197 | } else if (Double.class == clz) {
198 | to = Double.valueOf(number.doubleValue());
199 | } else if (BigDecimal.class == clz) {
200 | // always use BigDecimal(String) here to avoid unpredictability of BigDecimal(double)
201 | // (see BigDecimal javadoc for details)
202 | to = new BigDecimal(number.toString());
203 | }
204 | if (to == null) {
205 | throw new IllegalArgumentException("Could not convert number [" + number + "] of type [" + number.getClass().getName() + "] to unsupported target class [" + clz.getName() + "]");
206 | }
207 | return (T) to;
208 | }
209 |
210 | /**
211 | * Check for a {@code BigInteger}/{@code BigDecimal} long overflow
212 | * before returning the given number as a long value.
213 | *
214 | * @param number the number to convert
215 | * @param targetClass the target class to convert to
216 | * @return the long value, if convertible without overflow
217 | * @throws IllegalArgumentException if there is an overflow
218 | * @see #raiseOverflowException
219 | */
220 | private static long checkedLongValue(Number number, Class targetClass) {
221 | BigInteger bigInt = null;
222 | if (number instanceof BigInteger) {
223 | bigInt = (BigInteger) number;
224 | } else if (number instanceof BigDecimal) {
225 | bigInt = ((BigDecimal) number).toBigInteger();
226 | }
227 | // Effectively analogous to JDK 8's BigInteger.longValueExact()
228 | if (bigInt != null && (bigInt.compareTo(LONG_MIN) < 0 || bigInt.compareTo(LONG_MAX) > 0)) {
229 | raiseOverflowException(number, targetClass);
230 | }
231 | return number.longValue();
232 | }
233 |
234 | /**
235 | * Raise an overflow exception for the given number and target class.
236 | *
237 | * @param number the number we tried to convert
238 | * @param targetClass the target class we tried to convert to
239 | * @throws IllegalArgumentException if there is an overflow
240 | */
241 | private static void raiseOverflowException(Number number, Class targetClass) {
242 | throw new IllegalArgumentException("Could not convert number [" + number + "] of type [" + number.getClass().getName() + "] to target class [" + targetClass.getName() + "]: overflow");
243 | }
244 |
245 | /**
246 | * Parse the given {@code text} into a {@link Number} instance of the given
247 | * target class, using the corresponding {@code decode} / {@code valueOf} method.
248 | * Trims the input {@code String} before attempting to parse the number.
249 | *
Supports numbers in hex format (with leading "0x", "0X", or "#") as well.
250 | *
251 | * @param text the text to convert
252 | * @param targetClass the target class to parse into
253 | * @return the parsed number
254 | * @throws IllegalArgumentException if the target class is not supported
255 | * (i.e. not a standard Number subclass as included in the JDK)
256 | * @see Byte#decode
257 | * @see Short#decode
258 | * @see Integer#decode
259 | * @see Long#decode
260 | * @see #decodeBigInteger(String)
261 | * @see Float#valueOf
262 | * @see Double#valueOf
263 | * @see BigDecimal#BigDecimal(String)
264 | */
265 | @SuppressWarnings("unchecked")
266 | public static T parseNumber(String text, Class targetClass) {
267 | if (text == null) return null;
268 | String trimmed = text.replace(" ", "");
269 | if (trimmed.equals("")) return null;
270 | Class clz = targetClass;
271 | if (clz.isPrimitive()) clz = namePrimitiveMap.get(clz.getName());
272 | if (Byte.class == clz) {
273 | return (T) (isHexNumber(trimmed) ? Byte.decode(trimmed) : Byte.valueOf(trimmed));
274 | } else if (Short.class == clz) {
275 | return (T) (isHexNumber(trimmed) ? Short.decode(trimmed) : Short.valueOf(trimmed));
276 | } else if (Integer.class == clz) {
277 | return (T) (isHexNumber(trimmed) ? Integer.decode(trimmed) : Integer.valueOf(trimmed));
278 | } else if (Long.class == clz) {
279 | return (T) (isHexNumber(trimmed) ? Long.decode(trimmed) : Long.valueOf(trimmed));
280 | } else if (BigInteger.class == clz) {
281 | return (T) (isHexNumber(trimmed) ? decodeBigInteger(trimmed) : new BigInteger(trimmed));
282 | } else if (Float.class == clz) {
283 | return (T) Float.valueOf(trimmed);
284 | } else if (Double.class == clz) {
285 | return (T) Double.valueOf(trimmed);
286 | } else if (BigDecimal.class == clz || Number.class == clz) {
287 | return (T) new BigDecimal(trimmed);
288 | } else {
289 | throw new IllegalArgumentException("Cannot convert String [" + text + "] to target class [" + clz.getName() + "]");
290 | }
291 | }
292 |
293 | /**
294 | * Determine whether the given {@code value} String indicates a hex number,
295 | * i.e. needs to be passed into {@code Integer.decode} instead of
296 | * {@code Integer.valueOf}, etc.
297 | */
298 | private static boolean isHexNumber(String value) {
299 | int index = (value.startsWith("-") ? 1 : 0);
300 | return (value.startsWith("0x", index) || value.startsWith("0X", index) || value.startsWith("#", index));
301 | }
302 |
303 | /**
304 | * Decode a {@link BigInteger} from the supplied {@link String} value.
305 | * Supports decimal, hex, and octal notation.
306 | *
307 | * @see BigInteger#BigInteger(String, int)
308 | */
309 | private static BigInteger decodeBigInteger(String value) {
310 | int radix = 10;
311 | int index = 0;
312 | boolean negative = false;
313 |
314 | // Handle minus sign, if present.
315 | if (value.startsWith("-")) {
316 | negative = true;
317 | index++;
318 | }
319 |
320 | // Handle radix specifier, if present.
321 | if (value.startsWith("0x", index) || value.startsWith("0X", index)) {
322 | index += 2;
323 | radix = 16;
324 | } else if (value.startsWith("#", index)) {
325 | index++;
326 | radix = 16;
327 | } else if (value.startsWith("0", index) && value.length() > 1 + index) {
328 | index++;
329 | radix = 8;
330 | }
331 |
332 | BigInteger result = new BigInteger(value.substring(index), radix);
333 | return (negative ? result.negate() : result);
334 | }
335 | }
--------------------------------------------------------------------------------
/src/com/esotericsoftware/reflectasm/util/Probe.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm.util;
2 |
3 | import java.util.*;
4 | import java.util.concurrent.locks.ReentrantLock;
5 |
6 | public class Probe {
7 | public static Probe p = new Probe();
8 | static Comparator comparator = new Comparator() {
9 | public int compare(Object[] o1, Object[] o2) {
10 | return ((Long) ((Long) o2[1] - (Long) o1[1])).intValue();
11 | }
12 | };
13 | public boolean warmup = true;
14 | public Map times = new HashMap(10);
15 | private long s;
16 | private volatile long e;
17 | private String prevTag;
18 | private volatile boolean isRunning = false;
19 | private Thread thread = null;
20 | private long duration;
21 | private ArrayDeque queue = new ArrayDeque();
22 | private ReentrantLock lock = new ReentrantLock();
23 |
24 | public static void mark_(String tag) {p.mark(tag);}
25 |
26 | public static void clear_() {p.clear();}
27 |
28 | public static void end_() {p.end();}
29 |
30 | public static void print_() {p.print();}
31 |
32 | public static void reset_() {p.reset();}
33 |
34 | public void mark(String tag) {
35 | if (warmup) return;
36 | if (prevTag != null) {
37 | Long time = e - s;
38 | String name = prevTag + " -> " + (tag == null ? "" : tag);
39 | //lock.lock();
40 | Long[] oldTime = times.get(name);
41 | if (oldTime == null) times.put(name, new Long[]{time, 1L, Integer.valueOf(times.size()).longValue()});
42 | else {
43 | oldTime[0] += time;
44 | ++oldTime[1];
45 | }
46 | //lock.unlock();
47 | }
48 | prevTag = tag == null ? "" : tag;
49 | s = e;
50 | }
51 |
52 | public void reset() {
53 | mark(null);
54 | if (thread == null && !warmup) {
55 | duration = System.nanoTime();
56 | e = 0L;
57 | isRunning = true;
58 | thread = new Thread(new Runnable() {
59 | @Override
60 | public void run() {
61 | while (isRunning) {
62 | try {
63 | Thread.sleep(0, 10);
64 | } catch (InterruptedException e1) {
65 | e1.printStackTrace();
66 | }
67 | e = System.nanoTime();
68 | }
69 | }
70 | });
71 | thread.setDaemon(true);
72 | thread.start();
73 |
74 | try {
75 | while (e == 0L) Thread.sleep(1L);
76 | } catch (InterruptedException e) {
77 | thread = null;
78 | }
79 | s = e;
80 | }
81 | }
82 |
83 | public void end() {
84 | if (isRunning) {
85 | isRunning = false;
86 | if (thread != null && thread.isAlive()) try {
87 | thread.join();
88 | } catch (InterruptedException e) {}
89 | thread = null;
90 | duration = e - duration;
91 | }
92 | }
93 |
94 | public void clear() {
95 | queue.clear();
96 | end();
97 | if (warmup) return;
98 | times.clear();
99 | prevTag = null;
100 | }
101 |
102 | public void print() {
103 | end();
104 | String[] keys = times.keySet().toArray(new String[]{});
105 | Object[][] o = new Object[keys.length][];
106 | Long totalTime = 0L;
107 | int maxsize = 0;
108 | for (int i = 0, n = o.length; i < n; i++) {
109 | Long[] item = times.get(keys[i]);
110 | o[i] = new Object[]{keys[i], item[0], item[1], item[2]};
111 | totalTime += item[0];
112 | maxsize = Math.max(maxsize, keys[i].length());
113 | }
114 | Arrays.sort(o, comparator);
115 | StringBuilder sb = new StringBuilder(1024);
116 | for (Object[] i : o) {
117 | sb.append(String.format("|%4d:%-" + (maxsize + 1) + "s | %10.3f ms | %2.2f%% | %10d times |\n",//
118 | i[3], i[0], ((Long) i[1]) / (Double) 1e6, 100 * ((Long) i[1]) / totalTime.doubleValue(), ((Long) i[2]).intValue()));
119 | }
120 | System.out.println(sb.toString());
121 | }
122 | }
123 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/ClassAccessTest.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm;
2 |
3 | import junit.framework.TestCase;
4 | import test.Many;
5 | import test.TestObject;
6 |
7 | import java.util.concurrent.CountDownLatch;
8 | import java.util.concurrent.ExecutorService;
9 | import java.util.concurrent.Executors;
10 |
11 | /**
12 | * Created by Will on 2017/2/6.
13 | */
14 | public class ClassAccessTest extends TestCase {
15 | public void testBigClass() throws ClassNotFoundException {
16 | Class clz = Class.forName("oracle.jdbc.driver.T4CConnection");
17 | ClassAccess.access(clz, ".");
18 | }
19 |
20 | public void testCase1() {
21 | //Generic style
22 | ClassAccess.access(TestObject.class, ".");
23 | ClassAccess access0 = ClassAccess.access(Many.class);
24 | Many many = access0.newInstance();
25 | access0.set(many, "x295", 123);
26 | int value = access0.get(many, "x295");
27 | assertEquals(123, value);
28 |
29 | //Non-generic style
30 | ClassAccess access5 = ClassAccess.access(Many.class);
31 | Object many1 = access5.newInstance();
32 | access5.set(many1, "x295", 456);
33 | value = (int) access5.get(many1, "x295");
34 | assertEquals(456, value);
35 |
36 | //Cast back to generic style
37 | ClassAccess access6 = access5;
38 | Many many2 = (Many) many1;
39 | access6.set(many2, "x295", 789);
40 | value = access6.get(many2, "x295");
41 | assertEquals(789, value);
42 |
43 | ClassAccess access = ClassAccess.access(BaseClass.class, ".", "");
44 | ClassAccess access1 = ClassAccess.access(BaseClass.Inner.class);
45 | try {
46 | BaseClass instance = access.newInstance();
47 | fail();
48 | } catch (IllegalArgumentException e) {}
49 | BaseClass instance = access.newInstance(this);
50 | instance.test0();
51 | BaseClass.Inner inner = (BaseClass.Inner) access.invoke(instance, "newInner");
52 | access1.newInstance(instance);
53 | access = ClassAccess.access(BaseClass.StaticInner.class);
54 | access.newInstance(instance);
55 | access = ClassAccess.access(BaseClass.Inner.DeeperInner.class);
56 | access.newInstance(inner);
57 | }
58 |
59 | public void testOverload0(ClassAccess... accesses) {
60 | ClassAccess access1 = ClassAccess.access(BaseClass.class);
61 | ClassAccess access2;
62 | if (accesses.length == 0) access2 = ClassAccess.access(ChildClass.class, ".");
63 | else access2 = accesses[0];
64 |
65 | ChildClass child = (ChildClass) access2.newInstance(this);
66 | assertEquals("test10", access2.invoke(child, "test0"));
67 | int index = access2.indexOfMethod("test1");
68 | assertEquals("test11", access2.invoke(child, "test1"));
69 | assertEquals("test02", access2.invoke(child, "test2"));
70 | assertEquals("test01", access1.invoke(child, "test1"));
71 | assertEquals(1, (int) access1.get(child, "x"));
72 | assertEquals(3, access2.get(child, "x"));
73 | assertEquals(4, access2.get(child, "y"));
74 | assertEquals(5, access2.get(child, "z"));
75 | //assertEquals(6, access2.get(child, "o"));
76 | //Invoke the overloaded parts of BaseClass
77 | int fieldIndex = access2.indexOfField(BaseClass.class, "x");
78 | int methodIndex = access2.indexOfMethod(BaseClass.class, "test1");
79 | assertEquals("test01", access2.invokeWithIndex(child, methodIndex));
80 | assertEquals(1, access2.get(child, fieldIndex));
81 | if ((Boolean) access2.isInvokeWithMethodHandle.get() == false) {
82 | access2.set(child, fieldIndex, 9);
83 | assertEquals(9, access2.get(child, fieldIndex));
84 | assertEquals(3, access2.get(child, "x"));
85 | assertEquals(6, access2.get(child, "o"));
86 | }
87 | }
88 |
89 | public void testOverload() {
90 | testOverload0();
91 | }
92 |
93 | public void testOverloadWithLambda() throws Throwable {
94 | ClassAccess access2 = ClassAccess.access(ChildClass.class, ".");
95 | access2.isInvokeWithMethodHandle.set(true);
96 | testOverload0(access2);
97 | }
98 |
99 | public void testCase2() throws InterruptedException, IllegalAccessException, InstantiationException, ClassNotFoundException {
100 | final int count = 100;
101 | final int rounds = 300;
102 | ExecutorService pool = Executors.newFixedThreadPool(count);
103 | final CountDownLatch latch = new CountDownLatch(count);
104 | Runnable R = new Runnable() {
105 | @Override
106 | public void run() {
107 | for (int i = 0; i < rounds; i++) ClassAccess.access(Many.class).newInstance();
108 | latch.countDown();
109 | }
110 | };
111 | Long s = System.nanoTime();
112 | for (int i = 0; i < count; i++) {
113 | pool.submit(R);
114 | }
115 |
116 | latch.await();
117 | assertEquals(1, ClassAccess.activeAccessClassLoaders());
118 | System.out.println(ClassAccess.totalAccesses + " invokes from ClassAccess.access() and " + ClassAccess.cacheHits + " hits from cache");
119 | System.out.println("Creating " + (count * rounds) + " same proxies with parallel 100 takes " + String.format("%.3f", (System.nanoTime() - s) / 1e6) + " ms.");
120 |
121 | ClassAccess.totalAccesses = 0;
122 | ClassAccess.cacheHits = 0;
123 | s = System.nanoTime();
124 | for (int i = 0; i < rounds * count; i++) ClassAccess.access(Many.class).newInstance();
125 | System.out.println(ClassAccess.totalAccesses + " invokes from ClassAccess.access() and " + ClassAccess.cacheHits + " hits from cache");
126 | System.out.println("Creating " + (count * rounds) + " same proxies#1 in serial mode takes " + String.format("%.3f", (System.nanoTime() - s) / 1e6) + " ms.");
127 |
128 | ClassAccess.totalAccesses = 0;
129 | ClassAccess.cacheHits = 0;
130 | ClassAccess.IS_CACHED = false;
131 | s = System.nanoTime();
132 | for (int i = 0; i < rounds * count; i++) ClassAccess.access(Many.class).newInstance();
133 | System.out.println(ClassAccess.totalAccesses + " invokes from ClassAccess.access() and " + ClassAccess.loaderHits + " hits from loader");
134 | System.out.println("Creating " + (count * rounds) + " same proxies#1 in serial mode takes " + String.format("%.3f", (System.nanoTime() - s) / 1e6) + " ms.");
135 |
136 | ClassAccess.totalAccesses = 0;
137 | ClassAccess.cacheHits = 0;
138 | ClassAccess.IS_CACHED = true;
139 | s = System.nanoTime();
140 | for (int i = 0; i < rounds * count; i++) {
141 | ClassLoader testClassLoader = new ClassLoaderTest.TestClassLoader1();
142 | Class testClass = testClassLoader.loadClass(Many.class.getName());
143 | ClassAccess access = ClassAccess.access(Many.class);
144 | Many many = access.newInstance();
145 | access.set(many, "x1", i);
146 | }
147 | System.out.println(ClassAccess.totalAccesses + " invokes from ClassAccess.access() and " + ClassAccess.cacheHits + " hits from cache");
148 | System.out.println("Creating " + (count * rounds) + " same proxies#2 in serial mode takes " + String.format("%.3f", (System.nanoTime() - s) / 1e6) + " ms.");
149 | }
150 |
151 | public void testCase3() throws Exception {
152 | {
153 | ClassAccess access = ClassAccess.access(TestObject.class);
154 | TestObject obj;
155 | // Construction
156 | obj = access.newInstance();
157 | obj = access.newInstance(1, 2, 3, 4);
158 |
159 | // Set+Get field
160 | access.set(null, "fs", 1); // static field
161 | System.out.println((String) access.get(null, "fs"));
162 |
163 | access.set(obj, "fd", 2);
164 | System.out.println(access.get(obj, "fd").toString());
165 |
166 | // Method invoke
167 | access.invoke(null, "func1", "a"); //static call
168 | System.out.println((String) access.invoke(obj, "func2", 1, 2, 3, 4));
169 | }
170 |
171 | {
172 | ClassAccess access = ClassAccess.access(TestObject.class);
173 | TestObject obj;
174 | //Identify the indexes for further use
175 | int newIndex = access.indexOfConstructor(int.class, Double.class, String.class, long.class);
176 | int fieldIndex = access.indexOfField("fd");
177 | int methodIndex = access.indexOfMethod("func1", String.class);
178 | //Now use the index to access object in loop or other part
179 | for (int i = 0; i < 100; i++) {
180 | obj = access.newInstanceWithIndex(newIndex, 1, 2, 3, 4);
181 | access.set(obj, fieldIndex, 123);
182 | String result = access.invokeWithIndex(null, methodIndex, "x");
183 | }
184 | }
185 |
186 | {
187 | ClassAccess access = ClassAccess.access(TestObject.class);
188 | TestObject obj;
189 | //Identify the indexes for further use
190 | int newIndex = access.indexOfConstructor(int.class, Double.class, String.class, long.class);
191 | int fieldIndex = access.indexOfField("fd");
192 | int methodIndex = access.indexOfMethod("func1", String.class);
193 | //Now use the index to access object in loop or other part
194 | for (int i = 0; i < 100; i++) {
195 | obj = access.accessor.newInstanceWithIndex(newIndex, 1, Double.valueOf(2), "3", 4L);
196 | access.accessor.set(obj, fieldIndex, Double.valueOf(123));
197 | String result = access.accessor.invokeWithIndex(null, methodIndex, "x");
198 | }
199 | }
200 | }
201 |
202 | interface BaseInterface {
203 | int o = 6;
204 |
205 | String test0();
206 | }
207 |
208 | class BaseClass implements BaseInterface {
209 | public int x = 1;
210 | int y = 2;
211 | int z = 5;
212 |
213 | public String test0() {return "test00";}
214 |
215 | private String test1() {return "test01";}
216 |
217 | private String test2() {return "test02";}
218 |
219 | Inner newInner() {
220 | return new Inner();
221 | }
222 |
223 | class Inner {
224 | class DeeperInner {}
225 | }
226 |
227 | class StaticInner {}
228 | }
229 |
230 | class ChildClass extends BaseClass {
231 | public int x = 3;
232 | int y = 4;
233 |
234 | public String test0() {return "test10";}
235 |
236 | private String test1() {
237 | return "test11";
238 | }
239 | }
240 | }
241 |
242 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/ClassLoaderTest.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm;
2 |
3 | import junit.framework.TestCase;
4 |
5 | import java.io.ByteArrayOutputStream;
6 | import java.io.IOException;
7 | import java.io.InputStream;
8 |
9 | public class ClassLoaderTest extends TestCase {
10 | public void testDifferentClassloaders() throws Exception {
11 | ClassLoader testClassLoader = new TestClassLoader1();
12 | Class testClass = testClassLoader.loadClass("com.esotericsoftware.reflectasm.ClassLoaderTest$Test");
13 | Object testObject = testClass.newInstance();
14 |
15 | // Ensure AccessClassLoader can access both the Test class and FieldAccess.
16 | FieldAccess access = FieldAccess.access(testObject.getClass());
17 | access.set(testObject, "name", "first");
18 | assertEquals("first", testObject.toString());
19 | assertEquals("first", access.get(testObject, "name"));
20 | }
21 |
22 | public void testAutoUnloadClassloaders() throws Exception {
23 | int initialCount = AccessClassLoader.activeAccessClassLoaders();
24 | ClassLoader testClassLoader1 = new TestClassLoader1();
25 | Class testClass1 = testClassLoader1.loadClass("com.esotericsoftware.reflectasm.ClassLoaderTest$Test");
26 | Object testObject1 = testClass1.newInstance();
27 | FieldAccess access1 = FieldAccess.access(testObject1.getClass());
28 | access1.set(testObject1, "name", "first");
29 | assertEquals("first", testObject1.toString());
30 | assertEquals("first", access1.get(testObject1, "name"));
31 |
32 | ClassLoader testClassLoader2 = new TestClassLoader2();
33 | Class testClass2 = testClassLoader1.loadClass("com.esotericsoftware.reflectasm.ClassLoaderTest$Test");
34 | Object testObject2 = testClass2.newInstance();
35 | FieldAccess access2 = FieldAccess.access(testObject2.getClass());
36 | access2.set(testObject2, "name", "second");
37 | assertEquals("second", testObject2.toString());
38 | assertEquals("second", access2.get(testObject2, "name"));
39 |
40 | assertEquals(access1.console.getClass().toString(), access2.console.getClass().toString()); // Same class names
41 | assertTrue(access1.console.accessor.getClass().equals(access2.console.accessor.getClass())); // But different classes
42 |
43 | assertEquals(true, (initialCount + 2 >= AccessClassLoader.activeAccessClassLoaders()));
44 |
45 | testClassLoader1 = null;
46 | testClass1 = null;
47 | testObject1 = null;
48 | access1 = null;
49 | testClassLoader2 = null;
50 | testClass2 = null;
51 | testObject2 = null;
52 | access2 = null;
53 |
54 | // Force GC to reclaim unreachable (or only weak-reachable) objects
55 | System.gc();
56 | try {
57 | Object[] array = new Object[(int) Runtime.getRuntime().maxMemory()];
58 | System.out.println(array.length);
59 | } catch (Throwable e) {
60 | // Ignore OME
61 | }
62 | System.gc();
63 | int times = 0;
64 | while (AccessClassLoader.activeAccessClassLoaders() > 1 && times < 50) { // max 5 seconds, should be instant
65 | Thread.sleep(100); // test again
66 | times++;
67 | }
68 | // Yeah, both reclaimed!
69 | assertEquals(1, AccessClassLoader.activeAccessClassLoaders());
70 | }
71 |
72 | public void testRemoveClassloaders() throws Exception {
73 | int initialCount = AccessClassLoader.activeAccessClassLoaders();
74 |
75 | ClassLoader testClassLoader1 = new TestClassLoader1();
76 | Class testClass1 = testClassLoader1.loadClass("com.esotericsoftware.reflectasm.ClassLoaderTest$Test");
77 | Object testObject1 = testClass1.newInstance();
78 | FieldAccess access1 = FieldAccess.access(testObject1.getClass());
79 | access1.set(testObject1, "name", "first");
80 | assertEquals("first", testObject1.toString());
81 | assertEquals("first", access1.get(testObject1, "name"));
82 |
83 | ClassLoader testClassLoader2 = new TestClassLoader2();
84 | Class testClass2 = testClassLoader2.loadClass("com.esotericsoftware.reflectasm.ClassLoaderTest$Test");
85 | Object testObject2 = testClass2.newInstance();
86 | FieldAccess access2 = FieldAccess.access(testObject2.getClass());
87 | access2.set(testObject2, "name", "second");
88 | assertEquals("second", testObject2.toString());
89 | assertEquals("second", access2.get(testObject2, "name"));
90 |
91 | assertEquals(access1.console.accessor.getClass().toString(), access2.console.accessor.getClass().toString()); // Same class names
92 | assertFalse(access1.console.accessor.getClass().equals(access2.console.accessor.getClass())); // But different classes
93 |
94 | assertEquals(initialCount + 2, AccessClassLoader.activeAccessClassLoaders());
95 |
96 | AccessClassLoader.remove(testObject1.getClass().getClassLoader());
97 | assertEquals(initialCount + 1, AccessClassLoader.activeAccessClassLoaders());
98 | AccessClassLoader.remove(testObject2.getClass().getClassLoader());
99 | assertEquals(initialCount + 0, AccessClassLoader.activeAccessClassLoaders());
100 | AccessClassLoader.remove(this.getClass().getClassLoader());
101 | assertEquals(initialCount - 1, AccessClassLoader.activeAccessClassLoaders());
102 | }
103 |
104 | static public class Test {
105 | public String name;
106 |
107 | public String toString() {
108 | return name;
109 | }
110 | }
111 |
112 | static public class TestClassLoader1 extends ClassLoader {
113 | protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
114 | Class c = findLoadedClass(name);
115 | if (c != null) return c;
116 | if (!name.startsWith("com.esotericsoftware.reflectasm.ClassLoaderTest"))
117 | return super.loadClass(name, resolve);
118 | ByteArrayOutputStream output = new ByteArrayOutputStream(32 * 1024);
119 | InputStream input = ClassLoaderTest.class.getResourceAsStream("/" + name.replace('.', '/') + ".class");
120 | if (input == null) return null;
121 | try {
122 | byte[] buffer = new byte[4096];
123 | int total = 0;
124 | while (true) {
125 | int length = input.read(buffer, 0, buffer.length);
126 | if (length == -1) break;
127 | output.write(buffer, 0, length);
128 | }
129 | } catch (IOException ex) {
130 | throw new ClassNotFoundException("Error reading class file.", ex);
131 | } finally {
132 | try {
133 | input.close();
134 | } catch (IOException ignored) {
135 | }
136 | }
137 | byte[] buffer = output.toByteArray();
138 | return defineClass(name, buffer, 0, buffer.length);
139 | }
140 | }
141 |
142 | static public class TestClassLoader2 extends TestClassLoader1 {}
143 | }
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/ConstructorAccessTest.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm;
2 |
3 | import junit.framework.TestCase;
4 |
5 | public class ConstructorAccessTest extends TestCase {
6 | public void testNewInstance() {
7 | ConstructorAccess access = ConstructorAccess.access(SomeClass.class, ".");
8 | SomeClass someObject = new SomeClass();
9 | assertEquals(someObject, access.newInstance());
10 | assertEquals(someObject, access.newInstance());
11 | assertEquals(someObject, access.newInstance());
12 | }
13 |
14 | public void testPackagePrivateNewInstance() {
15 | ConstructorAccess access = ConstructorAccess.access(PackagePrivateClass.class);
16 | PackagePrivateClass someObject = new PackagePrivateClass();
17 | assertEquals(someObject, access.newInstance());
18 | assertEquals(someObject, access.newInstance());
19 | assertEquals(someObject, access.newInstance());
20 | }
21 |
22 | public void testHasArgumentConstructor() {
23 | HasArgumentConstructor someObject = new HasArgumentConstructor("bla");
24 | ConstructorAccess access = ConstructorAccess.access(HasArgumentConstructor.class, ".");
25 | assertEquals(someObject, access.newInstance("bla"));
26 | int index = access.getIndex(String.class);
27 | assertEquals(someObject, access.newInstanceWithIndex(index, "bla"));
28 | assertEquals(someObject, access.newInstanceWithTypes(new Class[]{String.class}, "bla"));
29 | assertEquals((int) (access.console.get(access.newInstance(1), "y")), 1);
30 | }
31 |
32 | public void testHasPrivateConstructor() {
33 | ConstructorAccess access = ConstructorAccess.access(HasPrivateConstructor.class);
34 | HasPrivateConstructor someObject = new HasPrivateConstructor();
35 | assertEquals(someObject, access.newInstance());
36 | assertEquals(someObject, access.newInstance());
37 | assertEquals(someObject, access.newInstance());
38 | }
39 |
40 | public void testHasProtectedConstructor() {
41 | try {
42 | ConstructorAccess access = ConstructorAccess.access(HasProtectedConstructor.class);
43 | HasProtectedConstructor newInstance = access.newInstance();
44 | assertEquals("cow", newInstance.getMoo());
45 | } catch (Throwable t) {
46 | System.out.println("Unexpected exception happened: " + t);
47 | assertTrue(false);
48 | }
49 | }
50 |
51 | public void testHasPackageProtectedConstructor() {
52 | try {
53 | ConstructorAccess access = ConstructorAccess.access(HasPackageProtectedConstructor.class);
54 | HasPackageProtectedConstructor newInstance = access.newInstance();
55 | assertEquals("cow", newInstance.getMoo());
56 | } catch (Throwable t) {
57 | System.out.println("Unexpected exception happened: " + t);
58 | assertTrue(false);
59 | }
60 | }
61 |
62 | public void testHasPublicConstructor() {
63 | try {
64 | ConstructorAccess access = ConstructorAccess.access(HasPublicConstructor.class);
65 | HasPublicConstructor newInstance = access.newInstance();
66 | assertEquals("cow", newInstance.getMoo());
67 | } catch (Throwable t) {
68 | System.out.println("Unexpected exception happened: " + t);
69 | assertTrue(false);
70 | }
71 | }
72 |
73 | static class PackagePrivateClass {
74 | public String name;
75 | public int intValue;
76 | protected float test1;
77 | Float test2;
78 | private String test3;
79 |
80 | public boolean equals(Object obj) {
81 | if (this == obj) return true;
82 | if (obj == null) return false;
83 | if (getClass() != obj.getClass()) return false;
84 | PackagePrivateClass other = (PackagePrivateClass) obj;
85 | if (intValue != other.intValue) return false;
86 | if (name == null) {
87 | if (other.name != null) return false;
88 | } else if (!name.equals(other.name)) return false;
89 | if (Float.floatToIntBits(test1) != Float.floatToIntBits(other.test1)) return false;
90 | if (test2 == null) {
91 | if (other.test2 != null) return false;
92 | } else if (!test2.equals(other.test2)) return false;
93 | if (test3 == null) {
94 | if (other.test3 != null) return false;
95 | } else if (!test3.equals(other.test3)) return false;
96 | return true;
97 | }
98 | }
99 |
100 | static public class SomeClass {
101 | public String name;
102 | public int intValue;
103 | protected float test1;
104 | Float test2;
105 | private String test3;
106 |
107 | public boolean equals(Object obj) {
108 | if (this == obj) return true;
109 | if (obj == null) return false;
110 | if (getClass() != obj.getClass()) return false;
111 | SomeClass other = (SomeClass) obj;
112 | if (intValue != other.intValue) return false;
113 | if (name == null) {
114 | if (other.name != null) return false;
115 | } else if (!name.equals(other.name)) return false;
116 | if (Float.floatToIntBits(test1) != Float.floatToIntBits(other.test1)) return false;
117 | if (test2 == null) {
118 | if (other.test2 != null) return false;
119 | } else if (!test2.equals(other.test2)) return false;
120 | if (test3 == null) {
121 | if (other.test3 != null) return false;
122 | } else if (!test3.equals(other.test3)) return false;
123 | return true;
124 | }
125 | }
126 |
127 | static public class HasArgumentConstructor {
128 | public String moo;
129 | public int y;
130 |
131 | public HasArgumentConstructor(String moo) {
132 | this.moo = moo;
133 | }
134 |
135 | public HasArgumentConstructor(int x) {
136 | this.y = x;
137 | }
138 |
139 | public boolean equals(Object obj) {
140 | if (this == obj) return true;
141 | if (obj == null) return false;
142 | if (getClass() != obj.getClass()) return false;
143 | HasArgumentConstructor other = (HasArgumentConstructor) obj;
144 | if (moo == null) {
145 | if (other.moo != null) return false;
146 | } else if (!moo.equals(other.moo)) return false;
147 | return true;
148 | }
149 |
150 | public String getMoo() {
151 | return moo;
152 | }
153 | }
154 |
155 | static public class HasPrivateConstructor extends HasArgumentConstructor {
156 | private HasPrivateConstructor() {
157 | super("cow");
158 | }
159 | }
160 |
161 | static public class HasProtectedConstructor extends HasPrivateConstructor {
162 | @SuppressWarnings("synthetic-access")
163 | protected HasProtectedConstructor() {
164 | super();
165 | }
166 | }
167 |
168 | static public class HasPackageProtectedConstructor extends HasProtectedConstructor {
169 | HasPackageProtectedConstructor() {
170 | super();
171 | }
172 | }
173 |
174 | static public class HasPublicConstructor extends HasPackageProtectedConstructor {
175 | HasPublicConstructor() {
176 | super();
177 | }
178 | }
179 | }
180 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/ConvertionTest.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm;
2 |
3 | import junit.framework.TestCase;
4 |
5 | import java.util.Arrays;
6 |
7 | import static com.esotericsoftware.reflectasm.util.NumberUtils.convert;
8 |
9 | /**
10 | * Created by Will on 2017/2/10.
11 | */
12 | public class ConvertionTest extends TestCase {
13 |
14 | public void testConvert() {
15 | assertTrue(Integer.class == convert(1L, int.class).getClass());
16 | assertEquals(Integer[].class, convert(new String[]{"1", "2", "3"}, Integer[].class).getClass());
17 | assertEquals("[1, 2]", Arrays.toString(convert(new Object[]{Double.valueOf(1.6), Float.valueOf(2.3F)}, Integer[].class)));
18 | assertEquals(Character.class, convert(123, char.class).getClass());
19 | int i = 0;
20 | }
21 |
22 | public abstract class Abstract> {
23 | private final Class subClass;
24 |
25 | protected Abstract(Class subClass) {
26 | this.subClass = subClass;
27 | }
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/FieldAccessTest.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (c) 2008, Nathan Sweet
3 | * All rights reserved.
4 | *
5 | * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
6 | *
7 | * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
8 | * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
9 | * 3. Neither the name of Esoteric Software nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
10 | *
11 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
12 | */
13 | package com.esotericsoftware.reflectasm;
14 |
15 | import junit.framework.TestCase;
16 |
17 | public class FieldAccessTest extends TestCase {
18 | public void testNameSetAndGet() {
19 | FieldAccess access = FieldAccess.access(SomeClass.class, ".");
20 | SomeClass test = new SomeClass();
21 |
22 | assertEquals(null, test.name);
23 | access.set(test, "name", "first");
24 | assertEquals("first", test.name);
25 | assertEquals("first", access.get(test, "name"));
26 |
27 | assertEquals(0, test.intValue);
28 | access.set(test, "intValue", 1234);
29 | assertEquals(1234, test.intValue);
30 | assertEquals(1234, (int) access.get(test, "intValue"));
31 | }
32 |
33 | public void testIndexSetAndGet() {
34 | FieldAccess access = FieldAccess.access(SomeClass.class, ".");
35 | SomeClass test = new SomeClass();
36 | int index;
37 |
38 | assertEquals(null, test.name);
39 | index = access.getIndex("name");
40 | access.set(test, index, "first");
41 | assertEquals("first", test.name);
42 | assertEquals("first", access.get(test, index));
43 |
44 | index = access.getIndex("intValue");
45 | assertEquals(0, test.intValue);
46 | access.set(test, index, 1234);
47 | assertEquals(1234, test.intValue);
48 | int value = access.get(test, index);
49 | assertEquals(1234, value);
50 |
51 | assertEquals(false, access.getBoolean(test, access.getIndex("booleanField")));
52 | access.setBoolean(test, access.getIndex("booleanField"), true);
53 | assertEquals(true, access.getBoolean(test, access.getIndex("booleanField")));
54 |
55 | assertEquals(0, access.getByte(test, access.getIndex("byteField")));
56 | access.setByte(test, access.getIndex("byteField"), (byte) 23);
57 | assertEquals(23, access.getByte(test, access.getIndex("byteField")));
58 |
59 | assertEquals(0, access.getChar(test, access.getIndex("charField")));
60 | access.setChar(test, access.getIndex("charField"), (char) 53);
61 | assertEquals(53, access.getChar(test, access.getIndex("charField")));
62 |
63 | assertEquals(0, access.getShort(test, access.getIndex("shortField")));
64 | access.setShort(test, access.getIndex("shortField"), (short) 123);
65 | assertEquals(123, access.getShort(test, access.getIndex("shortField")));
66 |
67 | assertEquals(0, access.getInt(test, access.getIndex("intField")));
68 | access.setInt(test, access.getIndex("intField"), 123);
69 | assertEquals(123, access.getInt(test, access.getIndex("intField")));
70 |
71 | assertEquals(0, access.getLong(test, access.getIndex("longField")));
72 | access.setLong(test, access.getIndex("longField"), 123456789l);
73 | assertEquals(123456789l, access.getLong(test, access.getIndex("longField")));
74 |
75 | assertEquals(0f, access.getFloat(test, access.getIndex("floatField")));
76 | access.setFloat(test, access.getIndex("floatField"), 1.23f);
77 | assertEquals(1.23f, access.getFloat(test, access.getIndex("floatField")));
78 |
79 | assertEquals(0d, access.getDouble(test, access.getIndex("doubleField")));
80 | access.setDouble(test, access.getIndex("doubleField"), 123.456);
81 | assertEquals(123.456, access.getDouble(test, access.getIndex("doubleField")));
82 | }
83 |
84 | public void testEmptyClass() {
85 | FieldAccess access = FieldAccess.access(EmptyClass.class);
86 | try {
87 | access.getIndex("name");
88 | fail();
89 | } catch (IllegalArgumentException expected) {
90 | // expected.printStackTrace();
91 | }
92 | try {
93 | access.get(new EmptyClass(), "meow");
94 | fail();
95 | } catch (IllegalArgumentException expected) {
96 | // expected.printStackTrace();
97 | }
98 | try {
99 | access.get(new EmptyClass(), 0);
100 | fail();
101 | } catch (IllegalArgumentException expected) {
102 | // expected.printStackTrace();
103 | }
104 | try {
105 | access.set(new EmptyClass(), "foo", "moo");
106 | fail();
107 | } catch (IllegalArgumentException expected) {
108 | // expected.printStackTrace();
109 | }
110 | }
111 |
112 | static public class SomeClass {
113 | public String name;
114 | public int intValue;
115 | public boolean booleanField;
116 | public byte byteField;
117 | public char charField;
118 | public short shortField;
119 | public int intField;
120 | public long longField;
121 | public float floatField;
122 | public double doubleField;
123 | protected float test1;
124 | Float test2;
125 | private String test3;
126 | }
127 |
128 | static public class EmptyClass {}
129 | }
130 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/MethodAccessTest.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm;
2 |
3 | import junit.framework.TestCase;
4 |
5 | import java.math.BigDecimal;
6 | import java.util.Arrays;
7 | import java.util.concurrent.ConcurrentHashMap;
8 | import java.util.concurrent.ConcurrentMap;
9 |
10 | public class MethodAccessTest extends TestCase {
11 |
12 | public void testInvoke() {
13 |
14 | MethodAccess access = MethodAccess.access(SomeClass.class, ".");
15 | SomeClass someObject = access.console.newInstance();
16 | Object value;
17 | value = access.invoke(someObject, "test");
18 | value = access.invoke(someObject, "getName");
19 | assertEquals(null, value);
20 | value = access.invoke(someObject, "setName", "sweet");
21 | assertEquals(null, value);
22 | value = access.invoke(someObject, "getName");
23 | assertEquals("sweet", value);
24 | value = access.invoke(someObject, "setName", (Object) null);
25 | assertEquals(null, value);
26 | value = access.invoke(someObject, "getName");
27 | assertEquals(null, value);
28 |
29 | value = access.invoke(someObject, "getIntValue");
30 | assertEquals(0, value);
31 | value = access.invoke(someObject, "setValue", 1234, false);
32 | assertEquals(null, value);
33 | value = access.invoke(someObject, "getIntValue");
34 | assertEquals(1234, value);
35 | value = access.invoke(someObject, "methodWithManyArguments", 6, 2f, null, null);
36 | assertEquals("test0", value);
37 | value = access.invoke(someObject, "methodWithManyArguments", "1", 2f, new int[]{3, 4}, 4.2f, null, true);
38 | assertEquals("0", value);
39 | value = access.invoke(someObject, "methodWithManyArguments", "1", 2f, new int[]{3, 4}, 4.2f, null, true, new int[]{1, 2, 3});
40 | value = access.invoke(someObject, "methodWithManyArguments", "1", 2f, new int[]{3, 4}, 4.2f, null, true, 1, 2, 3);
41 | assertEquals(Arrays.toString(new int[]{1, 2, 3}), value);
42 | value = access.invoke(null, "staticMethod", "moo", 1234);
43 | assertEquals("meow! moo, 1234", value);
44 | //int methodWithVarArgs(char,Double,Long,Integer[])
45 | try {
46 | value = access.invoke(someObject, "methodWithVarArgs", null, 2, 3);
47 | fail();
48 | } catch (IllegalArgumentException e) {}
49 | value = access.invoke(someObject, "methodWithVarArgs", 1, 2, 3);
50 | assertEquals(0, value);
51 | value = access.invoke(someObject, "methodWithVarArgs", 1, 2, 3, null);
52 | assertEquals(1, value);
53 | value = access.invoke(someObject, "methodWithVarArgs", 1, 2, 3, 4, 5, 6, 7);
54 | assertEquals(4, value);
55 | value = access.invoke(someObject, "methodWithVarArgs", 'x', 2, 3, 4);
56 | assertEquals(1, value);
57 | ClassAccess.IS_STRICT_CONVERT = false;
58 | value = access.invoke(someObject, "methodWithVarArgs", "B", null, 3, 4, null);
59 | assertEquals(2, value);
60 | value = access.invoke(someObject, "methodWithVarArgs", new BigDecimal(1), 2, new BigDecimal(20), new Integer[2]);
61 | assertEquals(2, value);
62 | }
63 |
64 | public void testEmptyClass() {
65 | MethodAccess access = MethodAccess.access(EmptyClass.class, ".");
66 | try {
67 | access.getIndex("name");
68 | fail();
69 | } catch (IllegalArgumentException expected) {
70 | // expected.printStackTrace();
71 | }
72 | try {
73 | access.getIndex("name", String.class);
74 | fail();
75 | } catch (IllegalArgumentException expected) {
76 | // expected.printStackTrace();
77 | }
78 | try {
79 | access.invoke(new EmptyClass(), "meow", "moo");
80 | fail();
81 | } catch (IllegalArgumentException expected) {
82 | // expected.printStackTrace();
83 | }
84 | try {
85 | access.invokeWithIndex(new EmptyClass(), 0);
86 | fail();
87 | } catch (IllegalArgumentException expected) {
88 | // expected.printStackTrace();
89 | }
90 | try {
91 | access.invokeWithIndex(new EmptyClass(), 0, "moo");
92 | fail();
93 | } catch (IllegalArgumentException expected) {
94 | // expected.printStackTrace();
95 | }
96 | }
97 |
98 | public void testInvokeInterface() {
99 | MethodAccess access = MethodAccess.access(ConcurrentMap.class, ".");
100 | ConcurrentHashMap someMap = new ConcurrentHashMap();
101 | someMap.put("first", "one");
102 | someMap.put("second", "two");
103 | Object value;
104 |
105 | // invokeWithIndex a method declared directly in the ConcurrentMap interface
106 | value = access.invoke(someMap, "replace", "first", "foo");
107 | assertEquals("one", value);
108 | // invokeWithIndex a method declared in the Map superinterface
109 | value = access.invoke(someMap, "size");
110 | assertEquals(someMap.size(), value);
111 | }
112 |
113 | static public class EmptyClass {}
114 |
115 | static public class baseClass extends EmptyClass {
116 | public void test() {}
117 | }
118 |
119 | static public class SomeClass extends baseClass {
120 | public static boolean x;
121 | static boolean bu;
122 | String name;
123 | private int intValue;
124 |
125 | public SomeClass() {
126 |
127 | }
128 |
129 | public SomeClass(int x, int y) {
130 |
131 | }
132 |
133 | public SomeClass(String x) {
134 |
135 | }
136 |
137 | static public String staticMethod(String a, int b) {
138 | return "meow! " + a + ", " + b;
139 | }
140 |
141 | public String getName() {
142 | return name;
143 | }
144 |
145 | public void setName(String name) {
146 | this.name = name;
147 | }
148 |
149 | public int getIntValue() {
150 | return intValue;
151 | }
152 |
153 | public void setValue(int intValue, Boolean bu) {
154 | this.intValue = intValue;
155 | this.bu = bu;
156 | }
157 |
158 | public String methodWithManyArguments(int i, float f, Integer[] I, int c1) {
159 | return "test0";
160 | }
161 |
162 | public String methodWithManyArguments(int i, float f, Integer[] I, SomeClass[] c1) {
163 | return "test0";
164 | }
165 |
166 | public String methodWithManyArguments(int i, float f, Integer[] I, Float F, SomeClass[] c1, Boolean x, int... y) {
167 | if (y.length == 0) return "0";
168 | return Arrays.toString(y);
169 | }
170 |
171 | public int methodWithVarArgs(char a, Double b, Long c, Integer... d) {
172 | return d == null ? 0 : d.length;
173 | }
174 | }
175 | }
176 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/benchmark/Benchmark.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm.benchmark;
2 |
3 | import java.util.ArrayList;
4 | import java.util.Comparator;
5 | import java.util.Map;
6 | import java.util.Map.Entry;
7 | import java.util.TreeMap;
8 |
9 | public class Benchmark {
10 | static int testRounds = 300000;
11 | static int testCount = (System.getProperty("java.vm.name").indexOf("Server VM") > -1) ? 300 : 100;
12 | public boolean warmup = true;
13 | public Map testTimes = new TreeMap<>();
14 | private long s;
15 |
16 | public void start() {
17 | if (warmup) return;
18 | s = System.nanoTime();
19 | }
20 |
21 | public void end(String name) {
22 | if (warmup) return;
23 | long e = System.nanoTime();
24 | long time = e - s;
25 | /*
26 | if(System.getProperty("java.vm.name").indexOf("Server VM")>-1) name="ServerVM["+name+"]";
27 | else name="ClientVM["+name+"]";
28 | */
29 | Long oldTime = testTimes.get(name);
30 | if (oldTime == null || time < oldTime) testTimes.put(name, time);
31 | System.out.println(name + ": " + time / 1000000f + " ms");
32 | }
33 |
34 | public String[] chart(String title) {
35 | Comparator comparator = new Comparator() {
36 | public int compare(Entry o1, Entry o2) {
37 | // return ((String)o1.getKey()).compareTo((String)o2.getKey());
38 | return (int) ((Long) o1.getValue() - (Long) o2.getValue());
39 | }
40 | };
41 | ArrayList list = new ArrayList(testTimes.entrySet());
42 | //Collections.sort(list, comparator);
43 |
44 | StringBuilder names = new StringBuilder(512);
45 | StringBuilder times = new StringBuilder(512);
46 | long max = 0;
47 | int count = 0;
48 |
49 | for (Entry entry : list) {
50 | String name = entry.getKey();
51 | names.insert(0, '|');
52 | names.insert(0, name);
53 | long time = entry.getValue();
54 | times.append(time);
55 | times.append(',');
56 | max = Math.max(max, time);
57 | count++;
58 | }
59 | times.setLength(times.length() - 1);
60 | names.setLength(names.length() - 1);
61 | int height = count * 18 + 21;
62 | int width = Math.min(700, 300000 / height);
63 | System.out.println("![](http://chart.apis.google.com/chart?chtt=" + title + "&" + "chs=" + width + "x" + height + "&chd=t:" + times + "&chds=0," + max + "&chxl=0:|" + names + "&cht=bhg&chbh=10&chxt=y&" + "chco=660000|660033|660066|660099|6600CC|6600FF|663300|663333|" + "663366|663399|6633CC|6633FF|666600|666633|666666)\n");
64 | return new String[]{times.toString(), String.valueOf(max), names.toString()};
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/benchmark/ClassAccessBenchmark.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm.benchmark;
2 |
3 | import com.esotericsoftware.reflectasm.Accessor;
4 | import com.esotericsoftware.reflectasm.ClassAccess;
5 | import test.TestObject;
6 |
7 | import java.lang.reflect.Constructor;
8 | import java.lang.reflect.Field;
9 | import java.lang.reflect.Method;
10 | import java.util.Arrays;
11 | import java.util.HashMap;
12 |
13 | /**
14 | * Created by hyee on 2017/2/4.
15 | */
16 | public class ClassAccessBenchmark {
17 | public static String[] doBenchmark() throws Exception {
18 | final int count = Benchmark.testRounds;
19 | final int rounds = Benchmark.testCount;
20 | final String fieldName = "fi";
21 | final String methodName = "func2";
22 | final Benchmark benchmark = new Benchmark();
23 |
24 | TestObject obj = null;
25 |
26 | final Class[] args = new Class[]{int.class, Double.class, String.class, long.class};
27 |
28 | //access info from ClassAccessor;
29 | final ClassAccess console = ClassAccess.access(TestObject.class, ".");
30 | final Accessor asm = console.accessor;
31 | final int fieldIndex = console.indexOfField(fieldName);
32 | final int methodIndex = console.indexOfMethod(methodName, args);
33 | final int constructorIndex = console.indexOfConstructor(args);
34 |
35 | final Field field = TestObject.class.getField(fieldName);
36 | final Method method = TestObject.class.getDeclaredMethod(methodName, args);
37 | final Constructor constructor = TestObject.class.getConstructor(args);
38 |
39 | for (int c1 = 1; c1 <= 9; c1++) {
40 | for (int c = 0; c <= 1; c++) {
41 | benchmark.warmup = c == 0 ? true : false;
42 | String tag = (c1 <= 3 ? "Construction - " : c1 <= 6 ? "Field Set+Get - " : "Method Call - ") + (c1 % 3 == 1 ? "ReflectASM" : c1 % 3 == 2 ? "Reflection" : "Direct");
43 | benchmark.start();
44 | for (int i = 0; i < rounds; i++) {
45 | for (int ii = 0; ii < count; ii++) {
46 | int val = i + ii;
47 | switch (c1) {
48 | //Compare Constructions
49 | //=====================
50 | case 1:
51 | obj = asm.newInstanceWithIndex(constructorIndex, val, ((Number) val).doubleValue(), String.valueOf(val), ((Number) val).longValue());
52 | break;
53 | case 2:
54 | obj = (TestObject) constructor.newInstance(val, ((Number) val).doubleValue(), String.valueOf(val), ((Number) val).longValue());
55 | break;
56 | case 3:
57 | obj = new TestObject(val, ((Number) val).doubleValue(), String.valueOf(val), ((Number) val).longValue());
58 | break;
59 | //Compare Field Set+Get
60 | //=====================
61 | case 4:
62 | asm.set(obj, fieldIndex, val);
63 | val = asm.get(obj, fieldIndex);
64 | break;
65 | case 5:
66 | field.set(obj, val);
67 | val = (int) field.get(obj);
68 | break;
69 | case 6:
70 | obj.fi = val;
71 | val = obj.fi;
72 | break;
73 | //Compare Method Call
74 | //=====================
75 | case 7:
76 | asm.invokeWithIndex(obj, methodIndex, val, ((Number) val).doubleValue(), String.valueOf(val), ((Number) val).longValue());
77 | break;
78 | case 8:
79 | method.invoke(obj, val, ((Number) val).doubleValue(), String.valueOf(val), ((Number) val).longValue());
80 | break;
81 | case 9:
82 | obj.func2(val, ((Number) val).doubleValue(), String.valueOf(val), ((Number) val).longValue());
83 | break;
84 | }
85 | }
86 | }
87 | benchmark.end(tag);
88 | }
89 | }
90 |
91 | return benchmark.chart("Benchmark Summary");
92 | }
93 |
94 | public static String join(String sep, String[] s0) {
95 | String r = "";
96 | for (int i = 0; i < s0.length; i++) r += s0[i] + (i == s0.length - 1 ? "" : sep);
97 | return r;
98 | }
99 |
100 | public static void print(String[][] results) {
101 | long max = 0;
102 | String[] times = new String[results.length];
103 | String[] names = new String[results.length];
104 | int index = -1;
105 | String title = ((System.getProperty("java.vm.name").indexOf("Server VM") > -1) ? "Server" : "Client") + " VM";
106 | HashMap map = new HashMap();
107 | double count = Benchmark.testRounds * Benchmark.testCount;
108 | System.out.println(count);
109 | for (String[] result : results) {
110 | max = Math.max(max, Long.valueOf(result[1]));
111 | times[++index] = result[0];
112 | names[results.length - 1 - index] = result[2];
113 | String[] times0 = result[0].split(",");
114 | String[] names0 = result[2].split("\\|");
115 | String[] names1 = new String[names0.length];
116 | String[] times1 = new String[names0.length];
117 | String tag = null;
118 | int tagIdx = 0;
119 | for (int i = 0; i < names0.length; i++) {
120 | if (tag == null) {
121 | tagIdx = names0[i].indexOf('-');
122 | tag = names0[i].substring(0, tagIdx - 1).trim();
123 | }
124 | String name = names0[i].substring(tagIdx + 1).trim();
125 | names1[names0.length - 1 - i] = name;
126 | if (!map.containsKey(name)) {
127 | map.put(name, i);
128 | }
129 | times1[map.get(name)] = String.format("%.2f ns", Long.valueOf(times0[i]) / count);
130 | }
131 |
132 | if (index == 0) {
133 | System.out.println("| VM | Item | " + join(" | ", names1) + " |");
134 | Arrays.fill(names1, " --------- ");
135 | System.out.println("| --- | --- | " + join(" | ", names1) + " |");
136 | }
137 | System.out.println("| " + title + " | " + tag + " | " + join(" | ", times1) + " |");
138 | }
139 | int height = 12 * 18 + 21;
140 | int width = Math.min(700, 300000 / height);
141 | System.out.println("Active ClassLoaders: " + ClassAccess.activeAccessClassLoaders());
142 | title = "Java " + System.getProperty("java.version") + " " + System.getProperty("os.arch") + "(" + title + ")";
143 | System.out.println("![](http://chart.apis.google.com/chart?chtt=&" + title + "&chs=" + width + "x" + height + "&chd=t:" + join(",", times) + "&chds=0," + max + "&chxl=0:|" + join("|", names) + "&cht=bhg&chbh=10&chxt=y&" + "chco=660000|660033|660066|660099|6600CC|6600FF|663300|663333|" + "663366|663399|6633CC|6633FF|666600|666633|666666)\n");
144 | }
145 |
146 | public static void main(String[] args) throws Throwable {
147 | //ClassAccess.IS_CACHED = true;
148 | ClassAccess.IS_STRICT_CONVERT = true;
149 | new FieldAccessBenchmark();
150 | new MethodAccessBenchmark();
151 | new ConstructorAccessBenchmark();
152 | String[][] results = new String[][]{FieldAccessBenchmark.result, MethodAccessBenchmark.result, ConstructorAccessBenchmark.result};
153 | print(results);
154 | doBenchmark();
155 | }
156 | }
157 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/benchmark/ConstructorAccessBenchmark.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm.benchmark;
2 |
3 | import com.esotericsoftware.reflectasm.ClassAccess;
4 | import com.esotericsoftware.reflectasm.ConstructorAccess;
5 |
6 | import java.lang.invoke.MethodHandle;
7 |
8 | public class ConstructorAccessBenchmark extends Benchmark {
9 | public static String[] result;
10 |
11 | public ConstructorAccessBenchmark() throws Throwable {
12 | final int count = Benchmark.testRounds;
13 | final int rounds = Benchmark.testCount;
14 | Object[] dontCompileMeAway = new Object[count];
15 |
16 | Class type = SomeClass.class;
17 | ConstructorAccess access = ConstructorAccess.access(type);
18 | MethodHandle handle = access.console.getHandle(null, null, ClassAccess.NEW);
19 |
20 | for (int i = 0; i < rounds / 3; i++)
21 | for (int ii = 0; ii < count; ii++) {
22 | dontCompileMeAway[ii] = access.console.accessor.newInstance();
23 | dontCompileMeAway[ii] = type.newInstance();
24 | dontCompileMeAway[ii] = (SomeClass) handle.invokeExact();
25 | }
26 |
27 | for (int i = 0; i < rounds; i++)
28 | for (int ii = 0; ii < count; ii++)
29 |
30 | warmup = false;
31 | start();
32 | for (int i = 0; i < rounds; i++) {
33 | for (int ii = 0; ii < count; ii++)
34 | dontCompileMeAway[ii] = access.newInstance();
35 | }
36 | end("Constructor - ReflectASM");
37 | start();
38 | for (int i = 0; i < rounds; i++) {
39 | for (int ii = 0; ii < count; ii++)
40 | dontCompileMeAway[ii] = (SomeClass) handle.invokeExact();
41 | }
42 | end("Constructor - DirectMethodHandle");
43 | start();
44 | for (int i = 0; i < rounds; i++) {
45 | for (int ii = 0; ii < count; ii++)
46 | dontCompileMeAway[ii] = type.newInstance();
47 | }
48 | end("Constructor - Reflection");
49 | start();
50 | for (int i = 0; i < rounds; i++) {
51 | for (int ii = 0; ii < count; ii++)
52 | dontCompileMeAway[ii] = new SomeClass();
53 | }
54 | end("Constructor - Direct");
55 | result = chart("Constructor");
56 | }
57 |
58 | public static void main(String[] args) throws Throwable {
59 | new ConstructorAccessBenchmark();
60 | }
61 |
62 | static public class SomeClass {
63 | public String name;
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/benchmark/FieldAccessBenchmark.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm.benchmark;
2 |
3 | import com.esotericsoftware.reflectasm.ClassAccess;
4 | import com.esotericsoftware.reflectasm.FieldAccess;
5 |
6 | import java.lang.invoke.MethodHandle;
7 | import java.lang.reflect.Field;
8 |
9 | public class FieldAccessBenchmark extends Benchmark {
10 | public static String[] result;
11 |
12 | public FieldAccessBenchmark() throws Throwable {
13 | final int count = Benchmark.testRounds;
14 | final int rounds = Benchmark.testCount;
15 | String[] dontCompileMeAway = new String[count];
16 |
17 | FieldAccess access = FieldAccess.access(SomeClass.class);
18 | SomeClass someObject = new SomeClass();
19 | int index = access.getIndex("name");
20 | MethodHandle getter = access.console.getHandleWithIndex(index, ClassAccess.GETTER);
21 | MethodHandle setter = access.console.getHandleWithIndex(index, ClassAccess.SETTER);
22 |
23 | Field field = SomeClass.class.getField("name");
24 |
25 | for (int i = 0; i < rounds / 3; i++) {
26 | for (int ii = 0; ii < count; ii++) {
27 | access.console.accessor.set(someObject, index, "first");
28 | dontCompileMeAway[ii] = access.console.accessor.get(someObject, index);
29 | field.set(someObject, "first");
30 | dontCompileMeAway[ii] = (String) field.get(someObject);
31 | setter.invokeExact(someObject, "first");
32 | dontCompileMeAway[ii] = (String) getter.invokeExact(someObject);
33 | }
34 | }
35 | warmup = false;
36 | start();
37 | for (int i = 0; i < rounds; i++) {
38 | for (int ii = 0; ii < count; ii++) {
39 | access.console.accessor.set(someObject, index, "first");
40 | dontCompileMeAway[ii] = access.console.accessor.get(someObject, index);
41 | }
42 | }
43 | end("Field Set+Get - ReflectASM");
44 | start();
45 | for (int i = 0; i < rounds; i++) {
46 | for (int ii = 0; ii < count; ii++) {
47 | setter.invokeExact(someObject, "first");
48 | dontCompileMeAway[ii] = (String) getter.invokeExact(someObject);
49 | }
50 | }
51 | end("Field Set+Get - DirectMethodHandle");
52 | start();
53 | for (int i = 0; i < rounds; i++) {
54 | for (int ii = 0; ii < count; ii++) {
55 | field.set(someObject, "first");
56 | dontCompileMeAway[ii] = (String) field.get(someObject);
57 | }
58 | }
59 | end("Field Set+Get - Reflection");
60 | start();
61 | for (int i = 0; i < rounds; i++) {
62 | for (int ii = 0; ii < count; ii++) {
63 | someObject.name = "first";
64 | dontCompileMeAway[ii] = someObject.name;
65 | }
66 | }
67 | end("Field Set+Get - Direct");
68 | result = chart("Field Set/Get");
69 | }
70 |
71 | public static void main(String[] args) throws Throwable {
72 | new FieldAccessBenchmark();
73 | }
74 |
75 | static public class SomeClass {
76 | public String name;
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/benchmark/MethodAccessBenchmark.java:
--------------------------------------------------------------------------------
1 | package com.esotericsoftware.reflectasm.benchmark;
2 |
3 | import com.esotericsoftware.reflectasm.ClassAccess;
4 |
5 | import java.lang.invoke.MethodHandle;
6 | import java.lang.reflect.Method;
7 |
8 | public class MethodAccessBenchmark extends Benchmark {
9 | public static String[] result;
10 |
11 | public MethodAccessBenchmark() throws Throwable {
12 | //ClassAccess.IS_STRICT_CONVERT=true;
13 | final int count = Benchmark.testRounds;
14 | final int rounds = Benchmark.testCount;
15 | Object[] dontCompileMeAway = new Object[count];
16 | Object[] args = new Object[0];
17 |
18 | ClassAccess access = ClassAccess.access(SomeClass.class);
19 | SomeClass someObject = new SomeClass();
20 | int index = access.indexOfMethod("getName");
21 | MethodHandle handle = access.getHandleWithIndex(index, ClassAccess.METHOD);
22 |
23 | Method method = SomeClass.class.getMethod("getName");
24 | // method.setAccessible(true); // Improves reflection a bit.
25 |
26 | for (int i = 0; i < rounds / 3; i++) {
27 | for (int ii = 0; ii < count; ii++) {
28 | dontCompileMeAway[ii] = access.accessor.invokeWithIndex(someObject, index, args);
29 | dontCompileMeAway[ii] = method.invoke(someObject, args);
30 | dontCompileMeAway[ii] = (String) handle.invokeExact(someObject);
31 | }
32 | }
33 | warmup = false;
34 | start();
35 | for (int i = 0; i < rounds; i++) {
36 | for (int ii = 0; ii < count; ii++)
37 | dontCompileMeAway[ii] = access.accessor.invokeWithIndex(someObject, index, args);
38 | }
39 | end("Method Call - ReflectASM");
40 | start();
41 | for (int i = 0; i < rounds; i++) {
42 | for (int ii = 0; ii < count; ii++)
43 | dontCompileMeAway[ii] = (String) handle.invokeExact(someObject);
44 | }
45 | end("Method Call - DirectMethodHandle");
46 | start();
47 | for (int i = 0; i < rounds; i++) {
48 | for (int ii = 0; ii < count; ii++)
49 | dontCompileMeAway[ii] = method.invoke(someObject, args);
50 | }
51 | end("Method Call - Reflection");
52 | start();
53 | for (int i = 0; i < rounds; i++) {
54 | for (int ii = 0; ii < count; ii++)
55 | dontCompileMeAway[ii] = someObject.getName();
56 | }
57 | end("Method Call - Direct");
58 | result = chart("Method Call");
59 | }
60 |
61 | public static void main(String[] args) throws Throwable {
62 | new MethodAccessBenchmark();
63 | }
64 |
65 | static public class SomeClass {
66 | private String name = "something";
67 |
68 | public String getName() {
69 | return name;
70 | }
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/test/com/esotericsoftware/reflectasm/test.java:
--------------------------------------------------------------------------------
1 | //
2 | // Source code recreated from a .class file by IntelliJ IDEA
3 | // (powered by Fernflower decompiler)
4 | //
5 |
6 | package com.esotericsoftware.reflectasm;
7 |
8 | import com.esotericsoftware.reflectasm.MethodAccessTest.SomeClass;
9 | import com.esotericsoftware.reflectasm.MethodAccessTest.baseClass;
10 |
11 | import java.lang.invoke.MethodHandle;
12 |
13 | public final class test implements Accessor {
14 | static MethodHandle[][] methodHandles = new MethodHandle[3][10];
15 | static final ClassInfo classInfo = new ClassInfo();
16 |
17 | public test() {
18 | }
19 |
20 | public MethodHandle[][] getMethodHandles() {
21 | return methodHandles;
22 | }
23 |
24 | public ClassInfo getInfo() {
25 | return classInfo;
26 | }
27 |
28 | static {
29 | classInfo.baseClass = SomeClass.class;
30 | classInfo.isNonStaticMemberClass = false;
31 | classInfo.bucket = 7;
32 | methodNames();
33 | methodParamTypes();
34 | returnTypes();
35 | methodModifiers();
36 | methodDescs();
37 | fieldNames();
38 | fieldTypes();
39 | fieldModifiers();
40 | fieldDescs();
41 | constructorParamTypes();
42 | constructorModifiers();
43 | constructorDescs();
44 | ClassAccess.buildIndex(classInfo);
45 | }
46 |
47 | static void methodNames() {
48 | classInfo.methodNames = new String[]{"getName", "setName", "setValue", "methodWithManyArguments", "methodWithManyArguments", "methodWithManyArguments", "methodWithVarArgs", "getIntValue", "staticMethod", "test"};
49 | }
50 |
51 | static void methodParamTypes() {
52 | classInfo.methodParamTypes = new Class[][]{new Class[0], {String.class}, {Integer.TYPE, Boolean.class}, {Integer.TYPE, Float.TYPE, Integer[].class, Integer.TYPE}, {Integer.TYPE, Float.TYPE, Integer[].class, SomeClass[].class}, {Integer.TYPE, Float.TYPE, Integer[].class, Float.class, SomeClass[].class, Boolean.class, int[].class}, {Character.TYPE, Double.class, Long.class, Integer[].class}, new Class[0], {String.class, Integer.TYPE}, new Class[0]};
53 | }
54 |
55 | static void returnTypes() {
56 | classInfo.returnTypes = new Class[]{String.class, Void.TYPE, Void.TYPE, String.class, String.class, String.class, Integer.TYPE, Integer.TYPE, String.class, Void.TYPE, null, null, null, null, null, null, null, null, null, baseClass.class};
57 | }
58 |
59 | static void methodModifiers() {
60 | classInfo.methodModifiers = new Integer[]{Integer.valueOf(1), Integer.valueOf(1), Integer.valueOf(1), Integer.valueOf(1), Integer.valueOf(1), Integer.valueOf(262273), Integer.valueOf(262273), Integer.valueOf(1), Integer.valueOf(9), Integer.valueOf(1)};
61 | }
62 |
63 | static void methodDescs() {
64 | classInfo.methodDescs = new String[][]{{"getName", "()Ljava/lang/String;"}, {"setName", "(Ljava/lang/String;)V"}, {"setValue", "(ILjava/lang/Boolean;)V"}, {"methodWithManyArguments", "(IF[Ljava/lang/Integer;I)Ljava/lang/String;"}, {"methodWithManyArguments", "(IF[Ljava/lang/Integer;[Lcom/esotericsoftware/reflectasm/MethodAccessTest$SomeClass;)Ljava/lang/String;"}, {"methodWithManyArguments", "(IF[Ljava/lang/Integer;Ljava/lang/Float;[Lcom/esotericsoftware/reflectasm/MethodAccessTest$SomeClass;Ljava/lang/Boolean;[I)Ljava/lang/String;"}, {"methodWithVarArgs", "(CLjava/lang/Double;Ljava/lang/Long;[Ljava/lang/Integer;)I"}, {"getIntValue", "()I"}, {"staticMethod", "(Ljava/lang/String;I)Ljava/lang/String;"}, {"test", "()V"}};
65 | }
66 |
67 | static void fieldNames() {
68 | classInfo.fieldNames = new String[]{"x", "bu", "name", "intValue"};
69 | }
70 |
71 | static void fieldTypes() {
72 | classInfo.fieldTypes = new Class[]{Boolean.TYPE, Boolean.TYPE, String.class, Integer.TYPE, null, null, null, null};
73 | }
74 |
75 | static void fieldModifiers() {
76 | classInfo.fieldModifiers = new Integer[]{Integer.valueOf(9), Integer.valueOf(8), Integer.valueOf(0), Integer.valueOf(2)};
77 | }
78 |
79 | static void fieldDescs() {
80 | classInfo.fieldDescs = new String[][]{{"x", "Z"}, {"bu", "Z"}, {"name", "Ljava/lang/String;"}, {"intValue", "I"}};
81 | }
82 |
83 | static void constructorParamTypes() {
84 | classInfo.constructorParamTypes = new Class[][]{{String.class}, {Integer.TYPE, Integer.TYPE}, new Class[0]};
85 | }
86 |
87 | static void constructorModifiers() {
88 | classInfo.constructorModifiers = new Integer[]{Integer.valueOf(1), Integer.valueOf(1), Integer.valueOf(1)};
89 | }
90 |
91 | static void constructorDescs() {
92 | classInfo.constructorDescs = new String[]{"(Ljava/lang/String;)V", "(II)V", "()V"};
93 | }
94 |
95 | public final T invokeWithIndex(SomeClass var1, int var2, V... var3) {
96 | switch (var2) {
97 | case 0:
98 | return (T) var1.getName();
99 | case 1:
100 | var1.setName((String) var3[0]);
101 | return null;
102 | case 2:
103 | var1.setValue(((Integer) var3[0]).intValue(), (Boolean) var3[1]);
104 | return null;
105 | case 3:
106 | return (T) var1.methodWithManyArguments(((Integer) var3[0]).intValue(), ((Float) var3[1]).floatValue(), (Integer[]) var3[2], ((Integer) var3[3]).intValue());
107 | case 4:
108 | return (T) var1.methodWithManyArguments(((Integer) var3[0]).intValue(), ((Float) var3[1]).floatValue(), (Integer[]) var3[2], (SomeClass[]) var3[3]);
109 | case 5:
110 | return (T) var1.methodWithManyArguments(((Integer) var3[0]).intValue(), ((Float) var3[1]).floatValue(), (Integer[]) var3[2], (Float) var3[3], (SomeClass[]) var3[4], (Boolean) var3[5], (int[]) var3[6]);
111 | case 6:
112 | return (T) Integer.valueOf(var1.methodWithVarArgs(((Character) var3[0]).charValue(), (Double) var3[1], (Long) var3[2], (Integer[]) var3[3]));
113 | case 7:
114 | return (T) Integer.valueOf(var1.getIntValue());
115 | case 8:
116 | return (T) SomeClass.staticMethod((String) var3[0], ((Integer) var3[1]).intValue());
117 | case 9:
118 | var1.test();
119 | return null;
120 | default:
121 | throw new IllegalArgumentException("Method not found: " + var2);
122 | }
123 | }
124 |
125 | public final T get(SomeClass var1, int var2) {
126 | switch (var2) {
127 | case 0:
128 | return (T) Boolean.valueOf(SomeClass.x);
129 | case 1:
130 | return (T) Boolean.valueOf(SomeClass.bu);
131 | case 2:
132 | return (T) var1.name;
133 | default:
134 | throw new IllegalArgumentException("Field not found: " + var2);
135 | }
136 | }
137 |
138 | public final void set(SomeClass var1, int var2, V var3) {
139 | switch (var2) {
140 | case 0:
141 | SomeClass.x = ((Boolean) var3).booleanValue();
142 | return;
143 | case 1:
144 | SomeClass.bu = ((Boolean) var3).booleanValue();
145 | return;
146 | case 2:
147 | var1.name = (String) var3;
148 | return;
149 | default:
150 | throw new IllegalArgumentException("Field not found: " + var2);
151 | }
152 | }
153 |
154 | public final SomeClass newInstanceWithIndex(int var1, T... var2) {
155 | switch (var1) {
156 | case 0:
157 | return new SomeClass((String) var2[0]);
158 | case 1:
159 | return new SomeClass(((Integer) var2[0]).intValue(), ((Integer) var2[1]).intValue());
160 | case 2:
161 | return new SomeClass();
162 | default:
163 | throw new IllegalArgumentException("Constructor not found: " + var1);
164 | }
165 | }
166 |
167 | public final SomeClass newInstance() {
168 | return new SomeClass();
169 | }
170 | }
171 |
--------------------------------------------------------------------------------
/test/test/Many.java:
--------------------------------------------------------------------------------
1 | package test;
2 |
3 | /**
4 | * Created by Will on 2017/2/7.
5 | */
6 | public class Many {
7 | int x0;
8 | int x1;
9 | int x2;
10 | int x3;
11 | int x4;
12 | int x5;
13 | int x6;
14 | int x7;
15 | int x8;
16 | int x9;
17 | int x10;
18 | int x11;
19 | int x12;
20 | int x13;
21 | int x14;
22 | int x15;
23 | int x16;
24 | int x17;
25 | int x18;
26 | int x19;
27 | int x20;
28 | int x21;
29 | int x22;
30 | int x23;
31 | int x24;
32 | int x25;
33 | int x26;
34 | int x27;
35 | int x28;
36 | int x29;
37 | int x30;
38 | int x31;
39 | int x32;
40 | int x33;
41 | int x34;
42 | int x35;
43 | int x36;
44 | int x37;
45 | int x38;
46 | int x39;
47 | int x40;
48 | int x41;
49 | int x42;
50 | int x43;
51 | int x44;
52 | int x45;
53 | int x46;
54 | int x47;
55 | int x48;
56 | int x49;
57 | int x50;
58 | int x51;
59 | int x52;
60 | int x53;
61 | int x54;
62 | int x55;
63 | int x56;
64 | int x57;
65 | int x58;
66 | int x59;
67 | int x60;
68 | int x61;
69 | int x62;
70 | int x63;
71 | int x64;
72 | int x65;
73 | int x66;
74 | int x67;
75 | int x68;
76 | int x69;
77 | int x70;
78 | int x71;
79 | int x72;
80 | int x73;
81 | int x74;
82 | int x75;
83 | int x76;
84 | int x77;
85 | int x78;
86 | int x79;
87 | int x80;
88 | int x81;
89 | int x82;
90 | int x83;
91 | int x84;
92 | int x85;
93 | int x86;
94 | int x87;
95 | int x88;
96 | int x89;
97 | int x90;
98 | int x91;
99 | int x92;
100 | int x93;
101 | int x94;
102 | int x95;
103 | int x96;
104 | int x97;
105 | int x98;
106 | int x99;
107 | int x100;
108 | int x101;
109 | int x102;
110 | int x103;
111 | int x104;
112 | int x105;
113 | int x106;
114 | int x107;
115 | int x108;
116 | int x109;
117 | int x110;
118 | int x111;
119 | int x112;
120 | int x113;
121 | int x114;
122 | int x115;
123 | int x116;
124 | int x117;
125 | int x118;
126 | int x119;
127 | int x120;
128 | int x121;
129 | int x122;
130 | int x123;
131 | int x124;
132 | int x125;
133 | int x126;
134 | int x127;
135 | int x128;
136 | int x129;
137 | int x130;
138 | int x131;
139 | int x132;
140 | int x133;
141 | int x134;
142 | int x135;
143 | int x136;
144 | int x137;
145 | int x138;
146 | int x139;
147 | int x140;
148 | int x141;
149 | int x142;
150 | int x143;
151 | int x144;
152 | int x145;
153 | int x146;
154 | int x147;
155 | int x148;
156 | int x149;
157 | int x150;
158 | int x151;
159 | int x152;
160 | int x153;
161 | int x154;
162 | int x155;
163 | int x156;
164 | int x157;
165 | int x158;
166 | int x159;
167 | int x160;
168 | int x161;
169 | int x162;
170 | int x163;
171 | int x164;
172 | int x165;
173 | int x166;
174 | int x167;
175 | int x168;
176 | int x169;
177 | int x170;
178 | int x171;
179 | int x172;
180 | int x173;
181 | int x174;
182 | int x175;
183 | int x176;
184 | int x177;
185 | int x178;
186 | int x179;
187 | int x180;
188 | int x181;
189 | int x182;
190 | int x183;
191 | int x184;
192 | int x185;
193 | int x186;
194 | int x187;
195 | int x188;
196 | int x189;
197 | int x190;
198 | int x191;
199 | int x192;
200 | int x193;
201 | int x194;
202 | int x195;
203 | int x196;
204 | int x197;
205 | int x198;
206 | int x199;
207 | int x200;
208 | int x201;
209 | int x202;
210 | int x203;
211 | int x204;
212 | int x205;
213 | int x206;
214 | int x207;
215 | int x208;
216 | int x209;
217 | int x210;
218 | int x211;
219 | int x212;
220 | int x213;
221 | int x214;
222 | int x215;
223 | int x216;
224 | int x217;
225 | int x218;
226 | int x219;
227 | int x220;
228 | int x221;
229 | int x222;
230 | int x223;
231 | int x224;
232 | int x225;
233 | int x226;
234 | int x227;
235 | int x228;
236 | int x229;
237 | int x230;
238 | int x231;
239 | int x232;
240 | int x233;
241 | int x234;
242 | int x235;
243 | int x236;
244 | int x237;
245 | int x238;
246 | int x239;
247 | int x240;
248 | int x241;
249 | int x242;
250 | int x243;
251 | int x244;
252 | int x245;
253 | int x246;
254 | int x247;
255 | int x248;
256 | int x249;
257 | int x250;
258 | int x251;
259 | int x252;
260 | int x253;
261 | int x254;
262 | int x255;
263 | int x256;
264 | int x257;
265 | int x258;
266 | int x259;
267 | int x260;
268 | int x261;
269 | int x262;
270 | int x263;
271 | int x264;
272 | int x265;
273 | int x266;
274 | int x267;
275 | int x268;
276 | int x269;
277 | int x270;
278 | int x271;
279 | int x272;
280 | int x273;
281 | int x274;
282 | int x275;
283 | int x276;
284 | int x277;
285 | int x278;
286 | int x279;
287 | int x280;
288 | int x281;
289 | int x282;
290 | int x283;
291 | int x284;
292 | int x285;
293 | int x286;
294 | int x287;
295 | int x288;
296 | int x289;
297 | int x290;
298 | int x291;
299 | int x292;
300 | int x293;
301 | int x294;
302 | int x295;
303 | int x296;
304 | int x297;
305 | int x298;
306 | int x299;
307 |
308 | public static void main(String[] args) {
309 | for (int i = 0; i < 300; i++) {
310 | System.out.println("int x" + i + ";");
311 | }
312 | }
313 | }
314 |
--------------------------------------------------------------------------------
/test/test/TestObject.java:
--------------------------------------------------------------------------------
1 | package test;
2 |
3 | /**
4 | * Created by Will on 2017/2/7.
5 | */
6 | public class TestObject {
7 | static String fs;
8 | public Double fd;
9 | public int fi;
10 | private long fl;
11 |
12 | public TestObject() {
13 | fs = "TestObject0";
14 | }
15 |
16 | public TestObject(int fi1, Double fd1, String fs1, long l) {}
17 |
18 | static String func1(String str) {
19 | fs = str;
20 | return str;
21 | }
22 |
23 | public String func2(int fi1, Double fd1, String fs1, long l) {
24 | return fs;
25 | }
26 | }
27 |
--------------------------------------------------------------------------------