/*
* Copyright (C) 2011 The Android Open Source Project
*
* 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.*;
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 {
boolean causeNpeOnReturn = false;
Class<?> returnType = null;
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 (causeNpeOnReturn) {
return null;
} else if (name.equals("voidFoo") || name.equals("voidBar")) {
return null;
} else if (name.equals("booleanFoo")) {
return true;
} else if (name.equals("booleanBar")) {
return false;
} else if (name.equals("selectArg")) {
check(args.length == 6);
int select = (Integer)args[0];
return args[select];
} else {
try {
if (name.endsWith("Foo")) {
return returnType.getField("MAX_VALUE").get(null);
} else {
check(name.endsWith("Bar"));
return returnType.getField("MIN_VALUE").get(null);
}
} catch (Exception e) {
throw new Error("return type = " + returnType, e);
}
}
}
}
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);
myHandler.returnType = Boolean.class;
check(proxyMyInterface.booleanFoo() == true);
check(fooInvocations == 2);
check(barInvocations == 1);
check(proxyMyInterface.booleanBar() == false);
check(barInvocations == 2);
check(fooInvocations == 2);
myHandler.returnType = Byte.class;
check(proxyMyInterface.byteFoo() == Byte.MAX_VALUE);
check(fooInvocations == 3);
check(barInvocations == 2);
check(proxyMyInterface.byteBar() == Byte.MIN_VALUE);
check(barInvocations == 3);
check(fooInvocations == 3);
myHandler.returnType = Character.class;
check(proxyMyInterface.charFoo() == Character.MAX_VALUE);
check(fooInvocations == 4);
check(barInvocations == 3);
check(proxyMyInterface.charBar() == Character.MIN_VALUE);
check(barInvocations == 4);
check(fooInvocations == 4);
myHandler.returnType = Short.class;
check(proxyMyInterface.shortFoo() == Short.MAX_VALUE);
check(fooInvocations == 5);
check(barInvocations == 4);
check(proxyMyInterface.shortBar() == Short.MIN_VALUE);
check(barInvocations == 5);
check(fooInvocations == 5);
myHandler.returnType = Integer.class;
check(proxyMyInterface.intFoo() == Integer.MAX_VALUE);
check(fooInvocations == 6);
check(barInvocations == 5);
check(proxyMyInterface.intBar() == Integer.MIN_VALUE);
check(barInvocations == 6);
check(fooInvocations == 6);
myHandler.returnType = Long.class;
check(proxyMyInterface.longFoo() == Long.MAX_VALUE);
check(fooInvocations == 7);
check(barInvocations == 6);
check(proxyMyInterface.longBar() == Long.MIN_VALUE);
check(barInvocations == 7);
check(fooInvocations == 7);
myHandler.returnType = Float.class;
check(proxyMyInterface.floatFoo() == Float.MAX_VALUE);
check(fooInvocations == 8);
check(barInvocations == 7);
check(proxyMyInterface.floatBar() == Float.MIN_VALUE);
check(barInvocations == 8);
check(fooInvocations == 8);
myHandler.returnType = Double.class;
check(proxyMyInterface.doubleFoo() == Double.MAX_VALUE);
check(fooInvocations == 9);
check(barInvocations == 8);
check(proxyMyInterface.doubleBar() == Double.MIN_VALUE);
check(barInvocations == 9);
// Toggle flag to get return values to cause NPEs
myHandler.causeNpeOnReturn = true;
check(fooInvocations == 9);
try {
proxyMyInterface.booleanFoo();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(fooInvocations == 10);
check(barInvocations == 9);
try {
proxyMyInterface.booleanBar();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(barInvocations == 10);
check(fooInvocations == 10);
try {
proxyMyInterface.byteFoo();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(fooInvocations == 11);
check(barInvocations == 10);
try {
proxyMyInterface.byteBar();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(barInvocations == 11);
check(fooInvocations == 11);
try {
proxyMyInterface.charFoo();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(fooInvocations == 12);
check(barInvocations == 11);
try {
proxyMyInterface.charBar();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(barInvocations == 12);
check(fooInvocations == 12);
try {
proxyMyInterface.shortFoo();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(fooInvocations == 13);
check(barInvocations == 12);
try {
proxyMyInterface.shortBar();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(barInvocations == 13);
check(fooInvocations == 13);
try {
proxyMyInterface.intFoo();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(fooInvocations == 14);
check(barInvocations == 13);
try {
proxyMyInterface.intBar();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(barInvocations == 14);
check(fooInvocations == 14);
try {
proxyMyInterface.longFoo();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(fooInvocations == 15);
check(barInvocations == 14);
try {
proxyMyInterface.longBar();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(barInvocations == 15);
check(fooInvocations == 15);
try {
proxyMyInterface.floatFoo();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(fooInvocations == 16);
check(barInvocations == 15);
try {
proxyMyInterface.floatBar();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(barInvocations == 16);
check(fooInvocations == 16);
try {
proxyMyInterface.doubleFoo();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(fooInvocations == 17);
check(barInvocations == 16);
try {
proxyMyInterface.doubleBar();
throw new AssertionError("Expected NPE");
} catch (NullPointerException e) {
}
check(barInvocations == 17);
// Toggle flag to stop NPEs
myHandler.causeNpeOnReturn = false;
check(fooInvocations == 17);
myHandler.returnType = Double.class; // Double -> byte == fail
try {
proxyMyInterface.byteFoo();
throw new AssertionError("Expected ClassCastException");
} catch (ClassCastException e) {
}
check(fooInvocations == 18);
check(barInvocations == 17);
try {
proxyMyInterface.byteBar();
throw new AssertionError("Expected NPE");
} catch (ClassCastException e) {
}
check(barInvocations == 18);
check(fooInvocations == 18);
myHandler.returnType = Float.class; // Float -> byte == fail
try {
proxyMyInterface.byteFoo();
throw new AssertionError("Expected ClassCastException");
} catch (ClassCastException e) {
}
check(fooInvocations == 19);
check(barInvocations == 18);
try {
proxyMyInterface.byteBar();
throw new AssertionError("Expected NPE");
} catch (ClassCastException e) {
}
check(barInvocations == 19);
check(fooInvocations == 19);
myHandler.returnType = Long.class; // Long -> byte == fail
try {
proxyMyInterface.byteFoo();
throw new AssertionError("Expected ClassCastException");
} catch (ClassCastException e) {
}
check(fooInvocations == 20);
check(barInvocations == 19);
try {
proxyMyInterface.byteBar();
throw new AssertionError("Expected NPE");
} catch (ClassCastException e) {
}
check(barInvocations == 20);
check(fooInvocations == 20);
myHandler.returnType = Integer.class; // Int -> byte == fail
try {
proxyMyInterface.byteFoo();
throw new AssertionError("Expected ClassCastException");
} catch (ClassCastException e) {
}
check(fooInvocations == 21);
check(barInvocations == 20);
try {
proxyMyInterface.byteBar();
throw new AssertionError("Expected NPE");
} catch (ClassCastException e) {
}
check(barInvocations == 21);
check(fooInvocations == 21);
myHandler.returnType = Short.class; // Short -> byte == fail
try {
proxyMyInterface.byteFoo();
throw new AssertionError("Expected ClassCastException");
} catch (ClassCastException e) {
}
check(fooInvocations == 22);
check(barInvocations == 21);
try {
proxyMyInterface.byteBar();
throw new AssertionError("Expected NPE");
} catch (ClassCastException e) {
}
check(barInvocations == 22);
check(fooInvocations == 22);
myHandler.returnType = Character.class; // Char -> byte == fail
try {
proxyMyInterface.byteFoo();
throw new AssertionError("Expected ClassCastException");
} catch (ClassCastException e) {
}
check(fooInvocations == 23);
check(barInvocations == 22);
try {
proxyMyInterface.byteBar();
throw new AssertionError("Expected NPE");
} catch (ClassCastException e) {
}
check(barInvocations == 23);
check(fooInvocations == 23);
myHandler.returnType = Character.class; // Char -> short == fail
try {
proxyMyInterface.shortFoo();
throw new AssertionError("Expected ClassCastException");
} catch (ClassCastException e) {
}
check(fooInvocations == 24);
check(barInvocations == 23);
try {
proxyMyInterface.shortBar();
throw new AssertionError("Expected NPE");
} catch (ClassCastException e) {
}
check(barInvocations == 24);
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();
}
}