/*
* Copyright (C) 2013 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.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Main {
public static void main(String[] args) {
System.loadLibrary(args[0]);
testFindClassOnAttachedNativeThread();
testFindFieldOnAttachedNativeThread();
testReflectFieldGetFromAttachedNativeThreadNative();
testCallStaticVoidMethodOnSubClass();
testGetMirandaMethod();
testZeroLengthByteBuffers();
testByteMethod();
testShortMethod();
testBooleanMethod();
testCharMethod();
testIsAssignableFromOnPrimitiveTypes();
testShallowGetCallingClassLoader();
testShallowGetStackClass2();
testCallNonvirtual();
testNewStringObject();
testRemoveLocalObject();
testProxyGetMethodID();
testJniCriticalSectionAndGc();
testCallDefaultMethods();
String lambda = "λ";
testInvokeLambdaMethod(() -> { System.out.println("hi-lambda: " + lambda); });
String def = "δ";
testInvokeLambdaDefaultMethod(() -> { System.out.println("hi-default " + def + lambda); });
}
private static native void testCallDefaultMethods();
private static native void testFindClassOnAttachedNativeThread();
private static boolean testFindFieldOnAttachedNativeThreadField;
private static native void testReflectFieldGetFromAttachedNativeThreadNative();
public static boolean testReflectFieldGetFromAttachedNativeThreadField;
private static void testFindFieldOnAttachedNativeThread() {
testFindFieldOnAttachedNativeThreadNative();
if (!testFindFieldOnAttachedNativeThreadField) {
throw new AssertionError();
}
}
private static native void testFindFieldOnAttachedNativeThreadNative();
private static void testCallStaticVoidMethodOnSubClass() {
testCallStaticVoidMethodOnSubClassNative();
if (!testCallStaticVoidMethodOnSubClass_SuperClass.executed) {
throw new AssertionError();
}
}
private static native void testCallStaticVoidMethodOnSubClassNative();
private static class testCallStaticVoidMethodOnSubClass_SuperClass {
private static boolean executed = false;
private static void execute() {
executed = true;
}
}
private static class testCallStaticVoidMethodOnSubClass_SubClass
extends testCallStaticVoidMethodOnSubClass_SuperClass {
}
private static native Method testGetMirandaMethodNative();
private static void testGetMirandaMethod() {
Method m = testGetMirandaMethodNative();
if (m.getDeclaringClass() != testGetMirandaMethod_MirandaInterface.class) {
throw new AssertionError();
}
}
private static native void testZeroLengthByteBuffers();
private static abstract class testGetMirandaMethod_MirandaAbstract implements testGetMirandaMethod_MirandaInterface {
public boolean inAbstract() {
return true;
}
}
private static interface testGetMirandaMethod_MirandaInterface {
public boolean inInterface();
}
// Test sign-extension for values < 32b
static native byte byteMethod(byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7,
byte b8, byte b9, byte b10);
private static void testByteMethod() {
byte returns[] = { 0, 1, 2, 127, -1, -2, -128 };
for (int i = 0; i < returns.length; i++) {
byte result = byteMethod((byte)i, (byte)2, (byte)(-3), (byte)4, (byte)(-5), (byte)6,
(byte)(-7), (byte)8, (byte)(-9), (byte)10);
if (returns[i] != result) {
System.out.println("Run " + i + " with " + returns[i] + " vs " + result);
throw new AssertionError();
}
}
}
private static native void removeLocalObject(Object o);
private static void testRemoveLocalObject() {
removeLocalObject(new Object());
}
private static native short shortMethod(short s1, short s2, short s3, short s4, short s5, short s6, short s7,
short s8, short s9, short s10);
private static void testShortMethod() {
short returns[] = { 0, 1, 2, 127, 32767, -1, -2, -128, -32768 };
for (int i = 0; i < returns.length; i++) {
short result = shortMethod((short)i, (short)2, (short)(-3), (short)4, (short)(-5), (short)6,
(short)(-7), (short)8, (short)(-9), (short)10);
if (returns[i] != result) {
System.out.println("Run " + i + " with " + returns[i] + " vs " + result);
throw new AssertionError();
}
}
}
// Test zero-extension for values < 32b
private static native boolean booleanMethod(boolean b1, boolean b2, boolean b3, boolean b4, boolean b5, boolean b6, boolean b7,
boolean b8, boolean b9, boolean b10);
private static void testBooleanMethod() {
if (booleanMethod(false, true, false, true, false, true, false, true, false, true)) {
throw new AssertionError();
}
if (!booleanMethod(true, true, false, true, false, true, false, true, false, true)) {
throw new AssertionError();
}
}
private static native char charMethod(char c1, char c2, char c3, char c4, char c5, char c6, char c7,
char c8, char c9, char c10);
private static void testCharMethod() {
char returns[] = { (char)0, (char)1, (char)2, (char)127, (char)255, (char)256, (char)15000,
(char)34000 };
for (int i = 0; i < returns.length; i++) {
char result = charMethod((char)i, 'a', 'b', 'c', '0', '1', '2', (char)1234, (char)2345,
(char)3456);
if (returns[i] != result) {
System.out.println("Run " + i + " with " + (int)returns[i] + " vs " + (int)result);
throw new AssertionError();
}
}
}
// http://b/16531674
private static void testIsAssignableFromOnPrimitiveTypes() {
if (!nativeIsAssignableFrom(int.class, Integer.TYPE)) {
System.out.println("IsAssignableFrom(int.class, Integer.TYPE) returned false, expected true");
throw new AssertionError();
}
if (!nativeIsAssignableFrom(Integer.TYPE, int.class)) {
System.out.println("IsAssignableFrom(Integer.TYPE, int.class) returned false, expected true");
throw new AssertionError();
}
}
private static native boolean nativeIsAssignableFrom(Class<?> from, Class<?> to);
private static void testShallowGetCallingClassLoader() {
nativeTestShallowGetCallingClassLoader();
}
private native static void nativeTestShallowGetCallingClassLoader();
private static void testShallowGetStackClass2() {
nativeTestShallowGetStackClass2();
}
private static native void nativeTestShallowGetStackClass2();
private static native void testCallNonvirtual();
private static native void testNewStringObject();
private interface SimpleInterface {
void a();
}
private static class DummyInvocationHandler implements InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
}
private static void testProxyGetMethodID() {
InvocationHandler handler = new DummyInvocationHandler();
SimpleInterface proxy =
(SimpleInterface) Proxy.newProxyInstance(SimpleInterface.class.getClassLoader(),
new Class[] {SimpleInterface.class}, handler);
if (testGetMethodID(SimpleInterface.class) == 0) {
throw new AssertionError();
}
if (testGetMethodID(proxy.getClass()) == 0) {
throw new AssertionError();
}
}
private static native long testGetMethodID(Class<?> c);
// Exercise GC and JNI critical sections in parallel.
private static void testJniCriticalSectionAndGc() {
Thread runGcThread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; ++i) {
Runtime.getRuntime().gc();
}
}
});
Thread jniCriticalThread = new Thread(new Runnable() {
@Override
public void run() {
final int arraySize = 32;
byte[] array0 = new byte[arraySize];
byte[] array1 = new byte[arraySize];
enterJniCriticalSection(arraySize, array0, array1);
}
});
jniCriticalThread.start();
runGcThread.start();
try {
jniCriticalThread.join();
runGcThread.join();
} catch (InterruptedException ignored) {}
}
private static native void enterJniCriticalSection(int arraySize, byte[] array0, byte[] array);
private static native void testInvokeLambdaMethod(LambdaInterface iface);
private static native void testInvokeLambdaDefaultMethod(LambdaInterface iface);
}
@FunctionalInterface
interface LambdaInterface {
public void sayHi();
public default void sayHiTwice() {
sayHi();
sayHi();
}
}
class JniCallNonvirtualTest {
public boolean nonstaticMethodSuperCalled = false;
public boolean nonstaticMethodSubCalled = false;
private static native void testCallNonvirtual();
public JniCallNonvirtualTest() {
System.out.println("Super.<init>");
}
public static void staticMethod() {
System.out.println("Super.staticMethod");
}
public void nonstaticMethod() {
System.out.println("Super.nonstaticMethod");
nonstaticMethodSuperCalled = true;
}
}
class JniCallNonvirtualTestSubclass extends JniCallNonvirtualTest {
public JniCallNonvirtualTestSubclass() {
System.out.println("Subclass.<init>");
}
public static void staticMethod() {
System.out.println("Subclass.staticMethod");
}
public void nonstaticMethod() {
System.out.println("Subclass.nonstaticMethod");
nonstaticMethodSubCalled = true;
}
}