1 /* 2 * Copyright (C) 2011 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 import java.lang.reflect.*; 17 18 public class ReturnsAndArgPassing { 19 20 public static final String testName = "ReturnsAndArgPassing"; 21 check(boolean x)22 static void check(boolean x) { 23 if (!x) { 24 throw new AssertionError(testName + " Check failed"); 25 } 26 } 27 28 interface MyInterface { voidFoo()29 void voidFoo(); voidBar()30 void voidBar(); booleanFoo()31 boolean booleanFoo(); booleanBar()32 boolean booleanBar(); byteFoo()33 byte byteFoo(); byteBar()34 byte byteBar(); charFoo()35 char charFoo(); charBar()36 char charBar(); shortFoo()37 short shortFoo(); shortBar()38 short shortBar(); intFoo()39 int intFoo(); intBar()40 int intBar(); longFoo()41 long longFoo(); longBar()42 long longBar(); floatFoo()43 float floatFoo(); floatBar()44 float floatBar(); doubleFoo()45 double doubleFoo(); doubleBar()46 double doubleBar(); selectArg(int select, int a, long b, float c, double d, Object x)47 Object selectArg(int select, int a, long b, float c, double d, Object x); 48 } 49 50 static int fooInvocations = 0; 51 static int barInvocations = 0; 52 53 static class MyInvocationHandler implements InvocationHandler { 54 boolean causeNpeOnReturn = false; 55 Class<?> returnType = null; invoke(Object proxy, Method method, Object[] args)56 public Object invoke(Object proxy, Method method, Object[] args) { 57 check(proxy instanceof Proxy); 58 check(method.getDeclaringClass() == MyInterface.class); 59 String name = method.getName(); 60 // Check for moving GC bugs in proxy stubs. 61 Runtime.getRuntime().gc(); 62 if (name.endsWith("Foo")) { 63 check(args == null); 64 fooInvocations++; 65 } else if (name.endsWith("Bar")) { 66 check(args == null); 67 barInvocations++; 68 } 69 if (causeNpeOnReturn) { 70 return null; 71 } else if (name.equals("voidFoo") || name.equals("voidBar")) { 72 return null; 73 } else if (name.equals("booleanFoo")) { 74 return true; 75 } else if (name.equals("booleanBar")) { 76 return false; 77 } else if (name.equals("selectArg")) { 78 check(args.length == 6); 79 int select = (Integer)args[0]; 80 return args[select]; 81 } else { 82 try { 83 if (name.endsWith("Foo")) { 84 return returnType.getField("MAX_VALUE").get(null); 85 } else { 86 check(name.endsWith("Bar")); 87 return returnType.getField("MIN_VALUE").get(null); 88 } 89 } catch (Exception e) { 90 throw new Error("return type = " + returnType, e); 91 } 92 } 93 } 94 } 95 testProxyReturns()96 static void testProxyReturns() { 97 System.out.println(testName + ".testProxyReturns RUNNING"); 98 MyInvocationHandler myHandler = new MyInvocationHandler(); 99 MyInterface proxyMyInterface = 100 (MyInterface)Proxy.newProxyInstance(ReturnsAndArgPassing.class.getClassLoader(), 101 new Class[] { MyInterface.class }, 102 myHandler); 103 check(fooInvocations == 0); 104 proxyMyInterface.voidFoo(); 105 check(fooInvocations == 1); 106 107 check(barInvocations == 0); 108 proxyMyInterface.voidBar(); 109 check(barInvocations == 1); 110 111 check(fooInvocations == 1); 112 myHandler.returnType = Boolean.class; 113 check(proxyMyInterface.booleanFoo() == true); 114 check(fooInvocations == 2); 115 116 check(barInvocations == 1); 117 check(proxyMyInterface.booleanBar() == false); 118 check(barInvocations == 2); 119 120 check(fooInvocations == 2); 121 myHandler.returnType = Byte.class; 122 check(proxyMyInterface.byteFoo() == Byte.MAX_VALUE); 123 check(fooInvocations == 3); 124 125 check(barInvocations == 2); 126 check(proxyMyInterface.byteBar() == Byte.MIN_VALUE); 127 check(barInvocations == 3); 128 129 check(fooInvocations == 3); 130 myHandler.returnType = Character.class; 131 check(proxyMyInterface.charFoo() == Character.MAX_VALUE); 132 check(fooInvocations == 4); 133 134 check(barInvocations == 3); 135 check(proxyMyInterface.charBar() == Character.MIN_VALUE); 136 check(barInvocations == 4); 137 138 check(fooInvocations == 4); 139 myHandler.returnType = Short.class; 140 check(proxyMyInterface.shortFoo() == Short.MAX_VALUE); 141 check(fooInvocations == 5); 142 143 check(barInvocations == 4); 144 check(proxyMyInterface.shortBar() == Short.MIN_VALUE); 145 check(barInvocations == 5); 146 147 check(fooInvocations == 5); 148 myHandler.returnType = Integer.class; 149 check(proxyMyInterface.intFoo() == Integer.MAX_VALUE); 150 check(fooInvocations == 6); 151 152 check(barInvocations == 5); 153 check(proxyMyInterface.intBar() == Integer.MIN_VALUE); 154 check(barInvocations == 6); 155 156 check(fooInvocations == 6); 157 myHandler.returnType = Long.class; 158 check(proxyMyInterface.longFoo() == Long.MAX_VALUE); 159 check(fooInvocations == 7); 160 161 check(barInvocations == 6); 162 check(proxyMyInterface.longBar() == Long.MIN_VALUE); 163 check(barInvocations == 7); 164 165 check(fooInvocations == 7); 166 myHandler.returnType = Float.class; 167 check(proxyMyInterface.floatFoo() == Float.MAX_VALUE); 168 check(fooInvocations == 8); 169 170 check(barInvocations == 7); 171 check(proxyMyInterface.floatBar() == Float.MIN_VALUE); 172 check(barInvocations == 8); 173 174 check(fooInvocations == 8); 175 myHandler.returnType = Double.class; 176 check(proxyMyInterface.doubleFoo() == Double.MAX_VALUE); 177 check(fooInvocations == 9); 178 179 check(barInvocations == 8); 180 check(proxyMyInterface.doubleBar() == Double.MIN_VALUE); 181 check(barInvocations == 9); 182 183 // Toggle flag to get return values to cause NPEs 184 myHandler.causeNpeOnReturn = true; 185 186 check(fooInvocations == 9); 187 try { 188 proxyMyInterface.booleanFoo(); 189 throw new AssertionError("Expected NPE"); 190 } catch (NullPointerException e) { 191 } 192 check(fooInvocations == 10); 193 194 check(barInvocations == 9); 195 try { 196 proxyMyInterface.booleanBar(); 197 throw new AssertionError("Expected NPE"); 198 } catch (NullPointerException e) { 199 } 200 check(barInvocations == 10); 201 202 check(fooInvocations == 10); 203 try { 204 proxyMyInterface.byteFoo(); 205 throw new AssertionError("Expected NPE"); 206 } catch (NullPointerException e) { 207 } 208 check(fooInvocations == 11); 209 210 check(barInvocations == 10); 211 try { 212 proxyMyInterface.byteBar(); 213 throw new AssertionError("Expected NPE"); 214 } catch (NullPointerException e) { 215 } 216 check(barInvocations == 11); 217 218 check(fooInvocations == 11); 219 try { 220 proxyMyInterface.charFoo(); 221 throw new AssertionError("Expected NPE"); 222 } catch (NullPointerException e) { 223 } 224 check(fooInvocations == 12); 225 226 check(barInvocations == 11); 227 try { 228 proxyMyInterface.charBar(); 229 throw new AssertionError("Expected NPE"); 230 } catch (NullPointerException e) { 231 } 232 check(barInvocations == 12); 233 234 check(fooInvocations == 12); 235 try { 236 proxyMyInterface.shortFoo(); 237 throw new AssertionError("Expected NPE"); 238 } catch (NullPointerException e) { 239 } 240 check(fooInvocations == 13); 241 242 check(barInvocations == 12); 243 try { 244 proxyMyInterface.shortBar(); 245 throw new AssertionError("Expected NPE"); 246 } catch (NullPointerException e) { 247 } 248 check(barInvocations == 13); 249 250 check(fooInvocations == 13); 251 try { 252 proxyMyInterface.intFoo(); 253 throw new AssertionError("Expected NPE"); 254 } catch (NullPointerException e) { 255 } 256 check(fooInvocations == 14); 257 258 check(barInvocations == 13); 259 try { 260 proxyMyInterface.intBar(); 261 throw new AssertionError("Expected NPE"); 262 } catch (NullPointerException e) { 263 } 264 check(barInvocations == 14); 265 266 check(fooInvocations == 14); 267 try { 268 proxyMyInterface.longFoo(); 269 throw new AssertionError("Expected NPE"); 270 } catch (NullPointerException e) { 271 } 272 check(fooInvocations == 15); 273 274 check(barInvocations == 14); 275 try { 276 proxyMyInterface.longBar(); 277 throw new AssertionError("Expected NPE"); 278 } catch (NullPointerException e) { 279 } 280 check(barInvocations == 15); 281 282 check(fooInvocations == 15); 283 try { 284 proxyMyInterface.floatFoo(); 285 throw new AssertionError("Expected NPE"); 286 } catch (NullPointerException e) { 287 } 288 check(fooInvocations == 16); 289 290 check(barInvocations == 15); 291 try { 292 proxyMyInterface.floatBar(); 293 throw new AssertionError("Expected NPE"); 294 } catch (NullPointerException e) { 295 } 296 check(barInvocations == 16); 297 298 check(fooInvocations == 16); 299 try { 300 proxyMyInterface.doubleFoo(); 301 throw new AssertionError("Expected NPE"); 302 } catch (NullPointerException e) { 303 } 304 check(fooInvocations == 17); 305 306 check(barInvocations == 16); 307 try { 308 proxyMyInterface.doubleBar(); 309 throw new AssertionError("Expected NPE"); 310 } catch (NullPointerException e) { 311 } 312 check(barInvocations == 17); 313 314 // Toggle flag to stop NPEs 315 myHandler.causeNpeOnReturn = false; 316 317 check(fooInvocations == 17); 318 myHandler.returnType = Double.class; // Double -> byte == fail 319 try { 320 proxyMyInterface.byteFoo(); 321 throw new AssertionError("Expected ClassCastException"); 322 } catch (ClassCastException e) { 323 } 324 check(fooInvocations == 18); 325 326 check(barInvocations == 17); 327 try { 328 proxyMyInterface.byteBar(); 329 throw new AssertionError("Expected NPE"); 330 } catch (ClassCastException e) { 331 } 332 check(barInvocations == 18); 333 334 check(fooInvocations == 18); 335 myHandler.returnType = Float.class; // Float -> byte == fail 336 try { 337 proxyMyInterface.byteFoo(); 338 throw new AssertionError("Expected ClassCastException"); 339 } catch (ClassCastException e) { 340 } 341 check(fooInvocations == 19); 342 343 check(barInvocations == 18); 344 try { 345 proxyMyInterface.byteBar(); 346 throw new AssertionError("Expected NPE"); 347 } catch (ClassCastException e) { 348 } 349 check(barInvocations == 19); 350 351 check(fooInvocations == 19); 352 myHandler.returnType = Long.class; // Long -> byte == fail 353 try { 354 proxyMyInterface.byteFoo(); 355 throw new AssertionError("Expected ClassCastException"); 356 } catch (ClassCastException e) { 357 } 358 check(fooInvocations == 20); 359 360 check(barInvocations == 19); 361 try { 362 proxyMyInterface.byteBar(); 363 throw new AssertionError("Expected NPE"); 364 } catch (ClassCastException e) { 365 } 366 check(barInvocations == 20); 367 368 check(fooInvocations == 20); 369 myHandler.returnType = Integer.class; // Int -> byte == fail 370 try { 371 proxyMyInterface.byteFoo(); 372 throw new AssertionError("Expected ClassCastException"); 373 } catch (ClassCastException e) { 374 } 375 check(fooInvocations == 21); 376 377 check(barInvocations == 20); 378 try { 379 proxyMyInterface.byteBar(); 380 throw new AssertionError("Expected NPE"); 381 } catch (ClassCastException e) { 382 } 383 check(barInvocations == 21); 384 385 check(fooInvocations == 21); 386 myHandler.returnType = Short.class; // Short -> byte == fail 387 try { 388 proxyMyInterface.byteFoo(); 389 throw new AssertionError("Expected ClassCastException"); 390 } catch (ClassCastException e) { 391 } 392 check(fooInvocations == 22); 393 394 check(barInvocations == 21); 395 try { 396 proxyMyInterface.byteBar(); 397 throw new AssertionError("Expected NPE"); 398 } catch (ClassCastException e) { 399 } 400 check(barInvocations == 22); 401 402 check(fooInvocations == 22); 403 myHandler.returnType = Character.class; // Char -> byte == fail 404 try { 405 proxyMyInterface.byteFoo(); 406 throw new AssertionError("Expected ClassCastException"); 407 } catch (ClassCastException e) { 408 } 409 check(fooInvocations == 23); 410 411 check(barInvocations == 22); 412 try { 413 proxyMyInterface.byteBar(); 414 throw new AssertionError("Expected NPE"); 415 } catch (ClassCastException e) { 416 } 417 check(barInvocations == 23); 418 419 check(fooInvocations == 23); 420 myHandler.returnType = Character.class; // Char -> short == fail 421 try { 422 proxyMyInterface.shortFoo(); 423 throw new AssertionError("Expected ClassCastException"); 424 } catch (ClassCastException e) { 425 } 426 check(fooInvocations == 24); 427 428 check(barInvocations == 23); 429 try { 430 proxyMyInterface.shortBar(); 431 throw new AssertionError("Expected NPE"); 432 } catch (ClassCastException e) { 433 } 434 check(barInvocations == 24); 435 436 System.out.println(testName + ".testProxyReturns PASSED"); 437 } 438 testProxyArgPassing()439 static void testProxyArgPassing() { 440 System.out.println(testName + ".testProxyArgPassing RUNNING"); 441 MyInvocationHandler myHandler = new MyInvocationHandler(); 442 MyInterface proxyMyInterface = 443 (MyInterface)Proxy.newProxyInstance(ReturnsAndArgPassing.class.getClassLoader(), 444 new Class[] { MyInterface.class }, 445 myHandler); 446 447 check((Integer)proxyMyInterface.selectArg(0, Integer.MAX_VALUE, Long.MAX_VALUE, 448 Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == 0); 449 check((Integer)proxyMyInterface.selectArg(1, Integer.MAX_VALUE, Long.MAX_VALUE, 450 Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == Integer.MAX_VALUE); 451 check((Long)proxyMyInterface.selectArg(2, Integer.MAX_VALUE, Long.MAX_VALUE, 452 Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == Long.MAX_VALUE); 453 check((Float)proxyMyInterface.selectArg(3, Integer.MAX_VALUE, Long.MAX_VALUE, 454 Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == Float.MAX_VALUE); 455 check((Double)proxyMyInterface.selectArg(4, Integer.MAX_VALUE, Long.MAX_VALUE, 456 Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == Double.MAX_VALUE); 457 check(proxyMyInterface.selectArg(5, Integer.MAX_VALUE, Long.MAX_VALUE, 458 Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == Object.class); 459 460 System.out.println(testName + ".testProxyArgPassing PASSED"); 461 } 462 main(String args[])463 public static void main(String args[]) { 464 testProxyReturns(); 465 testProxyArgPassing(); 466 } 467 } 468