diff options
Diffstat (limited to 'test/044-proxy/src')
| -rw-r--r-- | test/044-proxy/src/BasicTest.java | 11 | ||||
| -rw-r--r-- | test/044-proxy/src/Main.java | 1 | ||||
| -rw-r--r-- | test/044-proxy/src/ReturnsAndArgPassing.java | 206 |
3 files changed, 218 insertions, 0 deletions
diff --git a/test/044-proxy/src/BasicTest.java b/test/044-proxy/src/BasicTest.java index 2a453c47f7..fa1896fd9a 100644 --- a/test/044-proxy/src/BasicTest.java +++ b/test/044-proxy/src/BasicTest.java @@ -22,6 +22,7 @@ import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.Arrays; +import java.util.Comparator; /** * Do some basic tests. @@ -70,6 +71,11 @@ public class BasicTest { */ System.out.println(""); Method[] methods = proxy.getClass().getDeclaredMethods(); + Arrays.sort(methods, new Comparator<Method>() { + public int compare(Method o1, Method o2) { + return o1.getName().compareTo(o2.getName()); + } + }); System.out.println("Proxy methods: " + Arrays.deepToString(methods)); Method meth = methods[methods.length -1]; System.out.println("Decl annos: " + Arrays.deepToString(meth.getDeclaredAnnotations())); @@ -77,6 +83,11 @@ public class BasicTest { System.out.println("Param annos (" + paramAnnos.length + ") : " + Arrays.deepToString(paramAnnos)); Field[] fields = proxy.getClass().getDeclaredFields(); + Arrays.sort(fields, new Comparator<Field>() { + public int compare(Field o1, Field o2) { + return o1.getName().compareTo(o2.getName()); + } + }); System.out.println("Proxy fields: " + Arrays.deepToString(fields)); } diff --git a/test/044-proxy/src/Main.java b/test/044-proxy/src/Main.java index 01926af2c2..5396ab8842 100644 --- a/test/044-proxy/src/Main.java +++ b/test/044-proxy/src/Main.java @@ -19,6 +19,7 @@ */ public class Main { public static void main(String[] args) { + ReturnsAndArgPassing.main(null); BasicTest.main(null); Clash.main(null); Clash2.main(null); diff --git a/test/044-proxy/src/ReturnsAndArgPassing.java b/test/044-proxy/src/ReturnsAndArgPassing.java new file mode 100644 index 0000000000..6a706cbf6c --- /dev/null +++ b/test/044-proxy/src/ReturnsAndArgPassing.java @@ -0,0 +1,206 @@ +/* + * 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(); + } +} |