diff --git a/test/functional/Valhalla/src_qtypes/org/openj9/test/lworld/ValueTypeSystemArraycopyTests.java b/test/functional/Valhalla/src_qtypes/org/openj9/test/lworld/ValueTypeSystemArraycopyTests.java
index 5292ac66d3e..701b9c61180 100644
--- a/test/functional/Valhalla/src_qtypes/org/openj9/test/lworld/ValueTypeSystemArraycopyTests.java
+++ b/test/functional/Valhalla/src_qtypes/org/openj9/test/lworld/ValueTypeSystemArraycopyTests.java
@@ -60,9 +60,10 @@ public static class SomeIdentityClass2 implements SomeInterface {
 	}
 
 	@ImplicitlyConstructible
-	public value static class SomeValueClass implements SomeInterface {
+	public static value class SomeValueClass implements SomeInterface {
 		double val1;
 		long val2;
+		@NullRestricted
 		SomeValueClass2 val3;
 		int val4;
 
@@ -74,37 +75,12 @@ public value static class SomeValueClass implements SomeInterface {
 		}
 	}
 
-	public static class SomeValueClass2 implements SomeInterface {
-		long val1;
-		double val2;
-
-		SomeValueClass2(int i) {
-			this.val1 = (long)(i*5);
-			this.val2 = (double)(i*6);
-		}
-	}
-
-	@ImplicitlyConstructible
-	public static value class SomePrimitiveValueClass implements SomeInterface {
-		double val1;
-		long val2;
-		SomePrimitiveValueClass2 val3;
-		int val4;
-
-		SomePrimitiveValueClass(int i) {
-			this.val1 = (double)i;
-			this.val2 = (long)(i*2);
-			this.val3 = new SomePrimitiveValueClass2(i*3);
-			this.val4 = i*4;
-		}
-	}
-
 	@ImplicitlyConstructible
-	public static value class SomePrimitiveValueClass2 implements SomeInterface {
+	public static value class SomeValueClass2 implements SomeInterface {
 		long val1;
 		double val2;
 
-		SomePrimitiveValueClass2(int i) {
+		SomeValueClass2(int i) {
 			this.val1 = (long)(i*5);
 			this.val2 = (double)(i*6);
 		}
@@ -116,11 +92,6 @@ public static value class SomePrimitiveValueClass2 implements SomeInterface {
 	public static SomeIdentityClass[] idArraySrc = new SomeIdentityClass[ARRAY_SIZE];
 	public static SomeValueClass[] vtArrayDst = new SomeValueClass[ARRAY_SIZE];
 	public static SomeValueClass[] vtArraySrc = new SomeValueClass[ARRAY_SIZE];
-	public static SomePrimitiveValueClass[] primitiveVtArrayDst =
-		(SomePrimitiveValueClass[])ValueClass.newNullRestrictedArray(SomePrimitiveValueClass.class, ARRAY_SIZE);
-	public static SomePrimitiveValueClass[] primitiveVtArraySrc =
-			(SomePrimitiveValueClass[])ValueClass.newNullRestrictedArray(SomePrimitiveValueClass.class, ARRAY_SIZE);
-	/* These arrays should be used instead of primitiveVTArrayDst/Src once javac supports null-restricted classes. */
 	public static SomeValueClass[] nullRestrictedVtArraySrc =
 		(SomeValueClass[])ValueClass.newNullRestrictedArray(SomeValueClass.class, ARRAY_SIZE);
 	public static SomeValueClass[] nullRestrictedVtArrayDst =
@@ -129,15 +100,17 @@ public static value class SomePrimitiveValueClass2 implements SomeInterface {
 	public static SomeInterface[] ifIdArraySrc = new SomeIdentityClass[ARRAY_SIZE];
 	public static SomeInterface[] ifVtArrayDst = new SomeValueClass[ARRAY_SIZE];
 	public static SomeInterface[] ifVtArraySrc = new SomeValueClass[ARRAY_SIZE];
-	public static SomeInterface[] ifPrimitiveVtArrayDst = new SomePrimitiveValueClass[ARRAY_SIZE];
-	public static SomeInterface[] ifPrimitiveVtArraySrc = new SomePrimitiveValueClass[ARRAY_SIZE];
+	public static SomeInterface[] ifNullRestrictedVtArrayDst =
+		(SomeValueClass[])ValueClass.newNullRestrictedArray(SomeValueClass.class, ARRAY_SIZE);
+	public static SomeInterface[] ifNullRestrictedVtArraySrc =
+		(SomeValueClass[])ValueClass.newNullRestrictedArray(SomeValueClass.class, ARRAY_SIZE);
 	public static SomeInterface[] ifArray1 = new SomeInterface[ARRAY_SIZE];
 	public static SomeInterface[] ifArray2 = new SomeInterface[ARRAY_SIZE];
 	public static SomeInterface[] ifArray3 = new SomeInterface[ARRAY_SIZE];
 
 	public static SomeIdentityClass[] idArrayDstCheckForException = new SomeIdentityClass[ARRAY_SIZE];
-	public static SomePrimitiveValueClass[] primitiveVtArrayDstCheckForException =
-		(SomePrimitiveValueClass[])ValueClass.newNullRestrictedArray(SomePrimitiveValueClass.class, ARRAY_SIZE);
+	public static SomeValueClass[] nullRestrictedVtArrayDstCheckForException =
+		(SomeValueClass[])ValueClass.newNullRestrictedArray(SomeValueClass.class, ARRAY_SIZE);
 
 	static private void initArrays() {
 		for (int i=0; i < ARRAY_SIZE; i++) {
@@ -148,8 +121,8 @@ static private void initArrays() {
 			vtArrayDst[i] = new SomeValueClass(i*3);
 			vtArraySrc[i] = new SomeValueClass(i*4);
 
-			primitiveVtArrayDst[i] = new SomePrimitiveValueClass(i*5);
-			primitiveVtArraySrc[i] = new SomePrimitiveValueClass(i*6);
+			nullRestrictedVtArrayDst[i] = new SomeValueClass(i*5);
+			nullRestrictedVtArraySrc[i] = new SomeValueClass(i*6);
 
 			ifIdArrayDst[i] = new SomeIdentityClass(i*7);
 			ifIdArraySrc[i] = new SomeIdentityClass(i*8);
@@ -157,12 +130,12 @@ static private void initArrays() {
 			ifVtArrayDst[i] = new SomeValueClass(i*9);
 			ifVtArraySrc[i] = new SomeValueClass(i*10);
 
-			ifPrimitiveVtArrayDst[i] = new SomePrimitiveValueClass(i*11);
-			ifPrimitiveVtArraySrc[i] = new SomePrimitiveValueClass(i*12);
+			ifNullRestrictedVtArrayDst[i] = new SomeValueClass(i*11);
+			ifNullRestrictedVtArraySrc[i] = new SomeValueClass(i*12);
 
 			ifArray1[i] = new SomeIdentityClass(i*13);
 			ifArray2[i] = new SomeValueClass(i*14);
-			ifArray3[i] = new SomePrimitiveValueClass(i*15);
+			ifArray3[i] = new SomeValueClass(i*15); // TODO nr
 
 			nullRestrictedVtArrayDst[i] = new SomeValueClass(i*16);
 			nullRestrictedVtArraySrc[i] = new SomeValueClass(i*17);
@@ -175,29 +148,29 @@ static private void initArraysForASETest() {
 				ifArray3[i] = null;
 			}
 			else {
-				ifArray3[i] = new SomePrimitiveValueClass(i*30);
+				ifArray3[i] = new SomeValueClass(i*30); // TODO nr
 			}
 
-			primitiveVtArrayDst[i] = new SomePrimitiveValueClass(i*5);
-			primitiveVtArrayDstCheckForException[i] = primitiveVtArrayDst[i];
+			nullRestrictedVtArrayDst[i] = new SomeValueClass(i*5);
+			nullRestrictedVtArrayDstCheckForException[i] = nullRestrictedVtArrayDst[i];
 		}
 	}
 
 	static private void initArraysForArrayStoreChkExceptionTest() {
 		for (int i=0; i < ARRAY_SIZE; i++) {
 			if (i >= ARRAY_SIZE/2) {
-				ifArray1[i] = new SomePrimitiveValueClass(i*13);
+				ifArray1[i] = new SomeValueClass(i*13); // TODO nr
 				ifArray3[i] = new SomeIdentityClass(i*30);
 			}
 			else {
 				ifArray1[i] = new SomeIdentityClass(i*13);
-				ifArray3[i] = new SomePrimitiveValueClass(i*30);
+				ifArray3[i] = new SomeValueClass(i*30); // TODO nr
 			}
 
 			idArrayDst[i] = new SomeIdentityClass(i);
 			idArrayDstCheckForException[i] = idArrayDst[i];
-			primitiveVtArrayDst[i] = new SomePrimitiveValueClass(i*5);
-			primitiveVtArrayDstCheckForException[i] = primitiveVtArrayDst[i];
+			nullRestrictedVtArrayDst[i] = new SomeValueClass(i*5);
+			nullRestrictedVtArrayDstCheckForException[i] = nullRestrictedVtArrayDst[i];
 		}
 	}
 
@@ -221,8 +194,8 @@ static private void checkResultsPartial(Object[] arr1, Object[] arr2, int numOfE
 	}
 
 	static private void checkPVTArrayAfterException(int index) {
-		for (int i=index; i < primitiveVtArrayDst.length; ++i) {
-			assertEquals(primitiveVtArrayDst[i], primitiveVtArrayDstCheckForException[i]);
+		for (int i=index; i < nullRestrictedVtArrayDst.length; ++i) {
+			assertEquals(nullRestrictedVtArrayDst[i], nullRestrictedVtArrayDstCheckForException[i]);
 		}
 	}
 
@@ -256,18 +229,6 @@ static private void testIFVT(SomeInterface[] src, SomeValueClass[] dst) {
 		System.arraycopy(src, 0, dst, 0, ARRAY_SIZE);
 	}
 
-	static private void testPVTPVT(SomePrimitiveValueClass[] src, SomePrimitiveValueClass[] dst) {
-		System.arraycopy(src, 0, dst, 0, ARRAY_SIZE);
-	}
-
-	static private void testPVTIF(SomePrimitiveValueClass[] src, SomeInterface[] dst) {
-		System.arraycopy(src, 0, dst, 0, ARRAY_SIZE);
-	}
-
-	static private void testIFPVT(SomeInterface[] src, SomePrimitiveValueClass[] dst) {
-		System.arraycopy(src, 0, dst, 0, ARRAY_SIZE);
-	}
-
 	static private void testIFIF(SomeInterface[] src, SomeInterface[] dst) {
 		System.arraycopy(src, 0, dst, 0, ARRAY_SIZE);
 	}
@@ -324,38 +285,12 @@ static private void testOBJVT(SomeValueClass[] dst) {
 		checkResults(src, dst);
 	}
 
-	static private void testPVTOBJ(SomePrimitiveValueClass[] src) {
-
-		Object[] dst = new Object[ARRAY_SIZE];
-
-		for (int i=0; i < ARRAY_SIZE; i++) {
-			dst[i] = new SomePrimitiveValueClass(i*20);
-		}
-
-		System.arraycopy(src, 0, dst, 0, ARRAY_SIZE);
-
-		checkResults(src, dst);
-	}
-
-	static private void testOBJPVT(SomePrimitiveValueClass[] dst) {
-
-		Object[] src = new Object[ARRAY_SIZE];
-
-		for (int i=0; i < ARRAY_SIZE; i++) {
-			src[i] = new SomePrimitiveValueClass(i*21);
-		}
-
-		System.arraycopy(src, 0, dst, 0, ARRAY_SIZE);
-
-		checkResults(src, dst);
-	}
-
 	static private void testIFOBJ(SomeInterface[] src) {
 
 		Object[] dst = new Object[ARRAY_SIZE];
 
 		for (int i=0; i < ARRAY_SIZE; i++) {
-			dst[i] = new SomePrimitiveValueClass(i*22);
+			dst[i] = new SomeValueClass(i*22); // TODO nr
 		}
 
 		System.arraycopy(src, 0, dst, 0, ARRAY_SIZE);
@@ -368,7 +303,7 @@ static private void testOBJIF(SomeInterface[] dst) {
 		Object[] src = new Object[ARRAY_SIZE];
 
 		for (int i=0; i < ARRAY_SIZE; i++) {
-			src[i] = new SomePrimitiveValueClass(i*23);
+			src[i] = new SomeValueClass(i*23); // TODO nr
 		}
 
 		System.arraycopy(src, 0, dst, 0, ARRAY_SIZE);
@@ -456,36 +391,36 @@ static public void testSystemArrayCopy6() throws Throwable {
 	static public void testSystemArrayCopy7() throws Throwable {
 
 		initArrays();
-		testPVTPVT(primitiveVtArraySrc, primitiveVtArrayDst); // Fist invocation (Interpreter)
+		testVTVT(nullRestrictedVtArraySrc, nullRestrictedVtArrayDst); // Fist invocation (Interpreter)
 
 		initArrays();
-		testPVTPVT(primitiveVtArraySrc, primitiveVtArrayDst);
+		testVTVT(nullRestrictedVtArraySrc, nullRestrictedVtArrayDst);
 
-		checkResults(primitiveVtArraySrc, primitiveVtArrayDst);
+		checkResults(nullRestrictedVtArraySrc, nullRestrictedVtArrayDst);
 	}
 
 	@Test(priority=1)
 	static public void testSystemArrayCopy8() throws Throwable {
 
 		initArrays();
-		testPVTIF(primitiveVtArraySrc, ifPrimitiveVtArrayDst); // Fist invocation (Interpreter)
+		testVTIF(nullRestrictedVtArraySrc, ifNullRestrictedVtArrayDst); // Fist invocation (Interpreter)
 
 		initArrays();
-		testPVTIF(primitiveVtArraySrc, ifPrimitiveVtArrayDst);
+		testVTIF(nullRestrictedVtArraySrc, ifNullRestrictedVtArrayDst);
 
-		checkResults(primitiveVtArraySrc, ifPrimitiveVtArrayDst);
+		checkResults(nullRestrictedVtArraySrc, ifNullRestrictedVtArrayDst);
 	}
 
 	@Test(priority=1)
 	static public void testSystemArrayCopy9() throws Throwable {
 
 		initArrays();
-		testIFPVT(ifPrimitiveVtArraySrc, primitiveVtArrayDst); // Fist invocation (Interpreter)
+		testIFVT(ifNullRestrictedVtArraySrc, nullRestrictedVtArrayDst); // Fist invocation (Interpreter)
 
 		initArrays();
-		testIFPVT(ifPrimitiveVtArraySrc, primitiveVtArrayDst);
+		testIFVT(ifNullRestrictedVtArraySrc, nullRestrictedVtArrayDst);
 
-		checkResults(ifPrimitiveVtArraySrc, primitiveVtArrayDst);
+		checkResults(ifNullRestrictedVtArraySrc, nullRestrictedVtArrayDst);
 	}
 
 
@@ -504,8 +439,8 @@ static public void testSystemArrayCopy10() throws Throwable {
 		checkResults(ifVtArraySrc, ifVtArrayDst);
 
 		initArrays();
-		testIFIF(ifPrimitiveVtArraySrc, ifPrimitiveVtArrayDst);
-		checkResults(ifPrimitiveVtArraySrc, ifPrimitiveVtArrayDst);
+		testIFIF(ifNullRestrictedVtArraySrc, ifNullRestrictedVtArrayDst);
+		checkResults(ifNullRestrictedVtArraySrc, ifNullRestrictedVtArrayDst);
 
 		initArrays();
 		testIFIF(ifArray1, ifIdArrayDst);
@@ -524,12 +459,12 @@ static public void testSystemArrayCopy10() throws Throwable {
 		checkResults(ifVtArraySrc, ifArray2);
 
 		initArrays();
-		testIFIF(ifArray3, ifPrimitiveVtArrayDst);
-		checkResults(ifArray3, ifPrimitiveVtArrayDst);
+		testIFIF(ifArray3, ifNullRestrictedVtArrayDst);
+		checkResults(ifArray3, ifNullRestrictedVtArrayDst);
 
 		initArrays();
-		testIFIF(ifPrimitiveVtArraySrc, ifArray3);
-		checkResults(ifPrimitiveVtArraySrc, ifArray3);
+		testIFIF(ifNullRestrictedVtArraySrc, ifArray3);
+		checkResults(ifNullRestrictedVtArraySrc, ifArray3);
 	}
 
 	@Test(priority=1)
@@ -576,40 +511,40 @@ static public void testSystemArrayCopy14() throws Throwable {
 	static public void testSystemArrayCopy15() throws Throwable {
 
 		initArrays();
-		testPVTOBJ(primitiveVtArraySrc); // Fist invocation (Interpreter)
+		testVTOBJ(nullRestrictedVtArraySrc); // Fist invocation (Interpreter)
 
 		initArrays();
-		testPVTOBJ(primitiveVtArraySrc);
+		testVTOBJ(nullRestrictedVtArraySrc);
 	}
 
 	@Test(priority=1)
 	static public void testSystemArrayCopy16() throws Throwable {
 
 		initArrays();
-		testOBJPVT(primitiveVtArrayDst); // Fist invocation (Interpreter)
+		testOBJVT(nullRestrictedVtArrayDst); // Fist invocation (Interpreter)
 
 		initArrays();
-		testOBJPVT(primitiveVtArrayDst);
+		testOBJVT(nullRestrictedVtArrayDst);
 	}
 
 	@Test(priority=1)
 	static public void testSystemArrayCopy17() throws Throwable {
 
 		initArrays();
-		testIFOBJ(ifPrimitiveVtArraySrc); // Fist invocation (Interpreter)
+		testIFOBJ(ifNullRestrictedVtArraySrc); // Fist invocation (Interpreter)
 
 		initArrays();
-		testIFOBJ(ifPrimitiveVtArraySrc);
+		testIFOBJ(ifNullRestrictedVtArraySrc);
 	}
 
 	@Test(priority=1)
 	static public void testSystemArrayCopy18() throws Throwable {
 
 		initArrays();
-		testOBJIF(ifPrimitiveVtArrayDst); // Fist invocation (Interpreter)
+		testOBJIF(ifNullRestrictedVtArrayDst); // Fist invocation (Interpreter)
 
 		initArrays();
-		testOBJIF(ifPrimitiveVtArrayDst);
+		testOBJIF(ifNullRestrictedVtArrayDst);
 	}
 
 	@Test(priority=1)
@@ -627,8 +562,8 @@ static public void testSystemArrayCopy19() throws Throwable {
 		checkResults(ifVtArraySrc, ifVtArrayDst);
 
 		initArrays();
-		testOBJOBJ(ifPrimitiveVtArraySrc, ifPrimitiveVtArrayDst);
-		checkResults(ifPrimitiveVtArraySrc, ifPrimitiveVtArrayDst);
+		testOBJOBJ(ifNullRestrictedVtArraySrc, ifNullRestrictedVtArrayDst);
+		checkResults(ifNullRestrictedVtArraySrc, ifNullRestrictedVtArrayDst);
 
 		initArrays();
 		testOBJOBJ(ifArray1, ifIdArrayDst);
@@ -647,12 +582,12 @@ static public void testSystemArrayCopy19() throws Throwable {
 		checkResults(ifVtArraySrc, ifArray2);
 
 		initArrays();
-		testOBJOBJ(ifArray3, ifPrimitiveVtArrayDst);
-		checkResults(ifArray3, ifPrimitiveVtArrayDst);
+		testOBJOBJ(ifArray3, ifNullRestrictedVtArrayDst);
+		checkResults(ifArray3, ifNullRestrictedVtArrayDst);
 
 		initArrays();
-		testOBJOBJ(ifPrimitiveVtArraySrc, ifArray3);
-		checkResults(ifPrimitiveVtArraySrc, ifArray3);
+		testOBJOBJ(ifNullRestrictedVtArraySrc, ifArray3);
+		checkResults(ifNullRestrictedVtArraySrc, ifArray3);
 	}
 
 	@Test(priority=1)
@@ -677,10 +612,10 @@ static public void testSystemArrayCopy20() throws Throwable {
 		checkResults(src, ifVtArrayDst);
 
 		for (int i=0; i < ARRAY_SIZE; i++) {
-			src[i] = new SomePrimitiveValueClass(i*25);
+			src[i] = new SomeValueClass(i*25); // TODO nr
 		}
-		testOBJOBJ(src, ifPrimitiveVtArrayDst);
-		checkResults(src, ifPrimitiveVtArrayDst);
+		testOBJOBJ(src, ifNullRestrictedVtArrayDst);
+		checkResults(src, ifNullRestrictedVtArrayDst);
 	}
 
 	@Test(priority=1)
@@ -708,10 +643,10 @@ static public void testSystemArrayCopy21() throws Throwable {
 		checkResults(ifVtArraySrc, dst);
 
 		for (int i=0; i < ARRAY_SIZE; i++) {
-			dst[i] = new SomePrimitiveValueClass(i*26);
+			dst[i] = new SomeValueClass(i*26); // TODO nr
 		}
-		testOBJOBJ(ifPrimitiveVtArraySrc, dst);
-		checkResults(ifPrimitiveVtArraySrc, dst);
+		testOBJOBJ(ifNullRestrictedVtArraySrc, dst);
+		checkResults(ifNullRestrictedVtArraySrc, dst);
 	}
 
 	@Test(priority=1)
@@ -719,16 +654,16 @@ static public void testSystemArrayCopy22() throws Throwable {
 
 		try {
 			initArraysForASETest(); // ifArray3[ARRAY_SIZE/2] is NULL
-			testIFPVT(ifArray3, primitiveVtArrayDst);
+			testIFVT(ifArray3, nullRestrictedVtArrayDst);
 		} catch (java.lang.ArrayStoreException ase1) {
 			try {
-				checkResultsPartial(ifArray3, primitiveVtArrayDst, ARRAY_SIZE/2);
+				checkResultsPartial(ifArray3, nullRestrictedVtArrayDst, ARRAY_SIZE/2);
 				checkPVTArrayAfterException(ARRAY_SIZE/2);
 
 				initArraysForASETest();
-				testIFPVT(ifArray3, primitiveVtArrayDst);
+				testIFVT(ifArray3, nullRestrictedVtArrayDst);
 			} catch (java.lang.ArrayStoreException ase2) {
-				checkResultsPartial(ifArray3, primitiveVtArrayDst, ARRAY_SIZE/2);
+				checkResultsPartial(ifArray3, nullRestrictedVtArrayDst, ARRAY_SIZE/2);
 				// pass
 				return;
 			}
@@ -742,16 +677,16 @@ static public void testSystemArrayCopy23() throws Throwable {
 
 		try {
 			initArraysForASETest(); // ifArray3[ARRAY_SIZE/2] is NULL
-			testIFIF(ifArray3, primitiveVtArrayDst);
+			testIFIF(ifArray3, nullRestrictedVtArrayDst);
 		} catch (java.lang.ArrayStoreException ase1) {
 			try {
-				checkResultsPartial(ifArray3, primitiveVtArrayDst, ARRAY_SIZE/2);
+				checkResultsPartial(ifArray3, nullRestrictedVtArrayDst, ARRAY_SIZE/2);
 				checkPVTArrayAfterException(ARRAY_SIZE/2);
 
 				initArraysForASETest();
-				testIFIF(ifArray3, primitiveVtArrayDst);
+				testIFIF(ifArray3, nullRestrictedVtArrayDst);
 			} catch (java.lang.ArrayStoreException ase2) {
-				checkResultsPartial(ifArray3, primitiveVtArrayDst, ARRAY_SIZE/2);
+				checkResultsPartial(ifArray3, nullRestrictedVtArrayDst, ARRAY_SIZE/2);
 				checkPVTArrayAfterException(ARRAY_SIZE/2);
 				// pass
 				return;
@@ -766,16 +701,16 @@ static public void testSystemArrayCopy24() throws Throwable {
 
 		try {
 			initArraysForArrayStoreChkExceptionTest();  // ifArray3[ARRAY_SIZE/2] is SomeIdentityClass
-			testIFPVT(ifArray3, primitiveVtArrayDst);
+			testIFVT(ifArray3, nullRestrictedVtArrayDst);
 		} catch (java.lang.ArrayStoreException ase1) {
 			try {
-				checkResultsPartial(ifArray3, primitiveVtArrayDst, ARRAY_SIZE/2);
+				checkResultsPartial(ifArray3, nullRestrictedVtArrayDst, ARRAY_SIZE/2);
 				checkPVTArrayAfterException(ARRAY_SIZE/2);
 
 				initArraysForArrayStoreChkExceptionTest();
-				testIFPVT(ifArray3, primitiveVtArrayDst);
+				testIFVT(ifArray3, nullRestrictedVtArrayDst);
 			} catch (java.lang.ArrayStoreException ase2) {
-				checkResultsPartial(ifArray3, primitiveVtArrayDst, ARRAY_SIZE/2);
+				checkResultsPartial(ifArray3, nullRestrictedVtArrayDst, ARRAY_SIZE/2);
 				checkPVTArrayAfterException(ARRAY_SIZE/2);
 				// pass
 				return;
@@ -790,16 +725,16 @@ static public void testSystemArrayCopy25() throws Throwable {
 
 		try {
 			initArraysForArrayStoreChkExceptionTest();  // ifArray3[ARRAY_SIZE/2] is SomeIdentityClass
-			testIFIF(ifArray3, primitiveVtArrayDst);
+			testIFIF(ifArray3, nullRestrictedVtArrayDst);
 		} catch (java.lang.ArrayStoreException ase1) {
 			try {
-				checkResultsPartial(ifArray3, primitiveVtArrayDst, ARRAY_SIZE/2);
+				checkResultsPartial(ifArray3, nullRestrictedVtArrayDst, ARRAY_SIZE/2);
 				checkPVTArrayAfterException(ARRAY_SIZE/2);
 
 				initArraysForArrayStoreChkExceptionTest();
-				testIFIF(ifArray3, primitiveVtArrayDst);
+				testIFIF(ifArray3, nullRestrictedVtArrayDst);
 			} catch (java.lang.ArrayStoreException ase2) {
-				checkResultsPartial(ifArray3, primitiveVtArrayDst, ARRAY_SIZE/2);
+				checkResultsPartial(ifArray3, nullRestrictedVtArrayDst, ARRAY_SIZE/2);
 				checkPVTArrayAfterException(ARRAY_SIZE/2);
 				// pass
 				return;
@@ -813,7 +748,7 @@ static public void testSystemArrayCopy25() throws Throwable {
 	static public void testSystemArrayCopy26() throws Throwable {
 
 		try {
-			initArraysForArrayStoreChkExceptionTest();  // ifArray1[ARRAY_SIZE/2] is SomePrimitiveValueClass
+			initArraysForArrayStoreChkExceptionTest();  // ifArray1[ARRAY_SIZE/2] is null-restricted SomeValueClass
 			testIFIF(ifArray1, idArrayDst);
 		} catch (java.lang.ArrayStoreException ase1) {
 			try {