1a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers/* 2a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * Copyright (C) 2011 The Android Open Source Project 3a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * 4a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * Licensed under the Apache License, Version 2.0 (the "License"); 5a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * you may not use this file except in compliance with the License. 6a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * You may obtain a copy of the License at 7a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * 8a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * http://www.apache.org/licenses/LICENSE-2.0 9a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * 10a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * Unless required by applicable law or agreed to in writing, software 11a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * distributed under the License is distributed on an "AS IS" BASIS, 12a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * See the License for the specific language governing permissions and 14a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * limitations under the License. 15a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers */ 16a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 17a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogerspackage dalvik.system; 18a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 19a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogersimport junit.framework.TestCase; 20a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 21a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers/** 22a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers * Test JNI behavior 23a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers */ 24a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogerspublic final class JniTest extends TestCase { 25a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 26a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers static { 27a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers System.loadLibrary("javacoretests"); 28a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 29a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 30a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** @return this argument of method */ 31a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private native JniTest returnThis(); 32a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** @return class argument of method */ 33a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private static native Class<JniTest> returnClass(); 34a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 35a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private native Object returnObjectArgFrom16(int arg_no, 36a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Object o1, Object o2, Object o3, Object o4, Object o5, 37a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Object o6, Object o7, Object o8, Object o9, Object o10, 38a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Object o11, Object o12, Object o13, Object o14, Object o15, 39a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Object o16); 40a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private native boolean returnBooleanArgFrom16(int arg_no, 41a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers boolean o1, boolean o2, boolean o3, boolean o4, boolean o5, 42a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers boolean o6, boolean o7, boolean o8, boolean o9, boolean o10, 43a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers boolean o11, boolean o12, boolean o13, boolean o14, boolean o15, 44a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers boolean o16); 45a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private native char returnCharArgFrom16(int arg_no, 46a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers char o1, char o2, char o3, char o4, char o5, 47a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers char o6, char o7, char o8, char o9, char o10, 48a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers char o11, char o12, char o13, char o14, char o15, 49a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers char o16); 50a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private native byte returnByteArgFrom16(int arg_no, 51a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers byte o1, byte o2, byte o3, byte o4, byte o5, 52a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers byte o6, byte o7, byte o8, byte o9, byte o10, 53a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers byte o11, byte o12, byte o13, byte o14, byte o15, 54a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers byte o16); 55a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private native short returnShortArgFrom16(int arg_no, 56a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers short o1, short o2, short o3, short o4, short o5, 57a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers short o6, short o7, short o8, short o9, short o10, 58a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers short o11, short o12, short o13, short o14, short o15, 59a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers short o16); 60a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private native int returnIntArgFrom16(int arg_no, 61a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers int o1, int o2, int o3, int o4, int o5, 62a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers int o6, int o7, int o8, int o9, int o10, 63a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers int o11, int o12, int o13, int o14, int o15, 64a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers int o16); 65a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private native long returnLongArgFrom16(int arg_no, 66a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers long o1, long o2, long o3, long o4, long o5, 67a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers long o6, long o7, long o8, long o9, long o10, 68a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers long o11, long o12, long o13, long o14, long o15, 69a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers long o16); 70a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private native float returnFloatArgFrom16(int arg_no, 71a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers float o1, float o2, float o3, float o4, float o5, 72a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers float o6, float o7, float o8, float o9, float o10, 73a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers float o11, float o12, float o13, float o14, float o15, 74a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers float o16); 75a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers private native double returnDoubleArgFrom16(int arg_no, 76a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers double o1, double o2, double o3, double o4, double o5, 77a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers double o6, double o7, double o8, double o9, double o10, 78a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers double o11, double o12, double o13, double o14, double o15, 79a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers double o16); 80a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 81a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test cases for implicit this argument */ 82a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingThis() { 83a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(this, returnThis()); 84a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 85a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 86a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test cases for implicit class argument */ 87a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingClass() { 88a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(JniTest.class, returnClass()); 89a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 90a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 91a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test passing object references as arguments to a native method */ 92a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingObjectReferences() { 93a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final Object[] literals = {"Bradshaw", "Isherwood", "Oldknow", "Mallet", 94a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers JniTest.class, null, Integer.valueOf(0)}; 95a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final Object[] a = new Object[16]; 96a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are all the same 97a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(Object literal : literals) { 98a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 99a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literal; 100a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 101a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 102a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnObjectArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 103a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 104a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 105a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 106a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 107a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are shuffled 108a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int j = 0; j < literals.length; j++) { 109a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 110a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literals[(i + j) % literals.length]; 111a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 112a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 113a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnObjectArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 114a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 115a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 116a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 117a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 118a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 119a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 120a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test passing booleans as arguments to a native method */ 121a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingBooleans() { 122a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final boolean[] literals = {true, false, false, true}; 123a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final boolean[] a = new boolean[16]; 124a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are all the same 125a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(boolean literal : literals) { 126a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 127a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literal; 128a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 129a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 130a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnBooleanArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 131a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 132a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 133a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 134a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 135a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are shuffled 136a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int j = 0; j < literals.length; j++) { 137a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 138a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literals[(i + j) % literals.length]; 139a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 140a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 141a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnBooleanArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 142a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 143a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 144a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 145a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 146a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 147a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 148a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test passing characters as arguments to a native method */ 149a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingChars() { 150a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final char[] literals = {Character.MAX_VALUE, Character.MIN_VALUE, 151a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Character.MAX_HIGH_SURROGATE, Character.MAX_LOW_SURROGATE, 152a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Character.MIN_HIGH_SURROGATE, Character.MIN_LOW_SURROGATE, 153a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 'a', 'z', 'A', 'Z', '0', '9'}; 154a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final char[] a = new char[16]; 155a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are all the same 156a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(char literal : literals) { 157a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 158a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literal; 159a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 160a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 161a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnCharArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 162a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 163a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 164a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 165a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 166a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are shuffled 167a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int j = 0; j < literals.length; j++) { 168a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 169a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literals[(i + j) % literals.length]; 170a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 171a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 172a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnCharArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 173a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 174a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 175a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 176a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 177a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 178a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 179a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test passing bytes as arguments to a native method */ 180a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingBytes() { 181a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final byte[] literals = {Byte.MAX_VALUE, Byte.MIN_VALUE, 0, -1}; 182a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final byte[] a = new byte[16]; 183a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are all the same 184a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(byte literal : literals) { 185a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 186a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literal; 187a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 188a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 189a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnByteArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 190a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 191a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 192a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 193a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 194a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are shuffled 195a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int j = 0; j < literals.length; j++) { 196a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 197a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literals[(i + j) % literals.length]; 198a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 199a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 200a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnByteArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 201a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 202a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 203a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 204a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 205a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 206a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 207a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test passing shorts as arguments to a native method */ 208a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingShorts() { 209a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final short[] literals = {Byte.MAX_VALUE, Byte.MIN_VALUE, Short.MAX_VALUE, Short.MIN_VALUE, 0, -1}; 210a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final short[] a = new short[16]; 211a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are all the same 212a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(short literal : literals) { 213a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 214a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literal; 215a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 216a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 217a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnShortArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 218a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 219a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 220a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 221a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 222a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are shuffled 223a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int j = 0; j < literals.length; j++) { 224a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 225a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literals[(i + j) % literals.length]; 226a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 227a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 228a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnShortArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 229a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 230a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 231a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 232a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 233a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 234a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 235a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test passing ints as arguments to a native method */ 236a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingInts() { 237a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final int[] literals = {Byte.MAX_VALUE, Byte.MIN_VALUE, Short.MAX_VALUE, Short.MIN_VALUE, 238a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Integer.MAX_VALUE, Integer.MIN_VALUE, 0, -1}; 239a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final int[] a = new int[16]; 240a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are all the same 241a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int literal : literals) { 242a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 243a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literal; 244a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 245a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 246a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnIntArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 247a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 248a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 249a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 250a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 251a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are shuffled 252a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int j = 0; j < literals.length; j++) { 253a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 254a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literals[(i + j) % literals.length]; 255a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 256a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 257a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnIntArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 258a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 259a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 260a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 261a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 262a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 263a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 264a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test passing longs as arguments to a native method */ 265a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingLongs() { 266a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final long[] literals = {Byte.MAX_VALUE, Byte.MIN_VALUE, Short.MAX_VALUE, Short.MIN_VALUE, 267a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Integer.MAX_VALUE, Integer.MIN_VALUE, Long.MAX_VALUE, Long.MIN_VALUE, 0, -1}; 268a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final long[] a = new long[16]; 269a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are all the same 270a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(long literal : literals) { 271a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 272a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literal; 273a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 274a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 275a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnLongArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 276a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 277a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 278a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 279a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 280a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are shuffled 281a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int j = 0; j < literals.length; j++) { 282a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 283a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literals[(i + j) % literals.length]; 284a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 285a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 286a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnLongArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 287a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 288a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 289a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 290a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 291a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 292a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 293a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test passing floats as arguments to a native method */ 294a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingFloats() { 295a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final float[] literals = {Byte.MAX_VALUE, Byte.MIN_VALUE, Short.MAX_VALUE, Short.MIN_VALUE, 296a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Integer.MAX_VALUE, Integer.MIN_VALUE, Long.MAX_VALUE, Long.MIN_VALUE, 297a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Float.MAX_VALUE, Float.MIN_VALUE, Float.MIN_NORMAL, Float.NaN, 298a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, (float)Math.E, (float)Math.PI, 0, -1}; 299a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final float[] a = new float[16]; 300a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are all the same 301a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(float literal : literals) { 302a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 303a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literal; 304a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 305a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 306a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnFloatArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 307a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 308a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 309a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 310a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 311a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are shuffled 312a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int j = 0; j < literals.length; j++) { 313a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 314a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literals[(i + j) % literals.length]; 315a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 316a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 317a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnFloatArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 318a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 319a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 320a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 321a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 322a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 323a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers 324a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers /** Test passing doubles as arguments to a native method */ 325a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers public void testPassingDoubles() { 326a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final double[] literals = {Byte.MAX_VALUE, Byte.MIN_VALUE, Short.MAX_VALUE, Short.MIN_VALUE, 327a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Integer.MAX_VALUE, Integer.MIN_VALUE, Long.MAX_VALUE, Long.MIN_VALUE, 328a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Float.MAX_VALUE, Float.MIN_VALUE, Float.MIN_NORMAL, Float.NaN, 329a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, 330a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Double.MAX_VALUE, Double.MIN_VALUE, Double.MIN_NORMAL, Double.NaN, 331a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 332a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers Math.E, Math.PI, 0, -1}; 333a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers final double[] a = new double[16]; 334a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are all the same 335a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(double literal : literals) { 336a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 337a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literal; 338a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 339a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 340a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnDoubleArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 341a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 342a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 343a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 344a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 345a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers // test selection from a list of object literals where the literals are shuffled 346a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int j = 0; j < literals.length; j++) { 347a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 348a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[i] = literals[(i + j) % literals.length]; 349a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 350a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers for(int i = 0; i < 16; i++) { 351a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers assertEquals(a[i], returnDoubleArgFrom16(i, a[0], a[1], a[2], a[3], a[4], 352a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[5], a[6], a[7], a[8], a[9], a[10], 353a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers a[11], a[12], a[13], a[14], a[15])); 354a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 355a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 356a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers } 3575dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson 3585dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson private static native Class<?> envGetSuperclass(Class<?> clazz); 3595dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson 3605dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson public void testGetSuperclass() { 3615dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson assertEquals(Object.class, envGetSuperclass(String.class)); 3625dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson assertEquals(null, envGetSuperclass(Object.class)); 3635dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson assertEquals(null, envGetSuperclass(int.class)); 3645dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson 3655dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson // incorrect! the spec says this should be null. http://b/5652725 3665dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson assertEquals(Object.class, envGetSuperclass(Runnable.class)); 3675dd7203e5b355bc5829260646aa4281d1182415fJesse Wilson } 368a515759d83bac3e3b6bfdea20eb9576621e6596aIan Rogers} 369