--- old/test/compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/HotSpotConstantReflectionProviderTest.java	2016-05-04 09:43:19.000000000 -1000
+++ new/test/compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/HotSpotConstantReflectionProviderTest.java	2016-05-04 09:43:19.000000000 -1000
@@ -21,12 +21,12 @@
  * questions.
  */
 
-/*
+/**
  * @test jdk.vm.ci.hotspot.test.HotSpotConstantReflectionProviderTest
  * @requires (os.simpleArch == "x64" | os.simpleArch == "sparcv9" | os.simpleArch == "aarch64")
  * @modules jdk.vm.ci/jdk.vm.ci.runtime
  *          jdk.vm.ci/jdk.vm.ci.meta
- *          jdk.vm.ci/jdk.vm.ci.hotspot
+ *          jdk.vm.ci.hotspot/jdk.vm.ci.hotspot
  *          java.base/jdk.internal.vm.annotation
  *          java.base/jdk.internal.misc
  * @library /testlibrary /test/lib /compiler/jvmci/jdk.vm.ci.hotspot.test/src
@@ -58,7 +58,7 @@
     public void testForObject(Object obj, String expected) {
         JavaConstant jConst = TestHelper.CONSTANT_REFLECTION_PROVIDER.forObject(obj);
         Assert.assertNotNull(jConst,
-                             "An instance of JavaConstant returned by" + " \"forObject\" method should not be null");
+                        "An instance of JavaConstant returned by" + " \"forObject\" method should not be null");
         Assert.assertEquals(jConst.toString(), expected, "Unexpected result:");
     }
 
@@ -66,67 +66,63 @@
     public void testForString(String string, String expected) {
         JavaConstant jConst = CONSTANT_REFLECTION_PROVIDER.forString(string);
         Assert.assertNotNull(jConst,
-                             "An instance of JavaConstant returned by" + " \"forString\" method should not be null");
+                        "An instance of JavaConstant returned by" + " \"forString\" method should not be null");
         Assert.assertEquals(jConst.toString(), expected, "Unexpected result:");
     }
 
     @Test(dataProvider = "constantEqualsDataProvider", dataProviderClass = ConstantEqualsDataProvider.class)
     public void testConstantEquals(Constant const1, Constant const2, Boolean expected) {
         Assert.assertEquals(CONSTANT_REFLECTION_PROVIDER.constantEquals(const1, const2), expected,
-                            "Unexpected result:");
+                        "Unexpected result:");
     }
 
     @Test(dataProvider = "readArrayLengthDataProvider", dataProviderClass = ReadArrayLengthDataProvider.class)
     public void testReadArrayLength(JavaConstant array, Integer expected) {
         Assert.assertEquals(CONSTANT_REFLECTION_PROVIDER.readArrayLength(array), expected,
-                            "Unexpected result:");
+                        "Unexpected result:");
     }
 
     @Test(dataProvider = "readArrayElementDataProvider", dataProviderClass = ReadArrayElementDataProvider.class)
     public void testReadArrayElement(JavaConstant array, int index, Object expected) {
         Assert.assertEquals(CONSTANT_REFLECTION_PROVIDER.readArrayElement(array, index), expected,
-                            "Unexpected result:");
+                        "Unexpected result:");
     }
 
     @Test(dataProvider = "readFieldValueDataProvider", dataProviderClass = ReadFieldValueDataProvider.class)
     public void testReadFieldValue(ResolvedJavaField field, JavaConstant receiver, JavaConstant expected) {
         JavaConstant actual = CONSTANT_REFLECTION_PROVIDER.readFieldValue(field, receiver);
         Assert.assertEquals(actual == null ? "null" : actual.toString(),
-                            expected == null ? "null" : expected.toString(), "Unexpected result:");
+                        expected == null ? "null" : expected.toString(), "Unexpected result:");
     }
 
-    @Test(dataProvider = "readFieldValueNegativeDataProvider",
-            dataProviderClass = ReadFieldValueDataProvider.class,
-            expectedExceptions = {NullPointerException.class})
+    @Test(dataProvider = "readFieldValueNegativeDataProvider", dataProviderClass = ReadFieldValueDataProvider.class, expectedExceptions = {NullPointerException.class})
     public void testNegativeReadFieldValue(ResolvedJavaField field, JavaConstant receiver) {
         CONSTANT_REFLECTION_PROVIDER.readFieldValue(field, receiver);
     }
 
-    @Test(dataProvider = "readStableFieldValueDataProvider",
-            dataProviderClass = ReadStableFieldValueDataProvider.class)
+    @Test(dataProvider = "readStableFieldValueDataProvider", dataProviderClass = ReadStableFieldValueDataProvider.class)
     public void testReadStableFieldValue(ResolvedJavaField field, JavaConstant receiver, boolean isDefStab,
-                                         JavaConstant expected) {
+                    JavaConstant expected) {
         Assert.assertEquals(
-                CONSTANT_REFLECTION_PROVIDER.readStableFieldValue(field, receiver, isDefStab),
-                expected,
-                "Unexpected result:");
+                        CONSTANT_REFLECTION_PROVIDER.readStableFieldValue(field, receiver, isDefStab),
+                        expected,
+                        "Unexpected result:");
     }
 
-    @Test(dataProvider = "readStableFieldValueArrayDataProvider",
-            dataProviderClass = ReadStableFieldValueDataProvider.class)
+    @Test(dataProvider = "readStableFieldValueArrayDataProvider", dataProviderClass = ReadStableFieldValueDataProvider.class)
     public void testReadStableFieldValueForArray(ResolvedJavaField field, JavaConstant receiver, boolean isDefStab,
-                                                 int arrayDim, JavaConstant expected) {
+                    int arrayDim, JavaConstant expected) {
         JavaConstant result = CONSTANT_REFLECTION_PROVIDER.readStableFieldValue(field, receiver,
-                                                                                isDefStab);
+                        isDefStab);
         boolean resultDefStab = false;
         int resultStableDim = -1;
         try {
             Class<?> hotSpotObjectConstantImplClass = Class.forName(
-                    "jdk.vm.ci.hotspot.HotSpotObjectConstantImpl");
+                            "jdk.vm.ci.hotspot.HotSpotObjectConstantImpl");
             Method getStableDimensionMethod = hotSpotObjectConstantImplClass.getDeclaredMethod(
-                    "getStableDimension");
+                            "getStableDimension");
             Method isDefaultStableMethod = hotSpotObjectConstantImplClass.getDeclaredMethod(
-                    "isDefaultStable");
+                            "isDefaultStable");
             getStableDimensionMethod.setAccessible(true);
             isDefaultStableMethod.setAccessible(true);
             resultDefStab = (boolean) isDefaultStableMethod.invoke(result);
@@ -135,62 +131,55 @@
             throw new Error("Unexpected error: " + e, e);
         }
         Assert.assertEquals(resultDefStab, isDefStab,
-                            "Wrong default stable value for " + result.toString());
+                        "Wrong default stable value for " + result.toString());
         Assert.assertEquals(resultStableDim, arrayDim,
-                            "Wrong array dimension for " + result.toString());
+                        "Wrong array dimension for " + result.toString());
         Assert.assertEquals(result.toString(), expected.toString(), "Unexpected result:");
     }
 
-    @Test(dataProvider = "readStableFieldValueNegativeDataProvider",
-            dataProviderClass = ReadStableFieldValueDataProvider.class,
-            expectedExceptions = {NullPointerException.class})
+    @Test(dataProvider = "readStableFieldValueNegativeDataProvider", dataProviderClass = ReadStableFieldValueDataProvider.class, expectedExceptions = {NullPointerException.class})
     public void testNegativeReadStableFieldValue(ResolvedJavaField field, JavaConstant receiver, boolean isDefStab) {
         CONSTANT_REFLECTION_PROVIDER.readStableFieldValue(field, receiver, isDefStab);
     }
 
-    @Test(dataProvider = "readConstantFieldValueDataProvider",
-            dataProviderClass = ReadConstantFieldValueDataProvider.class)
+    @Test(dataProvider = "readConstantFieldValueDataProvider", dataProviderClass = ReadConstantFieldValueDataProvider.class)
     public void testReadConstantFieldValue(ResolvedJavaField field, JavaConstant receiver, JavaConstant expected,
-                                           String testInfo) {
+                    String testInfo) {
         String msg = String.format("Unexpected result for %s. Field is stable = %s.", testInfo,
-                                   ((HotSpotResolvedJavaField) field).isStable());
+                        ((HotSpotResolvedJavaField) field).isStable());
         Assert.assertEquals(CONSTANT_REFLECTION_PROVIDER.readConstantFieldValue(field, receiver),
-                            expected, msg);
+                        expected, msg);
     }
 
-    @Test(dataProvider = "readConstantFieldValueNegativeDataProvider",
-            dataProviderClass = ReadConstantFieldValueDataProvider.class,
-            expectedExceptions = {NullPointerException.class})
+    @Test(dataProvider = "readConstantFieldValueNegativeDataProvider", dataProviderClass = ReadConstantFieldValueDataProvider.class, expectedExceptions = {NullPointerException.class})
     public void testNegativeReadConstantFieldValue(ResolvedJavaField field, JavaConstant receiver) {
         CONSTANT_REFLECTION_PROVIDER.readConstantFieldValue(field, receiver);
     }
 
-    @Test(dataProvider = "readConstantArrayElementDataProvider",
-            dataProviderClass = ReadConstantArrayElementDataProvider.class)
+    @Test(dataProvider = "readConstantArrayElementDataProvider", dataProviderClass = ReadConstantArrayElementDataProvider.class)
     public void testReadConstantArrayElement(JavaConstant array, int index, JavaConstant expected, String testInfo) {
         JavaConstant actual = CONSTANT_REFLECTION_PROVIDER.readConstantArrayElement(array, index);
         Assert.assertEquals(actual == null ? "null" : actual.toString(),
-                            expected == null ? "null" : expected.toString(),
-                            String.format("Unexpected result while testing %s:", testInfo));
+                        expected == null ? "null" : expected.toString(),
+                        String.format("Unexpected result while testing %s:", testInfo));
     }
 
-    @Test(dataProvider = "readConstantArrayElementForOffsetDataProvider",
-            dataProviderClass = ReadConstantArrayElementDataProvider.class)
+    @Test(dataProvider = "readConstantArrayElementForOffsetDataProvider", dataProviderClass = ReadConstantArrayElementDataProvider.class)
     public void testReadConstantArrayElementForOffset(JavaConstant array, long offset, JavaConstant expected,
-                                                      String testInfo) {
+                    String testInfo) {
         JavaConstant actual = CONSTANT_REFLECTION_PROVIDER.readConstantArrayElementForOffset(array,
-                                                                                             offset);
+                        offset);
         Assert.assertEquals(actual == null ? "null" : actual.toString(),
-                            expected == null ? "null" : expected.toString(),
-                            String.format("Unexpected result while testing %s:", testInfo));
+                        expected == null ? "null" : expected.toString(),
+                        String.format("Unexpected result while testing %s:", testInfo));
     }
 
     @Test(dataProvider = "asJavaTypeDataProvider", dataProviderClass = AsJavaTypeDataProvider.class)
     public void testAsJavaType(JavaConstant constant, String expected) {
         ResolvedJavaType actual = CONSTANT_REFLECTION_PROVIDER.asJavaType(constant);
         Assert.assertEquals(actual == null ? "null" : actual.toJavaName(),
-                            expected == null ? "null" : expected,
-                            "Unexpected result, wrong type returned:");
+                        expected == null ? "null" : expected,
+                        "Unexpected result, wrong type returned:");
     }
 
     @Test(dataProvider = "boxPrimitiveDataProvider", dataProviderClass = BoxPrimitiveDataProvider.class)
@@ -221,6 +210,6 @@
     public void testGetMethodHandleAccess() {
         MethodHandleAccessProvider actual = CONSTANT_REFLECTION_PROVIDER.getMethodHandleAccess();
         Assert.assertNotNull(actual,
-                             "Returned MethodHandleAccessProvider instance should not be null");
+                        "Returned MethodHandleAccessProvider instance should not be null");
     }
 }