< prev index next >
test/compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestMetaAccessProvider.java
Print this page
*** 33,61 ****
--- 33,67 ----
package jdk.vm.ci.runtime.test;
import static jdk.vm.ci.meta.MetaUtil.toInternalName;
import static org.junit.Assert.assertEquals;
+ import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNotNull;
+ import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
+ import jdk.vm.ci.meta.DeoptimizationAction;
+ import jdk.vm.ci.meta.DeoptimizationReason;
import jdk.vm.ci.meta.JavaConstant;
import jdk.vm.ci.meta.JavaKind;
import jdk.vm.ci.meta.MetaAccessProvider;
import jdk.vm.ci.meta.ResolvedJavaField;
import jdk.vm.ci.meta.ResolvedJavaMethod;
import jdk.vm.ci.meta.ResolvedJavaType;
+ import jdk.vm.ci.meta.Signature;
import org.junit.Test;
/**
* Tests for {@link MetaAccessProvider}.
*/
public class TestMetaAccessProvider extends TypeUniverse {
+ private static final int[] VALID_ENCODED_VALUES = new int[]{-180, -436, -10932, -2147483572};
@Test
public void lookupJavaTypeTest() {
for (Class<?> c : classes) {
ResolvedJavaType type = metaAccess.lookupJavaType(c);
*** 67,76 ****
--- 73,120 ----
assertEquals(c.toString(), c.getName(), type.toJavaName());
}
}
}
+ @Test(expected = IllegalArgumentException.class)
+ public void lookupJavaTypeNegativeTest() {
+ metaAccess.lookupJavaType((Class<?>) null);
+ }
+
+ @Test
+ public void lookupJavaTypesTest() {
+ ResolvedJavaType[] result = metaAccess
+ .lookupJavaTypes(classes.toArray(new Class<?>[classes.size()]));
+ int counter = 0;
+ for (Class<?> aClass : classes) {
+ assertEquals("Unexpected javaType: " + result[counter]
+ + " while expecting of class: " + aClass,
+ result[counter].toClassName(), aClass.getName());
+ counter++;
+ }
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void lookupJavaTypesNegative1Test() {
+ assertNull("Expected null", metaAccess.lookupJavaTypes(null));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void lookupJavaTypesNegative2Test() {
+ ResolvedJavaType[] result = metaAccess.lookupJavaTypes(
+ new Class<?>[]{null, null, null});
+ for (ResolvedJavaType aType : result) {
+ assertNull("Expected null javaType", aType);
+ }
+ result = metaAccess.lookupJavaTypes(new Class<?>[]{String.class,
+ String.class});
+ assertEquals("Results not equals", result[0].getClass(),
+ result[1].getClass());
+ assertEquals("Result is not String.class", result[0].getClass(),
+ String.class);
+ }
+
@Test
public void lookupJavaMethodTest() {
for (Class<?> c : classes) {
for (Method reflect : c.getDeclaredMethods()) {
ResolvedJavaMethod method = metaAccess.lookupJavaMethod(reflect);
*** 78,87 ****
--- 122,136 ----
assertTrue(method.getDeclaringClass().equals(metaAccess.lookupJavaType(reflect.getDeclaringClass())));
}
}
}
+ @Test(expected = NullPointerException.class)
+ public void lookupJavaMethodNegativeTest() {
+ metaAccess.lookupJavaMethod(null);
+ }
+
@Test
public void lookupJavaFieldTest() {
for (Class<?> c : classes) {
for (Field reflect : c.getDeclaredFields()) {
ResolvedJavaField field = metaAccess.lookupJavaField(reflect);
*** 103,108 ****
--- 152,298 ----
} else {
assertEquals(metaAccess.lookupJavaType(c), null);
}
}
}
+
+ @Test(expected = NullPointerException.class)
+ public void lookupJavaTypeConstantNegativeTest() {
+ metaAccess.lookupJavaType((JavaConstant) null);
+ }
+
+ @Test
+ public void getMemorySizeTest() {
+ for (ConstantValue cv : constants()) {
+ JavaConstant c = cv.value;
+ long memSize = metaAccess.getMemorySize(c);
+ if (c.isNull()) {
+ assertEquals("Expected size = 0 for null", memSize, 0L);
+ } else {
+ assertTrue("Expected size != 0 for " + cv, memSize != 0L);
+ }
+ }
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void getMemorySizeNegativeTest() {
+ metaAccess.getMemorySize(null);
+ }
+
+ @Test
+ public void parseMethodDescriptorTest() {
+ for (String retType : new String[] {"V", "Z", "Ljava/lang/String;"}) {
+ for (String paramTypes : new String[] {"", "B",
+ "Ljava/lang/String;", "JLjava/lang/String;",
+ "Ljava/lang/String;F",
+ "[Ljava/lang/String;ZBCDFIJLS[ILjava/lang/Object;"}) {
+ String signature = "(" + paramTypes + ")" + retType;
+ Signature result = metaAccess.parseMethodDescriptor(signature);
+ assertEquals("Expected signatures to be equal",
+ result.toMethodDescriptor(), signature);
+ }
+ }
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void parseMethodDescriptorNegativeNullTest() {
+ metaAccess.parseMethodDescriptor(null);
+ }
+
+ @Test
+ public void encodeDeoptActionAndReasonTest() {
+ int[] ids = new int[]{-1, 0, 1, Integer.MAX_VALUE};
+ int casesLength = ids.length * DeoptimizationAction.values().length
+ * DeoptimizationReason.values().length;
+ JavaConstant[] allValues = new JavaConstant[casesLength];
+ int counter = 0;
+ for (DeoptimizationAction action : DeoptimizationAction.values()) {
+ for (DeoptimizationReason reason : DeoptimizationReason.values()) {
+ for (int debugId : new int[]{-1, 0, 1, Integer.MAX_VALUE}) {
+ JavaConstant result = metaAccess
+ .encodeDeoptActionAndReason(action, reason,
+ debugId);
+ JavaConstant result2 = metaAccess
+ .encodeDeoptActionAndReason(action, reason,
+ debugId);
+ assertNotNull("Expected not null result", result);
+ assertEquals("Expected equal results", result, result2);
+ allValues[counter++] = result;
+ for (int i = 0; i < counter - 1; i++) {
+ assertNotSame("Expected unique result for value "
+ + result, result, allValues[i]);
+ }
+ }
+ }
+ }
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void encodeDeoptActionAndReasonNegative1Test() {
+ metaAccess.encodeDeoptActionAndReason(null,
+ DeoptimizationReason.Aliasing, 0);
+
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void encodeDeoptActionAndReasonNegative2Test() {
+ metaAccess.encodeDeoptActionAndReason(
+ DeoptimizationAction.InvalidateRecompile, null, 0);
+ }
+
+ @Test
+ public void decodeDeoptReasonTest() {
+ for (int encoded : VALID_ENCODED_VALUES) {
+ JavaConstant value = JavaConstant.forInt(encoded);
+ DeoptimizationReason reason = metaAccess.decodeDeoptReason(value);
+ DeoptimizationReason reason2 = metaAccess.decodeDeoptReason(value);
+ assertNotNull("Expected not null reason", reason);
+ assertEquals("Expected equal reasons", reason, reason2);
+ }
+ }
+
+ @Test
+ public void decodeDeoptReasonNegative1Test() {
+ int encoded = 42;
+ JavaConstant value = JavaConstant.forInt(encoded);
+ metaAccess.decodeDeoptReason(value);
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void decodeDeoptReasonNegative2Test() {
+ metaAccess.decodeDeoptReason(null);
+ }
+
+ @Test
+ public void decodeDeoptActionTest() {
+ for (int encoded : VALID_ENCODED_VALUES) {
+ JavaConstant value = JavaConstant.forInt(encoded);
+ DeoptimizationAction action = metaAccess.decodeDeoptAction(value);
+ DeoptimizationAction action2 = metaAccess.decodeDeoptAction(value);
+ assertNotNull("Expected not null action", action);
+ assertEquals("Expected equal actions", action, action2);
+ }
+ }
+
+ @Test
+ public void decodeDeoptActionNegative1Test() {
+ int encoded = 123456789;
+ JavaConstant value = JavaConstant.forInt(encoded);
+ metaAccess.decodeDeoptAction(value);
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void decodeDeoptActionNegative2Test() {
+ metaAccess.decodeDeoptAction(null);
+ }
+
+ @Test
+ public void decodeDebugIdTest() {
+ int[] input = new int[]{-1, 0, 1, 42, Integer.MAX_VALUE, Integer.MIN_VALUE};
+ for (int encoded : input) {
+ JavaConstant value = JavaConstant.forInt(encoded);
+ int id = metaAccess.decodeDebugId(value);
+ int id2 = metaAccess.decodeDebugId(value);
+ assertEquals("Expected equal debugId", id, id2);
+ }
+ }
}
< prev index next >