Main.java revision 741b5b7ef4c7fd4a786364bbf60d515489caff47
1/* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17import java.lang.reflect.*; 18import java.io.IOException; 19import java.util.Collections; 20import java.util.ArrayList; 21import java.util.List; 22import java.util.Map; 23 24/** 25 * Reflection test. 26 */ 27public class Main { 28 private static boolean FULL_ACCESS_CHECKS = false; // b/5861201 29 public Main() {} 30 public Main(ArrayList<Integer> stuff) {} 31 32 void printMethodInfo(Method meth) { 33 Class[] params, exceptions; 34 int i; 35 36 System.out.println("Method name is " + meth.getName()); 37 System.out.println(" Declaring class is " 38 + meth.getDeclaringClass().getName()); 39 params = meth.getParameterTypes(); 40 for (i = 0; i < params.length; i++) 41 System.out.println(" Arg " + i + ": " + params[i].getName()); 42 exceptions = meth.getExceptionTypes(); 43 for (i = 0; i < exceptions.length; i++) 44 System.out.println(" Exc " + i + ": " + exceptions[i].getName()); 45 System.out.println(" Return type is " + meth.getReturnType().getName()); 46 System.out.println(" Access flags are 0x" 47 + Integer.toHexString(meth.getModifiers())); 48 //System.out.println(" GenericStr is " + meth.toGenericString()); 49 } 50 51 void printFieldInfo(Field field) { 52 System.out.println("Field name is " + field.getName()); 53 System.out.println(" Declaring class is " 54 + field.getDeclaringClass().getName()); 55 System.out.println(" Field type is " + field.getType().getName()); 56 System.out.println(" Access flags are 0x" 57 + Integer.toHexString(field.getModifiers())); 58 } 59 60 private void showStrings(Target instance) 61 throws NoSuchFieldException, IllegalAccessException { 62 63 Class target = Target.class; 64 String one, two, three, four; 65 Field field = null; 66 67 field = target.getField("string1"); 68 one = (String) field.get(instance); 69 70 field = target.getField("string2"); 71 two = (String) field.get(instance); 72 73 field = target.getField("string3"); 74 three = (String) field.get(instance); 75 76 System.out.println(" ::: " + one + ":" + two + ":" + three); 77 } 78 79 public static void checkAccess() { 80 try { 81 Class target = otherpackage.Other.class; 82 Object instance = new otherpackage.Other(); 83 Method meth; 84 85 meth = target.getMethod("publicMethod", (Class[]) null); 86 meth.invoke(instance); 87 88 try { 89 meth = target.getMethod("packageMethod", (Class[]) null); 90 System.err.println("succeeded on package-scope method"); 91 } catch (NoSuchMethodException nsme) { 92 // good 93 } 94 95 96 instance = otherpackage.Other.getInnerClassInstance(); 97 target = instance.getClass(); 98 meth = target.getMethod("innerMethod", (Class[]) null); 99 try { 100 if (!FULL_ACCESS_CHECKS) { throw new IllegalAccessException(); } 101 meth.invoke(instance); 102 System.err.println("inner-method invoke unexpectedly worked"); 103 } catch (IllegalAccessException iae) { 104 // good 105 } 106 107 Field field = target.getField("innerField"); 108 try { 109 int x = field.getInt(instance); 110 if (!FULL_ACCESS_CHECKS) { throw new IllegalAccessException(); } 111 System.err.println("field get unexpectedly worked: " + x); 112 } catch (IllegalAccessException iae) { 113 // good 114 } 115 } catch (Exception ex) { 116 System.out.println("----- unexpected exception -----"); 117 ex.printStackTrace(); 118 } 119 } 120 121 public void run() { 122 Class target = Target.class; 123 Method meth = null; 124 Field field = null; 125 boolean excep; 126 127 try { 128 meth = target.getMethod("myMethod", new Class[] { int.class }); 129 130 if (meth.getDeclaringClass() != target) 131 throw new RuntimeException(); 132 printMethodInfo(meth); 133 134 meth = target.getMethod("myMethod", new Class[] { float.class }); 135 printMethodInfo(meth); 136 137 meth = target.getMethod("myNoargMethod", (Class[]) null); 138 printMethodInfo(meth); 139 140 meth = target.getMethod("myMethod", 141 new Class[] { String[].class, float.class, char.class }); 142 printMethodInfo(meth); 143 144 Target instance = new Target(); 145 Object[] argList = new Object[] { 146 new String[] { "hi there" }, 147 new Float(3.1415926f), 148 new Character('Q') 149 }; 150 System.out.println("Before, float is " 151 + ((Float)argList[1]).floatValue()); 152 153 Integer boxval; 154 boxval = (Integer) meth.invoke(instance, argList); 155 System.out.println("Result of invoke: " + boxval.intValue()); 156 157 System.out.println("Calling no-arg void-return method"); 158 meth = target.getMethod("myNoargMethod", (Class[]) null); 159 meth.invoke(instance, (Object[]) null); 160 161 /* try invoking a method that throws an exception */ 162 meth = target.getMethod("throwingMethod", (Class[]) null); 163 try { 164 meth.invoke(instance, (Object[]) null); 165 System.out.println("GLITCH: didn't throw"); 166 } catch (InvocationTargetException ite) { 167 System.out.println("Invoke got expected exception:"); 168 System.out.println(ite.getClass().getName()); 169 System.out.println(ite.getCause()); 170 } 171 catch (Exception ex) { 172 System.out.println("GLITCH: invoke got wrong exception:"); 173 ex.printStackTrace(); 174 } 175 System.out.println(""); 176 177 178 field = target.getField("string1"); 179 if (field.getDeclaringClass() != target) 180 throw new RuntimeException(); 181 printFieldInfo(field); 182 String strVal = (String) field.get(instance); 183 System.out.println(" string1 value is '" + strVal + "'"); 184 185 showStrings(instance); 186 187 field.set(instance, new String("a new string")); 188 strVal = (String) field.get(instance); 189 System.out.println(" string1 value is now '" + strVal + "'"); 190 191 showStrings(instance); 192 193 try { 194 field.set(instance, new Object()); 195 System.out.println("WARNING: able to store Object into String"); 196 } 197 catch (IllegalArgumentException iae) { 198 System.out.println(" got expected illegal obj store exc"); 199 } 200 201 202 try { 203 String four; 204 field = target.getField("string4"); 205 four = (String) field.get(instance); 206 System.out.println("WARNING: able to access string4: " 207 + four); 208 } 209 catch (IllegalAccessException iae) { 210 System.out.println(" got expected access exc"); 211 } 212 catch (NoSuchFieldException nsfe) { 213 System.out.println(" got the other expected access exc"); 214 } 215 try { 216 String three; 217 field = target.getField("string3"); 218 three = (String) field.get(this); 219 System.out.println("WARNING: able to get string3 in wrong obj: " 220 + three); 221 } 222 catch (IllegalArgumentException iae) { 223 System.out.println(" got expected arg exc"); 224 } 225 226 /* 227 * Try setting a field to null. 228 */ 229 String four; 230 field = target.getDeclaredField("string3"); 231 field.set(instance, null); 232 233 /* 234 * Do some stuff with long. 235 */ 236 long longVal; 237 field = target.getField("pubLong"); 238 longVal = field.getLong(instance); 239 System.out.println("pubLong initial value is " + 240 Long.toHexString(longVal)); 241 field.setLong(instance, 0x9988776655443322L); 242 longVal = field.getLong(instance); 243 System.out.println("pubLong new value is " + 244 Long.toHexString(longVal)); 245 246 247 field = target.getField("superInt"); 248 if (field.getDeclaringClass() == target) 249 throw new RuntimeException(); 250 printFieldInfo(field); 251 int intVal = field.getInt(instance); 252 System.out.println(" superInt value is " + intVal); 253 Integer boxedIntVal = (Integer) field.get(instance); 254 System.out.println(" superInt boxed is " + boxedIntVal); 255 256 field.set(instance, new Integer(20202)); 257 intVal = field.getInt(instance); 258 System.out.println(" superInt value is now " + intVal); 259 field.setShort(instance, (short)30303); 260 intVal = field.getInt(instance); 261 System.out.println(" superInt value (from short) is now " +intVal); 262 field.setInt(instance, 40404); 263 intVal = field.getInt(instance); 264 System.out.println(" superInt value is now " + intVal); 265 try { 266 field.set(instance, new Long(123)); 267 System.out.println("FAIL: expected exception not thrown"); 268 } 269 catch (IllegalArgumentException iae) { 270 System.out.println(" got expected long->int failure"); 271 } 272 try { 273 field.setLong(instance, 123); 274 System.out.println("FAIL: expected exception not thrown"); 275 } 276 catch (IllegalArgumentException iae) { 277 System.out.println(" got expected long->int failure"); 278 } 279 try { 280 field.set(instance, new String("abc")); 281 System.out.println("FAIL: expected exception not thrown"); 282 } 283 catch (IllegalArgumentException iae) { 284 System.out.println(" got expected string->int failure"); 285 } 286 287 try { 288 field.getShort(instance); 289 System.out.println("FAIL: expected exception not thrown"); 290 } 291 catch (IllegalArgumentException iae) { 292 System.out.println(" got expected int->short failure"); 293 } 294 295 field = target.getField("superClassInt"); 296 printFieldInfo(field); 297 int superClassIntVal = field.getInt(instance); 298 System.out.println(" superClassInt value is " + superClassIntVal); 299 300 field = target.getField("staticDouble"); 301 printFieldInfo(field); 302 double staticDoubleVal = field.getDouble(null); 303 System.out.println(" staticDoubleVal value is " + staticDoubleVal); 304 305 try { 306 field.getLong(instance); 307 System.out.println("FAIL: expected exception not thrown"); 308 } 309 catch (IllegalArgumentException iae) { 310 System.out.println(" got expected double->long failure"); 311 } 312 313 excep = false; 314 try { 315 field = target.getField("aPrivateInt"); 316 printFieldInfo(field); 317 } 318 catch (NoSuchFieldException nsfe) { 319 System.out.println("as expected: aPrivateInt not found"); 320 excep = true; 321 } 322 if (!excep) 323 System.out.println("BUG: got aPrivateInt"); 324 325 326 field = target.getField("constantString"); 327 printFieldInfo(field); 328 String val = (String) field.get(instance); 329 System.out.println(" Constant test value is " + val); 330 331 332 field = target.getField("cantTouchThis"); 333 printFieldInfo(field); 334 intVal = field.getInt(instance); 335 System.out.println(" cantTouchThis is " + intVal); 336 try { 337 field.setInt(instance, 99); 338 System.out.println(" setAccessible is always true"); 339 } catch (IllegalAccessException iae) { 340 System.out.println("ERROR: set-final failed"); 341 } 342 intVal = field.getInt(instance); 343 System.out.println(" cantTouchThis is now " + intVal); 344 345 field.setAccessible(true); 346 field.setInt(instance, 87); // exercise int version 347 intVal = field.getInt(instance); 348 System.out.println(" cantTouchThis is now " + intVal); 349 field.set(instance, 88); // exercise Object version 350 intVal = field.getInt(instance); 351 System.out.println(" cantTouchThis is now " + intVal); 352 353 Constructor<Target> cons; 354 Target targ; 355 Object[] args; 356 357 cons = target.getConstructor(new Class[] { int.class,float.class }); 358 args = new Object[] { new Integer(7), new Float(3.3333) }; 359 System.out.println("cons modifiers=" + cons.getModifiers()); 360 targ = cons.newInstance(args); 361 targ.myMethod(17); 362 363 } catch (Exception ex) { 364 System.out.println("----- unexpected exception -----"); 365 ex.printStackTrace(); 366 } 367 368 System.out.println("ReflectTest done!"); 369 } 370 371 public static void checkType() { 372 Method m; 373 374 try { 375 m = Collections.class.getDeclaredMethod("checkType", 376 Object.class, Class.class); 377 } catch (NoSuchMethodException nsme) { 378 nsme.printStackTrace(); 379 return; 380 } 381 382 m.setAccessible(true); 383 try { 384 m.invoke(null, new Object(), Object.class); 385 } catch (IllegalAccessException iae) { 386 iae.printStackTrace(); 387 return; 388 } catch (InvocationTargetException ite) { 389 ite.printStackTrace(); 390 return; 391 } 392 393 try { 394 System.out.println("checkType invoking null"); 395 m.invoke(null, new Object(), int.class); 396 System.out.println("ERROR: should throw InvocationTargetException"); 397 } catch (InvocationTargetException ite) { 398 System.out.println("checkType got expected exception"); 399 } catch (IllegalAccessException iae) { 400 iae.printStackTrace(); 401 return; 402 } 403 } 404 405 public static void checkInit() { 406 System.out.println("calling const-class NoisyInitUser.class"); 407 Class niuClass = NoisyInitUser.class; 408 System.out.println("called const-class NoisyInitUser.class"); 409 Method[] methods; 410 411 methods = niuClass.getDeclaredMethods(); 412 System.out.println("got methods"); 413 /* neither NoisyInit nor NoisyInitUser should be initialized yet */ 414 NoisyInitUser niu = new NoisyInitUser(); 415 NoisyInit ni = new NoisyInit(); 416 417 System.out.println(""); 418 } 419 420 421 /* 422 * Test some generic type stuff. 423 */ 424 public List<String> dummy; 425 public Map<Integer,String> fancyMethod(ArrayList<String> blah) { return null; } 426 public static void checkGeneric() { 427 Field field; 428 try { 429 field = Main.class.getField("dummy"); 430 } catch (NoSuchFieldException nsfe) { 431 throw new RuntimeException(nsfe); 432 } 433 Type listType = field.getGenericType(); 434 System.out.println("generic field: " + listType); 435 436 Method method; 437 try { 438 method = Main.class.getMethod("fancyMethod", 439 new Class[] { ArrayList.class }); 440 } catch (NoSuchMethodException nsme) { 441 throw new RuntimeException(nsme); 442 } 443 Type[] parmTypes = method.getGenericParameterTypes(); 444 Type ret = method.getGenericReturnType(); 445 System.out.println("generic method " + method.getName() + " params='" 446 + stringifyTypeArray(parmTypes) + "' ret='" + ret + "'"); 447 448 Constructor ctor; 449 try { 450 ctor = Main.class.getConstructor(new Class[] { ArrayList.class }); 451 } catch (NoSuchMethodException nsme) { 452 throw new RuntimeException(nsme); 453 } 454 parmTypes = ctor.getGenericParameterTypes(); 455 System.out.println("generic ctor " + ctor.getName() + " params='" 456 + stringifyTypeArray(parmTypes) + "'"); 457 } 458 459 /* 460 * Convert an array of Type into a string. Start with an array count. 461 */ 462 private static String stringifyTypeArray(Type[] types) { 463 StringBuilder stb = new StringBuilder(); 464 boolean first = true; 465 466 stb.append("[" + types.length + "]"); 467 468 for (Type t: types) { 469 if (first) { 470 stb.append(" "); 471 first = false; 472 } else { 473 stb.append(", "); 474 } 475 stb.append(t.toString()); 476 } 477 478 return stb.toString(); 479 } 480 481 482 public static void main(String[] args) { 483 Main test = new Main(); 484 test.run(); 485 486 checkAccess(); 487 checkType(); 488 checkInit(); 489 checkGeneric(); 490 } 491} 492 493 494class SuperTarget { 495 public SuperTarget() { 496 System.out.println("SuperTarget constructor ()V"); 497 superInt = 1010101; 498 superClassInt = 1010102; 499 } 500 501 public int myMethod(float floatArg) { 502 System.out.println("myMethod (F)I " + floatArg); 503 return 6; 504 } 505 506 public int superInt; 507 public static int superClassInt; 508} 509 510class Target extends SuperTarget { 511 public Target() { 512 System.out.println("Target constructor ()V"); 513 } 514 515 public Target(int ii, float ff) { 516 System.out.println("Target constructor (IF)V : ii=" 517 + ii + " ff=" + ff); 518 anInt = ii; 519 } 520 521 public int myMethod(int intarg) throws NullPointerException, IOException { 522 System.out.println("myMethod (I)I"); 523 System.out.println(" arg=" + intarg + " anInt=" + anInt); 524 return 5; 525 } 526 527 public int myMethod(String[] strarg, float f, char c) { 528 System.out.println("myMethod: " + strarg[0] + " " + f + " " + c + " !"); 529 return 7; 530 } 531 532 public static void myNoargMethod() { 533 System.out.println("myNoargMethod ()V"); 534 } 535 536 public void throwingMethod() { 537 System.out.println("throwingMethod"); 538 throw new NullPointerException("gratuitous throw!"); 539 } 540 541 public void misc() { 542 System.out.println("misc"); 543 } 544 545 public int anInt; 546 public String string1 = "hey"; 547 public String string2 = "yo"; 548 public String string3 = "there"; 549 private String string4 = "naughty"; 550 public static final String constantString = "a constant string"; 551 private int aPrivateInt; 552 553 public final int cantTouchThis = 77; 554 555 public long pubLong = 0x1122334455667788L; 556 557 public static double staticDouble = 3.3; 558} 559 560class NoisyInit { 561 static { 562 System.out.println("NoisyInit is initializing"); 563 //Throwable th = new Throwable(); 564 //th.printStackTrace(); 565 } 566} 567 568class NoisyInitUser { 569 static { 570 System.out.println("NoisyInitUser is initializing"); 571 } 572 public void createNoisyInit(NoisyInit ni) {} 573} 574