| /* |
| * Copyright 2011 Google Inc. All Rights Reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| import java.lang.reflect.*; |
| |
| /** |
| * @author irogers@google.com (Ian Rogers) |
| */ |
| public class ReturnsAndArgPassing { |
| |
| public static final String testName = "ReturnsAndArgPassing"; |
| |
| static void check(boolean x) { |
| if (!x) { |
| throw new AssertionError(testName + " Check failed"); |
| } |
| } |
| |
| interface MyInterface { |
| void voidFoo(); |
| void voidBar(); |
| boolean booleanFoo(); |
| boolean booleanBar(); |
| byte byteFoo(); |
| byte byteBar(); |
| char charFoo(); |
| char charBar(); |
| short shortFoo(); |
| short shortBar(); |
| int intFoo(); |
| int intBar(); |
| long longFoo(); |
| long longBar(); |
| float floatFoo(); |
| float floatBar(); |
| double doubleFoo(); |
| double doubleBar(); |
| Object selectArg(int select, int a, long b, float c, double d, Object x); |
| } |
| |
| static int fooInvocations = 0; |
| static int barInvocations = 0; |
| |
| static class MyInvocationHandler implements InvocationHandler { |
| public Object invoke(Object proxy, Method method, Object[] args) { |
| check(proxy instanceof Proxy); |
| check(method.getDeclaringClass() == MyInterface.class); |
| String name = method.getName(); |
| if (name.endsWith("Foo")) { |
| check(args == null); |
| fooInvocations++; |
| } else if (name.endsWith("Bar")) { |
| check(args == null); |
| barInvocations++; |
| } |
| if (name.equals("voidFoo")) { return null; } |
| else if (name.equals("voidBar")) { return null; } |
| else if (name.equals("booleanFoo")) { return true; } |
| else if (name.equals("booleanBar")) { return false; } |
| else if (name.equals("byteFoo")) { return Byte.MAX_VALUE; } |
| else if (name.equals("byteBar")) { return Byte.MIN_VALUE; } |
| else if (name.equals("charFoo")) { return Character.MAX_VALUE; } |
| else if (name.equals("charBar")) { return Character.MIN_VALUE; } |
| else if (name.equals("shortFoo")) { return Short.MAX_VALUE; } |
| else if (name.equals("shortBar")) { return Short.MIN_VALUE; } |
| else if (name.equals("intFoo")) { return Integer.MAX_VALUE; } |
| else if (name.equals("intBar")) { return Integer.MIN_VALUE; } |
| else if (name.equals("longFoo")) { return Long.MAX_VALUE; } |
| else if (name.equals("longBar")) { return Long.MIN_VALUE; } |
| else if (name.equals("floatFoo")) { return Float.MAX_VALUE; } |
| else if (name.equals("floatBar")) { return Float.MIN_VALUE; } |
| else if (name.equals("doubleFoo")) { return Double.MAX_VALUE; } |
| else if (name.equals("doubleBar")) { return Double.MIN_VALUE; } |
| else if (name.equals("selectArg")) { |
| check(args.length == 6); |
| int select = (Integer)args[0]; |
| return args[select]; |
| } else { |
| throw new AssertionError("Unexpect method " + method); |
| } |
| } |
| } |
| |
| static void testProxyReturns() { |
| System.out.println(testName + ".testProxyReturns RUNNING"); |
| MyInvocationHandler myHandler = new MyInvocationHandler(); |
| MyInterface proxyMyInterface = |
| (MyInterface)Proxy.newProxyInstance(ReturnsAndArgPassing.class.getClassLoader(), |
| new Class[] { MyInterface.class }, |
| myHandler); |
| check(fooInvocations == 0); |
| proxyMyInterface.voidFoo(); |
| check(fooInvocations == 1); |
| |
| check(barInvocations == 0); |
| proxyMyInterface.voidBar(); |
| check(barInvocations == 1); |
| |
| check(fooInvocations == 1); |
| check(proxyMyInterface.booleanFoo() == true); |
| check(fooInvocations == 2); |
| |
| check(barInvocations == 1); |
| check(proxyMyInterface.booleanBar() == false); |
| check(barInvocations == 2); |
| |
| check(fooInvocations == 2); |
| check(proxyMyInterface.byteFoo() == Byte.MAX_VALUE); |
| check(fooInvocations == 3); |
| |
| check(barInvocations == 2); |
| check(proxyMyInterface.byteBar() == Byte.MIN_VALUE); |
| check(barInvocations == 3); |
| |
| check(fooInvocations == 3); |
| check(proxyMyInterface.charFoo() == Character.MAX_VALUE); |
| check(fooInvocations == 4); |
| |
| check(barInvocations == 3); |
| check(proxyMyInterface.charBar() == Character.MIN_VALUE); |
| check(barInvocations == 4); |
| |
| check(fooInvocations == 4); |
| check(proxyMyInterface.shortFoo() == Short.MAX_VALUE); |
| check(fooInvocations == 5); |
| |
| check(barInvocations == 4); |
| check(proxyMyInterface.shortBar() == Short.MIN_VALUE); |
| check(barInvocations == 5); |
| |
| check(fooInvocations == 5); |
| check(proxyMyInterface.intFoo() == Integer.MAX_VALUE); |
| check(fooInvocations == 6); |
| |
| check(barInvocations == 5); |
| check(proxyMyInterface.intBar() == Integer.MIN_VALUE); |
| check(barInvocations == 6); |
| |
| check(fooInvocations == 6); |
| check(proxyMyInterface.longFoo() == Long.MAX_VALUE); |
| check(fooInvocations == 7); |
| |
| check(barInvocations == 6); |
| check(proxyMyInterface.longBar() == Long.MIN_VALUE); |
| check(barInvocations == 7); |
| |
| check(fooInvocations == 7); |
| check(proxyMyInterface.floatFoo() == Float.MAX_VALUE); |
| check(fooInvocations == 8); |
| |
| check(barInvocations == 7); |
| check(proxyMyInterface.floatBar() == Float.MIN_VALUE); |
| check(barInvocations == 8); |
| |
| check(fooInvocations == 8); |
| check(proxyMyInterface.doubleFoo() == Double.MAX_VALUE); |
| check(fooInvocations == 9); |
| |
| check(barInvocations == 8); |
| check(proxyMyInterface.doubleBar() == Double.MIN_VALUE); |
| check(barInvocations == 9); |
| |
| System.out.println(testName + ".testProxyReturns PASSED"); |
| } |
| |
| static void testProxyArgPassing() { |
| System.out.println(testName + ".testProxyArgPassing RUNNING"); |
| MyInvocationHandler myHandler = new MyInvocationHandler(); |
| MyInterface proxyMyInterface = |
| (MyInterface)Proxy.newProxyInstance(ReturnsAndArgPassing.class.getClassLoader(), |
| new Class[] { MyInterface.class }, |
| myHandler); |
| |
| check((Integer)proxyMyInterface.selectArg(0, Integer.MAX_VALUE, Long.MAX_VALUE, |
| Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == 0); |
| check((Integer)proxyMyInterface.selectArg(1, Integer.MAX_VALUE, Long.MAX_VALUE, |
| Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == Integer.MAX_VALUE); |
| check((Long)proxyMyInterface.selectArg(2, Integer.MAX_VALUE, Long.MAX_VALUE, |
| Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == Long.MAX_VALUE); |
| check((Float)proxyMyInterface.selectArg(3, Integer.MAX_VALUE, Long.MAX_VALUE, |
| Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == Float.MAX_VALUE); |
| check((Double)proxyMyInterface.selectArg(4, Integer.MAX_VALUE, Long.MAX_VALUE, |
| Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == Double.MAX_VALUE); |
| check(proxyMyInterface.selectArg(5, Integer.MAX_VALUE, Long.MAX_VALUE, |
| Float.MAX_VALUE, Double.MAX_VALUE, Object.class) == Object.class); |
| |
| System.out.println(testName + ".testProxyArgPassing PASSED"); |
| } |
| |
| public static void main(String args[]) { |
| testProxyReturns(); |
| testProxyArgPassing(); |
| } |
| } |