From 40f7a18b2dbf120a95432174664fa897331e8973 Mon Sep 17 00:00:00 2001 From: Chen Liang Date: Fri, 23 Jan 2026 17:32:53 +0000 Subject: [PATCH] 8373935: Migrate java/lang/invoke tests away from TestNG Reviewed-by: jvernee, alanb --- .../java/lang/invoke/8147078/Test8147078.java | 23 +- .../invoke/8177146/TestMethodHandleBind.java | 33 +- .../java/lang/invoke/AccessControlTest.java | 57 +-- .../lang/invoke/ArrayConstructorTest.java | 52 +-- .../jdk/java/lang/invoke/ArrayLengthTest.java | 58 +-- .../invoke/CallerSensitiveMethodHandle.java | 13 +- .../lang/invoke/ClassSpecializerTest.java | 15 +- .../invoke/CompileThresholdBootstrapTest.java | 20 +- .../lang/invoke/ConstantIdentityMHTest.java | 30 +- .../jdk/java/lang/invoke/DefineClassTest.java | 73 ++-- .../java/lang/invoke/DropArgumentsTest.java | 39 +- .../java/lang/invoke/DropLookupModeTest.java | 107 +++-- .../java/lang/invoke/FilterArgumentsTest.java | 22 +- test/jdk/java/lang/invoke/FindAccessTest.java | 32 +- test/jdk/java/lang/invoke/FoldTest.java | 18 +- .../java/lang/invoke/InvokeGenericTest.java | 66 +-- .../InvokeMethodHandleWithBadArgument.java | 98 +++-- .../lang/invoke/InvokeWithArgumentsTest.java | 40 +- .../java/lang/invoke/JavaDocExamplesTest.java | 12 +- .../invoke/JavaUtilConcurrentLookupTest.java | 7 +- .../java/lang/invoke/LoopCombinatorTest.java | 384 +++++++++--------- .../lang/invoke/MethodHandleInvokeUOE.java | 8 +- .../invoke/MethodHandleProxies/Driver.java | 4 +- .../invoke/MethodHandleProxies/Unnamed.java | 7 +- .../MethodHandleProxies/m1/module-info.java | 4 +- .../MethodHandleProxies/m1/p1/Main.java | 21 +- .../invoke/MethodHandles/TestDropReturn.java | 20 +- .../invoke/MethodHandles/TestTableSwitch.java | 64 +-- .../classData/ClassDataTest.java | 102 ++--- .../MethodHandles/ensureInitialized/Main.java | 21 +- .../MethodHandles/privateLookupIn/Driver.java | 4 +- .../privateLookupIn/test/module-info.java | 6 +- .../test/p/PrivateLookupInTests.java | 107 +++-- .../invoke/MethodHandlesCollectArgsTest.java | 23 +- .../lang/invoke/MethodHandlesGeneralTest.java | 8 +- test/jdk/java/lang/invoke/MethodTypeTest.java | 48 ++- .../invoke/PermuteArgsReturnVoidTest.java | 18 +- .../jdk/java/lang/invoke/PermuteArgsTest.java | 19 +- .../java/lang/invoke/SpreadCollectTest.java | 102 +++-- .../lang/invoke/TestVHInvokerCaching.java | 16 +- .../java/lang/invoke/ThrowExceptionsTest.java | 23 +- test/jdk/java/lang/invoke/TryFinallyTest.java | 62 ++- test/jdk/java/lang/invoke/VarArgsTest.java | 19 +- .../VarHandleBaseByteArrayTest.java | 11 +- .../invoke/VarHandles/VarHandleBaseTest.java | 47 +-- .../VarHandleMethodReferenceTest.java | 6 +- .../VarHandleTestAccessBoolean.java | 324 ++++++++------- .../VarHandles/VarHandleTestAccessByte.java | 360 ++++++++-------- .../VarHandles/VarHandleTestAccessChar.java | 360 ++++++++-------- .../VarHandles/VarHandleTestAccessDouble.java | 252 ++++++------ .../VarHandles/VarHandleTestAccessFloat.java | 252 ++++++------ .../VarHandles/VarHandleTestAccessInt.java | 360 ++++++++-------- .../VarHandles/VarHandleTestAccessLong.java | 360 ++++++++-------- .../VarHandleTestAccessModeMethodNames.java | 23 +- .../VarHandles/VarHandleTestAccessShort.java | 360 ++++++++-------- .../VarHandles/VarHandleTestAccessString.java | 216 +++++----- .../VarHandleTestByteArrayAsChar.java | 54 +-- .../VarHandleTestByteArrayAsDouble.java | 98 ++--- .../VarHandleTestByteArrayAsFloat.java | 98 ++--- .../VarHandleTestByteArrayAsInt.java | 146 +++---- .../VarHandleTestByteArrayAsLong.java | 146 +++---- .../VarHandleTestByteArrayAsShort.java | 54 +-- .../invoke/VarHandles/VarHandleTestExact.java | 49 ++- ...arHandleTestMethodHandleAccessBoolean.java | 280 +++++++------ .../VarHandleTestMethodHandleAccessByte.java | 316 +++++++------- .../VarHandleTestMethodHandleAccessChar.java | 316 +++++++------- ...VarHandleTestMethodHandleAccessDouble.java | 208 +++++----- .../VarHandleTestMethodHandleAccessFloat.java | 208 +++++----- .../VarHandleTestMethodHandleAccessInt.java | 316 +++++++------- .../VarHandleTestMethodHandleAccessLong.java | 316 +++++++------- .../VarHandleTestMethodHandleAccessShort.java | 316 +++++++------- ...VarHandleTestMethodHandleAccessString.java | 172 ++++---- .../VarHandleTestMethodTypeBoolean.java | 29 +- .../VarHandleTestMethodTypeByte.java | 29 +- .../VarHandleTestMethodTypeChar.java | 29 +- .../VarHandleTestMethodTypeDouble.java | 29 +- .../VarHandleTestMethodTypeFloat.java | 29 +- .../VarHandleTestMethodTypeInt.java | 29 +- .../VarHandleTestMethodTypeLong.java | 29 +- .../VarHandleTestMethodTypeShort.java | 29 +- .../VarHandleTestMethodTypeString.java | 29 +- .../VarHandles/VarHandleTestReflection.java | 56 +-- .../X-VarHandleTestAccess.java.template | 360 ++++++++-------- ...X-VarHandleTestByteArrayView.java.template | 146 +++---- ...HandleTestMethodHandleAccess.java.template | 316 +++++++------- .../X-VarHandleTestMethodType.java.template | 29 +- .../TestFieldLookupAccessibility.java | 26 +- .../java/lang/invoke/WrongMethodTypeTest.java | 36 +- .../TestAccessClass.java | 24 +- .../TestFindClass.java | 26 +- .../accessClassAndFindClass/TestLookup.java | 14 +- .../CallerSensitiveAccess.java | 142 ++++--- .../condy/BootstrapMethodJumboArgsTest.java | 24 +- .../lang/invoke/condy/CondyBSMException.java | 29 +- .../lang/invoke/condy/CondyBSMInvocation.java | 46 +-- .../invoke/condy/CondyBSMValidationTest.java | 35 +- .../CondyInterfaceWithOverpassMethods.java | 18 +- .../invoke/condy/CondyNameValidationTest.java | 40 +- .../lang/invoke/condy/CondyNestedTest.java | 38 +- .../condy/CondyRepeatFailedResolution.java | 60 ++- .../condy/CondyReturnPrimitiveTest.java | 34 +- .../condy/CondyStaticArgumentsTest.java | 17 +- .../invoke/condy/CondyTypeValidationTest.java | 31 +- .../invoke/condy/CondyWithGarbageTest.java | 17 +- .../lang/invoke/condy/CondyWrongType.java | 45 +- .../invoke/condy/ConstantBootstrapsTest.java | 115 +++--- .../invoke/defineHiddenClass/BasicTest.java | 175 ++++---- .../defineHiddenClass/HiddenNestmateTest.java | 44 +- .../LambdaNestedInnerTest.java | 29 +- .../defineHiddenClass/PreviewHiddenClass.java | 14 +- .../StaticInvocableTest.java | 6 +- .../defineHiddenClass/TypeDescriptorTest.java | 67 ++- .../defineHiddenClass/UnloadingTest.java | 20 +- .../invoke/findSpecial/FindSpecialTest.java | 12 +- .../LambdaFileEncodingSerialization.java | 15 +- .../invoke/lambda/LambdaHiddenCaller.java | 5 +- .../lambda/LogGeneratedClassesTest.java | 76 ++-- .../InvokeSpecialMethodTest.java | 22 +- .../InheritedProtectedMethod.java | 18 +- .../ProtectedMethodInOtherPackage.java | 26 +- .../lang/invoke/lookup/ChainedLookupTest.java | 10 +- .../lang/invoke/lookup/LookupClassTest.java | 30 +- .../lang/invoke/lookup/SpecialStatic.java | 12 +- test/jdk/java/lang/invoke/modules/Driver.java | 6 +- .../jdk/java/lang/invoke/modules/Driver1.java | 6 +- .../lang/invoke/modules/m1/module-info.java | 4 +- .../java/lang/invoke/modules/m1/p1/Main.java | 75 ++-- .../modules/m3/jdk/test/ModuleAccessTest.java | 173 ++++---- .../lang/invoke/modules/m3/module-info.java | 4 +- 129 files changed, 5276 insertions(+), 5487 deletions(-) diff --git a/test/jdk/java/lang/invoke/8147078/Test8147078.java b/test/jdk/java/lang/invoke/8147078/Test8147078.java index 08532d30929..51580aa6f10 100644 --- a/test/jdk/java/lang/invoke/8147078/Test8147078.java +++ b/test/jdk/java/lang/invoke/8147078/Test8147078.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,17 +23,18 @@ /* @test * @bug 8147078 - * @run testng/othervm -ea -esa Test8147078 + * @run junit/othervm -ea -esa Test8147078 */ -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; public class Test8147078 { @@ -65,16 +66,10 @@ public class Test8147078 { @Test public void testNoExceptionType() { - boolean caught = false; - try { + var cce = assertThrows(ClassCastException.class, () -> { MethodHandle eek = (MethodHandle) MH_catchException.invoke(MH_target, String.class, MH_handler); - } catch (ClassCastException cce) { - assertEquals("java.lang.String", cce.getMessage()); - caught = true; - } catch (Throwable t) { - fail("unexpected exception caught: " + t); - } - assertTrue(caught); + }); + assertEquals("java.lang.String", cce.getMessage()); } } \ No newline at end of file diff --git a/test/jdk/java/lang/invoke/8177146/TestMethodHandleBind.java b/test/jdk/java/lang/invoke/8177146/TestMethodHandleBind.java index 134cc9f7514..518d07b1518 100644 --- a/test/jdk/java/lang/invoke/8177146/TestMethodHandleBind.java +++ b/test/jdk/java/lang/invoke/8177146/TestMethodHandleBind.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,17 +23,16 @@ /* @test * @bug 8177146 - * @run testng/othervm TestMethodHandleBind + * @run junit/othervm TestMethodHandleBind */ -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodType; import static java.lang.invoke.MethodHandles.lookup; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class TestMethodHandleBind extends pkg.A { static class B extends TestMethodHandleBind {} @@ -42,7 +41,7 @@ public class TestMethodHandleBind extends pkg.A { public void testInstanceOfCallerClass() throws Throwable { MethodHandle bound = lookup().bind(new TestMethodHandleBind() , "m1", MethodType.methodType(String.class)); String x = (String)bound.invoke(); - assertEquals(x, this.getClass().getSimpleName()); + assertEquals(this.getClass().getSimpleName(), x); } @Test @@ -50,47 +49,37 @@ public class TestMethodHandleBind extends pkg.A { MethodHandle bound = lookup().bind(new B() , "m1", MethodType.methodType(String.class)); // MethodHandle bound = lookup().findVirtual(B.class, "m1", MethodType.methodType(String.class)).bindTo(new B()); String x = (String)bound.invoke(); - assertEquals(x, "B"); + assertEquals("B", x); } @Test public void testInstanceOfReceiverClass() throws Throwable { - try { - MethodHandle bound = lookup().bind(new pkg.A() , "m1", MethodType.methodType(String.class)); - bound.invoke(); - fail("IllegalAccessException expected"); - } catch (IllegalAccessException e) { - } + assertThrows(IllegalAccessException.class, () -> lookup().bind(new pkg.A() , "m1", MethodType.methodType(String.class))); } @Test public void testPublicMethod() throws Throwable { MethodHandle bound = lookup().bind(new pkg.A() , "m2", MethodType.methodType(String.class)); String x = (String)bound.invoke(); - assertEquals(x, "A"); + assertEquals("A", x); } @Test public void testPublicMethod2() throws Throwable { MethodHandle bound = lookup().bind(new TestMethodHandleBind(), "m2", MethodType.methodType(String.class)); String x = (String)bound.invoke(); - assertEquals(x, this.getClass().getSimpleName()); + assertEquals(this.getClass().getSimpleName(), x); } @Test public void testInstanceOfCallerClassVarargs() throws Throwable { MethodHandle bound = lookup().bind(new TestMethodHandleBind() , "m3", MethodType.methodType(String.class, String[].class)); String x = (String)bound.invoke("a", "b", "c"); - assertEquals(x, this.getClass().getSimpleName() + "abc"); + assertEquals(this.getClass().getSimpleName() + "abc", x); } @Test public void testInstanceOfReceiverClassVarargs() throws Throwable { - try { - MethodHandle bound = lookup().bind(new pkg.A(), "m3", MethodType.methodType(String.class, String[].class)); - bound.invoke(); - fail("IllegalAccessException expected"); - } catch (IllegalAccessException e) { - } + assertThrows(IllegalAccessException.class, () -> lookup().bind(new pkg.A(), "m3", MethodType.methodType(String.class, String[].class))); } } diff --git a/test/jdk/java/lang/invoke/AccessControlTest.java b/test/jdk/java/lang/invoke/AccessControlTest.java index e177f08d876..fcd945a5d7f 100644 --- a/test/jdk/java/lang/invoke/AccessControlTest.java +++ b/test/jdk/java/lang/invoke/AccessControlTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* @test * @summary test access checking by java.lang.invoke.MethodHandles.Lookup * @compile AccessControlTest.java AccessControlTest_subpkg/Acquaintance_remote.java - * @run testng/othervm test.java.lang.invoke.AccessControlTest + * @run junit/othervm test.java.lang.invoke.AccessControlTest */ package test.java.lang.invoke; @@ -33,12 +33,13 @@ import java.lang.invoke.*; import java.lang.reflect.*; import java.lang.reflect.Modifier; import java.util.*; -import org.testng.annotations.*; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodHandles.Lookup.*; import static java.lang.invoke.MethodType.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; import test.java.lang.invoke.AccessControlTest_subpkg.Acquaintance_remote; @@ -69,7 +70,7 @@ public class AccessControlTest { this.prevLookupClass = lookup.previousLookupClass(); this.lookupModes = lookup.lookupModes(); - assert(lookupString().equals(lookup.toString())); + assertEquals(lookupString(), lookup.toString()); numberOf(lookupClass().getClassLoader()); // assign CL# } public LookupCase(Class lookupClass, Class prevLookupClass, int lookupModes) { @@ -96,7 +97,7 @@ public class AccessControlTest { int cmp = c1.getName().compareTo(c2.getName()); if (cmp != 0) return cmp; cmp = numberOf(c1.getClassLoader()) - numberOf(c2.getClassLoader()); - assert(cmp != 0); + assertNotEquals(0, cmp); return cmp; } else if (p1 != p2){ if (p1 == null) @@ -106,7 +107,7 @@ public class AccessControlTest { int cmp = p1.getName().compareTo(p2.getName()); if (cmp != 0) return cmp; cmp = numberOf(p1.getClassLoader()) - numberOf(p2.getClassLoader()); - assert(cmp != 0); + assertNotEquals(0, cmp); return cmp; } return -(this.lookupModes() - that.lookupModes()); @@ -211,8 +212,8 @@ public class AccessControlTest { c1.getPackageName().equals(c2.getPackageName())); boolean sameTopLevel = (topLevelClass(c1) == topLevelClass(c2)); boolean sameClass = (c1 == c2); - assert(samePackage || !sameTopLevel); - assert(sameTopLevel || !sameClass); + assertTrue(samePackage || !sameTopLevel); + assertTrue(sameTopLevel || !sameClass); boolean accessible = sameClass; if ((modes1 & PACKAGE) != 0) accessible |= samePackage; @@ -251,17 +252,17 @@ public class AccessControlTest { changed |= (PRIVATE|PROTECTED); // [A5] } if (sameClass) { - assert(changed == 0); // [A11] (no deprivation if same class) + assertEquals(0, changed); // [A11] (no deprivation if same class) } - if (accessible) assert((changed & PUBLIC) == 0); + if (accessible) assertEquals(0, changed & PUBLIC); int modes2 = modes1 & ~changed; Class plc = (m1 == m2) ? prevLookupClass() : c1; // [A9] [A10] if ((modes1 & UNCONDITIONAL) != 0) plc = null; // [A8] LookupCase l2 = new LookupCase(c2, plc, modes2); - assert(l2.lookupClass() == c2); // [A1] - assert((modes1 | modes2) == modes1); // [A1-a] (no elevation of access) - assert(l2.prevLookupClass() == null || (modes2 & MODULE) == 0); + assertSame(l2.lookupClass(), c2); // [A1] + assertEquals(modes1, modes1 | modes2); // [A1-a] (no elevation of access) + assertTrue(l2.prevLookupClass() == null || (modes2 & MODULE) == 0); return l2; } @@ -280,8 +281,8 @@ public class AccessControlTest { } if (newModes == oldModes) return this; // return self if no change LookupCase l2 = new LookupCase(lookupClass(), prevLookupClass(), newModes); - assert((oldModes | newModes) == oldModes); // [A2] (no elevation of access) - assert(l2.prevLookupClass() == null || (newModes & MODULE) == 0); + assertEquals(oldModes, oldModes | newModes); // [A2] (no elevation of access) + assertTrue(l2.prevLookupClass() == null || (newModes & MODULE) == 0); return l2; } @@ -331,7 +332,7 @@ public class AccessControlTest { && Modifier.isPublic(m.getModifiers()); } - assert(m1 == m2 && prevLookupClass == null); + assertNull(prevLookupClass); if (!willAccessClass(c2, false)) return false; @@ -380,7 +381,7 @@ public class AccessControlTest { && Modifier.isPublic(c2.getModifiers()); } - assert(m1 == m2 && prevLookupClass == null); + assertNull(prevLookupClass); LookupCase lc = this.in(c2); int modes1 = lc.lookupModes(); @@ -409,8 +410,8 @@ public class AccessControlTest { Class c = cls; for (Class ec; (ec = c.getEnclosingClass()) != null; ) c = ec; - assert(c.getEnclosingClass() == null); - assert(c == cls || cls.getEnclosingClass() != null); + assertNull(c.getEnclosingClass()); + assertTrue(c == cls || cls.getEnclosingClass() != null); return c; } @@ -443,14 +444,14 @@ public class AccessControlTest { if (edges == null) CASE_EDGES.put(l2, edges = new TreeSet<>()); if (edges.add(l1)) { Class c1 = l1.lookupClass(); - assert(l2.lookupClass() == c2); // [A1] + assertSame(l2.lookupClass(), c2); // [A1] int m1 = l1.lookupModes(); int m2 = l2.lookupModes(); - assert((m1 | m2) == m1); // [A2] (no elevation of access) + assertEquals(m1, (m1 | m2)); // [A2] (no elevation of access) LookupCase expect = dropAccess == 0 ? l1.in(c2) : l1.in(c2).dropLookupMode(dropAccess); if (!expect.equals(l2)) System.out.println("*** expect "+l1+" => "+expect+" but got "+l2); - assertEquals(l2, expect); + assertEquals(expect, l2); } } @@ -567,7 +568,7 @@ public class AccessControlTest { if (willAccess != didAccess) { System.out.println(sourceCase+" => "+targetClass.getSimpleName()+(isFindOrAccessClass?"":"."+methodName+methodType)); System.out.println("fail "+(isFindOrAccessClass?kind:"on "+method)+" ex="+accessError); - assertEquals(willAccess, didAccess); + assertEquals(didAccess, willAccess); } testCount++; if (!didAccess) testCountFails++; @@ -579,10 +580,10 @@ public class AccessControlTest { System.out.println(targetClass.getSimpleName()+"."+methodName+methodType); try { Method method = targetClass.getDeclaredMethod(methodName, methodType.parameterArray()); - assertEquals(method.getReturnType(), methodType.returnType()); + assertEquals(methodType.returnType(), method.getReturnType()); int haveMods = method.getModifiers(); - assert(Modifier.isStatic(haveMods)); - assert(targetAccess == fixMods(haveMods)); + assertTrue(Modifier.isStatic(haveMods)); + assertEquals(targetAccess, fixMods(haveMods)); return method; } catch (NoSuchMethodException ex) { throw new AssertionError(methodName, ex); @@ -604,7 +605,7 @@ public class AccessControlTest { case PACKAGE: return "pkg_in_"; case PRIVATE: return "pri_in_"; } - assert(false); + fail(); return "?"; } private static final int[] ACCESS_CASES = { diff --git a/test/jdk/java/lang/invoke/ArrayConstructorTest.java b/test/jdk/java/lang/invoke/ArrayConstructorTest.java index 749bb7926a0..313c2828380 100644 --- a/test/jdk/java/lang/invoke/ArrayConstructorTest.java +++ b/test/jdk/java/lang/invoke/ArrayConstructorTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,7 +23,7 @@ /* @test * @bug 8155106 - * @run testng/othervm -ea -esa test.java.lang.invoke.ArrayConstructorTest + * @run junit/othervm -ea -esa test.java.lang.invoke.ArrayConstructorTest */ package test.java.lang.invoke; @@ -32,30 +32,22 @@ import java.lang.invoke.MethodHandles; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; - -import org.testng.annotations.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import static org.junit.jupiter.api.Assertions.*; public class ArrayConstructorTest { static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testFindConstructorArray() { - boolean caught = false; - try { - MethodHandle h = LOOKUP.findConstructor(Object[].class, methodType(void.class)); - } catch (NoSuchMethodException nsme) { - assertEquals("no constructor for array class: [Ljava.lang.Object;", nsme.getMessage()); - caught = true; - } catch (Exception e) { - throw new AssertionError("unexpected exception: " + e); - } - assertTrue(caught); + public void testFindConstructorArray() { + var nsme = assertThrows(NoSuchMethodException.class, () -> LOOKUP.findConstructor(Object[].class, methodType(void.class))); + assertEquals("no constructor for array class: [Ljava.lang.Object;", nsme.getMessage()); } - @DataProvider static Object[][] arrayConstructorNegative() { return new Object[][]{ {String.class, IllegalArgumentException.class, "not an array class: java.lang.String"}, @@ -63,34 +55,28 @@ public class ArrayConstructorTest { }; } - @Test(dataProvider = "arrayConstructorNegative") - public static void testArrayConstructorNegative(Class clazz, Class exceptionClass, String message) { - boolean caught = false; - try { - MethodHandle h = MethodHandles.arrayConstructor(clazz); - } catch (Exception e) { - assertEquals(exceptionClass, e.getClass()); - if (message != null) { - assertEquals(message, e.getMessage()); - } - caught = true; + @ParameterizedTest + @MethodSource("arrayConstructorNegative") + public void testArrayConstructorNegative(Class clazz, Class exceptionClass, String message) { + var e = assertThrowsExactly(exceptionClass, () -> MethodHandles.arrayConstructor(clazz)); + if (message != null) { + assertEquals(message, e.getMessage()); } - assertTrue(caught); } @Test - public static void testArrayConstructor() throws Throwable { + public void testArrayConstructor() throws Throwable { MethodHandle h = MethodHandles.arrayConstructor(String[].class); assertEquals(methodType(String[].class, int.class), h.type()); String[] a = (String[]) h.invoke(17); assertEquals(17, a.length); } - @Test(expectedExceptions = {NegativeArraySizeException.class}) - public static void testArrayConstructorNegativeIndex() throws Throwable { + @Test + public void testArrayConstructorNegativeIndex() throws Throwable { MethodHandle h = MethodHandles.arrayConstructor(String[].class); assertEquals(methodType(String[].class, int.class), h.type()); - h.invoke(-1); // throws exception + assertThrows(NegativeArraySizeException.class, () -> h.invoke(-1)); } } diff --git a/test/jdk/java/lang/invoke/ArrayLengthTest.java b/test/jdk/java/lang/invoke/ArrayLengthTest.java index 9f3cc6fe240..2ef97442638 100644 --- a/test/jdk/java/lang/invoke/ArrayLengthTest.java +++ b/test/jdk/java/lang/invoke/ArrayLengthTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -22,36 +22,39 @@ */ /* @test - * @run testng/othervm -ea -esa test.java.lang.invoke.ArrayLengthTest + * @run junit/othervm -ea -esa test.java.lang.invoke.ArrayLengthTest */ package test.java.lang.invoke; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; public class ArrayLengthTest { - @DataProvider - Object[][] arrayClasses() { - return new Object[][] { - {int[].class}, - {long[].class}, - {float[].class}, - {double[].class}, - {boolean[].class}, - {byte[].class}, - {short[].class}, - {char[].class}, - {Object[].class}, - {StringBuffer[].class} + static Object[] arrayClasses() { + return new Object[] { + int[].class, + long[].class, + float[].class, + double[].class, + boolean[].class, + byte[].class, + short[].class, + char[].class, + Object[].class, + StringBuffer[].class }; } - @Test(dataProvider = "arrayClasses") + @ParameterizedTest + @MethodSource("arrayClasses") public void testArrayLength(Class arrayClass) throws Throwable { MethodHandle arrayLength = MethodHandles.arrayLength(arrayClass); assertEquals(int.class, arrayLength.type().returnType()); @@ -60,25 +63,28 @@ public class ArrayLengthTest { assertEquals(10, arrayLength.invoke(array)); } - @Test(dataProvider = "arrayClasses", expectedExceptions = NullPointerException.class) + @ParameterizedTest + @MethodSource("arrayClasses") public void testArrayLengthInvokeNPE(Class arrayClass) throws Throwable { MethodHandle arrayLength = MethodHandles.arrayLength(arrayClass); - arrayLength.invoke(null); + assertThrows(NullPointerException.class, () -> arrayLength.invoke(null)); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testArrayLengthNoArray() { - MethodHandles.arrayLength(String.class); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.arrayLength(String.class)); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testArrayLengthNPE() { - MethodHandles.arrayLength(null); + assertThrows(NullPointerException.class, () -> MethodHandles.arrayLength(null)); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testNullReference() throws Throwable { MethodHandle arrayLength = MethodHandles.arrayLength(String[].class); - int len = (int)arrayLength.invokeExact((String[])null); + assertThrows(NullPointerException.class, () -> { + int len = (int)arrayLength.invokeExact((String[])null); + }); } } diff --git a/test/jdk/java/lang/invoke/CallerSensitiveMethodHandle.java b/test/jdk/java/lang/invoke/CallerSensitiveMethodHandle.java index 369c2c2bea1..a2756fc2f23 100644 --- a/test/jdk/java/lang/invoke/CallerSensitiveMethodHandle.java +++ b/test/jdk/java/lang/invoke/CallerSensitiveMethodHandle.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -22,20 +22,19 @@ */ /* @test - * @run testng/othervm CallerSensitiveMethodHandle + * @run junit/othervm CallerSensitiveMethodHandle * @summary Check Lookup findVirtual, findStatic and unreflect behavior with * caller sensitive methods with focus on AccessibleObject.setAccessible */ -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; import java.lang.reflect.Field; import static java.lang.invoke.MethodType.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class CallerSensitiveMethodHandle { private static int field = 0; @@ -46,7 +45,7 @@ public class CallerSensitiveMethodHandle { MethodHandle mh = l.findVirtual(Field.class, "setInt", methodType(void.class, Object.class, int.class)); int newValue = 5; mh.invokeExact(f, (Object) null, newValue); - assertTrue(field == newValue); + assertEquals(newValue, field); } @Test @@ -55,6 +54,6 @@ public class CallerSensitiveMethodHandle { MethodHandle MH_lookup2 = lookup.findStatic(MethodHandles.class, "lookup", methodType(Lookup.class)); Lookup lookup2 = (Lookup) MH_lookup2.invokeExact(); System.out.println(lookup2 + " original lookup class " + lookup.lookupClass()); - assertTrue(lookup2.lookupClass() == lookup.lookupClass()); + assertSame(lookup.lookupClass(), lookup2.lookupClass()); } } diff --git a/test/jdk/java/lang/invoke/ClassSpecializerTest.java b/test/jdk/java/lang/invoke/ClassSpecializerTest.java index 671cf39e217..8bc5c58ad52 100644 --- a/test/jdk/java/lang/invoke/ClassSpecializerTest.java +++ b/test/jdk/java/lang/invoke/ClassSpecializerTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,15 +24,13 @@ /* @test * @summary Smoke-test class specializer, used to create BoundMethodHandle classes * @compile/module=java.base java/lang/invoke/ClassSpecializerHelper.java - * @run testng/othervm/timeout=250 -ea -esa ClassSpecializerTest + * @run junit/othervm/timeout=250 -ea -esa ClassSpecializerTest */ // Useful diagnostics to try: // -Djava.lang.invoke.MethodHandle.TRACE_RESOLVE=true // -Djava.lang.invoke.MethodHandle.DUMP_CLASS_FILES=true - -import org.testng.annotations.*; import java.lang.invoke.*; import java.util.ArrayList; import java.util.Arrays; @@ -40,6 +38,11 @@ import java.util.List; import static java.lang.invoke.ClassSpecializerHelper.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; + public class ClassSpecializerTest { @Test @@ -58,12 +61,12 @@ public class ClassSpecializerTest { } args.set(0, key * 1000 + 42); Frob f = (Frob) mh.invokeWithArguments(args.toArray()); - assert(f.kind() == k); + assertSame(k, f.kind()); System.out.println("k.f(...) = " + f.toString()); List l = f.asList(); System.out.println("f.l = " + l); args.subList(0,1).clear(); // drop label - assert(args.equals(l)); + assertEquals(args, l); } } private static Object coughUpA(Class pt) throws Throwable { diff --git a/test/jdk/java/lang/invoke/CompileThresholdBootstrapTest.java b/test/jdk/java/lang/invoke/CompileThresholdBootstrapTest.java index 848264b83a3..c6e093bd09a 100644 --- a/test/jdk/java/lang/invoke/CompileThresholdBootstrapTest.java +++ b/test/jdk/java/lang/invoke/CompileThresholdBootstrapTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,27 +26,19 @@ * @bug 8143232 * @summary Test verifies that LF bootstraps properly when run with COMPILE_THRESHOLD set * @compile CompileThresholdBootstrapTest.java - * @run testng/othervm -Djava.lang.invoke.MethodHandle.COMPILE_THRESHOLD=30 test.java.lang.invoke.CompileThresholdBootstrapTest + * @run junit/othervm -Djava.lang.invoke.MethodHandle.COMPILE_THRESHOLD=30 test.java.lang.invoke.CompileThresholdBootstrapTest */ package test.java.lang.invoke; import java.lang.invoke.MethodHandles; -import org.testng.*; -import org.testng.annotations.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; public final class CompileThresholdBootstrapTest { @Test public void testBootstrap() throws Throwable { - Assert.assertEquals((int)MethodHandles.constant(int.class, (int)0).invokeExact(), 0); - } - - public static void main(String ... args) { - try { - CompileThresholdBootstrapTest test = new CompileThresholdBootstrapTest(); - test.testBootstrap(); - } catch (Throwable t) { - t.printStackTrace(); - } + assertEquals(0, (int)MethodHandles.constant(int.class, (int)0).invokeExact()); } } diff --git a/test/jdk/java/lang/invoke/ConstantIdentityMHTest.java b/test/jdk/java/lang/invoke/ConstantIdentityMHTest.java index 320fd29abe6..43770ea023b 100644 --- a/test/jdk/java/lang/invoke/ConstantIdentityMHTest.java +++ b/test/jdk/java/lang/invoke/ConstantIdentityMHTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,7 +23,7 @@ /* @test * @summary unit tests for java.lang.invoke.MethodHandles - * @run testng/othervm -ea -esa test.java.lang.invoke.ConstantIdentityMHTest + * @run junit/othervm -ea -esa test.java.lang.invoke.ConstantIdentityMHTest */ package test.java.lang.invoke; @@ -31,13 +31,14 @@ import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; -import static org.testng.Assert.*; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class ConstantIdentityMHTest { - @DataProvider(name = "testZeroData") - private Object[][] testZeroData() { + private static Object[][] testZeroData() { return new Object[][] { {void.class, "()void"}, {int.class, "()int"}, @@ -52,26 +53,27 @@ public class ConstantIdentityMHTest { }; } - @Test(dataProvider = "testZeroData") + @ParameterizedTest + @MethodSource("testZeroData") public void testZero(Class expectedtype, String expected) throws Throwable { - assertEquals(MethodHandles.zero(expectedtype).type().toString(), expected); + assertEquals(expected, MethodHandles.zero(expectedtype).type().toString()); } - @Test(expectedExceptions={ NullPointerException.class }) + @Test public void testZeroNPE() { - MethodHandle mh = MethodHandles.zero(null); + assertThrows(NullPointerException.class, () -> MethodHandles.zero(null)); } @Test void testEmpty() throws Throwable { MethodHandle cat = lookup().findVirtual(String.class, "concat", methodType(String.class, String.class)); - assertEquals((String)cat.invoke("x","y"), "xy"); + assertEquals("xy", (String)cat.invoke("x","y")); MethodHandle mhEmpty = MethodHandles.empty(cat.type()); - assertEquals((String)mhEmpty.invoke("x","y"), null); + assertNull((String) mhEmpty.invoke("x", "y")); } - @Test(expectedExceptions = { NullPointerException.class }) + @Test void testEmptyNPE() { - MethodHandle lenEmptyMH = MethodHandles.empty(null); + assertThrows(NullPointerException.class, () -> MethodHandles.empty(null)); } } diff --git a/test/jdk/java/lang/invoke/DefineClassTest.java b/test/jdk/java/lang/invoke/DefineClassTest.java index f712c945e59..889607f38f5 100644 --- a/test/jdk/java/lang/invoke/DefineClassTest.java +++ b/test/jdk/java/lang/invoke/DefineClassTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,7 +23,7 @@ /* @test * @modules java.base/java.lang:open - * @run testng/othervm test.DefineClassTest + * @run junit/othervm test.DefineClassTest * @summary Basic test for java.lang.invoke.MethodHandles.Lookup.defineClass */ @@ -38,7 +38,6 @@ import java.net.URLClassLoader; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import org.testng.annotations.Test; import static java.lang.classfile.ClassFile.ACC_PUBLIC; import static java.lang.classfile.ClassFile.ACC_STATIC; @@ -48,7 +47,8 @@ import static java.lang.constant.ConstantDescs.INIT_NAME; import static java.lang.constant.ConstantDescs.MTD_void; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodHandles.Lookup.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class DefineClassTest { private static final String THIS_PACKAGE = DefineClassTest.class.getPackageName(); @@ -60,9 +60,9 @@ public class DefineClassTest { * protection domain, as a lookup class. */ void testSameAbode(Class clazz, Class lc) { - assertTrue(clazz.getClassLoader() == lc.getClassLoader()); - assertEquals(clazz.getPackageName(), lc.getPackageName()); - assertTrue(clazz.getProtectionDomain() == lc.getProtectionDomain()); + assertSame(lc.getClassLoader(), clazz.getClassLoader()); + assertEquals(lc.getPackageName(), clazz.getPackageName()); + assertSame(lc.getProtectionDomain(), clazz.getProtectionDomain()); } /** @@ -72,8 +72,8 @@ public class DefineClassTest { void testDiscoverable(Class clazz, Lookup lookup) throws Exception { String cn = clazz.getName(); ClassLoader loader = clazz.getClassLoader(); - assertTrue(Class.forName(cn, false, loader) == clazz); - assertTrue(lookup.findClass(cn) == clazz); + assertSame(clazz, Class.forName(cn, false, loader)); + assertSame(clazz, lookup.findClass(cn)); } /** @@ -86,7 +86,7 @@ public class DefineClassTest { Class clazz = lookup.defineClass(generateClass(CLASS_NAME)); // test name - assertEquals(clazz.getName(), CLASS_NAME); + assertEquals(CLASS_NAME, clazz.getName()); // test loader/package/protection-domain testSameAbode(clazz, lookup.lookupClass()); @@ -95,10 +95,8 @@ public class DefineClassTest { testDiscoverable(clazz, lookup); // attempt defineClass again - try { - lookup.defineClass(generateClass(CLASS_NAME)); - assertTrue(false); - } catch (LinkageError expected) { } + var bytes = generateClass(CLASS_NAME); + assertThrows(LinkageError.class, () -> lookup.defineClass(bytes)); } /** @@ -126,10 +124,7 @@ public class DefineClassTest { classBytes = generateRunner(CLASS_NAME + nextNumber(), THIS_CLASS, "method4"); Class clazz = lookup.defineClass(classBytes); Runnable r = (Runnable) clazz.newInstance(); - try { - r.run(); - assertTrue(false); - } catch (IllegalAccessError expected) { } + assertThrows(IllegalAccessError.class, r::run); } public static void method1() { } @@ -154,12 +149,8 @@ public class DefineClassTest { Class clazz = lookup().defineClass(classBytes); // trigger initializer to run - try { - clazz.newInstance(); - assertTrue(false); - } catch (ExceptionInInitializerError e) { - assertTrue(e.getCause() instanceof IllegalCallerException); - } + var e = assertThrows(ExceptionInInitializerError.class, clazz::newInstance); + assertInstanceOf(IllegalCallerException.class, e.getCause()); } static void fail() { throw new IllegalCallerException(); } @@ -189,9 +180,9 @@ public class DefineClassTest { ClassLoader loader = new URLClassLoader(new URL[] { url1, url2 }); Class target1 = Class.forName("p.C1", false, loader); Class target2 = Class.forName("p.C2", false, loader); - assertTrue(target1.getClassLoader() == loader); - assertTrue(target1.getClassLoader() == loader); - assertNotEquals(target1.getProtectionDomain(), target2.getProtectionDomain()); + assertSame(loader, target1.getClassLoader()); + assertSame(loader, target1.getClassLoader()); + assertNotEquals(target2.getProtectionDomain(), target1.getProtectionDomain()); // protection domain 1 Lookup lookup1 = privateLookupIn(target1, lookup()); @@ -214,43 +205,43 @@ public class DefineClassTest { @Test public void testBootLoader() throws Exception { Lookup lookup = privateLookupIn(Thread.class, lookup()); - assertTrue(lookup.getClass().getClassLoader() == null); + assertNull(lookup.getClass().getClassLoader()); Class clazz = lookup.defineClass(generateClass("java.lang.Foo")); - assertEquals(clazz.getName(), "java.lang.Foo"); + assertEquals("java.lang.Foo", clazz.getName()); testSameAbode(clazz, Thread.class); testDiscoverable(clazz, lookup); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void testWrongPackage() throws Exception { - lookup().defineClass(generateClass("other.C")); + assertThrows(IllegalArgumentException.class, () -> lookup().defineClass(generateClass("other.C"))); } - @Test(expectedExceptions = { IllegalAccessException.class }) + @Test public void testNoPackageAccess() throws Exception { Lookup lookup = lookup().dropLookupMode(PACKAGE); - lookup.defineClass(generateClass(THIS_PACKAGE + ".C")); + assertThrows(IllegalAccessException.class, () -> lookup.defineClass(generateClass(THIS_PACKAGE + ".C"))); } - @Test(expectedExceptions = { ClassFormatError.class }) + @Test public void testTruncatedClassFile() throws Exception { - lookup().defineClass(new byte[0]); + assertThrows(ClassFormatError.class, () -> lookup().defineClass(new byte[0])); } - @Test(expectedExceptions = { NullPointerException.class }) + @Test public void testNull() throws Exception { - lookup().defineClass(null); + assertThrows(NullPointerException.class, () -> lookup().defineClass(null)); } - @Test(expectedExceptions = { NoClassDefFoundError.class }) + @Test public void testLinking() throws Exception { - lookup().defineClass(generateNonLinkableClass(THIS_PACKAGE + ".NonLinkableClass")); + assertThrows(NoClassDefFoundError.class, () -> lookup().defineClass(generateNonLinkableClass(THIS_PACKAGE + ".NonLinkableClass"))); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void testModuleInfo() throws Exception { - lookup().defineClass(generateModuleInfo()); + assertThrows(IllegalArgumentException.class, () -> lookup().defineClass(generateModuleInfo())); } /** diff --git a/test/jdk/java/lang/invoke/DropArgumentsTest.java b/test/jdk/java/lang/invoke/DropArgumentsTest.java index 2df9b5f63ba..fb82bb312cd 100644 --- a/test/jdk/java/lang/invoke/DropArgumentsTest.java +++ b/test/jdk/java/lang/invoke/DropArgumentsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,19 +24,24 @@ /* @test * @bug 8158169 * @summary unit tests for java.lang.invoke.MethodHandles - * @run testng test.java.lang.invoke.DropArgumentsTest + * @run junit test.java.lang.invoke.DropArgumentsTest */ package test.java.lang.invoke; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; +import java.util.ArrayList; import java.util.Collections; import java.util.List; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; -import static org.testng.AssertJUnit.*; -import org.testng.annotations.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; public class DropArgumentsTest { @@ -53,8 +58,7 @@ public class DropArgumentsTest { } - @DataProvider(name = "dropArgumentsToMatchNPEData") - private Object[][] dropArgumentsToMatchNPEData() + private static Object[][] dropArgumentsToMatchNPEData() throws NoSuchMethodException, IllegalAccessException { MethodHandle cat = lookup().findVirtual(String.class, "concat", methodType(String.class, String.class)); return new Object[][] { @@ -63,13 +67,13 @@ public class DropArgumentsTest { }; } - @Test(dataProvider = "dropArgumentsToMatchNPEData", expectedExceptions = { NullPointerException.class }) + @ParameterizedTest + @MethodSource("dropArgumentsToMatchNPEData") public void dropArgumentsToMatchNPE(MethodHandle target, int pos, List> valueType, int skip) { - MethodHandles.dropArgumentsToMatch(target, pos, valueType , skip); + assertThrows(NullPointerException.class, () -> MethodHandles.dropArgumentsToMatch(target, pos, valueType, skip)); } - @DataProvider(name = "dropArgumentsToMatchIAEData") - private Object[][] dropArgumentsToMatchIAEData() + private static Object[][] dropArgumentsToMatchIAEData() throws NoSuchMethodException, IllegalAccessException { MethodHandle cat = lookup().findVirtual(String.class, "concat", methodType(String.class, String.class)); MethodType bigType = cat.type().insertParameterTypes(0, String.class, String.class, int.class); @@ -82,17 +86,20 @@ public class DropArgumentsTest { }; } - @Test(dataProvider = "dropArgumentsToMatchIAEData", expectedExceptions = { IllegalArgumentException.class }) + @ParameterizedTest + @MethodSource("dropArgumentsToMatchIAEData") public void dropArgumentsToMatchIAE(MethodHandle target, int pos, List> valueType, int skip) { - MethodHandles.dropArgumentsToMatch(target, pos, valueType , skip); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.dropArgumentsToMatch(target, pos, valueType, skip)); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void dropArgumentsToMatchTestWithVoid() throws Throwable { MethodHandle cat = lookup().findVirtual(String.class, "concat", - MethodType.methodType(String.class, String.class)); - MethodType bigTypewithVoid = cat.type().insertParameterTypes(0, void.class, String.class, int.class); - MethodHandle handle2 = MethodHandles.dropArgumentsToMatch(cat, 0, bigTypewithVoid.parameterList(), 1); + MethodType.methodType(String.class, String.class)); + List> bigTypewithVoid = new ArrayList<>(cat.type().parameterList()); + bigTypewithVoid.addAll(0, List.of(void.class, String.class, int.class)); + assertThrows(IllegalArgumentException.class, () -> + MethodHandles.dropArgumentsToMatch(cat, 0, bigTypewithVoid, 1)); } public static class MethodSet { diff --git a/test/jdk/java/lang/invoke/DropLookupModeTest.java b/test/jdk/java/lang/invoke/DropLookupModeTest.java index 1a4c311be8b..7619793c3c6 100644 --- a/test/jdk/java/lang/invoke/DropLookupModeTest.java +++ b/test/jdk/java/lang/invoke/DropLookupModeTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -21,9 +21,9 @@ * questions. */ -/** +/* * @test - * @run testng DropLookupModeTest + * @run junit DropLookupModeTest * @summary Basic unit tests Lookup::dropLookupMode */ @@ -31,83 +31,85 @@ import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; import static java.lang.invoke.MethodHandles.Lookup.*; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; -@Test public class DropLookupModeTest { /** * Basic test of dropLookupMode */ + @Test public void testBasic() { final Lookup fullPowerLookup = MethodHandles.lookup(); final Class lc = fullPowerLookup.lookupClass(); - assertTrue(fullPowerLookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PROTECTED|PRIVATE|ORIGINAL)); + assertEquals(PUBLIC | MODULE | PACKAGE | PROTECTED | PRIVATE | ORIGINAL, fullPowerLookup.lookupModes()); Lookup lookup = fullPowerLookup.dropLookupMode(PRIVATE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE | PACKAGE, lookup.lookupModes()); lookup = fullPowerLookup.dropLookupMode(PROTECTED); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PRIVATE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE | PACKAGE | PRIVATE, lookup.lookupModes()); lookup = fullPowerLookup.dropLookupMode(PACKAGE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE, lookup.lookupModes()); lookup = fullPowerLookup.dropLookupMode(MODULE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC, lookup.lookupModes()); lookup = fullPowerLookup.dropLookupMode(PUBLIC); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == 0); + assertSame(lc, lookup.lookupClass()); + assertEquals(0, lookup.lookupModes()); lookup = fullPowerLookup.dropLookupMode(UNCONDITIONAL); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PRIVATE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE | PACKAGE | PRIVATE, lookup.lookupModes()); } /** * Starting with a full power Lookup, use dropLookupMode to create new Lookups * with reduced access. */ + @Test public void testReducingAccess() { Lookup lookup = MethodHandles.lookup(); final Class lc = lookup.lookupClass(); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PROTECTED|PRIVATE|ORIGINAL)); + assertEquals(PUBLIC | MODULE | PACKAGE | PROTECTED | PRIVATE | ORIGINAL, lookup.lookupModes()); lookup = lookup.dropLookupMode(PROTECTED); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PRIVATE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE | PACKAGE | PRIVATE, lookup.lookupModes()); lookup = lookup.dropLookupMode(PRIVATE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE | PACKAGE, lookup.lookupModes()); lookup = lookup.dropLookupMode(PACKAGE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == (PUBLIC|MODULE)); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC | MODULE, lookup.lookupModes()); lookup = lookup.dropLookupMode(MODULE); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == PUBLIC); + assertSame(lc, lookup.lookupClass()); + assertEquals(PUBLIC, lookup.lookupModes()); lookup = lookup.dropLookupMode(PUBLIC); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == 0); + assertSame(lc, lookup.lookupClass()); + assertEquals(0, lookup.lookupModes()); // repeat with lookup has no access lookup = lookup.dropLookupMode(PUBLIC); - assertTrue(lookup.lookupClass() == lc); - assertTrue(lookup.lookupModes() == 0); + assertSame(lc, lookup.lookupClass()); + assertEquals(0, lookup.lookupModes()); } - @DataProvider(name = "unconditionals") - public Object[][] unconditionals() { + public static Object[][] unconditionals() { Lookup publicLookup = MethodHandles.publicLookup(); return new Object[][] { { publicLookup, Object.class }, @@ -120,9 +122,10 @@ public class DropLookupModeTest { * Test dropLookupMode on the lookup with public lookup * and UNCONDITIONAL */ - @Test(dataProvider = "unconditionals") + @ParameterizedTest + @MethodSource("unconditionals") public void testUnconditionalLookup(Lookup unconditionalLookup, Class expected) { - assertTrue(unconditionalLookup.lookupModes() == UNCONDITIONAL); + assertEquals(UNCONDITIONAL, unconditionalLookup.lookupModes()); assertPublicLookup(unconditionalLookup.dropLookupMode(PRIVATE), expected); assertPublicLookup(unconditionalLookup.dropLookupMode(PROTECTED), expected); @@ -132,31 +135,27 @@ public class DropLookupModeTest { // drop all access Lookup lookup = unconditionalLookup.dropLookupMode(UNCONDITIONAL); - assertTrue(lookup.lookupClass() == expected); - assertTrue(lookup.lookupModes() == 0); + assertSame(expected, lookup.lookupClass()); + assertEquals(0, lookup.lookupModes()); } private void assertPublicLookup(Lookup lookup, Class expected) { - assertTrue(lookup.lookupClass() == expected); - assertTrue(lookup.lookupModes() == UNCONDITIONAL); - } - - @DataProvider(name = "badInput") - public Object[][] badInput() { - return new Object[][] { - { 0, null }, - { (PACKAGE|PRIVATE), null }, // two modes - { Integer.MAX_VALUE, null }, - { Integer.MIN_VALUE, null }, - }; + assertSame(expected, lookup.lookupClass()); + assertEquals(UNCONDITIONAL, lookup.lookupModes()); } /** * Check that IllegalArgumentException is thrown for bad input */ - @Test(dataProvider = "badInput", expectedExceptions = {IllegalArgumentException.class}) - public void testBadInput(Integer modeToDrop, Object ignore) { - MethodHandles.lookup().dropLookupMode(modeToDrop); + @ParameterizedTest + @ValueSource(ints = { + 0, + (PACKAGE|PRIVATE), // two modes + Integer.MAX_VALUE, + Integer.MIN_VALUE, + }) + public void testBadInput(int modeToDrop) { + assertThrows(IllegalArgumentException.class, () -> MethodHandles.lookup().dropLookupMode(modeToDrop)); } } diff --git a/test/jdk/java/lang/invoke/FilterArgumentsTest.java b/test/jdk/java/lang/invoke/FilterArgumentsTest.java index 3c4884e7c6a..2326799cc1c 100644 --- a/test/jdk/java/lang/invoke/FilterArgumentsTest.java +++ b/test/jdk/java/lang/invoke/FilterArgumentsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* * @test * @bug 8194554 - * @run testng/othervm test.java.lang.invoke.FilterArgumentsTest + * @run junit/othervm test.java.lang.invoke.FilterArgumentsTest */ package test.java.lang.invoke; @@ -37,40 +37,40 @@ import java.util.List; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.methodType; -import org.testng.annotations.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class FilterArgumentsTest { @Test - public static void testFilterA_B_C() throws Throwable { + public void testFilterA_B_C() throws Throwable { FilterTest test = new FilterTest( filterArguments(MH_TEST, 0, MH_FILTER_A, MH_FILTER_B, MH_FILTER_C)); test.run(List.of("A", "B", "C")); } @Test - public static void testFilterA_B() throws Throwable { + public void testFilterA_B() throws Throwable { FilterTest test = new FilterTest( filterArguments(MH_TEST, 0, MH_FILTER_A, MH_FILTER_B)); test.run(List.of("A", "B")); } @Test - public static void testFilterB_C() throws Throwable { + public void testFilterB_C() throws Throwable { FilterTest test = new FilterTest( filterArguments(MH_TEST, 1, MH_FILTER_B, MH_FILTER_C)); test.run(List.of("B", "C")); } @Test - public static void testFilterB() throws Throwable { + public void testFilterB() throws Throwable { FilterTest test = new FilterTest(filterArguments(MH_TEST, 1, MH_FILTER_B)); test.run(List.of("B")); } @Test - public static void testFilterC() throws Throwable { + public void testFilterC() throws Throwable { FilterTest test = new FilterTest(filterArguments(MH_TEST, 2, MH_FILTER_C)); test.run(List.of("C")); } @@ -85,8 +85,8 @@ public class FilterArgumentsTest { void run(List expected) throws Throwable { filters.clear(); - assertEquals((String)mh.invokeExact("x", 0, 'z'), "x-0-z"); - assertEquals(filters, expected); + assertEquals("x-0-z", (String)mh.invokeExact("x", 0, 'z')); + assertEquals(expected, filters); } static String filterA(String s) { diff --git a/test/jdk/java/lang/invoke/FindAccessTest.java b/test/jdk/java/lang/invoke/FindAccessTest.java index f8602ee22bd..3bcff4f5324 100644 --- a/test/jdk/java/lang/invoke/FindAccessTest.java +++ b/test/jdk/java/lang/invoke/FindAccessTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,7 +23,7 @@ /* @test * @bug 8139885 - * @run testng/othervm -ea -esa test.java.lang.invoke.FindAccessTest + * @run junit/othervm -ea -esa test.java.lang.invoke.FindAccessTest */ package test.java.lang.invoke; @@ -33,9 +33,10 @@ import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; import java.lang.invoke.MethodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; /** * Tests for Lookup.findClass/accessClass extensions added in JEP 274. @@ -45,7 +46,7 @@ public class FindAccessTest { static final Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testFindSpecial() throws Throwable { + public void testFindSpecial() throws Throwable { FindSpecial.C c = new FindSpecial.C(); assertEquals("I1.m", c.m()); MethodType t = MethodType.methodType(String.class); @@ -54,25 +55,18 @@ public class FindAccessTest { } @Test - public static void testFindSpecialAbstract() throws Throwable { + public void testFindSpecialAbstract() throws Throwable { FindSpecial.C c = new FindSpecial.C(); assertEquals("q", c.q()); MethodType t = MethodType.methodType(String.class); - boolean caught = false; - try { - MethodHandle ci3q = LOOKUP.findSpecial(FindSpecial.I3.class, "q", t, FindSpecial.C.class); - } catch (Throwable thrown) { - if (!(thrown instanceof IllegalAccessException) || !FindSpecial.ABSTRACT_ERROR.equals(thrown.getMessage())) { - throw new AssertionError(thrown.getMessage(), thrown); - } - caught = true; - } - assertTrue(caught); + var thrown = assertThrows(IllegalAccessException.class, + () -> LOOKUP.findSpecial(FindSpecial.I3.class, "q", t, FindSpecial.C.class)); + assertEquals(FindSpecial.ABSTRACT_ERROR, thrown.getMessage()); } - @Test(expectedExceptions = {ClassNotFoundException.class}) - public static void testFindClassCNFE() throws ClassNotFoundException, IllegalAccessException { - LOOKUP.findClass("does.not.Exist"); + @Test + public void testFindClassCNFE() throws ClassNotFoundException, IllegalAccessException { + assertThrows(ClassNotFoundException.class, () -> LOOKUP.findClass("does.not.Exist")); } static class FindSpecial { diff --git a/test/jdk/java/lang/invoke/FoldTest.java b/test/jdk/java/lang/invoke/FoldTest.java index 157cfbffe2e..92ba246ebc8 100644 --- a/test/jdk/java/lang/invoke/FoldTest.java +++ b/test/jdk/java/lang/invoke/FoldTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,7 +23,7 @@ /* @test * @bug 8139885 - * @run testng/othervm -ea -esa test.java.lang.invoke.FoldTest + * @run junit/othervm -ea -esa test.java.lang.invoke.FoldTest */ package test.java.lang.invoke; @@ -36,9 +36,9 @@ import java.lang.invoke.MethodType; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.assertEquals; /** * Tests for the new fold method handle combinator added in JEP 274. @@ -48,7 +48,7 @@ public class FoldTest { static final Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testFold0a() throws Throwable { + public void testFold0a() throws Throwable { // equivalence to foldArguments(MethodHandle,MethodHandle) MethodHandle fold = MethodHandles.foldArguments(Fold.MH_multer, 0, Fold.MH_adder); assertEquals(Fold.MT_folded1, fold.type()); @@ -56,7 +56,7 @@ public class FoldTest { } @Test - public static void testFold1a() throws Throwable { + public void testFold1a() throws Throwable { // test foldArguments for folding position 1 MethodHandle fold = MethodHandles.foldArguments(Fold.MH_multer, 1, Fold.MH_adder1); assertEquals(Fold.MT_folded1, fold.type()); @@ -64,7 +64,7 @@ public class FoldTest { } @Test - public static void testFold0b() throws Throwable { + public void testFold0b() throws Throwable { // test foldArguments equivalence with multiple types MethodHandle fold = MethodHandles.foldArguments(Fold.MH_str, 0, Fold.MH_comb); assertEquals(Fold.MT_folded2, fold.type()); @@ -72,7 +72,7 @@ public class FoldTest { } @Test - public static void testFold1b() throws Throwable { + public void testFold1b() throws Throwable { // test folgArguments for folding position 1, with multiple types MethodHandle fold = MethodHandles.foldArguments(Fold.MH_str, 1, Fold.MH_comb2); assertEquals(Fold.MT_folded3, fold.type()); @@ -81,7 +81,7 @@ public class FoldTest { } @Test - public static void testFoldArgumentsExample() throws Throwable { + public void testFoldArgumentsExample() throws Throwable { // test the JavaDoc foldArguments-with-pos example StringWriter swr = new StringWriter(); MethodHandle trace = LOOKUP.findVirtual(StringWriter.class, "write", methodType(void.class, String.class)).bindTo(swr); diff --git a/test/jdk/java/lang/invoke/InvokeGenericTest.java b/test/jdk/java/lang/invoke/InvokeGenericTest.java index ef201caead1..0be810506de 100644 --- a/test/jdk/java/lang/invoke/InvokeGenericTest.java +++ b/test/jdk/java/lang/invoke/InvokeGenericTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2009, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* @test * @summary unit tests for java.lang.invoke.MethodHandle.invoke * @compile InvokeGenericTest.java - * @run testng/othervm test.java.lang.invoke.InvokeGenericTest + * @run junit/othervm test.java.lang.invoke.InvokeGenericTest */ package test.java.lang.invoke; @@ -34,9 +34,13 @@ import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; import java.lang.reflect.*; import java.util.*; -import org.testng.*; -import static org.testng.AssertJUnit.*; -import org.testng.annotations.*; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; /** * @@ -68,7 +72,7 @@ public class InvokeGenericTest { String testName; static int allPosTests, allNegTests; int posTests, negTests; - @AfterMethod + @AfterEach public void printCounts() { if (verbosity >= 2 && (posTests | negTests) != 0) { System.out.println(); @@ -92,14 +96,14 @@ public class InvokeGenericTest { testName = name; } - @BeforeClass + @BeforeAll public static void setUpClass() throws Exception { calledLog.clear(); calledLog.add(null); nextArgVal = INITIAL_ARG_VAL; } - @AfterClass + @AfterAll public static void tearDownClass() throws Exception { int posTests = allPosTests, negTests = allNegTests; if (verbosity >= 2 && (posTests | negTests) != 0) { @@ -127,7 +131,7 @@ public class InvokeGenericTest { System.out.println("actual: "+actual); System.out.println("ex. types: "+getClasses(expected)); System.out.println("act. types: "+getClasses(actual)); - assertEquals("previous method call", expected, actual); + assertEquals(expected, actual, "previous method call"); } static void printCalled(MethodHandle target, String name, Object... args) { if (verbosity >= 3) @@ -389,8 +393,7 @@ public class InvokeGenericTest { } public void testWrongArgumentCount(List> expect, List> observe) throws Throwable { countTest(false); - if (expect.equals(observe)) - assert(false); + assertNotEquals(expect, observe); MethodHandle target = callable(expect); Object[] args = zeroArgs(observe); Object junk; @@ -473,28 +476,25 @@ public class InvokeGenericTest { mh = MethodHandles.filterReturnValue(mh, toString_MH); mh = mh.asType(type); Object res = null; - if (nargs == 2) { - res = mh.invoke((Object)args[0], (Object)args[1]); - assertEquals(expectString, res); - res = mh.invoke((String)args[0], (Object)args[1]); - assertEquals(expectString, res); - res = mh.invoke((Object)args[0], (String)args[1]); - assertEquals(expectString, res); - res = mh.invoke((String)args[0], (String)args[1]); - assertEquals(expectString, res); - res = mh.invoke((String)args[0], (CharSequence)args[1]); - assertEquals(expectString, res); - res = mh.invoke((CharSequence)args[0], (Object)args[1]); - assertEquals(expectString, res); - res = (String) mh.invoke((Object)args[0], (Object)args[1]); - assertEquals(expectString, res); - res = (String) mh.invoke((String)args[0], (Object)args[1]); - assertEquals(expectString, res); - res = (CharSequence) mh.invoke((String)args[0], (Object)args[1]); - assertEquals(expectString, res); - } else { - assert(false); // write this code - } + assertEquals(2, nargs); + res = mh.invoke((Object)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = mh.invoke((String)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = mh.invoke((Object)args[0], (String)args[1]); + assertEquals(expectString, res); + res = mh.invoke((String)args[0], (String)args[1]); + assertEquals(expectString, res); + res = mh.invoke((String)args[0], (CharSequence)args[1]); + assertEquals(expectString, res); + res = mh.invoke((CharSequence)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = (String) mh.invoke((Object)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = (String) mh.invoke((String)args[0], (Object)args[1]); + assertEquals(expectString, res); + res = (CharSequence) mh.invoke((String)args[0], (Object)args[1]); + assertEquals(expectString, res); //System.out.println(res); } diff --git a/test/jdk/java/lang/invoke/InvokeMethodHandleWithBadArgument.java b/test/jdk/java/lang/invoke/InvokeMethodHandleWithBadArgument.java index 2479c22b2f4..f2749cfb164 100644 --- a/test/jdk/java/lang/invoke/InvokeMethodHandleWithBadArgument.java +++ b/test/jdk/java/lang/invoke/InvokeMethodHandleWithBadArgument.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,7 +25,7 @@ * @test * @bug 8157246 * @summary Tests invocation of MethodHandle with invalid leading argument - * @run testng/othervm test.java.lang.invoke.InvokeMethodHandleWithBadArgument + * @run junit/othervm test.java.lang.invoke.InvokeMethodHandleWithBadArgument */ package test.java.lang.invoke; @@ -38,9 +38,9 @@ import java.lang.invoke.VarHandle; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; /** * Tests invocation of MethodHandle with invalid leading argument such as @@ -49,86 +49,100 @@ import org.testng.annotations.*; public class InvokeMethodHandleWithBadArgument { // ---- null array reference ---- - @Test(expectedExceptions = {NullPointerException.class}) - public static void testAsSpreaderPosInvokeWithNull() throws Throwable { + @Test + public void testAsSpreaderPosInvokeWithNull() throws Throwable { MethodHandle spreader = MH_spread.asSpreader(1, int[].class, 3); - spreader.invoke("A", null, "B"); + assertThrows(NullPointerException.class, () -> spreader.invoke("A", null, "B")); } - @Test(expectedExceptions = {NullPointerException.class}) - public static void testAsSpreaderInvokeWithNull() throws Throwable { + @Test + public void testAsSpreaderInvokeWithNull() throws Throwable { MethodHandle spreader = MH_String_equals.asSpreader(String[].class, 2); - assert ((boolean) spreader.invokeExact(new String[]{"me", "me"})); - boolean eq = (boolean) spreader.invokeExact((String[]) null); + assertTrue((boolean) spreader.invokeExact(new String[]{"me", "me"})); + assertThrows(NullPointerException.class, () -> { + boolean eq = (boolean) spreader.invokeExact((String[]) null); + }); } // ---- incorrect array element count ---- - @Test(expectedExceptions = {IllegalArgumentException.class}) - public static void testAsSpreaderPosInvokeWithBadElementCount() throws Throwable { + @Test + public void testAsSpreaderPosInvokeWithBadElementCount() throws Throwable { MethodHandle spreader = MH_spread.asSpreader(1, int[].class, 3); - spreader.invoke("A", new int[]{1, 2}, "B"); + assertThrows(IllegalArgumentException.class, () -> spreader.invoke("A", new int[]{1, 2}, "B")); } - @Test(expectedExceptions = {IllegalArgumentException.class}) - public static void testAsSpreaderInvokeWithBadElementCount() throws Throwable { + @Test + public void testAsSpreaderInvokeWithBadElementCount() throws Throwable { MethodHandle spreader = MH_String_equals.asSpreader(String[].class, 2); - assert (!(boolean) spreader.invokeExact(new String[]{"me", "thee"})); - boolean eq = (boolean) spreader.invokeExact(new String[0]); + assertFalse((boolean) spreader.invokeExact(new String[]{"me", "thee"})); + assertThrows(IllegalArgumentException.class, () -> { + boolean eq = (boolean) spreader.invokeExact(new String[0]); + }); } // ---- spread no argument ---- @Test - public static void testAsSpreaderPosInvokeWithZeroLength() throws Throwable { + public void testAsSpreaderPosInvokeWithZeroLength() throws Throwable { MethodHandle spreader = MH_spread.asSpreader(1, int[].class, 0); - assert("A123B".equals(spreader.invoke("A", (int[])null, 1, 2, 3, "B"))); + assertEquals("A123B", spreader.invoke("A", (int[]) null, 1, 2, 3, "B")); } @Test - public static void testAsSpreaderInvokeWithZeroLength() throws Throwable { + public void testAsSpreaderInvokeWithZeroLength() throws Throwable { MethodHandle spreader = MH_String_equals.asSpreader(String[].class, 0); - assert ((boolean) spreader.invokeExact("me", (Object)"me", new String[0])); + assertTrue((boolean) spreader.invokeExact("me", (Object)"me", new String[0])); boolean eq = (boolean) spreader.invokeExact("me", (Object)"me", (String[]) null); } // ---- invokers with null method/var handle argument ---- - @Test(expectedExceptions = {NullPointerException.class}) - public static void testInvokerWithNull() throws Throwable { + @Test + public void testInvokerWithNull() throws Throwable { MethodType type = methodType(int.class, int.class, int.class); MethodHandle invoker = MethodHandles.invoker(type); - assert((int) invoker.invoke(MH_add, 1, 2) == 3); - int sum = (int)invoker.invoke((MethodHandle)null, 1, 2); + assertEquals(3, (int) invoker.invoke(MH_add, 1, 2)); + assertThrows(NullPointerException.class, () -> { + int sum = (int)invoker.invoke((MethodHandle)null, 1, 2); + }); } - @Test(expectedExceptions = {NullPointerException.class}) - public static void testExactInvokerWithNull() throws Throwable { + @Test + public void testExactInvokerWithNull() throws Throwable { MethodType type = methodType(int.class, int.class, int.class); MethodHandle invoker = MethodHandles.exactInvoker(type); - assert((int) invoker.invoke(MH_add, 1, 2) == 3); - int sum = (int)invoker.invokeExact((MethodHandle)null, 1, 2); + assertEquals(3, (int) invoker.invoke(MH_add, 1, 2)); + assertThrows(NullPointerException.class, () -> { + int sum = (int)invoker.invokeExact((MethodHandle)null, 1, 2); + }); } - @Test(expectedExceptions = {NullPointerException.class}) - public static void testSpreadInvokerWithNull() throws Throwable { + @Test + public void testSpreadInvokerWithNull() throws Throwable { MethodType type = methodType(boolean.class, String.class, String.class); MethodHandle invoker = MethodHandles.spreadInvoker(type, 0); - assert ((boolean) invoker.invoke(MH_String_equals, new String[]{"me", "me"})); - boolean eq = (boolean) invoker.invoke((MethodHandle)null, new String[]{"me", "me"}); + assertTrue((boolean) invoker.invoke(MH_String_equals, new String[]{"me", "me"})); + assertThrows(NullPointerException.class, () -> { + boolean eq = (boolean) invoker.invoke((MethodHandle)null, new String[]{"me", "me"}); + }); } - @Test(expectedExceptions = {NullPointerException.class}) - public static void testVarHandleInvokerWithNull() throws Throwable { + @Test + public void testVarHandleInvokerWithNull() throws Throwable { VarHandle.AccessMode am = VarHandle.AccessMode.GET; MethodHandle invoker = MethodHandles.varHandleInvoker(am, VH_array.accessModeType(am)); - assert ((int) invoker.invoke(VH_array, array, 3) == 3); - int value = (int)invoker.invoke((VarHandle)null, array, 3); + assertEquals(3, (int) invoker.invoke(VH_array, array, 3)); + assertThrows(NullPointerException.class, () -> { + int value = (int)invoker.invoke((VarHandle)null, array, 3); + }); } - @Test(expectedExceptions = {NullPointerException.class}) - public static void testVarHandleExactInvokerWithNull() throws Throwable { + @Test + public void testVarHandleExactInvokerWithNull() throws Throwable { VarHandle.AccessMode am = VarHandle.AccessMode.GET; MethodHandle invoker = MethodHandles.varHandleExactInvoker(am, VH_array.accessModeType(am)); - assert ((int) invoker.invoke(VH_array, array, 3) == 3); - int value = (int)invoker.invokeExact((VarHandle)null, array, 3); + assertEquals(3, (int) invoker.invoke(VH_array, array, 3)); + assertThrows(NullPointerException.class, () -> { + int value = (int)invoker.invokeExact((VarHandle)null, array, 3); + }); } static final Lookup LOOKUP = MethodHandles.lookup(); diff --git a/test/jdk/java/lang/invoke/InvokeWithArgumentsTest.java b/test/jdk/java/lang/invoke/InvokeWithArgumentsTest.java index 63a2101bd67..3a705aca699 100644 --- a/test/jdk/java/lang/invoke/InvokeWithArgumentsTest.java +++ b/test/jdk/java/lang/invoke/InvokeWithArgumentsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,19 +23,19 @@ /* @test * @summary basic tests for MethodHandle.invokeWithArguments - * @run testng test.java.lang.invoke.InvokeWithArgumentsTest + * @run junit test.java.lang.invoke.InvokeWithArgumentsTest */ package test.java.lang.invoke; -import org.testng.Assert; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.WrongMethodTypeException; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; public class InvokeWithArgumentsTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); @@ -49,10 +49,7 @@ public class InvokeWithArgumentsTest { MethodHandle mh = L.findStatic(L.lookupClass(), "arity", methodType(Object[].class, Object.class, Object.class, Object[].class)); - try { - mh.invokeWithArguments(""); - Assert.fail("WrongMethodTypeException expected"); - } catch (WrongMethodTypeException e) {} + assertThrows(WrongMethodTypeException.class, () -> mh.invokeWithArguments("")); } static Object[] passThrough(String... a) { @@ -72,10 +69,10 @@ public class InvokeWithArgumentsTest { // Note: the actual array is not preserved, the elements will be // unpacked and then packed into a new array before invoking the method - String[] expected = (String[]) mh.invokeWithArguments(actual); + String[] result = (String[]) mh.invokeWithArguments(actual); - Assert.assertTrue(actual != expected, "Array should not pass through"); - Assert.assertEquals(actual, expected, "Array contents should be equal"); + assertNotSame(actual, result, "Array should not pass through"); + assertArrayEquals(actual, result, "Array contents should be equal"); } @Test @@ -89,8 +86,8 @@ public class InvokeWithArgumentsTest { // will cast to Object become the single element of a new Object[] array Object[] expected = (Object[]) mh.invokeWithArguments("", actual); - Assert.assertEquals(1, expected.length, "Array should contain just one element"); - Assert.assertTrue(actual == expected[0], "Array should pass through"); + assertEquals(1, expected.length, "Array should contain just one element"); + assertSame(actual, expected[0], "Array should pass through"); } static void intArray(int... a) { @@ -100,20 +97,14 @@ public class InvokeWithArgumentsTest { public void testPrimitiveArrayWithNull() throws Throwable { MethodHandle mh = L.findStatic(L.lookupClass(), "intArray", methodType(void.class, int[].class)); - try { - mh.invokeWithArguments(null, null); - Assert.fail("NullPointerException expected"); - } catch (NullPointerException e) {} + assertThrows(NullPointerException.class, () -> mh.invokeWithArguments(null, null)); } @Test public void testPrimitiveArrayWithRef() throws Throwable { MethodHandle mh = L.findStatic(L.lookupClass(), "intArray", methodType(void.class, int[].class)); - try { - mh.invokeWithArguments("A", "B"); - Assert.fail("ClassCastException expected"); - } catch (ClassCastException e) {} + assertThrows(ClassCastException.class, () -> mh.invokeWithArguments("A", "B")); } @@ -127,9 +118,6 @@ public class InvokeWithArgumentsTest { // All numbers, should not throw mh.invokeWithArguments(1, 1.0, 1.0F, 1L); - try { - mh.invokeWithArguments("A"); - Assert.fail("ClassCastException expected"); - } catch (ClassCastException e) {} + assertThrows(ClassCastException.class, () -> mh.invokeWithArguments("A")); } } diff --git a/test/jdk/java/lang/invoke/JavaDocExamplesTest.java b/test/jdk/java/lang/invoke/JavaDocExamplesTest.java index 53257d9876d..0fa2614c83f 100644 --- a/test/jdk/java/lang/invoke/JavaDocExamplesTest.java +++ b/test/jdk/java/lang/invoke/JavaDocExamplesTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2009, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* @test * @summary example code used in javadoc for java.lang.invoke API * @compile JavaDocExamplesTest.java - * @run testng/othervm test.java.lang.invoke.JavaDocExamplesTest + * @run junit/othervm test.java.lang.invoke.JavaDocExamplesTest */ package test.java.lang.invoke; @@ -36,8 +36,8 @@ import static java.lang.invoke.MethodType.*; import java.util.*; -import org.testng.*; -import org.testng.annotations.*; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; /** * @author jrose @@ -350,14 +350,14 @@ assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum")); static void assertEquals(Object exp, Object act) { if (verbosity > 0) System.out.println("result: "+act); - Assert.assertEquals(exp, act); + Assertions.assertEquals(exp, act); } static void assertTrue(boolean b) { if (verbosity > 0) { System.out.println("result: " + b); } - Assert.assertTrue(b); + Assertions.assertTrue(b); } @Test public void testMethodHandlesSummary() throws Throwable { diff --git a/test/jdk/java/lang/invoke/JavaUtilConcurrentLookupTest.java b/test/jdk/java/lang/invoke/JavaUtilConcurrentLookupTest.java index 9715de8fd46..a9a6861bc05 100644 --- a/test/jdk/java/lang/invoke/JavaUtilConcurrentLookupTest.java +++ b/test/jdk/java/lang/invoke/JavaUtilConcurrentLookupTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,12 +25,11 @@ * @summary Tests that Lookup can be produced from classes under java.util.concurrent * @bug 8154447 * @compile/module=java.base java/util/concurrent/LookupTester.java - * @run testng/othervm JavaUtilConcurrentLookupTest + * @run junit/othervm JavaUtilConcurrentLookupTest */ -import org.testng.annotations.Test; - import java.util.concurrent.LookupTester; +import org.junit.jupiter.api.Test; public class JavaUtilConcurrentLookupTest { diff --git a/test/jdk/java/lang/invoke/LoopCombinatorTest.java b/test/jdk/java/lang/invoke/LoopCombinatorTest.java index 15fb9d320a3..91a752f2666 100644 --- a/test/jdk/java/lang/invoke/LoopCombinatorTest.java +++ b/test/jdk/java/lang/invoke/LoopCombinatorTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -32,7 +32,7 @@ * @bug 8154751 * @bug 8154754 * @bug 8167974 - * @run testng/othervm -ea -esa test.java.lang.invoke.LoopCombinatorTest + * @run junit/othervm -ea -esa test.java.lang.invoke.LoopCombinatorTest */ package test.java.lang.invoke; @@ -45,9 +45,12 @@ import java.util.*; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; /** * Tests for the loop combinators introduced in JEP 274. @@ -57,7 +60,7 @@ public class LoopCombinatorTest { static final Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testLoopFac() throws Throwable { + public void testLoopFac() throws Throwable { MethodHandle[] counterClause = new MethodHandle[]{Fac.MH_zero, Fac.MH_inc}; MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin}; MethodHandle loop = MethodHandles.loop(counterClause, accumulatorClause); @@ -66,7 +69,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopFacNullInit() throws Throwable { + public void testLoopFacNullInit() throws Throwable { // null initializer for counter, should initialize to 0 MethodHandle[] counterClause = new MethodHandle[]{null, Fac.MH_inc}; MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin}; @@ -76,7 +79,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopNullInit() throws Throwable { + public void testLoopNullInit() throws Throwable { // null initializer for counter, should initialize to 0, one-clause loop MethodHandle[] counterClause = new MethodHandle[]{null, Loop.MH_inc, Loop.MH_pred, Loop.MH_fin}; MethodHandle loop = MethodHandles.loop(counterClause); @@ -85,7 +88,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopVoid1() throws Throwable { + public void testLoopVoid1() throws Throwable { // construct a post-checked loop that only does one iteration and has a void body and void local state MethodHandle loop = MethodHandles.loop(new MethodHandle[]{Empty.MH_f, Empty.MH_f, Empty.MH_pred, null}); assertEquals(MethodType.methodType(void.class), loop.type()); @@ -93,7 +96,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopVoid2() throws Throwable { + public void testLoopVoid2() throws Throwable { // construct a post-checked loop that only does one iteration and has a void body and void local state, // initialized implicitly from the step type MethodHandle loop = MethodHandles.loop(new MethodHandle[]{null, Empty.MH_f, Empty.MH_pred, null}); @@ -102,7 +105,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopVoid3() throws Throwable { + public void testLoopVoid3() throws Throwable { // construct a post-checked loop that only does one iteration and has a void body and void local state, // and that has a void finalizer MethodHandle loop = MethodHandles.loop(new MethodHandle[]{null, Empty.MH_f, Empty.MH_pred, Empty.MH_f}); @@ -111,7 +114,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopFacWithVoidState() throws Throwable { + public void testLoopFacWithVoidState() throws Throwable { // like testLoopFac, but with additional void state that outputs a dot MethodHandle[] counterClause = new MethodHandle[]{Fac.MH_zero, Fac.MH_inc}; MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin}; @@ -122,7 +125,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopVoidInt() throws Throwable { + public void testLoopVoidInt() throws Throwable { // construct a post-checked loop that only does one iteration and has a void body and void local state, // and that returns a constant MethodHandle loop = MethodHandles.loop(new MethodHandle[]{null, Empty.MH_f, Empty.MH_pred, Empty.MH_c}); @@ -131,7 +134,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopWithVirtuals() throws Throwable { + public void testLoopWithVirtuals() throws Throwable { // construct a loop (to calculate factorial) that uses a mix of static and virtual methods MethodHandle[] counterClause = new MethodHandle[]{null, LoopWithVirtuals.permute(LoopWithVirtuals.MH_inc)}; MethodHandle[] accumulatorClause = new MethodHandle[]{ @@ -147,7 +150,7 @@ public class LoopCombinatorTest { } @Test - public static void testLoopOmitPred() throws Throwable { + public void testLoopOmitPred() throws Throwable { // construct a loop to calculate factorial that omits a predicate MethodHandle[] counterClause = new MethodHandle[]{null, Fac.MH_inc, null, Fac.MH_fin}; MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin}; @@ -156,7 +159,6 @@ public class LoopCombinatorTest { assertEquals(120, loop.invoke(5)); } - @DataProvider static Object[][] negativeTestData() { MethodHandle i0 = MethodHandles.constant(int.class, 0); MethodHandle ii = MethodHandles.dropArguments(i0, 0, int.class, int.class); @@ -214,36 +216,36 @@ public class LoopCombinatorTest { } } - @Test(dataProvider = "negativeTestData") - public static void testLoopNegative(MethodHandle[][] clauses, String expectedMessage) throws Throwable { - boolean caught = false; - try { - MH_loop.invokeWithArguments((Object[]) clauses); - } catch (IllegalArgumentException iae) { - assertEquals(expectedMessage, iae.getMessage()); - caught = true; - } - assertTrue(caught); + @ParameterizedTest + @MethodSource("negativeTestData") + public void testLoopNegative(MethodHandle[][] clauses, String expectedMessage) throws Throwable { + var iae = assertThrows(IllegalArgumentException.class, () -> MH_loop.invokeWithArguments((Object[]) clauses)); + assertEquals(expectedMessage, iae.getMessage()); } - @Test(dataProvider = "whileLoopTestData") - public static void testWhileLoop(MethodHandle MH_zero, - MethodHandle MH_pred, - MethodHandle MH_step, - String messageOrNull) throws Throwable { + @ParameterizedTest + @MethodSource("whileLoopPassData") + public void testWhileLoop(MethodHandle MH_zero, + MethodHandle MH_pred, + MethodHandle MH_step) throws Throwable { // int i = 0; while (i < limit) { ++i; } return i; => limit - try { - MethodHandle loop = MethodHandles.whileLoop(MH_zero, MH_pred, MH_step); - assert messageOrNull == null; - if (MH_step.type().equals(While.MH_step.type())) - assertEquals(While.MT_while, loop.type()); - assertEquals(MH_step.type().dropParameterTypes(0, 1), loop.type()); - while (loop.type().parameterCount() > 1) loop = snip(loop); - assertEquals(23, loop.invoke(23)); - } catch (IllegalArgumentException iae) { - assert messageOrNull != null; - assertEqualsFIXME(messageOrNull, iae.getMessage()); - } + MethodHandle loop = MethodHandles.whileLoop(MH_zero, MH_pred, MH_step); + if (MH_step.type().equals(While.MH_step.type())) + assertEquals(While.MT_while, loop.type()); + assertEquals(MH_step.type().dropParameterTypes(0, 1), loop.type()); + while (loop.type().parameterCount() > 1) loop = snip(loop); + assertEquals(23, loop.invoke(23)); + } + + @ParameterizedTest + @MethodSource("whileLoopFailData") + public void testWhileLoopFail(MethodHandle MH_zero, + MethodHandle MH_pred, + MethodHandle MH_step, + String message) throws Throwable { + // int i = 0; while (i < limit) { ++i; } return i; => limit + var iae = assertThrows(IllegalArgumentException.class, () -> MethodHandles.whileLoop(MH_zero, MH_pred, MH_step)); + assertEqualsFIXME(message, iae.getMessage()); } static void assertEqualsFIXME(String expect, String actual) { @@ -253,8 +255,7 @@ public class LoopCombinatorTest { } } - @DataProvider - static Object[][] whileLoopTestData() { + static Object[][] whileLoopPassData() { MethodHandle zeroI = While.MH_zero, zeroX = snip(zeroI), @@ -268,28 +269,44 @@ public class LoopCombinatorTest { ; return new Object[][] { // normal while loop clauses, perhaps with effectively-identical reductions - {zeroI, predII, stepII, null}, - {zeroX, predII, stepII, null}, - {null, predII, stepII, null}, + {zeroI, predII, stepII}, + {zeroX, predII, stepII}, + {null, predII, stepII}, // expanded while loop clauses - {zeroIB, predIIB, stepIIB, null}, - {zeroI, predIIB, stepIIB, null}, - {null, predIIB, stepIIB, null}, - {zeroIB, predII, stepIIB, null}, - {zeroX, predII, stepIIB, null}, - {null, predII, stepIIB, null}, - // short step clauses cause errors - {zeroI, predII, stepIX, "loop predicate must match: (int,int)boolean != (int)boolean"}, - {zeroIB, predIX, stepIX, "loop initializer must match: (int,byte)int != ()int"}, - // bad body type - {zeroI, predII, tweak(stepII, -1, char.class), "body function must match: (int,int)char != (char,int,int)char"}, - {zeroI, predII, tweak(stepII, 0, char.class), "body function must match: (char,int)int != (int,char,int)int"}, - // bad pred type - {zeroI, tweak(predII, -1, char.class), stepII, "loop predicate must match: (int,int)char != (int,int)boolean"}, - {zeroI, tweak(predII, 0, char.class), stepII, "loop predicate must match: (char,int)boolean != (int,int)boolean"}, - // bad init type - {tweak(zeroI, -1, char.class), predII, stepII, "loop initializer must match: (int)char != (int)int"}, - {tweak(zeroI, 0, char.class), predII, stepII, "loop initializer must match: (char)int != (int)int"}, + {zeroIB, predIIB, stepIIB}, + {zeroI, predIIB, stepIIB}, + {null, predIIB, stepIIB}, + {zeroIB, predII, stepIIB}, + {zeroX, predII, stepIIB}, + {null, predII, stepIIB}, + }; + } + + static Object[][] whileLoopFailData() { + MethodHandle + zeroI = While.MH_zero, + zeroX = snip(zeroI), + zeroIB = slap(zeroI, byte.class), + predII = While.MH_pred, + predIX = snip(predII), + predIIB = slap(predII, byte.class), + stepII = While.MH_step, + stepIX = snip(stepII), + stepIIB = slap(stepII, byte.class) + ; + return new Object[][] { + // short step clauses cause errors + {zeroI, predII, stepIX, "loop predicate must match: (int,int)boolean != (int)boolean"}, + {zeroIB, predIX, stepIX, "loop initializer must match: (int,byte)int != ()int"}, + // bad body type + {zeroI, predII, tweak(stepII, -1, char.class), "body function must match: (int,int)char != (char,int,int)char"}, + {zeroI, predII, tweak(stepII, 0, char.class), "body function must match: (char,int)int != (int,char,int)int"}, + // bad pred type + {zeroI, tweak(predII, -1, char.class), stepII, "loop predicate must match: (int,int)char != (int,int)boolean"}, + {zeroI, tweak(predII, 0, char.class), stepII, "loop predicate must match: (char,int)boolean != (int,int)boolean"}, + // bad init type + {tweak(zeroI, -1, char.class), predII, stepII, "loop initializer must match: (int)char != (int)int"}, + {tweak(zeroI, 0, char.class), predII, stepII, "loop initializer must match: (char)int != (int)int"}, }; } @@ -323,53 +340,50 @@ public class LoopCombinatorTest { } @Test - public static void testWhileLoopNoIteration() throws Throwable { + public void testWhileLoopNoIteration() throws Throwable { // a while loop that never executes its body because the predicate evaluates to false immediately MethodHandle loop = MethodHandles.whileLoop(While.MH_initString, While.MH_predString, While.MH_stepString); assertEquals(While.MT_string, loop.type()); assertEquals("a", loop.invoke()); } - @Test(dataProvider = "whileLoopTestData") - public static void testDoWhileLoop(MethodHandle MH_zero, - MethodHandle MH_pred, - MethodHandle MH_step, - String messageOrNull) throws Throwable { + @ParameterizedTest + @MethodSource("whileLoopPassData") + public void testDoWhileLoopPass(MethodHandle MH_zero, + MethodHandle MH_pred, + MethodHandle MH_step) throws Throwable { // int i = 0; do { ++i; } while (i < limit); return i; => limit - try { - MethodHandle loop = MethodHandles.doWhileLoop(MH_zero, MH_step, MH_pred); - assert messageOrNull == null; - if (MH_step.type().equals(While.MH_step.type())) - assertEquals(While.MT_while, loop.type()); - assertEquals(MH_step.type().dropParameterTypes(0, 1), loop.type()); - while (loop.type().parameterCount() > 1) loop = snip(loop); - assertEquals(23, loop.invoke(23)); - } catch (IllegalArgumentException iae) { - assert messageOrNull != null; - if (!messageOrNull.equals(iae.getMessage())) { - // just issue a warning - System.out.println("*** "+messageOrNull+"\n != "+iae.getMessage()); - } - } + MethodHandle loop = MethodHandles.doWhileLoop(MH_zero, MH_step, MH_pred); + if (MH_step.type().equals(While.MH_step.type())) + assertEquals(While.MT_while, loop.type()); + assertEquals(MH_step.type().dropParameterTypes(0, 1), loop.type()); + while (loop.type().parameterCount() > 1) loop = snip(loop); + assertEquals(23, loop.invoke(23)); + } + + @ParameterizedTest + @MethodSource("whileLoopFailData") + public void testDoWhileLoopFail(MethodHandle MH_zero, + MethodHandle MH_pred, + MethodHandle MH_step, + String message) throws Throwable { + // int i = 0; do { ++i; } while (i < limit); return i; => limit + var iae = assertThrows(IllegalArgumentException.class, () -> MethodHandles.doWhileLoop(MH_zero, MH_step, MH_pred)); + assertEqualsFIXME(message, iae.getMessage()); } @Test - public static void testDoWhileBadInit() throws Throwable { - boolean caught = false; - try { - While w = new While(); - MethodHandle loop = MethodHandles.doWhileLoop(MethodHandles.empty(methodType(char.class)), - While.MH_voidBody.bindTo(w), - While.MH_voidPred.bindTo(w)); - } catch (IllegalArgumentException iae) { - assertEquals("loop initializer must match: ()char != (int)void", iae.getMessage()); - caught = true; - } - assertTrue(caught); + public void testDoWhileBadInit() throws Throwable { + While w = new While(); + var iae = assertThrows(IllegalArgumentException.class, () -> + MethodHandles.doWhileLoop(MethodHandles.empty(methodType(char.class)), + While.MH_voidBody.bindTo(w), + While.MH_voidPred.bindTo(w))); + assertEquals("loop initializer must match: ()char != (int)void", iae.getMessage()); } @Test - public static void testWhileZip() throws Throwable { + public void testWhileZip() throws Throwable { MethodHandle loop = MethodHandles.doWhileLoop(While.MH_zipInitZip, While.MH_zipStep, While.MH_zipPred); assertEquals(While.MT_zip, loop.type()); List a = Arrays.asList("a", "b", "c", "d"); @@ -379,22 +393,17 @@ public class LoopCombinatorTest { } @Test - public static void testWhileBadInit() throws Throwable { - boolean caught = false; - try { - While w = new While(); - MethodHandle loop = MethodHandles.whileLoop(MethodHandles.empty(methodType(void.class, char.class)), - While.MH_voidPred.bindTo(w), - While.MH_voidBody.bindTo(w)); - } catch (IllegalArgumentException iae) { - assertEquals("loop initializer must match: (char)void != (int)void", iae.getMessage()); - caught = true; - } - assertTrue(caught); + public void testWhileBadInit() throws Throwable { + While w = new While(); + var iae = assertThrows(IllegalArgumentException.class, () -> + MethodHandles.whileLoop(MethodHandles.empty(methodType(void.class, char.class)), + While.MH_voidPred.bindTo(w), + While.MH_voidBody.bindTo(w))); + assertEquals("loop initializer must match: (char)void != (int)void", iae.getMessage()); } @Test - public static void testWhileVoidInit() throws Throwable { + public void testWhileVoidInit() throws Throwable { While w = new While(); int v = 5; MethodHandle loop = MethodHandles.whileLoop(While.MH_voidInit.bindTo(w), While.MH_voidPred.bindTo(w), @@ -405,7 +414,7 @@ public class LoopCombinatorTest { } @Test - public static void testDoWhileVoidInit() throws Throwable { + public void testDoWhileVoidInit() throws Throwable { While w = new While(); int v = 5; MethodHandle loop = MethodHandles.doWhileLoop(While.MH_voidInit.bindTo(w), While.MH_voidBody.bindTo(w), @@ -415,24 +424,25 @@ public class LoopCombinatorTest { assertEquals(v, w.i); } - @DataProvider static Object[][] nullArgs() { MethodHandle c = MethodHandles.constant(int.class, 1); return new Object[][]{{null, c}, {c, null}}; } - @Test(dataProvider = "nullArgs", expectedExceptions = NullPointerException.class) - public static void testWhileNullArgs(MethodHandle pred, MethodHandle body) { - MethodHandles.whileLoop(null, pred, body); + @ParameterizedTest + @MethodSource("nullArgs") + public void testWhileNullArgs(MethodHandle pred, MethodHandle body) { + assertThrows(NullPointerException.class, () -> MethodHandles.whileLoop(null, pred, body)); } - @Test(dataProvider = "nullArgs", expectedExceptions = NullPointerException.class) - public static void testDoWhileNullArgs(MethodHandle body, MethodHandle pred) { - MethodHandles.whileLoop(null, body, pred); + @ParameterizedTest + @MethodSource("nullArgs") + public void testDoWhileNullArgs(MethodHandle body, MethodHandle pred) { + assertThrows(NullPointerException.class, () -> MethodHandles.whileLoop(null, body, pred)); } @Test - public static void testCountedLoop() throws Throwable { + public void testCountedLoop() throws Throwable { // String s = "Lambdaman!"; for (int i = 0; i < 13; ++i) { s = "na " + s; } return s; => a variation on a well known theme MethodHandle fit13 = MethodHandles.dropArguments(MethodHandles.constant(int.class, 13), 0, String.class); MethodHandle loop = MethodHandles.countedLoop(fit13, Counted.MH_start, Counted.MH_step); @@ -441,7 +451,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedLoopVoidInit() throws Throwable { + public void testCountedLoopVoidInit() throws Throwable { MethodHandle fit5 = MethodHandles.constant(int.class, 5); for (int i = 0; i < 8; i++) { MethodHandle zero = MethodHandles.zero(void.class); @@ -465,7 +475,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedArrayLoop() throws Throwable { + public void testCountedArrayLoop() throws Throwable { // int[] a = new int[]{0}; for (int i = 0; i < 13; ++i) { ++a[0]; } => a[0] == 13 MethodHandle fit13 = MethodHandles.dropArguments(MethodHandles.constant(int.class, 13), 0, int[].class); MethodHandle loop = MethodHandles.countedLoop(fit13, null, Counted.MH_stepUpdateArray); @@ -476,37 +486,30 @@ public class LoopCombinatorTest { } @Test - public static void testCountedPrintingLoop() throws Throwable { + public void testCountedPrintingLoop() throws Throwable { MethodHandle fit5 = MethodHandles.constant(int.class, 5); MethodHandle loop = MethodHandles.countedLoop(fit5, null, Counted.MH_printHello); assertEquals(Counted.MT_countedPrinting, loop.type()); loop.invoke(); } - @Test(expectedExceptions = NullPointerException.class) - public static void testCountedLoopNullBody() throws Throwable { + @Test + public void testCountedLoopNullBody() throws Throwable { MethodHandle h5 = MethodHandles.constant(int.class, 5); MethodHandle h13 = MethodHandles.constant(int.class, 13); - MethodHandle loop = MethodHandles.countedLoop(h5, h13, null); - assertEquals(methodType(int.class), loop.type()); - assertEquals(13, loop.invoke()); + assertThrows(NullPointerException.class, () -> MethodHandles.countedLoop(h5, h13, null)); } - @Test(expectedExceptions = NullPointerException.class) - public static void testCountedLoopNullIterations() throws Throwable { - MethodHandle loop = MethodHandles.countedLoop(null, null, null); - assertEquals(methodType(void.class), loop.type()); - loop.invoke(); + @Test + public void testCountedLoopNullIterations() throws Throwable { + assertThrows(NullPointerException.class, () -> MethodHandles.countedLoop(null, null, null)); } - @Test(expectedExceptions = NullPointerException.class) - public static void testCountedLoopNullInitAndBody() throws Throwable { - MethodHandle loop = MethodHandles.countedLoop(MethodHandles.constant(int.class, 5), null, null); - assertEquals(methodType(void.class), loop.type()); - loop.invoke(); + @Test + public void testCountedLoopNullInitAndBody() throws Throwable { + assertThrows(NullPointerException.class, () -> MethodHandles.countedLoop(MethodHandles.constant(int.class, 5), null, null)); } - @DataProvider static Object[][] countedLoopBodyParameters() { Class V = String.class, I = int.class, A = List.class; // return types are of these forms: @@ -531,8 +534,9 @@ public class LoopCombinatorTest { }; } - @Test(dataProvider = "countedLoopBodyParameters") - public static void testCountedLoopBodyParameters(MethodType countType, MethodType initType, MethodType bodyType) throws Throwable { + @ParameterizedTest + @MethodSource("countedLoopBodyParameters") + public void testCountedLoopBodyParameters(MethodType countType, MethodType initType, MethodType bodyType) throws Throwable { MethodHandle loop = MethodHandles.countedLoop( MethodHandles.empty(countType), initType == null ? null : MethodHandles.empty(initType), @@ -546,13 +550,14 @@ public class LoopCombinatorTest { assertEquals(expectType, loop.type()); } - @Test(dataProvider = "countedLoopBodyParameters") - public static void testCountedLoopBodyParametersNullInit(MethodType countType, MethodType initType, MethodType bodyType) throws Throwable { + @ParameterizedTest + @MethodSource("countedLoopBodyParameters") + public void testCountedLoopBodyParametersNullInit(MethodType countType, MethodType initType, MethodType bodyType) throws Throwable { testCountedLoopBodyParameters(countType, null, bodyType); } @Test - public static void testCountedLoopStateInitializedToNull() throws Throwable { + public void testCountedLoopStateInitializedToNull() throws Throwable { MethodHandle loop = MethodHandles.countedLoop(MethodHandles.constant(int.class, 5), MethodHandles.empty(methodType(String.class)), Counted.MH_stateBody); assertEquals(Counted.MT_bodyDeterminesState, loop.type()); @@ -560,7 +565,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedLoopArgsDefinedByIterations() throws Throwable { + public void testCountedLoopArgsDefinedByIterations() throws Throwable { MethodHandle iterations = MethodHandles.dropArguments(MethodHandles.constant(int.class, 3), 0, String.class); MethodHandle loop = MethodHandles.countedLoop(iterations, @@ -570,7 +575,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedRangeLoop() throws Throwable { + public void testCountedRangeLoop() throws Throwable { // String s = "Lambdaman!"; for (int i = -5; i < 8; ++i) { s = "na " + s; } return s; => a well known theme MethodHandle fitm5 = MethodHandles.dropArguments(Counted.MH_m5, 0, String.class); MethodHandle fit8 = MethodHandles.dropArguments(Counted.MH_8, 0, String.class); @@ -580,7 +585,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedLoopCounterInit() throws Throwable { + public void testCountedLoopCounterInit() throws Throwable { // int x = 0; for (int i = 0; i < 5; ++i) { x += i; } return x; => 10 // (only if counter's first value in body is 0) MethodHandle iter = MethodHandles.constant(int.class, 5); @@ -592,7 +597,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedLoopEmpty() throws Throwable { + public void testCountedLoopEmpty() throws Throwable { // for (int i = 0; i < 5; ++i) { /* empty */ } MethodHandle loop = MethodHandles.countedLoop(MethodHandles.constant(int.class, 5), null, MethodHandles.empty(methodType(void.class, int.class))); @@ -601,7 +606,7 @@ public class LoopCombinatorTest { } @Test - public static void testCountedRangeLoopEmpty() throws Throwable { + public void testCountedRangeLoopEmpty() throws Throwable { // for (int i = -5; i < 5; ++i) { /* empty */ } MethodHandle loop = MethodHandles.countedLoop(MethodHandles.constant(int.class, -5), MethodHandles.constant(int.class, 5), null, MethodHandles.empty(methodType(void.class, int.class))); @@ -609,7 +614,6 @@ public class LoopCombinatorTest { loop.invoke(); } - @DataProvider static Object[][] countedLoopNegativeData() { MethodHandle dummy = MethodHandles.zero(void.class); MethodHandle one = MethodHandles.constant(int.class, 1); @@ -629,35 +633,30 @@ public class LoopCombinatorTest { }; } - @Test(dataProvider = "countedLoopNegativeData") - public static void testCountedLoopNegative(MethodHandle start, MethodHandle end, MethodHandle init, + @ParameterizedTest + @MethodSource("countedLoopNegativeData") + @Disabled //%%%FIXME%%%% + public void testCountedLoopNegative(MethodHandle start, MethodHandle end, MethodHandle init, MethodHandle body, String msg) { - if (true) return; //%%%FIXME%%%% - boolean caught = false; - try { - MethodHandles.countedLoop(start, end, init, body); - } catch (IllegalArgumentException iae) { - assertEquals(msg, iae.getMessage()); - caught = true; - } - assertTrue(caught); + var iae = assertThrows(IllegalArgumentException.class, () -> MethodHandles.countedLoop(start, end, init, body)); + assertEquals(msg, iae.getMessage()); } @Test - public static void testIterateSum() throws Throwable { + public void testIterateSum() throws Throwable { // Integer[] a = new Integer[]{1,2,3,4,5,6}; int sum = 0; for (int e : a) { sum += e; } return sum; => 21 MethodHandle loop = MethodHandles.iteratedLoop(Iterate.MH_sumIterator, Iterate.MH_sumInit, Iterate.MH_sumStep); assertEquals(Iterate.MT_sum, loop.type()); assertEquals(21, loop.invoke(new Integer[]{1, 2, 3, 4, 5, 6})); } - @DataProvider static Object[][] iteratorInits() { return new Object[][]{{Iterate.MH_iteratorFromList}, {Iterate.MH_iteratorFromIterable}, {null}}; } - @Test(dataProvider = "iteratorInits") - public static void testIterateReverse(MethodHandle iterator) throws Throwable { + @ParameterizedTest + @MethodSource("iteratorInits") + public void testIterateReverse(MethodHandle iterator) throws Throwable { // this test uses List as its loop state type; don't try to change that if (iterator != null) iterator = iterator.asType(iterator.type().changeParameterType(0, List.class)); @@ -685,8 +684,9 @@ public class LoopCombinatorTest { } } - @Test(dataProvider = "iteratorInits") - public static void testIterateLength(MethodHandle iterator) throws Throwable { + @ParameterizedTest + @MethodSource("iteratorInits") + public void testIterateLength(MethodHandle iterator) throws Throwable { MethodHandle body = Iterate.MH_lengthStep; MethodHandle init = Iterate.MH_lengthInit; MethodType expectedType = Iterate.MT_length; @@ -708,8 +708,9 @@ public class LoopCombinatorTest { } } - @Test(dataProvider = "iteratorInits") - public static void testIterateMap(MethodHandle iterator) throws Throwable { + @ParameterizedTest + @MethodSource("iteratorInits") + public void testIterateMap(MethodHandle iterator) throws Throwable { MethodHandle body = Iterate.MH_mapStep; MethodHandle init = Iterate.MH_mapInit; MethodType expectedType = Iterate.MT_map; @@ -731,8 +732,9 @@ public class LoopCombinatorTest { } } - @Test(dataProvider = "iteratorInits") - public static void testIteratePrint(MethodHandle iterator) throws Throwable { + @ParameterizedTest + @MethodSource("iteratorInits") + public void testIteratePrint(MethodHandle iterator) throws Throwable { MethodHandle body = Iterate.MH_printStep; MethodType expectedType = Iterate.MT_print; int barity = body.type().parameterCount(); @@ -747,32 +749,28 @@ public class LoopCombinatorTest { loop.invoke(Arrays.asList("hello", "world")); } - @Test(expectedExceptions = NullPointerException.class) - public static void testIterateNullBody() { - MethodHandles.iteratedLoop(MethodHandles.empty(methodType(Iterator.class, int.class)), - MethodHandles.identity(int.class), null); + @Test + public void testIterateNullBody() { + assertThrows(NullPointerException.class, () -> + MethodHandles.iteratedLoop(MethodHandles.empty(methodType(Iterator.class, int.class)), + MethodHandles.identity(int.class), null)); } - @DataProvider static Object[][] wrongIteratorTypes() { return new Object[][]{{void.class}, {Object.class}, {Iterable.class}}; } - @Test(dataProvider = "wrongIteratorTypes") - public static void testIterateVoidIterator(Class it) { - boolean caught = false; + @ParameterizedTest + @MethodSource("wrongIteratorTypes") + public void testIterateVoidIterator(Class it) { MethodType v = methodType(it); - try { - MethodHandles.iteratedLoop(MethodHandles.empty(v), null, MethodHandles.empty(v)); - } catch(IllegalArgumentException iae) { - assertEqualsFIXME("iteratedLoop first argument must have Iterator return type", iae.getMessage()); - caught = true; - } - assertTrue(caught); + var iae = assertThrows(IllegalArgumentException.class, () -> MethodHandles.iteratedLoop(MethodHandles.empty(v), null, MethodHandles.empty(v))); + assertEqualsFIXME("iteratedLoop first argument must have Iterator return type", iae.getMessage()); } - @Test(dataProvider = "iteratorInits") - public static void testIterateVoidInit(MethodHandle iterator) throws Throwable { + @ParameterizedTest + @MethodSource("iteratorInits") + public void testIterateVoidInit(MethodHandle iterator) throws Throwable { // this test uses List as its loop state type; don't try to change that if (iterator != null) iterator = iterator.asType(iterator.type().changeParameterType(0, List.class)); @@ -781,7 +779,6 @@ public class LoopCombinatorTest { loop.invoke(Arrays.asList("hello", "world")); } - @DataProvider static Object[][] iterateParameters() { MethodType i = methodType(int.class); MethodType sil_v = methodType(void.class, String.class, int.class, List.class); @@ -811,8 +808,9 @@ public class LoopCombinatorTest { }; } - @Test(dataProvider = "iterateParameters") - public static void testIterateParameters(MethodType it, MethodType in, MethodType bo, String msg) { + @ParameterizedTest + @MethodSource("iterateParameters") + public void testIterateParameters(MethodType it, MethodType in, MethodType bo, String msg) { boolean negative = !msg.isEmpty(); MethodHandle iterator = it == null ? null : MethodHandles.empty(it); MethodHandle init = in == null ? null : MethodHandles.empty(in); @@ -855,7 +853,7 @@ public class LoopCombinatorTest { } @Test - public static void testIteratorSubclass() throws Throwable { + public void testIteratorSubclass() throws Throwable { MethodHandle loop = MethodHandles.iteratedLoop(MethodHandles.empty(methodType(BogusIterator.class, List.class)), null, MethodHandles.empty(methodType(void.class, String.class, List.class))); assertEquals(methodType(void.class, List.class), loop.type()); diff --git a/test/jdk/java/lang/invoke/MethodHandleInvokeUOE.java b/test/jdk/java/lang/invoke/MethodHandleInvokeUOE.java index e728516fe03..510a65acabf 100644 --- a/test/jdk/java/lang/invoke/MethodHandleInvokeUOE.java +++ b/test/jdk/java/lang/invoke/MethodHandleInvokeUOE.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,20 +24,18 @@ /* @test * @summary Test MethodHandle::invokeExact and MethodHandle::invoke throws * UnsupportedOperationException when called via Method::invoke - * @run testng test.java.lang.invoke.MethodHandleInvokeUOE + * @run junit test.java.lang.invoke.MethodHandleInvokeUOE */ package test.java.lang.invoke; -import org.testng.*; -import org.testng.annotations.*; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.Test; public class MethodHandleInvokeUOE { @Test diff --git a/test/jdk/java/lang/invoke/MethodHandleProxies/Driver.java b/test/jdk/java/lang/invoke/MethodHandleProxies/Driver.java index 0e9c708e8e9..2d99db46c2c 100644 --- a/test/jdk/java/lang/invoke/MethodHandleProxies/Driver.java +++ b/test/jdk/java/lang/invoke/MethodHandleProxies/Driver.java @@ -25,8 +25,8 @@ * @test * @bug 8280377 * @build m1/* m2/* Unnamed - * @run testng/othervm m1/p1.Main - * @run main/othervm Unnamed + * @run junit/othervm m1/p1.Main + * @run junit/othervm Unnamed * @summary Test MethodHandleProxies::asInterfaceInstance with a default * method with varargs */ diff --git a/test/jdk/java/lang/invoke/MethodHandleProxies/Unnamed.java b/test/jdk/java/lang/invoke/MethodHandleProxies/Unnamed.java index f60f36ca9de..8cd9a37cc2f 100644 --- a/test/jdk/java/lang/invoke/MethodHandleProxies/Unnamed.java +++ b/test/jdk/java/lang/invoke/MethodHandleProxies/Unnamed.java @@ -26,13 +26,16 @@ import java.lang.invoke.MethodHandleProxies; import java.lang.invoke.MethodHandles; import java.lang.reflect.Method; -import static org.testng.Assert.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; /* * Test MethodHandleProxies::asInterfaceInstance with an inaccessible interface */ public class Unnamed { - public static void main(String... args) throws Throwable { + @Test + void testInaccessible() throws Throwable { MethodHandle target = MethodHandles.constant(String.class, "test"); Class intf = Class.forName("p2.TestIntf"); Object t = MethodHandleProxies.asInterfaceInstance(intf, target); diff --git a/test/jdk/java/lang/invoke/MethodHandleProxies/m1/module-info.java b/test/jdk/java/lang/invoke/MethodHandleProxies/m1/module-info.java index 1bdeddce28f..5e0174635fb 100644 --- a/test/jdk/java/lang/invoke/MethodHandleProxies/m1/module-info.java +++ b/test/jdk/java/lang/invoke/MethodHandleProxies/m1/module-info.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -22,6 +22,6 @@ */ module m1 { requires m2; - requires org.testng; + requires org.junit.platform.console.standalone; exports p1; } diff --git a/test/jdk/java/lang/invoke/MethodHandleProxies/m1/p1/Main.java b/test/jdk/java/lang/invoke/MethodHandleProxies/m1/p1/Main.java index df71809996b..1e4ffcb4aac 100644 --- a/test/jdk/java/lang/invoke/MethodHandleProxies/m1/p1/Main.java +++ b/test/jdk/java/lang/invoke/MethodHandleProxies/m1/p1/Main.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -32,9 +32,8 @@ import java.util.stream.Collectors; import p2.TestIntf; -import org.testng.annotations.Test; - -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class Main { public interface A { @@ -57,24 +56,24 @@ public class Main { * Test the invocation of default methods with varargs */ @Test - public static void testVarargsMethods() throws Throwable { + public void testVarargsMethods() throws Throwable { MethodHandle target = MethodHandles.lookup().findStatic(Main.class, "concat", MethodType.methodType(String.class, Object[].class)); C proxy = MethodHandleProxies.asInterfaceInstance(C.class, target); - assertEquals(proxy.c("a", "b", "c"), "abc"); - assertEquals(proxy.aConcat("a", "b", "c"), "[a, b, c]"); - assertEquals(proxy.aConcat(new Object[] { "a", "b", "c" }), "[a, b, c]"); - assertEquals(proxy.bConcat(new Object[] { "a", "b", "c" }), "[a, b, c]"); + assertEquals("abc", proxy.c("a", "b", "c")); + assertEquals("[a, b, c]", proxy.aConcat("a", "b", "c")); + assertEquals("[a, b, c]", proxy.aConcat(new Object[] { "a", "b", "c" })); + assertEquals("[a, b, c]", proxy.bConcat(new Object[] { "a", "b", "c" })); } /* * Test the invocation of a default method of an accessible interface */ @Test - public static void modulePrivateInterface() { + public void modulePrivateInterface() { MethodHandle target = MethodHandles.constant(String.class, "test"); TestIntf t = MethodHandleProxies.asInterfaceInstance(TestIntf.class, target); - assertEquals(t.test(), "test"); + assertEquals("test", t.test()); } } diff --git a/test/jdk/java/lang/invoke/MethodHandles/TestDropReturn.java b/test/jdk/java/lang/invoke/MethodHandles/TestDropReturn.java index ff31dd63f0b..1b8ef6331b3 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/TestDropReturn.java +++ b/test/jdk/java/lang/invoke/MethodHandles/TestDropReturn.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,33 +24,33 @@ /* * @test * @bug 8255398 - * @run testng TestDropReturn + * @run junit TestDropReturn */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import static java.lang.invoke.MethodType.methodType; -import static org.testng.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class TestDropReturn { - @Test(dataProvider = "dropReturnCases") + @ParameterizedTest + @MethodSource("dropReturnCases") public void testDropReturn(Class cls, Object testValue) throws Throwable { MethodHandle mh = MethodHandles.identity(cls); - assertEquals(mh.type(), methodType(cls, cls)); + assertEquals(methodType(cls, cls), mh.type()); Object x = mh.invoke(testValue); - assertEquals(x, testValue); + assertEquals(testValue, x); mh = MethodHandles.dropReturn(mh); - assertEquals(mh.type(), methodType(void.class, cls)); + assertEquals(methodType(void.class, cls), mh.type()); mh.invoke(testValue); // should at least work } - @DataProvider public static Object[][] dropReturnCases() { return new Object[][]{ { boolean.class, true }, diff --git a/test/jdk/java/lang/invoke/MethodHandles/TestTableSwitch.java b/test/jdk/java/lang/invoke/MethodHandles/TestTableSwitch.java index 4ff1a99cc28..960d98fb387 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/TestTableSwitch.java +++ b/test/jdk/java/lang/invoke/MethodHandles/TestTableSwitch.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,13 +23,9 @@ /* * @test - * @run testng/othervm -Xverify:all TestTableSwitch + * @run junit/othervm -Xverify:all TestTableSwitch */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - -import javax.management.ObjectName; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; @@ -38,7 +34,11 @@ import java.util.List; import java.util.function.IntConsumer; import java.util.function.IntFunction; -import static org.testng.Assert.assertEquals; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.*; public class TestTableSwitch { @@ -111,7 +111,6 @@ public class TestTableSwitch { return args; } - @DataProvider public static Object[][] nonVoidCases() { List tests = new ArrayList<>(); @@ -126,10 +125,11 @@ public class TestTableSwitch { } private static void check(List testValues, Object[] collectedValues) { - assertEquals(collectedValues, testValues.toArray()); + assertArrayEquals(testValues.toArray(), collectedValues); } - @Test(dataProvider = "nonVoidCases") + @ParameterizedTest + @MethodSource("nonVoidCases") public void testNonVoidHandles(Class type, int numCases, List> additionalTypes) throws Throwable { MethodHandle collector = MH_check; List testArguments = new ArrayList<>(); @@ -158,19 +158,19 @@ public class TestTableSwitch { testArguments.add(testValue(additionalType)); } - assertEquals(mhSwitch.invokeWithArguments(testArguments(-1, testArguments)), defaultReturnValue); + assertEquals(defaultReturnValue, mhSwitch.invokeWithArguments(testArguments(-1, testArguments))); for (int i = 0; i < numCases; i++) { - assertEquals(mhSwitch.invokeWithArguments(testArguments(i, testArguments)), returnValues[i]); + assertEquals(returnValues[i], mhSwitch.invokeWithArguments(testArguments(i, testArguments))); } - assertEquals(mhSwitch.invokeWithArguments(testArguments(numCases, testArguments)), defaultReturnValue); + assertEquals(defaultReturnValue, mhSwitch.invokeWithArguments(testArguments(numCases, testArguments))); } @Test public void testVoidHandles() throws Throwable { IntFunction makeTestCase = expectedIndex -> { - IntConsumer test = actualIndex -> assertEquals(actualIndex, expectedIndex); + IntConsumer test = actualIndex -> assertEquals(expectedIndex, actualIndex); return MH_IntConsumer_accept.bindTo(test); }; @@ -187,48 +187,48 @@ public class TestTableSwitch { mhSwitch.invokeExact((int) 2); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testNullDefaultHandle() { - MethodHandles.tableSwitch(null, simpleTestCase("test")); + assertThrows(NullPointerException.class, () -> MethodHandles.tableSwitch(null, simpleTestCase("test"))); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testNullCases() { MethodHandle[] cases = null; - MethodHandles.tableSwitch(simpleTestCase("default"), cases); + assertThrows(NullPointerException.class, () -> + MethodHandles.tableSwitch(simpleTestCase("default"), cases)); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testNullCase() { - MethodHandles.tableSwitch(simpleTestCase("default"), simpleTestCase("case"), null); + assertThrows(NullPointerException.class, () -> MethodHandles.tableSwitch(simpleTestCase("default"), simpleTestCase("case"), null)); } - @Test(expectedExceptions = IllegalArgumentException.class, - expectedExceptionsMessageRegExp = ".*Not enough cases.*") + @Test public void testNotEnoughCases() { - MethodHandles.tableSwitch(simpleTestCase("default")); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.tableSwitch(simpleTestCase("default"))); } - @Test(expectedExceptions = IllegalArgumentException.class, - expectedExceptionsMessageRegExp = ".*Case actions must have int as leading parameter.*") + @Test public void testNotEnoughParameters() { MethodHandle empty = MethodHandles.empty(MethodType.methodType(void.class)); - MethodHandles.tableSwitch(empty, empty, empty); + assertThrows(IllegalArgumentException.class, () -> + MethodHandles.tableSwitch(empty, empty, empty)); } - @Test(expectedExceptions = IllegalArgumentException.class, - expectedExceptionsMessageRegExp = ".*Case actions must have int as leading parameter.*") + @Test public void testNoLeadingIntParameter() { MethodHandle empty = MethodHandles.empty(MethodType.methodType(void.class, double.class)); - MethodHandles.tableSwitch(empty, empty, empty); + assertThrows(IllegalArgumentException.class, () -> + MethodHandles.tableSwitch(empty, empty, empty)); } - @Test(expectedExceptions = IllegalArgumentException.class, - expectedExceptionsMessageRegExp = ".*Case actions must have the same type.*") + @Test public void testWrongCaseType() { // doesn't return a String MethodHandle wrongType = MethodHandles.empty(MethodType.methodType(void.class, int.class)); - MethodHandles.tableSwitch(simpleTestCase("default"), simpleTestCase("case"), wrongType); + assertThrows(IllegalArgumentException.class, () -> + MethodHandles.tableSwitch(simpleTestCase("default"), simpleTestCase("case"), wrongType)); } } diff --git a/test/jdk/java/lang/invoke/MethodHandles/classData/ClassDataTest.java b/test/jdk/java/lang/invoke/MethodHandles/classData/ClassDataTest.java index 5880761f925..f96a6f23162 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/classData/ClassDataTest.java +++ b/test/jdk/java/lang/invoke/MethodHandles/classData/ClassDataTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,7 +25,7 @@ * @test * @bug 8230501 * @library /test/lib - * @run testng/othervm ClassDataTest + * @run junit/othervm ClassDataTest */ import java.io.IOException; @@ -54,13 +54,14 @@ import java.util.Map; import java.util.function.Consumer; import java.util.stream.Stream; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import static java.lang.classfile.ClassFile.*; import static java.lang.constant.ConstantDescs.*; import static java.lang.invoke.MethodHandles.Lookup.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class ClassDataTest { private static final Lookup LOOKUP = MethodHandles.lookup(); @@ -72,10 +73,10 @@ public class ClassDataTest { assertTrue(lookup.hasFullPrivilegeAccess()); int value = MethodHandles.classData(lookup, "_", int.class); - assertEquals(value, 20); + assertEquals(20, value); Integer i = MethodHandles.classData(lookup, "_", Integer.class); - assertEquals(i.intValue(), 20); + assertEquals(20, i.intValue()); } /* @@ -86,8 +87,7 @@ public class ClassDataTest { assertNull(MethodHandles.classData(LOOKUP, "_", Object.class)); } - @DataProvider(name = "teleportedLookup") - private Object[][] teleportedLookup() throws ReflectiveOperationException { + private static Object[][] teleportedLookup() throws ReflectiveOperationException { Lookup lookup = hiddenClass(30); Class hc = lookup.lookupClass(); assertClassData(lookup, 30); @@ -100,32 +100,33 @@ public class ClassDataTest { }; } - @Test(dataProvider = "teleportedLookup", expectedExceptions = { IllegalAccessException.class }) + @ParameterizedTest + @MethodSource("teleportedLookup") public void illegalAccess(Lookup lookup, int access) throws IllegalAccessException { int lookupModes = lookup.lookupModes(); - assertTrue((lookupModes & ORIGINAL) == 0); - assertEquals(lookupModes, access); - MethodHandles.classData(lookup, "_", int.class); + assertEquals(0, lookupModes & ORIGINAL); + assertEquals(access, lookupModes); + assertThrows(IllegalAccessException.class, () -> MethodHandles.classData(lookup, "_", int.class)); } - @Test(expectedExceptions = { ClassCastException.class }) + @Test public void incorrectType() throws IllegalAccessException { Lookup lookup = hiddenClass(20); - MethodHandles.classData(lookup, "_", Long.class); + assertThrows(ClassCastException.class, () -> MethodHandles.classData(lookup, "_", Long.class)); } - @Test(expectedExceptions = { IndexOutOfBoundsException.class }) + @Test public void invalidIndex() throws IllegalAccessException { Lookup lookup = hiddenClass(List.of()); - MethodHandles.classDataAt(lookup, "_", Object.class, 0); + assertThrows(IndexOutOfBoundsException.class, () -> MethodHandles.classDataAt(lookup, "_", Object.class, 0)); } - @Test(expectedExceptions = { NullPointerException.class }) + @Test public void unboxNull() throws IllegalAccessException { List list = new ArrayList<>(); list.add(null); Lookup lookup = hiddenClass(list); - MethodHandles.classDataAt(lookup, "_", int.class, 0); + assertThrows(NullPointerException.class, () -> MethodHandles.classDataAt(lookup, "_", int.class, 0)); } @Test @@ -133,7 +134,7 @@ public class ClassDataTest { List list = new ArrayList<>(); list.add(null); Lookup lookup = hiddenClass(list); - assertTrue(MethodHandles.classDataAt(lookup, "_", Object.class, 0) == null); + assertNull(MethodHandles.classDataAt(lookup, "_", Object.class, 0)); } @Test @@ -142,7 +143,7 @@ public class ClassDataTest { byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, int.class).build(); Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, 100, true); int value = MethodHandles.classData(lookup, "_", int.class); - assertEquals(value, 100); + assertEquals(100, value); // call through condy assertClassData(lookup, 100); } @@ -153,7 +154,7 @@ public class ClassDataTest { byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, float.class).build(); Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, 0.1234f, true); float value = MethodHandles.classData(lookup, "_", float.class); - assertEquals(value, 0.1234f); + assertEquals(0.1234f, value); // call through condy assertClassData(lookup, 0.1234f); } @@ -165,7 +166,7 @@ public class ClassDataTest { byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, Class.class).build(); Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, hc, true); Class value = MethodHandles.classData(lookup, "_", Class.class); - assertEquals(value, hc); + assertEquals(hc, value); // call through condy assertClassData(lookup, hc); } @@ -181,7 +182,7 @@ public class ClassDataTest { colors[0] = "black"; // it will get back the modified class data String[] value = MethodHandles.classData(lookup, "_", String[].class); - assertEquals(value, colors); + assertArrayEquals(colors, value); // even call through condy as it's not a constant assertClassData(lookup, colors); } @@ -194,7 +195,7 @@ public class ClassDataTest { int expected = 102; // element at index=2 Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, cd, true); int value = MethodHandles.classDataAt(lookup, "_", int.class, 2); - assertEquals(value, expected); + assertEquals(expected, value); // call through condy assertClassData(lookup, expected); } @@ -208,7 +209,7 @@ public class ClassDataTest { int expected = 101; // element at index=1 Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, cd, true); int value = MethodHandles.classDataAt(lookup, "_", int.class, 1); - assertEquals(value, expected); + assertEquals(expected, value); // call through condy assertClassData(lookup, expected); } @@ -216,20 +217,12 @@ public class ClassDataTest { private static Lookup hiddenClass(int value) { ClassByteBuilder builder = new ClassByteBuilder("HC"); byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, int.class).build(); - try { - return LOOKUP.defineHiddenClassWithClassData(bytes, value, true); - } catch (Throwable e) { - throw new RuntimeException(e); - } + return assertDoesNotThrow(() -> LOOKUP.defineHiddenClassWithClassData(bytes, value, true)); } private static Lookup hiddenClass(List list) { ClassByteBuilder builder = new ClassByteBuilder("HC"); byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, List.class).build(); - try { - return LOOKUP.defineHiddenClassWithClassData(bytes, list, true); - } catch (Throwable e) { - throw new RuntimeException(e); - } + return assertDoesNotThrow(() -> LOOKUP.defineHiddenClassWithClassData(bytes, list, true)); } @Test @@ -242,7 +235,7 @@ public class ClassDataTest { Class hc = hcLookup.lookupClass(); Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, hc, true); Class value = MethodHandles.classData(lookup, "_", Class.class); - assertEquals(value, hc); + assertEquals(hc, value); // call through condy Class c = lookup.lookupClass(); assertClassData(lookup, c.newInstance(), hc); @@ -257,7 +250,7 @@ public class ClassDataTest { int expected = 102; // element at index=2 Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, cd, true); int value = MethodHandles.classDataAt(lookup, "_", int.class, 2); - assertEquals(value, expected); + assertEquals(expected, value); // call through condy Class c = lookup.lookupClass(); assertClassData(lookup, c.newInstance() ,expected); @@ -285,13 +278,13 @@ public class ClassDataTest { Class c = lookup.lookupClass(); assertClassData(lookup, c.newInstance(), mtype); // modify the class data - assertTrue(cd.remove(0) == mtype); + assertSame(mtype, cd.remove(0)); cd.add(0, MethodType.methodType(void.class)); MethodType newMType = cd.get(0); // loading the element using condy returns the original value assertClassData(lookup, c.newInstance(), mtype); // direct invocation of MethodHandles.classDataAt returns the modified value - assertEquals(MethodHandles.classDataAt(lookup, "_", MethodType.class, 0), newMType); + assertEquals(newMType, MethodHandles.classDataAt(lookup, "_", MethodType.class, 0)); } // helper method to extract from a class data map @@ -334,7 +327,7 @@ public class ClassDataTest { assertEquals(mh, v1); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void nonDefaultName() throws ReflectiveOperationException { ClassByteBuilder builder = new ClassByteBuilder("nonDefaultName"); byte[] bytes = builder.classData(ACC_PUBLIC|ACC_STATIC, Class.class) @@ -342,7 +335,7 @@ public class ClassDataTest { Lookup lookup = LOOKUP.defineHiddenClassWithClassData(bytes, ClassDataTest.class, true); assertClassData(lookup, ClassDataTest.class); // throw IAE - MethodHandles.classData(lookup, "non_default_name", Class.class); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.classData(lookup, "non_default_name", Class.class)); } static class ClassByteBuilder { @@ -428,7 +421,7 @@ public class ClassDataTest { * Load an int constant from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, int value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, int value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); int v = (int) m.invoke(null); @@ -439,7 +432,7 @@ public class ClassDataTest { * Load an int constant from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, Object o, int value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, Object o, int value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); int v = (int) m.invoke(o); @@ -450,7 +443,7 @@ public class ClassDataTest { * Load a float constant from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, float value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, float value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); float v = (float) m.invoke(null); @@ -461,7 +454,7 @@ public class ClassDataTest { * Load a Class constant from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, Class value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, Class value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); Class v = (Class)m.invoke(null); @@ -472,7 +465,7 @@ public class ClassDataTest { * Load a Class from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, Object o, Class value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, Object o, Class value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); Object v = m.invoke(o); @@ -483,18 +476,29 @@ public class ClassDataTest { * Load an Object from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, Object value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, Object value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); Object v = m.invoke(null); assertEquals(value, v); } + /* + * Load an Object array from class data via condy and + * verify it matches the given value in content. + */ + private static void assertClassData(Lookup lookup, Object[] value) throws ReflectiveOperationException { + Class c = lookup.lookupClass(); + Method m = c.getMethod("classData"); + Object v = m.invoke(null); + assertArrayEquals(value, (Object[]) v); + } + /* * Load an Object from class data via condy and * verify it matches the given value. */ - private void assertClassData(Lookup lookup, Object o, Object value) throws ReflectiveOperationException { + private static void assertClassData(Lookup lookup, Object o, Object value) throws ReflectiveOperationException { Class c = lookup.lookupClass(); Method m = c.getMethod("classData"); Object v = m.invoke(o); diff --git a/test/jdk/java/lang/invoke/MethodHandles/ensureInitialized/Main.java b/test/jdk/java/lang/invoke/MethodHandles/ensureInitialized/Main.java index 58146286da1..afb628d31ba 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/ensureInitialized/Main.java +++ b/test/jdk/java/lang/invoke/MethodHandles/ensureInitialized/Main.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,16 +24,15 @@ import java.lang.invoke.MethodHandles; import java.lang.reflect.Method; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; /** * @test * @bug 8235521 * @summary Tests for Lookup::ensureClassInitialized * @build java.base/* m1/* m2/* Main - * @run testng/othervm --add-modules m1 Main + * @run junit/othervm --add-modules m1 Main */ public class Main { @@ -48,20 +47,20 @@ public class Main { } // access denied to package-private java.lang class - @Test(expectedExceptions = { IllegalAccessException.class }) + @Test public void testPackagePrivate() throws Exception { Class c = Class.forName("java.lang.DefaultInit", false, null); assertFalse(Helper.isInitialized(c)); // access denied - MethodHandles.lookup().ensureInitialized(c); + assertThrows(IllegalAccessException.class, () -> MethodHandles.lookup().ensureInitialized(c)); } // access denied to public class in a non-exported package - @Test(expectedExceptions = { IllegalAccessException.class }) + @Test public void testNonExportedPackage() throws Exception { Class c = Class.forName("jdk.internal.misc.VM", false, null); // access denied - MethodHandles.lookup().ensureInitialized(c); + assertThrows(IllegalAccessException.class, () -> MethodHandles.lookup().ensureInitialized(c)); } // invoke p1.Test::test to test module boundary access @@ -72,9 +71,9 @@ public class Main { m.invoke(null); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void testArrayType() throws Exception { Class arrayType = PublicInit.class.arrayType(); - MethodHandles.lookup().ensureInitialized(arrayType); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.lookup().ensureInitialized(arrayType)); } } diff --git a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/Driver.java b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/Driver.java index 810351bae3e..bf3f1f40913 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/Driver.java +++ b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/Driver.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,6 +24,6 @@ /** * @test * @build test/* m1/* m2/* m3/* Unnamed - * @run testng/othervm test/p.PrivateLookupInTests + * @run junit/othervm test/p.PrivateLookupInTests * @summary Unit tests for MethodHandles.privateLookupIn */ diff --git a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/module-info.java b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/module-info.java index da93c879ef1..f364c761aa3 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/module-info.java +++ b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/module-info.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -22,6 +22,6 @@ */ module test { - requires org.testng; - exports p to org.testng; // TestNG invokes the public methods + requires org.junit.platform.console.standalone; + exports p to org.junit.platform.console.standalone; // JUnit invokes the public methods in PrivateLookupInTests } diff --git a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/p/PrivateLookupInTests.java b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/p/PrivateLookupInTests.java index b17204de013..068d2fb534e 100644 --- a/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/p/PrivateLookupInTests.java +++ b/test/jdk/java/lang/invoke/MethodHandles/privateLookupIn/test/p/PrivateLookupInTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -29,15 +29,14 @@ import java.lang.reflect.Modifier; import static java.lang.invoke.MethodHandles.Lookup.*; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; /** * Unit tests for MethodHandles.privateLookupIn */ -@Test public class PrivateLookupInTests { /** * A public and non-public types in the test module but in a different @@ -52,24 +51,25 @@ public class PrivateLookupInTests { * private static final Object obj = ... * } */ - private Class publicType; - private Class nonPublicType; + private static Class publicType; + private static Class nonPublicType; // initialize and sanity check publicType/nonPublicType - @BeforeTest - public void init() throws Exception { + @BeforeAll + public static void init() throws Exception { publicType = Class.forName("p.internal.PublicType"); - assertTrue(this.getClass().getModule() == publicType.getModule()); - assertNotEquals(this.getClass().getPackageName(), publicType.getPackageName()); + assertSame(PrivateLookupInTests.class.getModule(), publicType.getModule()); + assertNotEquals(publicType.getPackageName(), PrivateLookupInTests.class.getPackageName()); assertTrue(Modifier.isPublic(publicType.getModifiers())); nonPublicType = Class.forName("p.internal.NonPublicType"); - assertTrue(this.getClass().getModule() == nonPublicType.getModule()); - assertNotEquals(this.getClass().getPackageName(), nonPublicType.getPackageName()); + assertSame(PrivateLookupInTests.class.getModule(), nonPublicType.getModule()); + assertNotEquals(nonPublicType.getPackageName(), PrivateLookupInTests.class.getPackageName()); assertFalse(Modifier.isPublic(nonPublicType.getModifiers())); } // Invoke MethodHandles.privateLookupIn with a full-power caller + @Test public void testAllAccessCallerSameModule() throws Throwable { Lookup lookup = MethodHandles.privateLookupIn(nonPublicType, MethodHandles.lookup()); assertTrue(lookup.lookupClass() == nonPublicType); @@ -82,29 +82,31 @@ public class PrivateLookupInTests { } // Invoke MethodHandles.privateLookupIn with a reduced-power caller - @Test(expectedExceptions = {IllegalAccessException.class}) + @Test public void testReducedAccessCallerSameModule() throws Throwable { Lookup caller = MethodHandles.lookup().dropLookupMode(PACKAGE); - assertTrue((caller.lookupModes() & PRIVATE) == 0); - assertTrue((caller.lookupModes() & PACKAGE) == 0); - assertTrue((caller.lookupModes() & MODULE) != 0); - assertTrue((caller.lookupModes() & ORIGINAL) == 0); - - Lookup lookup = MethodHandles.privateLookupIn(nonPublicType, caller); + assertEquals(0, caller.lookupModes() & PRIVATE); + assertEquals(0, caller.lookupModes() & PACKAGE); + assertNotEquals(0, caller.lookupModes() & MODULE); + assertEquals(0, caller.lookupModes() & ORIGINAL); + assertThrows(IllegalAccessException.class, () -> + MethodHandles.privateLookupIn(nonPublicType, caller)); } // Invoke MethodHandles.privateLookupIn with the public lookup as caller - @Test(expectedExceptions = {IllegalAccessException.class}) + @Test public void testPublicLookupSameModule() throws Exception { Lookup caller = MethodHandles.publicLookup(); - Lookup lookup = MethodHandles.privateLookupIn(publicType, caller); + assertThrows(IllegalAccessException.class, () -> + MethodHandles.privateLookupIn(publicType, caller)); } // test reads m1, open module m1 containing p1 + @Test public void testTargetClassInOpenModule() throws Throwable { // m1/p1.Type Class clazz = Class.forName("p1.Type"); - assertEquals(clazz.getModule().getName(), "m1"); + assertEquals("m1", clazz.getModule().getName()); // ensure that this module reads m1 Module thisModule = getClass().getModule(); @@ -113,9 +115,9 @@ public class PrivateLookupInTests { assertTrue(m1.isOpen("p1", thisModule)); Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()); - assertTrue(lookup.lookupClass() == clazz); - assertTrue((lookup.lookupModes() & PRIVATE) == PRIVATE); - assertTrue((lookup.lookupModes() & MODULE) == 0); + assertSame(clazz, lookup.lookupClass()); + assertEquals(PRIVATE, lookup.lookupModes() & PRIVATE); + assertEquals(0, lookup.lookupModes() & MODULE); // get obj field MethodHandle mh = lookup.findStaticGetter(clazz, "obj", Object.class); @@ -123,6 +125,7 @@ public class PrivateLookupInTests { } // test target class in unnamed module + @Test public void testTargetClassInUnnamedModule() throws Throwable { Class clazz = Class.forName("Unnamed"); assertFalse(clazz.getModule().isNamed()); @@ -130,76 +133,72 @@ public class PrivateLookupInTests { // thisModule does not read the unnamed module Module thisModule = getClass().getModule(); assertFalse(thisModule.canRead(clazz.getModule())); - try { - MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()); - assertTrue(false); - } catch (IllegalAccessException expected) { } + var baseLookup = MethodHandles.lookup(); + assertThrows(IllegalAccessException.class, () -> MethodHandles.privateLookupIn(clazz, baseLookup)); // thisModule reads the unnamed module thisModule.addReads(clazz.getModule()); - Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()); - assertTrue(lookup.lookupClass() == clazz); - assertTrue((lookup.lookupModes() & PRIVATE) == PRIVATE); - assertTrue((lookup.lookupModes() & MODULE) == 0); + Lookup lookup = MethodHandles.privateLookupIn(clazz, baseLookup); + assertSame(clazz, lookup.lookupClass()); + assertEquals(PRIVATE, (lookup.lookupModes() & PRIVATE)); + assertEquals(0, (lookup.lookupModes() & MODULE)); } // test does not read m2, m2 opens p2 to test - @Test(expectedExceptions = {IllegalAccessException.class}) + @Test public void testCallerDoesNotRead() throws Throwable { // m2/p2.Type Class clazz = Class.forName("p2.Type"); - assertEquals(clazz.getModule().getName(), "m2"); - + assertEquals("m2", clazz.getModule().getName()); Module thisModule = getClass().getModule(); Module m2 = clazz.getModule(); assertFalse(thisModule.canRead(m2)); assertTrue(m2.isOpen("p2", thisModule)); - - Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()); + assertThrows(IllegalAccessException.class, () -> + MethodHandles.privateLookupIn(clazz, MethodHandles.lookup())); } // test reads m3, m3 does not open p3 to test - @Test(expectedExceptions = {IllegalAccessException.class}) + @Test public void testNotOpenToCaller() throws Throwable { // m3/p2.Type Class clazz = Class.forName("p3.Type"); - assertEquals(clazz.getModule().getName(), "m3"); - + assertEquals("m3", clazz.getModule().getName()); Module thisModule = getClass().getModule(); Module m3 = clazz.getModule(); thisModule.addReads(clazz.getModule()); assertFalse(m3.isOpen("p3", thisModule)); - - Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()); + assertThrows(IllegalAccessException.class, () -> + MethodHandles.privateLookupIn(clazz, MethodHandles.lookup())); } // Invoke MethodHandles.privateLookupIn with a primitive class - @Test(expectedExceptions = {IllegalArgumentException.class}) + @Test public void testPrimitiveClassAsTargetClass() throws Exception { - MethodHandles.privateLookupIn(int.class, MethodHandles.lookup()); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.privateLookupIn(int.class, MethodHandles.lookup())); } // Invoke MethodHandles.privateLookupIn with an array class - @Test(expectedExceptions = {IllegalArgumentException.class}) + @Test public void testArrayClassAsTargetClass() throws Exception { - MethodHandles.privateLookupIn(PrivateLookupInTests[].class, MethodHandles.lookup()); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.privateLookupIn(PrivateLookupInTests[].class, MethodHandles.lookup())); } // Invoke MethodHandles.privateLookupIn with a primitive array class - @Test(expectedExceptions = {IllegalArgumentException.class}) + @Test public void testPrimitiveArrayClassAsTargetClass() throws Exception { - MethodHandles.privateLookupIn(int[].class, MethodHandles.lookup()); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.privateLookupIn(int[].class, MethodHandles.lookup())); } // Invoke MethodHandles.privateLookupIn with null - @Test(expectedExceptions = {NullPointerException.class}) + @Test public void testNullTargetClass() throws Exception { - MethodHandles.privateLookupIn(null, MethodHandles.lookup()); + assertThrows(NullPointerException.class, () -> MethodHandles.privateLookupIn(null, MethodHandles.lookup())); } // Invoke MethodHandles.privateLookupIn with null - @Test(expectedExceptions = {NullPointerException.class}) + @Test public void testNullCaller() throws Exception { - MethodHandles.privateLookupIn(getClass(), null); + assertThrows(NullPointerException.class, () -> MethodHandles.privateLookupIn(getClass(), null)); } } diff --git a/test/jdk/java/lang/invoke/MethodHandlesCollectArgsTest.java b/test/jdk/java/lang/invoke/MethodHandlesCollectArgsTest.java index 5fc0083d5fb..20f03454d32 100644 --- a/test/jdk/java/lang/invoke/MethodHandlesCollectArgsTest.java +++ b/test/jdk/java/lang/invoke/MethodHandlesCollectArgsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,18 +23,17 @@ /* @test * @bug 8259922 - * @run testng/othervm MethodHandlesCollectArgsTest + * @run junit/othervm MethodHandlesCollectArgsTest */ -import org.testng.annotations.Test; -import org.testng.annotations.DataProvider; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import static java.lang.invoke.MethodType.methodType; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class MethodHandlesCollectArgsTest { @@ -43,7 +42,6 @@ public class MethodHandlesCollectArgsTest { private static final MethodHandle FILTER_INT = MethodHandles.empty(methodType(int.class, String.class)); private static final MethodHandle FILTER_VOID = MethodHandles.empty(methodType(void.class, String.class)); - @DataProvider(name = "illegalPos") public static Object[][] illegalPos() { return new Object[][] { {TARGET_II_I, 2, FILTER_INT}, @@ -57,7 +55,6 @@ public class MethodHandlesCollectArgsTest { }; } - @DataProvider(name = "validPos") public static Object[][] validPos() { return new Object[][] { {TARGET_II_I, 0, FILTER_INT, methodType(int.class, String.class, int.class)}, @@ -69,14 +66,16 @@ public class MethodHandlesCollectArgsTest { }; } - @Test(dataProvider="illegalPos", expectedExceptions = {IllegalArgumentException.class}) + @ParameterizedTest + @MethodSource("illegalPos") public void illegalPosition(MethodHandle target, int position, MethodHandle filter) { - MethodHandles.collectArguments(target, position, filter); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.collectArguments(target, position, filter)); } - @Test(dataProvider="validPos") + @ParameterizedTest + @MethodSource("validPos") public void legalPosition(MethodHandle target, int position, MethodHandle filter, MethodType expectedType) { MethodHandle result = MethodHandles.collectArguments(target, position, filter); - assertEquals(result.type(), expectedType); + assertEquals(expectedType, result.type()); } } diff --git a/test/jdk/java/lang/invoke/MethodHandlesGeneralTest.java b/test/jdk/java/lang/invoke/MethodHandlesGeneralTest.java index b60c35fc30b..588227fef15 100644 --- a/test/jdk/java/lang/invoke/MethodHandlesGeneralTest.java +++ b/test/jdk/java/lang/invoke/MethodHandlesGeneralTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -60,6 +60,7 @@ import java.util.Map; import static java.lang.invoke.MethodType.methodType; import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; public class MethodHandlesGeneralTest extends MethodHandlesTest { @@ -398,7 +399,7 @@ public class MethodHandlesGeneralTest extends MethodHandlesTest { Object obj = target.invokeWithArguments(args); if (!(defc == Example.class && params.length < 2)) assertCalled(defc.getSimpleName()+".", args); - assertTrue("instance of "+defc.getName(), defc.isInstance(obj)); + assertInstanceOf(defc, obj); } @Test @@ -971,8 +972,7 @@ public class MethodHandlesGeneralTest extends MethodHandlesTest { arrayToMH = new SubIntExample[length]; else return; // can't make an ArrayStoreException test - assert(arrayType.isInstance(arrayToMH)) - : Arrays.asList(arrayType, arrayToMH.getClass(), testSetter, negTest); + assertInstanceOf(arrayType, arrayToMH, () -> Arrays.asList(testSetter, negTest).toString()); break; } countTest(positive); diff --git a/test/jdk/java/lang/invoke/MethodTypeTest.java b/test/jdk/java/lang/invoke/MethodTypeTest.java index 8ac03d1a7fd..dccc82fa348 100644 --- a/test/jdk/java/lang/invoke/MethodTypeTest.java +++ b/test/jdk/java/lang/invoke/MethodTypeTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,7 +25,7 @@ * @bug 8366028 * @summary unit tests for java.lang.invoke.MethodType * @compile MethodTypeTest.java - * @run testng/othervm test.java.lang.invoke.MethodTypeTest + * @run junit/othervm test.java.lang.invoke.MethodTypeTest */ package test.java.lang.invoke; @@ -35,11 +35,13 @@ import java.lang.invoke.MethodType; import java.lang.reflect.Method; import java.util.*; -import org.testng.*; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import static org.testng.Assert.assertThrows; -import static org.testng.AssertJUnit.*; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; /** * @@ -57,7 +59,7 @@ public class MethodTypeTest { private MethodType[] GALLERY; private Method compareTo; - @BeforeMethod + @BeforeEach public void setUp() throws Exception { rtype = void.class; ptypes = new Class[] { int.class, String.class }; @@ -98,7 +100,7 @@ public class MethodTypeTest { }; } - @AfterMethod + @AfterEach public void tearDown() throws Exception { } @@ -107,7 +109,7 @@ public class MethodTypeTest { public void testDistinct() { List gallery2 = new ArrayList<>(); for (MethodType mt : GALLERY) { - assertFalse(mt.toString(), gallery2.contains(mt)); + assertFalse(gallery2.contains(mt), mt.toString()); gallery2.add(mt); } // check self-equality also: @@ -198,9 +200,9 @@ public class MethodTypeTest { for (int i = 0; i < instances.length; i++) { MethodType instance = instances[i]; String result = instance.toMethodDescriptorString(); - assertEquals("#"+i, expResults[i], result); + assertEquals(expResults[i], result, "#"+i); MethodType parsed = MethodType.fromMethodDescriptorString(result, loader); - assertSame("--#"+i, instance, parsed); + assertSame(instance, parsed, "--#"+i); } } private static String concat(Object... parts) { @@ -221,8 +223,7 @@ public class MethodTypeTest { return sb.toString().replace('.', '/'); } - @DataProvider(name = "badMethodDescriptorStrings") - public String[] badMethodDescriptorStrings() { + public static String[] badMethodDescriptorStrings() { return new String[] { "(I)", "(V)V", @@ -239,9 +240,12 @@ public class MethodTypeTest { } // JDK-8366028 - @Test(dataProvider = "badMethodDescriptorStrings", expectedExceptions = IllegalArgumentException.class) + @ParameterizedTest + @MethodSource("badMethodDescriptorStrings") public void testFromMethodDescriptorStringNegatives(String desc) { - MethodType.fromMethodDescriptorString(desc, null); + assertThrows(IllegalArgumentException.class, () -> { + MethodType.fromMethodDescriptorString(desc, null); + }); } @Test @@ -251,7 +255,7 @@ public class MethodTypeTest { boolean[] expResults = {true, false, true, false, true, true, false, true}; for (int i = 0; i < instances.length; i++) { boolean result = instances[i].hasPrimitives(); - assertEquals("#"+i, expResults[i], result); + assertEquals(expResults[i], result, "#"+i); } } @@ -263,7 +267,7 @@ public class MethodTypeTest { for (int i = 0; i < instances.length; i++) { System.out.println(" hasWrappers "+instances[i]); boolean result = instances[i].hasWrappers(); - assertEquals("#"+i, expResults[i], result); + assertEquals(expResults[i], result, "#"+i); } } @@ -274,7 +278,7 @@ public class MethodTypeTest { MethodType[] expResults = {mt_viO, mt_OO2, mt_vv, mt_Ov, mt_iO2, mt_OOi, mt_OO2, mt_iOi}; for (int i = 0; i < instances.length; i++) { MethodType result = instances[i].erase(); - assertSame("#"+i, expResults[i], result); + assertSame(expResults[i], result, "#"+i); } } @@ -285,7 +289,7 @@ public class MethodTypeTest { MethodType[] expResults = {mt_OO2, mt_OO2, mt_Ov, mt_Ov, mt_OO2, mt_OO2, mt_OO2, mt_OO2}; for (int i = 0; i < instances.length; i++) { MethodType result = instances[i].generic(); - assertSame("#"+i, expResults[i], result); + assertSame(expResults[i], result, "#"+i); } } @@ -296,7 +300,7 @@ public class MethodTypeTest { MethodType[] expResults = {mt_VIS, mt_OO2, mt_Vv, mt_Ov, mt_ISI, mt_ISI, mt_ISI, mt_ISI}; for (int i = 0; i < instances.length; i++) { MethodType result = instances[i].wrap(); - assertSame("#"+i, expResults[i], result); + assertSame(expResults[i], result, "#"+i); } } @@ -307,7 +311,7 @@ public class MethodTypeTest { MethodType[] expResults = {mt_viS, mt_OO2, mt_vv, mt_Ov, mt_iSi, mt_iSi, mt_iSi, mt_iSi}; for (int i = 0; i < instances.length; i++) { MethodType result = instances[i].unwrap(); - assertSame("#"+i, expResults[i], result); + assertSame(expResults[i], result, "#"+i); } } @@ -436,7 +440,7 @@ public class MethodTypeTest { MethodType instance = instances[i]; String result = instance.toString(); System.out.println("#"+i+":"+result); - assertEquals("#"+i, expResults[i], result); + assertEquals(expResults[i], result, "#"+i); } } diff --git a/test/jdk/java/lang/invoke/PermuteArgsReturnVoidTest.java b/test/jdk/java/lang/invoke/PermuteArgsReturnVoidTest.java index b01a4aa2a99..6bd604dcd36 100644 --- a/test/jdk/java/lang/invoke/PermuteArgsReturnVoidTest.java +++ b/test/jdk/java/lang/invoke/PermuteArgsReturnVoidTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,21 +24,21 @@ /* @test * @bug 8184119 * @summary test permutation when return value is directly derived from an argument - * @run testng/othervm test.java.lang.invoke.PermuteArgsReturnVoidTest + * @run junit/othervm test.java.lang.invoke.PermuteArgsReturnVoidTest */ package test.java.lang.invoke; -import org.testng.Assert; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import static java.lang.invoke.MethodHandles.dropArguments; import static java.lang.invoke.MethodHandles.identity; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; public class PermuteArgsReturnVoidTest { @@ -65,8 +65,8 @@ public class PermuteArgsReturnVoidTest { MethodHandle p = MethodHandles.permuteArguments(f, MethodType.methodType(String.class, String.class, int.class, int.class), 0, 2, 1); String s = (String) p.invoke("IN", 0, 0); - Assert.assertEquals(s.getClass(), String.class); - Assert.assertEquals(s, "IN"); + assertEquals(String.class, s.getClass()); + assertEquals("IN", s); } @Test @@ -84,7 +84,7 @@ public class PermuteArgsReturnVoidTest { MethodHandle p = MethodHandles.permuteArguments(f, MethodType.methodType(String.class, String.class, int.class, int.class), 0, 2, 1); String s = (String) p.invoke("IN", 0, 0); - Assert.assertEquals(s.getClass(), String.class); - Assert.assertEquals(s, "IN"); + assertEquals(String.class, s.getClass()); + assertEquals("IN", s); } } diff --git a/test/jdk/java/lang/invoke/PermuteArgsTest.java b/test/jdk/java/lang/invoke/PermuteArgsTest.java index 3586dc9382f..77558714d11 100644 --- a/test/jdk/java/lang/invoke/PermuteArgsTest.java +++ b/test/jdk/java/lang/invoke/PermuteArgsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* @test * @summary unit tests for method handles which permute their arguments * @library /test/lib /java/lang/invoke/common - * @run testng/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-VerifyDependencies -ea -esa -DPermuteArgsTest.MAX_ARITY=8 test.java.lang.invoke.PermuteArgsTest + * @run junit/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-VerifyDependencies -ea -esa -DPermuteArgsTest.MAX_ARITY=8 test.java.lang.invoke.PermuteArgsTest */ /* Examples of manual runs: @@ -35,7 +35,6 @@ package test.java.lang.invoke; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.CodeCacheOverflowProcessor; import java.lang.invoke.MethodHandle; @@ -52,6 +51,10 @@ import static java.lang.invoke.MethodHandles.Lookup; import static java.lang.invoke.MethodHandles.lookup; import static java.lang.invoke.MethodHandles.permuteArguments; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; public class PermuteArgsTest { private static final Class CLASS = PermuteArgsTest.class; @@ -259,11 +262,11 @@ public class PermuteArgsTest { reverse(perm, 0, perm.length); } switch (perm.length) { - case 2: assert(testCases - testCases0 == 2); break; - case 3: assert(testCases - testCases0 == 6); break; - case 4: assert(testCases - testCases0 == 24); break; - case 5: assert(testCases - testCases0 == 120); break; - case 6: assert(testCases - testCases0 > 720/3); break; + case 2 -> assertEquals(2, testCases - testCases0); + case 3 -> assertEquals(6, testCases - testCases0); + case 4 -> assertEquals(24, testCases - testCases0); + case 5 -> assertEquals(120, testCases - testCases0); + case 6 -> assertTrue(testCases - testCases0 > 720/3); } } diff --git a/test/jdk/java/lang/invoke/SpreadCollectTest.java b/test/jdk/java/lang/invoke/SpreadCollectTest.java index bcddcd449f8..d58ebab3611 100644 --- a/test/jdk/java/lang/invoke/SpreadCollectTest.java +++ b/test/jdk/java/lang/invoke/SpreadCollectTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* @test * @bug 8139885 * @bug 8143798 - * @run testng/othervm -ea -esa test.java.lang.invoke.SpreadCollectTest + * @run junit/othervm -ea -esa test.java.lang.invoke.SpreadCollectTest */ package test.java.lang.invoke; @@ -39,9 +39,11 @@ import java.util.*; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; /** * Tests for the new asSpreader/asCollector API added in JEP 274. @@ -51,14 +53,14 @@ public class SpreadCollectTest { static final Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testAsSpreader() throws Throwable { + public void testAsSpreader() throws Throwable { MethodHandle spreader = SpreadCollect.MH_forSpreading.asSpreader(1, int[].class, 3); assertEquals(SpreadCollect.MT_spreader, spreader.type()); assertEquals("A456B", (String) spreader.invoke("A", new int[]{4, 5, 6}, "B")); } @Test - public static void testAsSpreaderExample() throws Throwable { + public void testAsSpreaderExample() throws Throwable { // test the JavaDoc asSpreader-with-pos example MethodHandle compare = LOOKUP.findStatic(Objects.class, "compare", methodType(int.class, Object.class, Object.class, Comparator.class)); MethodHandle compare2FromArray = compare.asSpreader(0, Object[].class, 2); @@ -66,49 +68,43 @@ public class SpreadCollectTest { Comparator cmp = (a, b) -> a - b; assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 0, 2), cmp) < 0); assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 1, 3), cmp) > 0); - assertTrue((int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 2, 4), cmp) == 0); + assertEquals(0, (int) compare2FromArray.invoke(Arrays.copyOfRange(ints, 2, 4), cmp)); } - @DataProvider static Object[][] asSpreaderIllegalPositions() { return new Object[][]{{-7}, {3}, {19}}; } - @Test(dataProvider = "asSpreaderIllegalPositions") - public static void testAsSpreaderIllegalPos(int p) throws Throwable { - boolean caught = false; - try { - SpreadCollect.MH_forSpreading.asSpreader(p, Object[].class, 3); - } catch (IllegalArgumentException iae) { - assertEquals("bad spread position", iae.getMessage()); - caught = true; - } - assertTrue(caught); - } - - @Test(expectedExceptions = {WrongMethodTypeException.class}) - public static void testAsSpreaderIllegalMethodType() { - MethodHandle h = MethodHandles.dropArguments(MethodHandles.constant(String.class, ""), 0, int.class, int.class); - MethodHandle s = h.asSpreader(String[].class, 1); - } - - @Test(expectedExceptions = {NullPointerException.class}) - public static void testAsSpreaderNullArrayType() { - SpreadCollect.MH_forSpreading.asSpreader(null, 0); - } - - @Test(expectedExceptions = {NullPointerException.class}) - public static void testAsSpreaderNullArrayNonZeroLength() { - SpreadCollect.MH_forSpreading.asSpreader(null, 1); - } - - @Test(expectedExceptions = {IllegalArgumentException.class}) - public static void testAsSpreaderTooManyParams() throws Throwable { - SpreadCollect.MH_forSpreading.asSpreader(1, int[].class, 6); + @ParameterizedTest + @MethodSource("asSpreaderIllegalPositions") + public void testAsSpreaderIllegalPos(int p) throws Throwable { + var iae = assertThrows(IllegalArgumentException.class, () -> SpreadCollect.MH_forSpreading.asSpreader(p, Object[].class, 3)); + assertEquals("bad spread position", iae.getMessage()); } @Test - public static void testAsCollector() throws Throwable { + public void testAsSpreaderIllegalMethodType() { + MethodHandle h = MethodHandles.dropArguments(MethodHandles.constant(String.class, ""), 0, int.class, int.class); + assertThrows(WrongMethodTypeException.class, () -> h.asSpreader(String[].class, 1)); + } + + @Test + public void testAsSpreaderNullArrayType() { + assertThrows(NullPointerException.class, () -> SpreadCollect.MH_forSpreading.asSpreader(null, 0)); + } + + @Test + public void testAsSpreaderNullArrayNonZeroLength() { + assertThrows(NullPointerException.class, () -> SpreadCollect.MH_forSpreading.asSpreader(null, 1)); + } + + @Test + public void testAsSpreaderTooManyParams() throws Throwable { + assertThrows(IllegalArgumentException.class, () -> SpreadCollect.MH_forSpreading.asSpreader(1, int[].class, 6)); + } + + @Test + public void testAsCollector() throws Throwable { MethodHandle collector = SpreadCollect.MH_forCollecting.asCollector(1, int[].class, 1); assertEquals(SpreadCollect.MT_collector1, collector.type()); assertEquals("A4B", (String) collector.invoke("A", 4, "B")); @@ -121,7 +117,7 @@ public class SpreadCollectTest { } @Test - public static void testAsCollectorInvokeWithArguments() throws Throwable { + public void testAsCollectorInvokeWithArguments() throws Throwable { MethodHandle collector = SpreadCollect.MH_forCollecting.asCollector(1, int[].class, 1); assertEquals(SpreadCollect.MT_collector1, collector.type()); assertEquals("A4B", (String) collector.invokeWithArguments("A", 4, "B")); @@ -134,7 +130,7 @@ public class SpreadCollectTest { } @Test - public static void testAsCollectorLeading() throws Throwable { + public void testAsCollectorLeading() throws Throwable { MethodHandle collector = SpreadCollect.MH_forCollectingLeading.asCollector(0, int[].class, 1); assertEquals(SpreadCollect.MT_collectorLeading1, collector.type()); assertEquals("7Q", (String) collector.invoke(7, "Q")); @@ -147,7 +143,7 @@ public class SpreadCollectTest { } @Test - public static void testAsCollectorLeadingInvokeWithArguments() throws Throwable { + public void testAsCollectorLeadingInvokeWithArguments() throws Throwable { MethodHandle collector = SpreadCollect.MH_forCollectingLeading.asCollector(0, int[].class, 1); assertEquals(SpreadCollect.MT_collectorLeading1, collector.type()); assertEquals("7Q", (String) collector.invokeWithArguments(7, "Q")); @@ -160,31 +156,25 @@ public class SpreadCollectTest { } @Test - public static void testAsCollectorNone() throws Throwable { + public void testAsCollectorNone() throws Throwable { MethodHandle collector = SpreadCollect.MH_forCollecting.asCollector(1, int[].class, 0); assertEquals(SpreadCollect.MT_collector0, collector.type()); assertEquals("AB", (String) collector.invoke("A", "B")); } - @DataProvider static Object[][] asCollectorIllegalPositions() { return new Object[][]{{-1}, {17}}; } - @Test(dataProvider = "asCollectorIllegalPositions") - public static void testAsCollectorIllegalPos(int p) { - boolean caught = false; - try { - SpreadCollect.MH_forCollecting.asCollector(p, int[].class, 0); - } catch (IllegalArgumentException iae) { - assertEquals("bad collect position", iae.getMessage()); - caught = true; - } - assertTrue(caught); + @ParameterizedTest + @MethodSource("asCollectorIllegalPositions") + public void testAsCollectorIllegalPos(int p) { + var iae = assertThrows(IllegalArgumentException.class, () -> SpreadCollect.MH_forCollecting.asCollector(p, int[].class, 0)); + assertEquals("bad collect position", iae.getMessage()); } @Test - public static void testAsCollectorExample() throws Throwable { + public void testAsCollectorExample() throws Throwable { // test the JavaDoc asCollector-with-pos example StringWriter swr = new StringWriter(); MethodHandle swWrite = LOOKUP. diff --git a/test/jdk/java/lang/invoke/TestVHInvokerCaching.java b/test/jdk/java/lang/invoke/TestVHInvokerCaching.java index 0a1ae5914ca..e5c7d50daa7 100644 --- a/test/jdk/java/lang/invoke/TestVHInvokerCaching.java +++ b/test/jdk/java/lang/invoke/TestVHInvokerCaching.java @@ -23,12 +23,9 @@ /* @test * @bug 8265079 - * @run testng/othervm -Xverify:all TestVHInvokerCaching + * @run junit/othervm -Xverify:all TestVHInvokerCaching */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; @@ -37,12 +34,16 @@ import java.util.ArrayList; import java.util.List; import static java.lang.invoke.MethodHandles.lookup; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class TestVHInvokerCaching { - @Test(dataProvider = "testHandles") - public static void testVHIInvokerCaching(VarHandle testHandle) throws Throwable { + @ParameterizedTest + @MethodSource("testHandles") + public void testVHIInvokerCaching(VarHandle testHandle) throws Throwable { for (VarHandle.AccessMode mode : VarHandle.AccessMode.values()) { MethodHandle handle1 = MethodHandles.varHandleInvoker(mode, testHandle.accessModeType(mode)); MethodHandle handle2 = MethodHandles.varHandleInvoker(mode, testHandle.accessModeType(mode)); @@ -56,7 +57,6 @@ public class TestVHInvokerCaching { } } - @DataProvider public static Object[][] testHandles() throws NoSuchFieldException, IllegalAccessException { List testHandles = new ArrayList<>(); diff --git a/test/jdk/java/lang/invoke/ThrowExceptionsTest.java b/test/jdk/java/lang/invoke/ThrowExceptionsTest.java index e12bb7040c4..627a056faec 100644 --- a/test/jdk/java/lang/invoke/ThrowExceptionsTest.java +++ b/test/jdk/java/lang/invoke/ThrowExceptionsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,14 +23,11 @@ /* @test * @summary unit tests for method handles which permute their arguments - * @run testng test.java.lang.invoke.ThrowExceptionsTest + * @run junit test.java.lang.invoke.ThrowExceptionsTest */ package test.java.lang.invoke; -import org.testng.*; -import org.testng.annotations.*; - import java.util.*; import java.lang.reflect.*; @@ -38,6 +35,10 @@ import java.lang.invoke.*; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class ThrowExceptionsTest { private static final Class CLASS = ThrowExceptionsTest.class; private static final Lookup LOOKUP = lookup(); @@ -51,7 +52,7 @@ public class ThrowExceptionsTest { // mostly call testWMTCallee, but sometimes call its void-returning variant MethodHandle mh = testWMTCallee(); MethodHandle mh1 = mh.asType(mh.type().changeReturnType(void.class)); - assert(mh1 != mh); + assertNotSame(mh, mh1); testWMT(mh, mh1, 1000); } @@ -108,7 +109,7 @@ public class ThrowExceptionsTest { MethodHandle[] cell = { null }; // recursion point MethodHandle getCell = insertArguments(arrayElementGetter(cell.getClass()), 0, cell, 0); MethodHandle invokeCell = foldArguments(exactInvoker(cellType), getCell); - assert(invokeCell.type() == cellType); + assertSame(cellType, invokeCell.type()); cell[0] = invokeCell; // make it conformable to any type: invokeCell = dropArguments(invokeCell, 0, Object[].class).asVarargsCollector(Object[].class); @@ -189,7 +190,6 @@ public class ThrowExceptionsTest { try { // FIXME: should not have to retype this n = (int) mh.invokeExact((Object)this, "x"); - assertEquals(n, i - catches); // Using the exact type for this causes endless deopt due to // 'non_cached_result' in SystemDictionary::find_method_handle_invoke. // The problem is that the compiler thread needs to access a cached @@ -198,7 +198,9 @@ public class ThrowExceptionsTest { } catch (Exception ex) { savedEx = ex; catches++; + continue; } + assertEquals(i - catches, n); } //VERBOSE: System.out.println("reps="+reps+" catches="+catches); return savedEx; @@ -220,9 +222,4 @@ public class ThrowExceptionsTest { } return savedEx; } - - private static void assertEquals(Object x, Object y) { - if (x == y || x != null && x.equals(y)) return; - throw new RuntimeException(x+" != "+y); - } } diff --git a/test/jdk/java/lang/invoke/TryFinallyTest.java b/test/jdk/java/lang/invoke/TryFinallyTest.java index 4a3c255201e..ebe276ede93 100644 --- a/test/jdk/java/lang/invoke/TryFinallyTest.java +++ b/test/jdk/java/lang/invoke/TryFinallyTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,7 +23,7 @@ /* @test * @bug 8139885 8150824 8150825 8194238 8233920 - * @run testng/othervm -ea -esa -Xverify:all test.java.lang.invoke.TryFinallyTest + * @run junit/othervm -ea -esa -Xverify:all test.java.lang.invoke.TryFinallyTest */ package test.java.lang.invoke; @@ -35,9 +35,12 @@ import java.lang.invoke.MethodType; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; /** * Tests for the tryFinally method handle combinator introduced in JEP 274. @@ -47,13 +50,12 @@ public class TryFinallyTest { static final Lookup LOOKUP = MethodHandles.lookup(); @Test - public static void testTryFinally() throws Throwable { + public void testTryFinally() throws Throwable { MethodHandle hello = MethodHandles.tryFinally(TryFinally.MH_greet, TryFinally.MH_exclaim); assertEquals(TryFinally.MT_hello, hello.type()); assertEquals("Hello, world!", hello.invoke("world")); } - @DataProvider static Object[][] tryFinallyArgs() { return new Object[][] { { boolean.class, true }, @@ -68,8 +70,9 @@ public class TryFinallyTest { }; } - @Test(dataProvider = "tryFinallyArgs") - public static void testTryFinally(Class argType, Object arg) throws Throwable { + @ParameterizedTest + @MethodSource("tryFinallyArgs") + public void testTryFinally(Class argType, Object arg) throws Throwable { MethodHandle identity = MethodHandles.identity(argType); MethodHandle tryFinally = MethodHandles.tryFinally( identity, @@ -78,31 +81,31 @@ public class TryFinallyTest { assertEquals(arg, tryFinally.invoke(arg)); } - @Test(dataProvider = "tryFinallyArgs", expectedExceptions = TryFinally.T1.class) - public static void testTryFinallyException(Class argType, Object arg) throws Throwable { + @ParameterizedTest + @MethodSource("tryFinallyArgs") + public void testTryFinallyException(Class argType, Object arg) throws Throwable { MethodHandle identity = TryFinally.MH_throwingTargetIdentity.asType(methodType(argType, argType)); MethodHandle tryFinally = MethodHandles.tryFinally( identity, MethodHandles.dropArguments(identity, 0, TryFinally.T1.class)); assertEquals(methodType(argType, argType), tryFinally.type()); - tryFinally.invoke(arg); // should throw + assertThrows(TryFinally.T1.class, () -> tryFinally.invoke(arg)); } @Test - public static void testTryFinallyVoid() throws Throwable { + public void testTryFinallyVoid() throws Throwable { MethodHandle tfVoid = MethodHandles.tryFinally(TryFinally.MH_print, TryFinally.MH_printMore); assertEquals(TryFinally.MT_printHello, tfVoid.type()); tfVoid.invoke("world"); } @Test - public static void testTryFinallySublist() throws Throwable { + public void testTryFinallySublist() throws Throwable { MethodHandle helloMore = MethodHandles.tryFinally(TryFinally.MH_greetMore, TryFinally.MH_exclaimMore); assertEquals(TryFinally.MT_moreHello, helloMore.type()); assertEquals("Hello, world and universe (but world first)!", helloMore.invoke("world", "universe")); } - @DataProvider static Object[][] omitTrailingArguments() { MethodHandle c = TryFinally.MH_voidCleanup; return new Object[][]{ @@ -114,13 +117,13 @@ public class TryFinallyTest { }; } - @Test(dataProvider = "omitTrailingArguments") - public static void testTryFinallyOmitTrailingArguments(MethodHandle cleanup) throws Throwable { + @ParameterizedTest + @MethodSource("omitTrailingArguments") + public void testTryFinallyOmitTrailingArguments(MethodHandle cleanup) throws Throwable { MethodHandle tf = MethodHandles.tryFinally(TryFinally.MH_dummyTarget, cleanup); tf.invoke(1, 2L, "a", 23, 42L, "b"); } - @DataProvider static Object[][] negativeTestData() { MethodHandle intid = MethodHandles.identity(int.class); MethodHandle intco = MethodHandles.constant(int.class, 0); @@ -145,29 +148,18 @@ public class TryFinallyTest { }; } - @Test(dataProvider = "negativeTestData") - public static void testTryFinallyNegative(MethodHandle target, MethodHandle cleanup, String expectedMessage) { - boolean caught = false; - try { - MethodHandles.tryFinally(target, cleanup); - } catch (IllegalArgumentException iae) { - assertEquals(expectedMessage, iae.getMessage()); - caught = true; - } - assertTrue(caught); + @ParameterizedTest + @MethodSource("negativeTestData") + public void testTryFinallyNegative(MethodHandle target, MethodHandle cleanup, String expectedMessage) { + var iae = assertThrows(IllegalArgumentException.class, () -> MethodHandles.tryFinally(target, cleanup)); + assertEquals(expectedMessage, iae.getMessage()); } @Test - public static void testTryFinallyThrowableCheck() { + public void testTryFinallyThrowableCheck() { MethodHandle mh = MethodHandles.tryFinally(TryFinally.MH_throwingTarget, TryFinally.MH_catchingCleanup); - try { - mh.invoke(); - fail("ClassCastException expected"); - } catch (Throwable t) { - assertTrue("Throwable not assignable to ClassCastException: " + t, - ClassCastException.class.isAssignableFrom(t.getClass())); - } + assertThrows(ClassCastException.class, mh::invoke); } static class TryFinally { diff --git a/test/jdk/java/lang/invoke/VarArgsTest.java b/test/jdk/java/lang/invoke/VarArgsTest.java index bb17881b514..bcea9a0b54e 100644 --- a/test/jdk/java/lang/invoke/VarArgsTest.java +++ b/test/jdk/java/lang/invoke/VarArgsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,19 +23,18 @@ /* @test * @summary unit tests for java.lang.invoke.MethodHandles - * @run testng/othervm -ea -esa test.java.lang.invoke.VarArgsTest + * @run junit/othervm -ea -esa test.java.lang.invoke.VarArgsTest */ package test.java.lang.invoke; import java.lang.invoke.MethodHandle; -import java.lang.invoke.MethodHandles; -import java.lang.invoke.MethodType; import java.util.Arrays; import java.util.List; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; -import static org.testng.AssertJUnit.*; -import org.testng.annotations.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; public class VarArgsTest { @@ -61,17 +60,17 @@ public class VarArgsTest { MethodHandle asList = publicLookup() .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class)); MethodHandle asListWithVarargs = asList.withVarargs(asList.isVarargsCollector()); - assert(asListWithVarargs.isVarargsCollector()); + assertTrue(asListWithVarargs.isVarargsCollector()); assertEquals("[]", asListWithVarargs.invoke().toString()); assertEquals("[1]", asListWithVarargs.invoke(1).toString()); assertEquals("[two, too]", asListWithVarargs.invoke("two", "too").toString()); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void testWithVarargsIAE() throws Throwable { MethodHandle lenMH = publicLookup() - .findVirtual(String.class, "length", methodType(int.class)); - MethodHandle lenMHWithVarargs = lenMH.withVarargs(true); + .findVirtual(String.class, "length", methodType(int.class)); + assertThrows(IllegalArgumentException.class, () -> lenMH.withVarargs(true)); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseByteArrayTest.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseByteArrayTest.java index f09ba518e48..c89fcc8289b 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseByteArrayTest.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseByteArrayTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -21,9 +21,6 @@ * questions. */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; - import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; @@ -32,6 +29,7 @@ import java.util.Arrays; import java.util.EnumSet; import java.util.List; import java.util.function.Function; +import org.junit.jupiter.api.BeforeAll; public abstract class VarHandleBaseByteArrayTest extends VarHandleBaseTest { @@ -338,7 +336,7 @@ public abstract class VarHandleBaseByteArrayTest extends VarHandleBaseTest { bavss.add(dbb_offset_unaligned_ro); } - @BeforeClass + @BeforeAll public void setup() { setupByteSources(); vhss = setupVarHandleSources(true); @@ -346,13 +344,10 @@ public abstract class VarHandleBaseByteArrayTest extends VarHandleBaseTest { abstract List setupVarHandleSources(boolean same); - - @DataProvider public Object[][] varHandlesProvider() throws Exception { return vhss.stream().map(cvh -> new Object[]{cvh}).toArray(Object[][]::new); } - @DataProvider public Object[][] typesProvider() throws Exception { List> aepts = Arrays.asList(byte[].class, int.class); List> bbpts = Arrays.asList(ByteBuffer.class, int.class); diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseTest.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseTest.java index 0c9a7fd3953..0e029b8f5f7 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseTest.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleBaseTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -36,7 +36,7 @@ import java.util.Map; import java.util.stream.Stream; import static java.util.stream.Collectors.toList; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; abstract class VarHandleBaseTest { static final int ITERS = Integer.getInteger("iters", 1); @@ -136,18 +136,7 @@ abstract class VarHandleBaseTest { static void checkWithThrowable(Class re, Object message, ThrowingRunnable r) { - Throwable _e = null; - try { - r.run(); - } - catch (Throwable e) { - _e = e; - } - message = message == null ? "" : message + ". "; - assertNotNull(_e, String.format("%sNo throwable thrown. Expected %s", message, re)); - if (!re.isInstance(_e)) { - fail(String.format("%sIncorrect throwable thrown, %s. Expected %s", message, _e, re), _e); - } + assertThrows(re, r::run, message == null ? null : message.toString()); } @@ -277,11 +266,11 @@ abstract class VarHandleBaseTest { } private static MethodHandle bind(VarHandle vh, MethodHandle mh, MethodType emt) { - assertEquals(mh.type(), emt.insertParameterTypes(0, VarHandle.class), + assertEquals(emt.insertParameterTypes(0, VarHandle.class), mh.type(), "MethodHandle type differs from access mode type"); MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh); - assertEquals(info.getMethodType(), emt, + assertEquals(emt, info.getMethodType(), "MethodHandleInfo method type differs from access mode type"); return mh.bindTo(vh); @@ -472,39 +461,39 @@ abstract class VarHandleBaseTest { for (TestAccessMode accessMode : testAccessModes()) { MethodType amt = vh.accessModeType(accessMode.toAccessMode()); - assertEquals(amt.parameterList().subList(0, pts.size()), pts); + assertEquals(pts, amt.parameterList().subList(0, pts.size())); } for (TestAccessMode testAccessMode : testAccessModesOfType(TestAccessType.GET)) { MethodType mt = vh.accessModeType(testAccessMode.toAccessMode()); - assertEquals(mt.returnType(), vh.varType()); - assertEquals(mt.parameterList(), pts); + assertEquals(vh.varType(), mt.returnType()); + assertEquals(pts, mt.parameterList()); } for (TestAccessMode testAccessMode : testAccessModesOfType(TestAccessType.SET)) { MethodType mt = vh.accessModeType(testAccessMode.toAccessMode()); - assertEquals(mt.returnType(), void.class); - assertEquals(mt.parameterType(mt.parameterCount() - 1), vh.varType()); + assertEquals(void.class, mt.returnType()); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 1)); } for (TestAccessMode testAccessMode : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) { MethodType mt = vh.accessModeType(testAccessMode.toAccessMode()); - assertEquals(mt.returnType(), boolean.class); - assertEquals(mt.parameterType(mt.parameterCount() - 1), vh.varType()); - assertEquals(mt.parameterType(mt.parameterCount() - 2), vh.varType()); + assertEquals(boolean.class, mt.returnType()); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 1)); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 2)); } for (TestAccessMode testAccessMode : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) { MethodType mt = vh.accessModeType(testAccessMode.toAccessMode()); - assertEquals(mt.returnType(), vh.varType()); - assertEquals(mt.parameterType(mt.parameterCount() - 1), vh.varType()); - assertEquals(mt.parameterType(mt.parameterCount() - 2), vh.varType()); + assertEquals(vh.varType(), mt.returnType()); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 1)); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 2)); } for (TestAccessMode testAccessMode : testAccessModesOfType(TestAccessType.GET_AND_SET, TestAccessType.GET_AND_ADD)) { MethodType mt = vh.accessModeType(testAccessMode.toAccessMode()); - assertEquals(mt.returnType(), vh.varType()); - assertEquals(mt.parameterType(mt.parameterCount() - 1), vh.varType()); + assertEquals(vh.varType(), mt.returnType()); + assertEquals(vh.varType(), mt.parameterType(mt.parameterCount() - 1)); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleMethodReferenceTest.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleMethodReferenceTest.java index 02de5a3e186..23e46096073 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleMethodReferenceTest.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleMethodReferenceTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,12 +25,12 @@ * @test * @bug 8195650 * @summary Test linking of method references to VarHandle access methods. - * @run testng VarHandleMethodReferenceTest + * @run junit VarHandleMethodReferenceTest */ -import org.testng.annotations.Test; import java.lang.invoke.*; +import org.junit.jupiter.api.Test; public class VarHandleMethodReferenceTest { diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessBoolean.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessBoolean.java index a9cd5a61655..548e008b09e 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessBoolean.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessBoolean.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessBoolean + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessBoolean * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessBoolean - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessBoolean - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessBoolean + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessBoolean + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessBoolean + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessBoolean */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessBoolean extends VarHandleBaseTest { static final boolean static_final_v = true; @@ -108,7 +110,7 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessBoolean.class, "final_v", boolean.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(boolean[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessBoolean.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), boolean.class); + assertEquals(boolean.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { // Plain { boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "get boolean value"); + assertEquals(true, x, "get boolean value"); } // Volatile { boolean x = (boolean) vh.getVolatile(recv); - assertEquals(x, true, "getVolatile boolean value"); + assertEquals(true, x, "getVolatile boolean value"); } // Lazy { boolean x = (boolean) vh.getAcquire(recv); - assertEquals(x, true, "getRelease boolean value"); + assertEquals(true, x, "getRelease boolean value"); } // Opaque { boolean x = (boolean) vh.getOpaque(recv); - assertEquals(x, true, "getOpaque boolean value"); + assertEquals(true, x, "getOpaque boolean value"); } } @@ -357,26 +355,26 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { // Plain { boolean x = (boolean) vh.get(); - assertEquals(x, true, "get boolean value"); + assertEquals(true, x, "get boolean value"); } // Volatile { boolean x = (boolean) vh.getVolatile(); - assertEquals(x, true, "getVolatile boolean value"); + assertEquals(true, x, "getVolatile boolean value"); } // Lazy { boolean x = (boolean) vh.getAcquire(); - assertEquals(x, true, "getRelease boolean value"); + assertEquals(true, x, "getRelease boolean value"); } // Opaque { boolean x = (boolean) vh.getOpaque(); - assertEquals(x, true, "getOpaque boolean value"); + assertEquals(true, x, "getOpaque boolean value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.set(recv, true); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "set boolean value"); + assertEquals(true, x, "set boolean value"); } @@ -426,21 +424,21 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.setVolatile(recv, false); boolean x = (boolean) vh.getVolatile(recv); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { vh.setRelease(recv, true); boolean x = (boolean) vh.getAcquire(recv); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { vh.setOpaque(recv, false); boolean x = (boolean) vh.getOpaque(recv); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } vh.set(recv, true); @@ -450,56 +448,56 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = vh.compareAndSet(recv, true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) vh.compareAndExchange(recv, false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchange(recv, false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(recv, true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(recv, true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(recv, false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(recv, false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -510,14 +508,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = vh.weakCompareAndSetPlain(recv, true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -528,14 +526,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { boolean success = vh.weakCompareAndSetAcquire(recv, false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -546,14 +544,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = vh.weakCompareAndSetRelease(recv, true, false); assertEquals(success, false, "failing weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "failing weakCompareAndSetRelease boolean value"); + assertEquals(false, x, "failing weakCompareAndSetRelease boolean value"); } { @@ -564,14 +562,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "success weakCompareAndSet boolean value"); + assertEquals(true, x, "success weakCompareAndSet boolean value"); } { boolean success = vh.weakCompareAndSet(recv, false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, true, "failing weakCompareAndSet boolean value"); + assertEquals(true, x, "failing weakCompareAndSet boolean value"); } // Compare set and get @@ -579,27 +577,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(recv, true); boolean o = (boolean) vh.getAndSet(recv, false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndSetAcquire(recv, false); - assertEquals(o, true, "getAndSetAcquire boolean"); + assertEquals(true, o, "getAndSetAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "getAndSetAcquire boolean value"); + assertEquals(false, x, "getAndSetAcquire boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndSetRelease(recv, false); - assertEquals(o, true, "getAndSetRelease boolean"); + assertEquals(true, o, "getAndSetRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, false, "getAndSetRelease boolean value"); + assertEquals(false, x, "getAndSetRelease boolean value"); } @@ -608,27 +606,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseOr(recv, false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseOrAcquire(recv, false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseOrRelease(recv, false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -636,27 +634,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseAnd(recv, false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseAndAcquire(recv, false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseAndRelease(recv, false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -664,27 +662,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseXor(recv, false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseXorAcquire(recv, false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { vh.set(recv, true); boolean o = (boolean) vh.getAndBitwiseXorRelease(recv, false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) vh.get(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } @@ -710,7 +708,7 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.set(true); boolean x = (boolean) vh.get(); - assertEquals(x, true, "set boolean value"); + assertEquals(true, x, "set boolean value"); } @@ -718,21 +716,21 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.setVolatile(false); boolean x = (boolean) vh.getVolatile(); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { vh.setRelease(true); boolean x = (boolean) vh.getAcquire(); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { vh.setOpaque(false); boolean x = (boolean) vh.getOpaque(); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } vh.set(true); @@ -742,56 +740,56 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { boolean r = vh.compareAndSet(true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = vh.compareAndSet(true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) vh.compareAndExchange(false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchange(false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -802,14 +800,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = vh.weakCompareAndSetPlain(true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -820,14 +818,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { boolean success = vh.weakCompareAndSetAcquire(false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -838,14 +836,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = vh.weakCompareAndSetRelease(true, false); assertEquals(success, false, "failing weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "failing weakCompareAndSetRelease boolean value"); + assertEquals(false, x, "failing weakCompareAndSetRelease boolean value"); } { @@ -856,14 +854,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "success weakCompareAndSet boolean"); + assertEquals(true, x, "success weakCompareAndSet boolean"); } { boolean success = vh.weakCompareAndSet(false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, true, "failing weakCompareAndSet boolean value"); + assertEquals(true, x, "failing weakCompareAndSet boolean value"); } // Compare set and get @@ -871,27 +869,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(true); boolean o = (boolean) vh.getAndSet(false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndSetAcquire(false); - assertEquals(o, true, "getAndSetAcquire boolean"); + assertEquals(true, o, "getAndSetAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "getAndSetAcquire boolean value"); + assertEquals(false, x, "getAndSetAcquire boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndSetRelease(false); - assertEquals(o, true, "getAndSetRelease boolean"); + assertEquals(true, o, "getAndSetRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, false, "getAndSetRelease boolean value"); + assertEquals(false, x, "getAndSetRelease boolean value"); } @@ -900,27 +898,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(true); boolean o = (boolean) vh.getAndBitwiseOr(false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseOrAcquire(false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseOrRelease(false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -928,27 +926,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(true); boolean o = (boolean) vh.getAndBitwiseAnd(false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseAndAcquire(false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseAndRelease(false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -956,27 +954,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(true); boolean o = (boolean) vh.getAndBitwiseXor(false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseXorAcquire(false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { vh.set(true); boolean o = (boolean) vh.getAndBitwiseXorRelease(false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) vh.get(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } @@ -1005,7 +1003,7 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.set(array, i, true); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "get boolean value"); + assertEquals(true, x, "get boolean value"); } @@ -1013,21 +1011,21 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { { vh.setVolatile(array, i, false); boolean x = (boolean) vh.getVolatile(array, i); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { vh.setRelease(array, i, true); boolean x = (boolean) vh.getAcquire(array, i); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { vh.setOpaque(array, i, false); boolean x = (boolean) vh.getOpaque(array, i); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } vh.set(array, i, true); @@ -1037,56 +1035,56 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = vh.compareAndSet(array, i, true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) vh.compareAndExchange(array, i, false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchange(array, i, false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(array, i, true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeAcquire(array, i, true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(array, i, false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) vh.compareAndExchangeRelease(array, i, false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -1097,14 +1095,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -1115,14 +1113,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -1133,14 +1131,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = vh.weakCompareAndSetRelease(array, i, true, false); assertEquals(success, false, "failing weakCompareAndSetRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "failing weakCompareAndSetRelease boolean value"); + assertEquals(false, x, "failing weakCompareAndSetRelease boolean value"); } { @@ -1151,14 +1149,14 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "success weakCompareAndSet boolean"); + assertEquals(true, x, "success weakCompareAndSet boolean"); } { boolean success = vh.weakCompareAndSet(array, i, false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, true, "failing weakCompareAndSet boolean value"); + assertEquals(true, x, "failing weakCompareAndSet boolean value"); } // Compare set and get @@ -1166,27 +1164,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(array, i, true); boolean o = (boolean) vh.getAndSet(array, i, false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndSetAcquire(array, i, false); - assertEquals(o, true, "getAndSetAcquire boolean"); + assertEquals(true, o, "getAndSetAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "getAndSetAcquire boolean value"); + assertEquals(false, x, "getAndSetAcquire boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndSetRelease(array, i, false); - assertEquals(o, true, "getAndSetRelease boolean"); + assertEquals(true, o, "getAndSetRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, false, "getAndSetRelease boolean value"); + assertEquals(false, x, "getAndSetRelease boolean value"); } @@ -1195,27 +1193,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseOr(array, i, false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseOrAcquire(array, i, false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseOrRelease(array, i, false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -1223,27 +1221,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseAnd(array, i, false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseAndAcquire(array, i, false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseAndRelease(array, i, false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -1251,27 +1249,27 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseXor(array, i, false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseXorAcquire(array, i, false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { vh.set(array, i, true); boolean o = (boolean) vh.getAndBitwiseXorRelease(array, i, false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) vh.get(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessByte.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessByte.java index 5dc4bf2d1d5..42c465af75e 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessByte.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessByte.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessByte + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessByte * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessByte - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessByte - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessByte + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessByte + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessByte + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessByte */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessByte extends VarHandleBaseTest { static final byte static_final_v = (byte)0x01; @@ -108,7 +110,7 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessByte.class, "final_v", byte.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(byte[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessByte.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), byte.class); + assertEquals(byte.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { // Plain { byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "get byte value"); + assertEquals((byte)0x01, x, "get byte value"); } // Volatile { byte x = (byte) vh.getVolatile(recv); - assertEquals(x, (byte)0x01, "getVolatile byte value"); + assertEquals((byte)0x01, x, "getVolatile byte value"); } // Lazy { byte x = (byte) vh.getAcquire(recv); - assertEquals(x, (byte)0x01, "getRelease byte value"); + assertEquals((byte)0x01, x, "getRelease byte value"); } // Opaque { byte x = (byte) vh.getOpaque(recv); - assertEquals(x, (byte)0x01, "getOpaque byte value"); + assertEquals((byte)0x01, x, "getOpaque byte value"); } } @@ -346,26 +344,26 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { // Plain { byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "get byte value"); + assertEquals((byte)0x01, x, "get byte value"); } // Volatile { byte x = (byte) vh.getVolatile(); - assertEquals(x, (byte)0x01, "getVolatile byte value"); + assertEquals((byte)0x01, x, "getVolatile byte value"); } // Lazy { byte x = (byte) vh.getAcquire(); - assertEquals(x, (byte)0x01, "getRelease byte value"); + assertEquals((byte)0x01, x, "getRelease byte value"); } // Opaque { byte x = (byte) vh.getOpaque(); - assertEquals(x, (byte)0x01, "getOpaque byte value"); + assertEquals((byte)0x01, x, "getOpaque byte value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.set(recv, (byte)0x01); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "set byte value"); + assertEquals((byte)0x01, x, "set byte value"); } @@ -404,21 +402,21 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.setVolatile(recv, (byte)0x23); byte x = (byte) vh.getVolatile(recv); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { vh.setRelease(recv, (byte)0x01); byte x = (byte) vh.getAcquire(recv); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { vh.setOpaque(recv, (byte)0x23); byte x = (byte) vh.getOpaque(recv); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } vh.set(recv, (byte)0x01); @@ -428,56 +426,56 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, (byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = vh.compareAndSet(recv, (byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) vh.compareAndExchange(recv, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchange(recv, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire(recv, (byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire(recv, (byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeRelease(recv, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) vh.compareAndExchangeRelease(recv, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -488,14 +486,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = vh.weakCompareAndSetPlain(recv, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -506,14 +504,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { boolean success = vh.weakCompareAndSetAcquire(recv, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -524,14 +522,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = vh.weakCompareAndSetRelease(recv, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetRelease byte value"); } { @@ -542,14 +540,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte value"); } { boolean success = vh.weakCompareAndSet(recv, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSet byte value"); } // Compare set and get @@ -557,27 +555,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndSet(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndSetAcquire(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetAcquire byte"); + assertEquals((byte)0x01, o, "getAndSetAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "getAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "getAndSetAcquire byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndSetRelease(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetRelease byte"); + assertEquals((byte)0x01, o, "getAndSetRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)0x23, "getAndSetRelease byte value"); + assertEquals((byte)0x23, x, "getAndSetRelease byte value"); } // get and add, add and get @@ -585,27 +583,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndAdd(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndAddAcquire(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndAddRelease(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddReleasebyte"); + assertEquals((byte)0x01, o, "getAndAddReleasebyte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -613,27 +611,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseOr(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseOrAcquire(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseOrRelease(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -641,27 +639,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseAnd(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseAndAcquire(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseAndRelease(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -669,27 +667,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseXor(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseXorAcquire(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { vh.set(recv, (byte)0x01); byte o = (byte) vh.getAndBitwiseXorRelease(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) vh.get(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } @@ -704,7 +702,7 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.set((byte)0x01); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "set byte value"); + assertEquals((byte)0x01, x, "set byte value"); } @@ -712,21 +710,21 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.setVolatile((byte)0x23); byte x = (byte) vh.getVolatile(); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { vh.setRelease((byte)0x01); byte x = (byte) vh.getAcquire(); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { vh.setOpaque((byte)0x23); byte x = (byte) vh.getOpaque(); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } vh.set((byte)0x01); @@ -736,56 +734,56 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { boolean r = vh.compareAndSet((byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = vh.compareAndSet((byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) vh.compareAndExchange((byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchange((byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire((byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire((byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeRelease((byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) vh.compareAndExchangeRelease((byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -796,14 +794,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = vh.weakCompareAndSetPlain((byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -814,14 +812,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { boolean success = vh.weakCompareAndSetAcquire((byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -832,14 +830,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = vh.weakCompareAndSetRelease((byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetRelease byte value"); } { @@ -850,14 +848,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte"); } { boolean success = vh.weakCompareAndSet((byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSet byte value"); } // Compare set and get @@ -865,27 +863,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set((byte)0x01); byte o = (byte) vh.getAndSet((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndSetAcquire((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetAcquire byte"); + assertEquals((byte)0x01, o, "getAndSetAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "getAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "getAndSetAcquire byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndSetRelease((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetRelease byte"); + assertEquals((byte)0x01, o, "getAndSetRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)0x23, "getAndSetRelease byte value"); + assertEquals((byte)0x23, x, "getAndSetRelease byte value"); } // get and add, add and get @@ -893,27 +891,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set((byte)0x01); byte o = (byte) vh.getAndAdd((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndAddAcquire((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndAddRelease((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddReleasebyte"); + assertEquals((byte)0x01, o, "getAndAddReleasebyte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -921,27 +919,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseOr((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseOrAcquire((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseOrRelease((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -949,27 +947,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseAnd((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseAndAcquire((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseAndRelease((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -977,27 +975,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseXor((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseXorAcquire((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { vh.set((byte)0x01); byte o = (byte) vh.getAndBitwiseXorRelease((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) vh.get(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } @@ -1015,7 +1013,7 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.set(array, i, (byte)0x01); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "get byte value"); + assertEquals((byte)0x01, x, "get byte value"); } @@ -1023,21 +1021,21 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { { vh.setVolatile(array, i, (byte)0x23); byte x = (byte) vh.getVolatile(array, i); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { vh.setRelease(array, i, (byte)0x01); byte x = (byte) vh.getAcquire(array, i); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { vh.setOpaque(array, i, (byte)0x23); byte x = (byte) vh.getOpaque(array, i); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } vh.set(array, i, (byte)0x01); @@ -1047,56 +1045,56 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, (byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = vh.compareAndSet(array, i, (byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) vh.compareAndExchange(array, i, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchange(array, i, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire(array, i, (byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeAcquire(array, i, (byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) vh.compareAndExchangeRelease(array, i, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) vh.compareAndExchangeRelease(array, i, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -1107,14 +1105,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -1125,14 +1123,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -1143,14 +1141,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = vh.weakCompareAndSetRelease(array, i, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetRelease byte value"); } { @@ -1161,14 +1159,14 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte"); } { boolean success = vh.weakCompareAndSet(array, i, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSet byte value"); } // Compare set and get @@ -1176,27 +1174,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndSet(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndSetAcquire(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetAcquire byte"); + assertEquals((byte)0x01, o, "getAndSetAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "getAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "getAndSetAcquire byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndSetRelease(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetRelease byte"); + assertEquals((byte)0x01, o, "getAndSetRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)0x23, "getAndSetRelease byte value"); + assertEquals((byte)0x23, x, "getAndSetRelease byte value"); } // get and add, add and get @@ -1204,27 +1202,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndAdd(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndAddAcquire(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndAddRelease(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddReleasebyte"); + assertEquals((byte)0x01, o, "getAndAddReleasebyte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -1232,27 +1230,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseOr(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseOrAcquire(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseOrRelease(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -1260,27 +1258,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseAnd(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseAndAcquire(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseAndRelease(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -1288,27 +1286,27 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseXor(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseXorAcquire(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { vh.set(array, i, (byte)0x01); byte o = (byte) vh.getAndBitwiseXorRelease(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) vh.get(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessChar.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessChar.java index bafde057167..e17e7616609 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessChar.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessChar.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessChar + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessChar * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessChar - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessChar - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessChar + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessChar + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessChar + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessChar */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessChar extends VarHandleBaseTest { static final char static_final_v = '\u0123'; @@ -108,7 +110,7 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessChar.class, "final_v", char.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(char[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessChar.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), char.class); + assertEquals(char.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { // Plain { char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "get char value"); + assertEquals('\u0123', x, "get char value"); } // Volatile { char x = (char) vh.getVolatile(recv); - assertEquals(x, '\u0123', "getVolatile char value"); + assertEquals('\u0123', x, "getVolatile char value"); } // Lazy { char x = (char) vh.getAcquire(recv); - assertEquals(x, '\u0123', "getRelease char value"); + assertEquals('\u0123', x, "getRelease char value"); } // Opaque { char x = (char) vh.getOpaque(recv); - assertEquals(x, '\u0123', "getOpaque char value"); + assertEquals('\u0123', x, "getOpaque char value"); } } @@ -346,26 +344,26 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { // Plain { char x = (char) vh.get(); - assertEquals(x, '\u0123', "get char value"); + assertEquals('\u0123', x, "get char value"); } // Volatile { char x = (char) vh.getVolatile(); - assertEquals(x, '\u0123', "getVolatile char value"); + assertEquals('\u0123', x, "getVolatile char value"); } // Lazy { char x = (char) vh.getAcquire(); - assertEquals(x, '\u0123', "getRelease char value"); + assertEquals('\u0123', x, "getRelease char value"); } // Opaque { char x = (char) vh.getOpaque(); - assertEquals(x, '\u0123', "getOpaque char value"); + assertEquals('\u0123', x, "getOpaque char value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.set(recv, '\u0123'); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "set char value"); + assertEquals('\u0123', x, "set char value"); } @@ -404,21 +402,21 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.setVolatile(recv, '\u4567'); char x = (char) vh.getVolatile(recv); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { vh.setRelease(recv, '\u0123'); char x = (char) vh.getAcquire(recv); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { vh.setOpaque(recv, '\u4567'); char x = (char) vh.getOpaque(recv); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } vh.set(recv, '\u0123'); @@ -428,56 +426,56 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, '\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = vh.compareAndSet(recv, '\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) vh.compareAndExchange(recv, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) vh.compareAndExchange(recv, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) vh.compareAndExchangeAcquire(recv, '\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeAcquire(recv, '\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeRelease(recv, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) vh.compareAndExchangeRelease(recv, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -488,14 +486,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = vh.weakCompareAndSetPlain(recv, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -506,14 +504,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { boolean success = vh.weakCompareAndSetAcquire(recv, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -524,14 +522,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = vh.weakCompareAndSetRelease(recv, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetRelease char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "failing weakCompareAndSetRelease char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value"); } { @@ -542,14 +540,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "success weakCompareAndSet char value"); + assertEquals('\u0123', x, "success weakCompareAndSet char value"); } { boolean success = vh.weakCompareAndSet(recv, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) vh.get(recv); - assertEquals(x, '\u0123', "failing weakCompareAndSet char value"); + assertEquals('\u0123', x, "failing weakCompareAndSet char value"); } // Compare set and get @@ -557,27 +555,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(recv, '\u0123'); char o = (char) vh.getAndSet(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndSetAcquire(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndSetAcquire char"); + assertEquals('\u0123', o, "getAndSetAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "getAndSetAcquire char value"); + assertEquals('\u4567', x, "getAndSetAcquire char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndSetRelease(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndSetRelease char"); + assertEquals('\u0123', o, "getAndSetRelease char"); char x = (char) vh.get(recv); - assertEquals(x, '\u4567', "getAndSetRelease char value"); + assertEquals('\u4567', x, "getAndSetRelease char value"); } // get and add, add and get @@ -585,27 +583,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(recv, '\u0123'); char o = (char) vh.getAndAdd(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndAddAcquire(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndAddRelease(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAddReleasechar"); + assertEquals('\u0123', o, "getAndAddReleasechar"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -613,27 +611,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseOr(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseOrAcquire(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseOrRelease(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -641,27 +639,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseAnd(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseAndAcquire(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseAndRelease(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -669,27 +667,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseXor(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseXorAcquire(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { vh.set(recv, '\u0123'); char o = (char) vh.getAndBitwiseXorRelease(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) vh.get(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } @@ -704,7 +702,7 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.set('\u0123'); char x = (char) vh.get(); - assertEquals(x, '\u0123', "set char value"); + assertEquals('\u0123', x, "set char value"); } @@ -712,21 +710,21 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.setVolatile('\u4567'); char x = (char) vh.getVolatile(); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { vh.setRelease('\u0123'); char x = (char) vh.getAcquire(); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { vh.setOpaque('\u4567'); char x = (char) vh.getOpaque(); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } vh.set('\u0123'); @@ -736,56 +734,56 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { boolean r = vh.compareAndSet('\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = vh.compareAndSet('\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) vh.compareAndExchange('\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) vh.compareAndExchange('\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) vh.compareAndExchangeAcquire('\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeAcquire('\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeRelease('\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) vh.compareAndExchangeRelease('\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -796,14 +794,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = vh.weakCompareAndSetPlain('\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -814,14 +812,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { boolean success = vh.weakCompareAndSetAcquire('\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -832,14 +830,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = vh.weakCompareAndSetRelease('\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetRelease char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "failing weakCompareAndSetRelease char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value"); } { @@ -850,14 +848,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "success weakCompareAndSet char"); + assertEquals('\u0123', x, "success weakCompareAndSet char"); } { boolean success = vh.weakCompareAndSet('\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) vh.get(); - assertEquals(x, '\u0123', "failing weakCompareAndSet char value"); + assertEquals('\u0123', x, "failing weakCompareAndSet char value"); } // Compare set and get @@ -865,27 +863,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set('\u0123'); char o = (char) vh.getAndSet('\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } { vh.set('\u0123'); char o = (char) vh.getAndSetAcquire('\u4567'); - assertEquals(o, '\u0123', "getAndSetAcquire char"); + assertEquals('\u0123', o, "getAndSetAcquire char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "getAndSetAcquire char value"); + assertEquals('\u4567', x, "getAndSetAcquire char value"); } { vh.set('\u0123'); char o = (char) vh.getAndSetRelease('\u4567'); - assertEquals(o, '\u0123', "getAndSetRelease char"); + assertEquals('\u0123', o, "getAndSetRelease char"); char x = (char) vh.get(); - assertEquals(x, '\u4567', "getAndSetRelease char value"); + assertEquals('\u4567', x, "getAndSetRelease char value"); } // get and add, add and get @@ -893,27 +891,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set('\u0123'); char o = (char) vh.getAndAdd('\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { vh.set('\u0123'); char o = (char) vh.getAndAddAcquire('\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { vh.set('\u0123'); char o = (char) vh.getAndAddRelease('\u4567'); - assertEquals(o, '\u0123', "getAndAddReleasechar"); + assertEquals('\u0123', o, "getAndAddReleasechar"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -921,27 +919,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set('\u0123'); char o = (char) vh.getAndBitwiseOr('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseOrAcquire('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseOrRelease('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -949,27 +947,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set('\u0123'); char o = (char) vh.getAndBitwiseAnd('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseAndAcquire('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseAndRelease('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -977,27 +975,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set('\u0123'); char o = (char) vh.getAndBitwiseXor('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseXorAcquire('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { vh.set('\u0123'); char o = (char) vh.getAndBitwiseXorRelease('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) vh.get(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } @@ -1015,7 +1013,7 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.set(array, i, '\u0123'); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "get char value"); + assertEquals('\u0123', x, "get char value"); } @@ -1023,21 +1021,21 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { { vh.setVolatile(array, i, '\u4567'); char x = (char) vh.getVolatile(array, i); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { vh.setRelease(array, i, '\u0123'); char x = (char) vh.getAcquire(array, i); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { vh.setOpaque(array, i, '\u4567'); char x = (char) vh.getOpaque(array, i); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } vh.set(array, i, '\u0123'); @@ -1047,56 +1045,56 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, '\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = vh.compareAndSet(array, i, '\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) vh.compareAndExchange(array, i, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) vh.compareAndExchange(array, i, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) vh.compareAndExchangeAcquire(array, i, '\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeAcquire(array, i, '\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) vh.compareAndExchangeRelease(array, i, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) vh.compareAndExchangeRelease(array, i, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -1107,14 +1105,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -1125,14 +1123,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -1143,14 +1141,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = vh.weakCompareAndSetRelease(array, i, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "failing weakCompareAndSetRelease char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value"); } { @@ -1161,14 +1159,14 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "success weakCompareAndSet char"); + assertEquals('\u0123', x, "success weakCompareAndSet char"); } { boolean success = vh.weakCompareAndSet(array, i, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u0123', "failing weakCompareAndSet char value"); + assertEquals('\u0123', x, "failing weakCompareAndSet char value"); } // Compare set and get @@ -1176,27 +1174,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(array, i, '\u0123'); char o = (char) vh.getAndSet(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndSetAcquire(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSetAcquire char"); + assertEquals('\u0123', o, "getAndSetAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "getAndSetAcquire char value"); + assertEquals('\u4567', x, "getAndSetAcquire char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndSetRelease(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSetRelease char"); + assertEquals('\u0123', o, "getAndSetRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, '\u4567', "getAndSetRelease char value"); + assertEquals('\u4567', x, "getAndSetRelease char value"); } // get and add, add and get @@ -1204,27 +1202,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(array, i, '\u0123'); char o = (char) vh.getAndAdd(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndAddAcquire(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndAddRelease(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAddReleasechar"); + assertEquals('\u0123', o, "getAndAddReleasechar"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -1232,27 +1230,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseOr(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseOrAcquire(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseOrRelease(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -1260,27 +1258,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseAnd(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseAndAcquire(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseAndRelease(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -1288,27 +1286,27 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseXor(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseXorAcquire(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { vh.set(array, i, '\u0123'); char o = (char) vh.getAndBitwiseXorRelease(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) vh.get(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessDouble.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessDouble.java index 0edb196076c..29fa6c2886d 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessDouble.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessDouble.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessDouble + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessDouble * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessDouble - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessDouble - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessDouble + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessDouble + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessDouble + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessDouble */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessDouble extends VarHandleBaseTest { static final double static_final_v = 1.0d; @@ -108,7 +110,7 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessDouble.class, "final_v", double.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(double[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessDouble.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), double.class); + assertEquals(double.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { // Plain { double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "get double value"); + assertEquals(1.0d, x, "get double value"); } // Volatile { double x = (double) vh.getVolatile(recv); - assertEquals(x, 1.0d, "getVolatile double value"); + assertEquals(1.0d, x, "getVolatile double value"); } // Lazy { double x = (double) vh.getAcquire(recv); - assertEquals(x, 1.0d, "getRelease double value"); + assertEquals(1.0d, x, "getRelease double value"); } // Opaque { double x = (double) vh.getOpaque(recv); - assertEquals(x, 1.0d, "getOpaque double value"); + assertEquals(1.0d, x, "getOpaque double value"); } } @@ -381,26 +379,26 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { // Plain { double x = (double) vh.get(); - assertEquals(x, 1.0d, "get double value"); + assertEquals(1.0d, x, "get double value"); } // Volatile { double x = (double) vh.getVolatile(); - assertEquals(x, 1.0d, "getVolatile double value"); + assertEquals(1.0d, x, "getVolatile double value"); } // Lazy { double x = (double) vh.getAcquire(); - assertEquals(x, 1.0d, "getRelease double value"); + assertEquals(1.0d, x, "getRelease double value"); } // Opaque { double x = (double) vh.getOpaque(); - assertEquals(x, 1.0d, "getOpaque double value"); + assertEquals(1.0d, x, "getOpaque double value"); } } @@ -466,7 +464,7 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.set(recv, 1.0d); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "set double value"); + assertEquals(1.0d, x, "set double value"); } @@ -474,21 +472,21 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.setVolatile(recv, 2.0d); double x = (double) vh.getVolatile(recv); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { vh.setRelease(recv, 1.0d); double x = (double) vh.getAcquire(recv); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { vh.setOpaque(recv, 2.0d); double x = (double) vh.getOpaque(recv); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } vh.set(recv, 1.0d); @@ -498,56 +496,56 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, 1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = vh.compareAndSet(recv, 1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) vh.compareAndExchange(recv, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) vh.compareAndExchange(recv, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) vh.compareAndExchangeAcquire(recv, 1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeAcquire(recv, 1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeRelease(recv, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) vh.compareAndExchangeRelease(recv, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -558,14 +556,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = vh.weakCompareAndSetPlain(recv, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -576,14 +574,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { boolean success = vh.weakCompareAndSetAcquire(recv, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -594,14 +592,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = vh.weakCompareAndSetRelease(recv, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "failing weakCompareAndSetRelease double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetRelease double value"); } { @@ -612,14 +610,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "success weakCompareAndSet double value"); + assertEquals(1.0d, x, "success weakCompareAndSet double value"); } { boolean success = vh.weakCompareAndSet(recv, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) vh.get(recv); - assertEquals(x, 1.0d, "failing weakCompareAndSet double value"); + assertEquals(1.0d, x, "failing weakCompareAndSet double value"); } // Compare set and get @@ -627,27 +625,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(recv, 1.0d); double o = (double) vh.getAndSet(recv, 2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } { vh.set(recv, 1.0d); double o = (double) vh.getAndSetAcquire(recv, 2.0d); - assertEquals(o, 1.0d, "getAndSetAcquire double"); + assertEquals(1.0d, o, "getAndSetAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "getAndSetAcquire double value"); + assertEquals(2.0d, x, "getAndSetAcquire double value"); } { vh.set(recv, 1.0d); double o = (double) vh.getAndSetRelease(recv, 2.0d); - assertEquals(o, 1.0d, "getAndSetRelease double"); + assertEquals(1.0d, o, "getAndSetRelease double"); double x = (double) vh.get(recv); - assertEquals(x, 2.0d, "getAndSetRelease double value"); + assertEquals(2.0d, x, "getAndSetRelease double value"); } // get and add, add and get @@ -655,27 +653,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(recv, 1.0d); double o = (double) vh.getAndAdd(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) vh.get(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { vh.set(recv, 1.0d); double o = (double) vh.getAndAddAcquire(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) vh.get(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { vh.set(recv, 1.0d); double o = (double) vh.getAndAddRelease(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAddReleasedouble"); + assertEquals(1.0d, o, "getAndAddReleasedouble"); double x = (double) vh.get(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } @@ -726,7 +724,7 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.set(1.0d); double x = (double) vh.get(); - assertEquals(x, 1.0d, "set double value"); + assertEquals(1.0d, x, "set double value"); } @@ -734,21 +732,21 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.setVolatile(2.0d); double x = (double) vh.getVolatile(); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { vh.setRelease(1.0d); double x = (double) vh.getAcquire(); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { vh.setOpaque(2.0d); double x = (double) vh.getOpaque(); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } vh.set(1.0d); @@ -758,56 +756,56 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { boolean r = vh.compareAndSet(1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = vh.compareAndSet(1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) vh.compareAndExchange(2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) vh.compareAndExchange(2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) vh.compareAndExchangeAcquire(1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeAcquire(1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeRelease(2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) vh.compareAndExchangeRelease(2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -818,14 +816,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = vh.weakCompareAndSetPlain(1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -836,14 +834,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { boolean success = vh.weakCompareAndSetAcquire(2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -854,14 +852,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = vh.weakCompareAndSetRelease(1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "failing weakCompareAndSetRelease double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetRelease double value"); } { @@ -872,14 +870,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "success weakCompareAndSet double"); + assertEquals(1.0d, x, "success weakCompareAndSet double"); } { boolean success = vh.weakCompareAndSet(2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) vh.get(); - assertEquals(x, 1.0d, "failing weakCompareAndSet double value"); + assertEquals(1.0d, x, "failing weakCompareAndSet double value"); } // Compare set and get @@ -887,27 +885,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(1.0d); double o = (double) vh.getAndSet(2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } { vh.set(1.0d); double o = (double) vh.getAndSetAcquire(2.0d); - assertEquals(o, 1.0d, "getAndSetAcquire double"); + assertEquals(1.0d, o, "getAndSetAcquire double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "getAndSetAcquire double value"); + assertEquals(2.0d, x, "getAndSetAcquire double value"); } { vh.set(1.0d); double o = (double) vh.getAndSetRelease(2.0d); - assertEquals(o, 1.0d, "getAndSetRelease double"); + assertEquals(1.0d, o, "getAndSetRelease double"); double x = (double) vh.get(); - assertEquals(x, 2.0d, "getAndSetRelease double value"); + assertEquals(2.0d, x, "getAndSetRelease double value"); } // get and add, add and get @@ -915,27 +913,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(1.0d); double o = (double) vh.getAndAdd(2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) vh.get(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { vh.set(1.0d); double o = (double) vh.getAndAddAcquire(2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) vh.get(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { vh.set(1.0d); double o = (double) vh.getAndAddRelease(2.0d); - assertEquals(o, 1.0d, "getAndAddReleasedouble"); + assertEquals(1.0d, o, "getAndAddReleasedouble"); double x = (double) vh.get(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } @@ -989,7 +987,7 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.set(array, i, 1.0d); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "get double value"); + assertEquals(1.0d, x, "get double value"); } @@ -997,21 +995,21 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { { vh.setVolatile(array, i, 2.0d); double x = (double) vh.getVolatile(array, i); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { vh.setRelease(array, i, 1.0d); double x = (double) vh.getAcquire(array, i); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { vh.setOpaque(array, i, 2.0d); double x = (double) vh.getOpaque(array, i); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } vh.set(array, i, 1.0d); @@ -1021,56 +1019,56 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, 1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = vh.compareAndSet(array, i, 1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) vh.compareAndExchange(array, i, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) vh.compareAndExchange(array, i, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) vh.compareAndExchangeAcquire(array, i, 1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeAcquire(array, i, 1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeRelease(array, i, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) vh.compareAndExchangeRelease(array, i, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -1081,14 +1079,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -1099,14 +1097,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -1117,14 +1115,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = vh.weakCompareAndSetRelease(array, i, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "failing weakCompareAndSetRelease double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetRelease double value"); } { @@ -1135,14 +1133,14 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "success weakCompareAndSet double"); + assertEquals(1.0d, x, "success weakCompareAndSet double"); } { boolean success = vh.weakCompareAndSet(array, i, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, 1.0d, "failing weakCompareAndSet double value"); + assertEquals(1.0d, x, "failing weakCompareAndSet double value"); } // Compare set and get @@ -1150,27 +1148,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(array, i, 1.0d); double o = (double) vh.getAndSet(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } { vh.set(array, i, 1.0d); double o = (double) vh.getAndSetAcquire(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSetAcquire double"); + assertEquals(1.0d, o, "getAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "getAndSetAcquire double value"); + assertEquals(2.0d, x, "getAndSetAcquire double value"); } { vh.set(array, i, 1.0d); double o = (double) vh.getAndSetRelease(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSetRelease double"); + assertEquals(1.0d, o, "getAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, 2.0d, "getAndSetRelease double value"); + assertEquals(2.0d, x, "getAndSetRelease double value"); } // get and add, add and get @@ -1178,27 +1176,27 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest { vh.set(array, i, 1.0d); double o = (double) vh.getAndAdd(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) vh.get(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { vh.set(array, i, 1.0d); double o = (double) vh.getAndAddAcquire(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { vh.set(array, i, 1.0d); double o = (double) vh.getAndAddRelease(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAddReleasedouble"); + assertEquals(1.0d, o, "getAndAddReleasedouble"); double x = (double) vh.get(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessFloat.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessFloat.java index c77a8d68008..750a1bbc408 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessFloat.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessFloat.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessFloat + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessFloat * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessFloat - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessFloat - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessFloat + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessFloat + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessFloat + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessFloat */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessFloat extends VarHandleBaseTest { static final float static_final_v = 1.0f; @@ -108,7 +110,7 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessFloat.class, "final_v", float.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(float[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessFloat.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), float.class); + assertEquals(float.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { // Plain { float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "get float value"); + assertEquals(1.0f, x, "get float value"); } // Volatile { float x = (float) vh.getVolatile(recv); - assertEquals(x, 1.0f, "getVolatile float value"); + assertEquals(1.0f, x, "getVolatile float value"); } // Lazy { float x = (float) vh.getAcquire(recv); - assertEquals(x, 1.0f, "getRelease float value"); + assertEquals(1.0f, x, "getRelease float value"); } // Opaque { float x = (float) vh.getOpaque(recv); - assertEquals(x, 1.0f, "getOpaque float value"); + assertEquals(1.0f, x, "getOpaque float value"); } } @@ -381,26 +379,26 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { // Plain { float x = (float) vh.get(); - assertEquals(x, 1.0f, "get float value"); + assertEquals(1.0f, x, "get float value"); } // Volatile { float x = (float) vh.getVolatile(); - assertEquals(x, 1.0f, "getVolatile float value"); + assertEquals(1.0f, x, "getVolatile float value"); } // Lazy { float x = (float) vh.getAcquire(); - assertEquals(x, 1.0f, "getRelease float value"); + assertEquals(1.0f, x, "getRelease float value"); } // Opaque { float x = (float) vh.getOpaque(); - assertEquals(x, 1.0f, "getOpaque float value"); + assertEquals(1.0f, x, "getOpaque float value"); } } @@ -466,7 +464,7 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.set(recv, 1.0f); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "set float value"); + assertEquals(1.0f, x, "set float value"); } @@ -474,21 +472,21 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.setVolatile(recv, 2.0f); float x = (float) vh.getVolatile(recv); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { vh.setRelease(recv, 1.0f); float x = (float) vh.getAcquire(recv); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { vh.setOpaque(recv, 2.0f); float x = (float) vh.getOpaque(recv); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } vh.set(recv, 1.0f); @@ -498,56 +496,56 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, 1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = vh.compareAndSet(recv, 1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) vh.compareAndExchange(recv, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) vh.compareAndExchange(recv, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) vh.compareAndExchangeAcquire(recv, 1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeAcquire(recv, 1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeRelease(recv, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) vh.compareAndExchangeRelease(recv, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -558,14 +556,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = vh.weakCompareAndSetPlain(recv, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -576,14 +574,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { boolean success = vh.weakCompareAndSetAcquire(recv, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -594,14 +592,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = vh.weakCompareAndSetRelease(recv, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "failing weakCompareAndSetRelease float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetRelease float value"); } { @@ -612,14 +610,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "success weakCompareAndSet float value"); + assertEquals(1.0f, x, "success weakCompareAndSet float value"); } { boolean success = vh.weakCompareAndSet(recv, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) vh.get(recv); - assertEquals(x, 1.0f, "failing weakCompareAndSet float value"); + assertEquals(1.0f, x, "failing weakCompareAndSet float value"); } // Compare set and get @@ -627,27 +625,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(recv, 1.0f); float o = (float) vh.getAndSet(recv, 2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } { vh.set(recv, 1.0f); float o = (float) vh.getAndSetAcquire(recv, 2.0f); - assertEquals(o, 1.0f, "getAndSetAcquire float"); + assertEquals(1.0f, o, "getAndSetAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "getAndSetAcquire float value"); + assertEquals(2.0f, x, "getAndSetAcquire float value"); } { vh.set(recv, 1.0f); float o = (float) vh.getAndSetRelease(recv, 2.0f); - assertEquals(o, 1.0f, "getAndSetRelease float"); + assertEquals(1.0f, o, "getAndSetRelease float"); float x = (float) vh.get(recv); - assertEquals(x, 2.0f, "getAndSetRelease float value"); + assertEquals(2.0f, x, "getAndSetRelease float value"); } // get and add, add and get @@ -655,27 +653,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(recv, 1.0f); float o = (float) vh.getAndAdd(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) vh.get(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { vh.set(recv, 1.0f); float o = (float) vh.getAndAddAcquire(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) vh.get(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { vh.set(recv, 1.0f); float o = (float) vh.getAndAddRelease(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAddReleasefloat"); + assertEquals(1.0f, o, "getAndAddReleasefloat"); float x = (float) vh.get(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } @@ -726,7 +724,7 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.set(1.0f); float x = (float) vh.get(); - assertEquals(x, 1.0f, "set float value"); + assertEquals(1.0f, x, "set float value"); } @@ -734,21 +732,21 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.setVolatile(2.0f); float x = (float) vh.getVolatile(); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { vh.setRelease(1.0f); float x = (float) vh.getAcquire(); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { vh.setOpaque(2.0f); float x = (float) vh.getOpaque(); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } vh.set(1.0f); @@ -758,56 +756,56 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { boolean r = vh.compareAndSet(1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = vh.compareAndSet(1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) vh.compareAndExchange(2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) vh.compareAndExchange(2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) vh.compareAndExchangeAcquire(1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeAcquire(1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeRelease(2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) vh.compareAndExchangeRelease(2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -818,14 +816,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = vh.weakCompareAndSetPlain(1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -836,14 +834,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { boolean success = vh.weakCompareAndSetAcquire(2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -854,14 +852,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = vh.weakCompareAndSetRelease(1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "failing weakCompareAndSetRelease float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetRelease float value"); } { @@ -872,14 +870,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "success weakCompareAndSet float"); + assertEquals(1.0f, x, "success weakCompareAndSet float"); } { boolean success = vh.weakCompareAndSet(2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) vh.get(); - assertEquals(x, 1.0f, "failing weakCompareAndSet float value"); + assertEquals(1.0f, x, "failing weakCompareAndSet float value"); } // Compare set and get @@ -887,27 +885,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(1.0f); float o = (float) vh.getAndSet(2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } { vh.set(1.0f); float o = (float) vh.getAndSetAcquire(2.0f); - assertEquals(o, 1.0f, "getAndSetAcquire float"); + assertEquals(1.0f, o, "getAndSetAcquire float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "getAndSetAcquire float value"); + assertEquals(2.0f, x, "getAndSetAcquire float value"); } { vh.set(1.0f); float o = (float) vh.getAndSetRelease(2.0f); - assertEquals(o, 1.0f, "getAndSetRelease float"); + assertEquals(1.0f, o, "getAndSetRelease float"); float x = (float) vh.get(); - assertEquals(x, 2.0f, "getAndSetRelease float value"); + assertEquals(2.0f, x, "getAndSetRelease float value"); } // get and add, add and get @@ -915,27 +913,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(1.0f); float o = (float) vh.getAndAdd(2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) vh.get(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { vh.set(1.0f); float o = (float) vh.getAndAddAcquire(2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) vh.get(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { vh.set(1.0f); float o = (float) vh.getAndAddRelease(2.0f); - assertEquals(o, 1.0f, "getAndAddReleasefloat"); + assertEquals(1.0f, o, "getAndAddReleasefloat"); float x = (float) vh.get(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } @@ -989,7 +987,7 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.set(array, i, 1.0f); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "get float value"); + assertEquals(1.0f, x, "get float value"); } @@ -997,21 +995,21 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { { vh.setVolatile(array, i, 2.0f); float x = (float) vh.getVolatile(array, i); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { vh.setRelease(array, i, 1.0f); float x = (float) vh.getAcquire(array, i); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { vh.setOpaque(array, i, 2.0f); float x = (float) vh.getOpaque(array, i); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } vh.set(array, i, 1.0f); @@ -1021,56 +1019,56 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, 1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = vh.compareAndSet(array, i, 1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) vh.compareAndExchange(array, i, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) vh.compareAndExchange(array, i, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) vh.compareAndExchangeAcquire(array, i, 1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeAcquire(array, i, 1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeRelease(array, i, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) vh.compareAndExchangeRelease(array, i, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -1081,14 +1079,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -1099,14 +1097,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -1117,14 +1115,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = vh.weakCompareAndSetRelease(array, i, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "failing weakCompareAndSetRelease float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetRelease float value"); } { @@ -1135,14 +1133,14 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "success weakCompareAndSet float"); + assertEquals(1.0f, x, "success weakCompareAndSet float"); } { boolean success = vh.weakCompareAndSet(array, i, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, 1.0f, "failing weakCompareAndSet float value"); + assertEquals(1.0f, x, "failing weakCompareAndSet float value"); } // Compare set and get @@ -1150,27 +1148,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(array, i, 1.0f); float o = (float) vh.getAndSet(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } { vh.set(array, i, 1.0f); float o = (float) vh.getAndSetAcquire(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSetAcquire float"); + assertEquals(1.0f, o, "getAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "getAndSetAcquire float value"); + assertEquals(2.0f, x, "getAndSetAcquire float value"); } { vh.set(array, i, 1.0f); float o = (float) vh.getAndSetRelease(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSetRelease float"); + assertEquals(1.0f, o, "getAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, 2.0f, "getAndSetRelease float value"); + assertEquals(2.0f, x, "getAndSetRelease float value"); } // get and add, add and get @@ -1178,27 +1176,27 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest { vh.set(array, i, 1.0f); float o = (float) vh.getAndAdd(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) vh.get(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { vh.set(array, i, 1.0f); float o = (float) vh.getAndAddAcquire(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { vh.set(array, i, 1.0f); float o = (float) vh.getAndAddRelease(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAddReleasefloat"); + assertEquals(1.0f, o, "getAndAddReleasefloat"); float x = (float) vh.get(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessInt.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessInt.java index d5dfaa4e1c6..4748d699555 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessInt.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessInt.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessInt + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessInt * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessInt - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessInt - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessInt + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessInt + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessInt + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessInt */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessInt extends VarHandleBaseTest { static final int static_final_v = 0x01234567; @@ -108,7 +110,7 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessInt.class, "final_v", int.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(int[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessInt.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), int.class); + assertEquals(int.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { // Plain { int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "get int value"); + assertEquals(0x01234567, x, "get int value"); } // Volatile { int x = (int) vh.getVolatile(recv); - assertEquals(x, 0x01234567, "getVolatile int value"); + assertEquals(0x01234567, x, "getVolatile int value"); } // Lazy { int x = (int) vh.getAcquire(recv); - assertEquals(x, 0x01234567, "getRelease int value"); + assertEquals(0x01234567, x, "getRelease int value"); } // Opaque { int x = (int) vh.getOpaque(recv); - assertEquals(x, 0x01234567, "getOpaque int value"); + assertEquals(0x01234567, x, "getOpaque int value"); } } @@ -346,26 +344,26 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { // Plain { int x = (int) vh.get(); - assertEquals(x, 0x01234567, "get int value"); + assertEquals(0x01234567, x, "get int value"); } // Volatile { int x = (int) vh.getVolatile(); - assertEquals(x, 0x01234567, "getVolatile int value"); + assertEquals(0x01234567, x, "getVolatile int value"); } // Lazy { int x = (int) vh.getAcquire(); - assertEquals(x, 0x01234567, "getRelease int value"); + assertEquals(0x01234567, x, "getRelease int value"); } // Opaque { int x = (int) vh.getOpaque(); - assertEquals(x, 0x01234567, "getOpaque int value"); + assertEquals(0x01234567, x, "getOpaque int value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.set(recv, 0x01234567); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "set int value"); + assertEquals(0x01234567, x, "set int value"); } @@ -404,21 +402,21 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.setVolatile(recv, 0x89ABCDEF); int x = (int) vh.getVolatile(recv); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { vh.setRelease(recv, 0x01234567); int x = (int) vh.getAcquire(recv); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { vh.setOpaque(recv, 0x89ABCDEF); int x = (int) vh.getOpaque(recv); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } vh.set(recv, 0x01234567); @@ -428,56 +426,56 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, 0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = vh.compareAndSet(recv, 0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) vh.compareAndExchange(recv, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) vh.compareAndExchange(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) vh.compareAndExchangeAcquire(recv, 0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeAcquire(recv, 0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeRelease(recv, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) vh.compareAndExchangeRelease(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -488,14 +486,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = vh.weakCompareAndSetPlain(recv, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -506,14 +504,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { boolean success = vh.weakCompareAndSetAcquire(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -524,14 +522,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = vh.weakCompareAndSetRelease(recv, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetRelease int value"); } { @@ -542,14 +540,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "success weakCompareAndSet int value"); + assertEquals(0x01234567, x, "success weakCompareAndSet int value"); } { boolean success = vh.weakCompareAndSet(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) vh.get(recv); - assertEquals(x, 0x01234567, "failing weakCompareAndSet int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSet int value"); } // Compare set and get @@ -557,27 +555,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(recv, 0x01234567); int o = (int) vh.getAndSet(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndSetAcquire(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetAcquire int"); + assertEquals(0x01234567, o, "getAndSetAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "getAndSetAcquire int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndSetRelease(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetRelease int"); + assertEquals(0x01234567, o, "getAndSetRelease int"); int x = (int) vh.get(recv); - assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "getAndSetRelease int value"); } // get and add, add and get @@ -585,27 +583,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(recv, 0x01234567); int o = (int) vh.getAndAdd(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndAddAcquire(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndAddRelease(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddReleaseint"); + assertEquals(0x01234567, o, "getAndAddReleaseint"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -613,27 +611,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseOr(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseOrAcquire(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseOrRelease(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -641,27 +639,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseAnd(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseAndAcquire(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseAndRelease(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -669,27 +667,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseXor(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseXorAcquire(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { vh.set(recv, 0x01234567); int o = (int) vh.getAndBitwiseXorRelease(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) vh.get(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } @@ -704,7 +702,7 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.set(0x01234567); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "set int value"); + assertEquals(0x01234567, x, "set int value"); } @@ -712,21 +710,21 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.setVolatile(0x89ABCDEF); int x = (int) vh.getVolatile(); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { vh.setRelease(0x01234567); int x = (int) vh.getAcquire(); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { vh.setOpaque(0x89ABCDEF); int x = (int) vh.getOpaque(); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } vh.set(0x01234567); @@ -736,56 +734,56 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { boolean r = vh.compareAndSet(0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = vh.compareAndSet(0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) vh.compareAndExchange(0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) vh.compareAndExchange(0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) vh.compareAndExchangeAcquire(0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeAcquire(0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeRelease(0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) vh.compareAndExchangeRelease(0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -796,14 +794,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = vh.weakCompareAndSetPlain(0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -814,14 +812,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { boolean success = vh.weakCompareAndSetAcquire(0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -832,14 +830,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = vh.weakCompareAndSetRelease(0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetRelease int value"); } { @@ -850,14 +848,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "success weakCompareAndSet int"); + assertEquals(0x01234567, x, "success weakCompareAndSet int"); } { boolean success = vh.weakCompareAndSet(0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) vh.get(); - assertEquals(x, 0x01234567, "failing weakCompareAndSet int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSet int value"); } // Compare set and get @@ -865,27 +863,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(0x01234567); int o = (int) vh.getAndSet(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } { vh.set(0x01234567); int o = (int) vh.getAndSetAcquire(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetAcquire int"); + assertEquals(0x01234567, o, "getAndSetAcquire int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "getAndSetAcquire int value"); } { vh.set(0x01234567); int o = (int) vh.getAndSetRelease(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetRelease int"); + assertEquals(0x01234567, o, "getAndSetRelease int"); int x = (int) vh.get(); - assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "getAndSetRelease int value"); } // get and add, add and get @@ -893,27 +891,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(0x01234567); int o = (int) vh.getAndAdd(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { vh.set(0x01234567); int o = (int) vh.getAndAddAcquire(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { vh.set(0x01234567); int o = (int) vh.getAndAddRelease(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddReleaseint"); + assertEquals(0x01234567, o, "getAndAddReleaseint"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -921,27 +919,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(0x01234567); int o = (int) vh.getAndBitwiseOr(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseOrAcquire(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseOrRelease(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -949,27 +947,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(0x01234567); int o = (int) vh.getAndBitwiseAnd(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseAndAcquire(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseAndRelease(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -977,27 +975,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(0x01234567); int o = (int) vh.getAndBitwiseXor(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseXorAcquire(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { vh.set(0x01234567); int o = (int) vh.getAndBitwiseXorRelease(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) vh.get(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } @@ -1015,7 +1013,7 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.set(array, i, 0x01234567); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "get int value"); + assertEquals(0x01234567, x, "get int value"); } @@ -1023,21 +1021,21 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { { vh.setVolatile(array, i, 0x89ABCDEF); int x = (int) vh.getVolatile(array, i); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { vh.setRelease(array, i, 0x01234567); int x = (int) vh.getAcquire(array, i); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { vh.setOpaque(array, i, 0x89ABCDEF); int x = (int) vh.getOpaque(array, i); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } vh.set(array, i, 0x01234567); @@ -1047,56 +1045,56 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, 0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = vh.compareAndSet(array, i, 0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) vh.compareAndExchange(array, i, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) vh.compareAndExchange(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) vh.compareAndExchangeAcquire(array, i, 0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeAcquire(array, i, 0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeRelease(array, i, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) vh.compareAndExchangeRelease(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -1107,14 +1105,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -1125,14 +1123,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -1143,14 +1141,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = vh.weakCompareAndSetRelease(array, i, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetRelease int value"); } { @@ -1161,14 +1159,14 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "success weakCompareAndSet int"); + assertEquals(0x01234567, x, "success weakCompareAndSet int"); } { boolean success = vh.weakCompareAndSet(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x01234567, "failing weakCompareAndSet int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSet int value"); } // Compare set and get @@ -1176,27 +1174,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(array, i, 0x01234567); int o = (int) vh.getAndSet(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndSetAcquire(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetAcquire int"); + assertEquals(0x01234567, o, "getAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "getAndSetAcquire int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndSetRelease(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetRelease int"); + assertEquals(0x01234567, o, "getAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "getAndSetRelease int value"); } // get and add, add and get @@ -1204,27 +1202,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(array, i, 0x01234567); int o = (int) vh.getAndAdd(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndAddAcquire(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndAddRelease(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddReleaseint"); + assertEquals(0x01234567, o, "getAndAddReleaseint"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -1232,27 +1230,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseOr(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseOrAcquire(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseOrRelease(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -1260,27 +1258,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseAnd(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseAndAcquire(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseAndRelease(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -1288,27 +1286,27 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseXor(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseXorAcquire(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { vh.set(array, i, 0x01234567); int o = (int) vh.getAndBitwiseXorRelease(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessLong.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessLong.java index e40256a8bd5..8bf997bb9a6 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessLong.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessLong.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessLong + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessLong * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessLong - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessLong - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessLong + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessLong + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessLong + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessLong */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessLong extends VarHandleBaseTest { static final long static_final_v = 0x0123456789ABCDEFL; @@ -108,7 +110,7 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessLong.class, "final_v", long.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(long[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessLong.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), long.class); + assertEquals(long.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { // Plain { long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "get long value"); + assertEquals(0x0123456789ABCDEFL, x, "get long value"); } // Volatile { long x = (long) vh.getVolatile(recv); - assertEquals(x, 0x0123456789ABCDEFL, "getVolatile long value"); + assertEquals(0x0123456789ABCDEFL, x, "getVolatile long value"); } // Lazy { long x = (long) vh.getAcquire(recv); - assertEquals(x, 0x0123456789ABCDEFL, "getRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "getRelease long value"); } // Opaque { long x = (long) vh.getOpaque(recv); - assertEquals(x, 0x0123456789ABCDEFL, "getOpaque long value"); + assertEquals(0x0123456789ABCDEFL, x, "getOpaque long value"); } } @@ -346,26 +344,26 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { // Plain { long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "get long value"); + assertEquals(0x0123456789ABCDEFL, x, "get long value"); } // Volatile { long x = (long) vh.getVolatile(); - assertEquals(x, 0x0123456789ABCDEFL, "getVolatile long value"); + assertEquals(0x0123456789ABCDEFL, x, "getVolatile long value"); } // Lazy { long x = (long) vh.getAcquire(); - assertEquals(x, 0x0123456789ABCDEFL, "getRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "getRelease long value"); } // Opaque { long x = (long) vh.getOpaque(); - assertEquals(x, 0x0123456789ABCDEFL, "getOpaque long value"); + assertEquals(0x0123456789ABCDEFL, x, "getOpaque long value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.set(recv, 0x0123456789ABCDEFL); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "set long value"); + assertEquals(0x0123456789ABCDEFL, x, "set long value"); } @@ -404,21 +402,21 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.setVolatile(recv, 0xCAFEBABECAFEBABEL); long x = (long) vh.getVolatile(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { vh.setRelease(recv, 0x0123456789ABCDEFL); long x = (long) vh.getAcquire(recv); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { vh.setOpaque(recv, 0xCAFEBABECAFEBABEL); long x = (long) vh.getOpaque(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } vh.set(recv, 0x0123456789ABCDEFL); @@ -428,56 +426,56 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = vh.compareAndSet(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) vh.compareAndExchange(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) vh.compareAndExchange(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) vh.compareAndExchangeAcquire(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeAcquire(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeRelease(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) vh.compareAndExchangeRelease(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -488,14 +486,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = vh.weakCompareAndSetPlain(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -506,14 +504,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { boolean success = vh.weakCompareAndSetAcquire(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -524,14 +522,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = vh.weakCompareAndSetRelease(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetRelease long value"); } { @@ -542,14 +540,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long value"); } { boolean success = vh.weakCompareAndSet(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) vh.get(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSet long value"); } // Compare set and get @@ -557,27 +555,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndSet(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndSetAcquire(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetAcquire long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndSetRelease(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetRelease long"); long x = (long) vh.get(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetRelease long value"); } // get and add, add and get @@ -585,27 +583,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndAdd(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndAddAcquire(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndAddRelease(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddReleaselong"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddReleaselong"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -613,27 +611,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOr(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrAcquire(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrRelease(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -641,27 +639,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAnd(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndAcquire(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndRelease(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -669,27 +667,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXor(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorAcquire(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { vh.set(recv, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorRelease(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) vh.get(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } @@ -704,7 +702,7 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.set(0x0123456789ABCDEFL); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "set long value"); + assertEquals(0x0123456789ABCDEFL, x, "set long value"); } @@ -712,21 +710,21 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.setVolatile(0xCAFEBABECAFEBABEL); long x = (long) vh.getVolatile(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { vh.setRelease(0x0123456789ABCDEFL); long x = (long) vh.getAcquire(); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { vh.setOpaque(0xCAFEBABECAFEBABEL); long x = (long) vh.getOpaque(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } vh.set(0x0123456789ABCDEFL); @@ -736,56 +734,56 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { boolean r = vh.compareAndSet(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = vh.compareAndSet(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) vh.compareAndExchange(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) vh.compareAndExchange(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) vh.compareAndExchangeAcquire(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeAcquire(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeRelease(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) vh.compareAndExchangeRelease(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -796,14 +794,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = vh.weakCompareAndSetPlain(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -814,14 +812,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { boolean success = vh.weakCompareAndSetAcquire(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -832,14 +830,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = vh.weakCompareAndSetRelease(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetRelease long value"); } { @@ -850,14 +848,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long"); } { boolean success = vh.weakCompareAndSet(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) vh.get(); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSet long value"); } // Compare set and get @@ -865,27 +863,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndSet(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndSetAcquire(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetAcquire long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetAcquire long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndSetRelease(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetRelease long"); long x = (long) vh.get(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetRelease long value"); } // get and add, add and get @@ -893,27 +891,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndAdd(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndAddAcquire(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndAddRelease(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddReleaselong"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddReleaselong"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -921,27 +919,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOr(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrAcquire(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrRelease(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -949,27 +947,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAnd(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndAcquire(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndRelease(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -977,27 +975,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXor(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorAcquire(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { vh.set(0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorRelease(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) vh.get(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } @@ -1015,7 +1013,7 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.set(array, i, 0x0123456789ABCDEFL); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "get long value"); + assertEquals(0x0123456789ABCDEFL, x, "get long value"); } @@ -1023,21 +1021,21 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { { vh.setVolatile(array, i, 0xCAFEBABECAFEBABEL); long x = (long) vh.getVolatile(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { vh.setRelease(array, i, 0x0123456789ABCDEFL); long x = (long) vh.getAcquire(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { vh.setOpaque(array, i, 0xCAFEBABECAFEBABEL); long x = (long) vh.getOpaque(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } vh.set(array, i, 0x0123456789ABCDEFL); @@ -1047,56 +1045,56 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = vh.compareAndSet(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) vh.compareAndExchange(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) vh.compareAndExchange(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) vh.compareAndExchangeAcquire(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeAcquire(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeRelease(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) vh.compareAndExchangeRelease(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -1107,14 +1105,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -1125,14 +1123,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -1143,14 +1141,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = vh.weakCompareAndSetRelease(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetRelease long value"); } { @@ -1161,14 +1159,14 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long"); } { boolean success = vh.weakCompareAndSet(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSet long value"); } // Compare set and get @@ -1176,27 +1174,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndSet(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndSetAcquire(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetAcquire long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndSetRelease(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetRelease long value"); } // get and add, add and get @@ -1204,27 +1202,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndAdd(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndAddAcquire(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndAddRelease(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddReleaselong"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddReleaselong"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -1232,27 +1230,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOr(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrAcquire(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseOrRelease(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -1260,27 +1258,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAnd(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndAcquire(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseAndRelease(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -1288,27 +1286,27 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXor(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorAcquire(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { vh.set(array, i, 0x0123456789ABCDEFL); long o = (long) vh.getAndBitwiseXorRelease(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessModeMethodNames.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessModeMethodNames.java index 3365bd923bc..61fc8a53fd0 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessModeMethodNames.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessModeMethodNames.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,32 +23,34 @@ /* * @test - * @run testng VarHandleTestAccessModeMethodNames + * @run junit VarHandleTestAccessModeMethodNames * @modules java.base/java.lang.invoke:open */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.lang.invoke.VarHandle; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.stream.Stream; -import static org.testng.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessModeMethodNames { - @DataProvider public static Object[][] accessModesProvider() { return Stream.of(VarHandle.AccessMode.values()). map(am -> new Object[]{am}). toArray(Object[][]::new); } - @Test(dataProvider = "accessModesProvider") + @ParameterizedTest + @MethodSource("accessModesProvider") public void testMethodName(VarHandle.AccessMode am) { - assertEquals(am.methodName(), toMethodName(am.name())); + assertEquals(toMethodName(am.name()), am.methodName()); } private static String toMethodName(String name) { @@ -62,9 +64,10 @@ public class VarHandleTestAccessModeMethodNames { } - @Test(dataProvider = "accessModesProvider") + @ParameterizedTest + @MethodSource("accessModesProvider") public void testReturnType(VarHandle.AccessMode am) throws Exception { - assertEquals(getReturnType(am.methodName()), getAccessModeReturnType(am)); + assertEquals(getAccessModeReturnType(am), getReturnType(am.methodName())); } private static Class getReturnType(String name) throws Exception { diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessShort.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessShort.java index b9daf4880a0..552672c7372 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessShort.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessShort.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessShort + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessShort * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessShort - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessShort - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessShort + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessShort + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessShort + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessShort */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessShort extends VarHandleBaseTest { static final short static_final_v = (short)0x0123; @@ -108,7 +110,7 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessShort.class, "final_v", short.class); @@ -125,8 +127,6 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(short[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -156,7 +156,8 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -194,8 +195,6 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessShort.class)}); @@ -205,16 +204,16 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), short.class); + assertEquals(short.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -241,8 +240,6 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -284,7 +281,8 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -297,26 +295,26 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { // Plain { short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "get short value"); + assertEquals((short)0x0123, x, "get short value"); } // Volatile { short x = (short) vh.getVolatile(recv); - assertEquals(x, (short)0x0123, "getVolatile short value"); + assertEquals((short)0x0123, x, "getVolatile short value"); } // Lazy { short x = (short) vh.getAcquire(recv); - assertEquals(x, (short)0x0123, "getRelease short value"); + assertEquals((short)0x0123, x, "getRelease short value"); } // Opaque { short x = (short) vh.getOpaque(recv); - assertEquals(x, (short)0x0123, "getOpaque short value"); + assertEquals((short)0x0123, x, "getOpaque short value"); } } @@ -346,26 +344,26 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { // Plain { short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "get short value"); + assertEquals((short)0x0123, x, "get short value"); } // Volatile { short x = (short) vh.getVolatile(); - assertEquals(x, (short)0x0123, "getVolatile short value"); + assertEquals((short)0x0123, x, "getVolatile short value"); } // Lazy { short x = (short) vh.getAcquire(); - assertEquals(x, (short)0x0123, "getRelease short value"); + assertEquals((short)0x0123, x, "getRelease short value"); } // Opaque { short x = (short) vh.getOpaque(); - assertEquals(x, (short)0x0123, "getOpaque short value"); + assertEquals((short)0x0123, x, "getOpaque short value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.set(recv, (short)0x0123); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "set short value"); + assertEquals((short)0x0123, x, "set short value"); } @@ -404,21 +402,21 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.setVolatile(recv, (short)0x4567); short x = (short) vh.getVolatile(recv); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { vh.setRelease(recv, (short)0x0123); short x = (short) vh.getAcquire(recv); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { vh.setOpaque(recv, (short)0x4567); short x = (short) vh.getOpaque(recv); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } vh.set(recv, (short)0x0123); @@ -428,56 +426,56 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, (short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = vh.compareAndSet(recv, (short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) vh.compareAndExchange(recv, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) vh.compareAndExchange(recv, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) vh.compareAndExchangeAcquire(recv, (short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeAcquire(recv, (short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeRelease(recv, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) vh.compareAndExchangeRelease(recv, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -488,14 +486,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = vh.weakCompareAndSetPlain(recv, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -506,14 +504,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { boolean success = vh.weakCompareAndSetAcquire(recv, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -524,14 +522,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = vh.weakCompareAndSetRelease(recv, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetRelease short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetRelease short value"); } { @@ -542,14 +540,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short value"); } { boolean success = vh.weakCompareAndSet(recv, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x0123, "failing weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSet short value"); } // Compare set and get @@ -557,27 +555,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(recv, (short)0x0123); short o = (short) vh.getAndSet(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndSetAcquire(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetAcquire short"); + assertEquals((short)0x0123, o, "getAndSetAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "getAndSetAcquire short value"); + assertEquals((short)0x4567, x, "getAndSetAcquire short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndSetRelease(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetRelease short"); + assertEquals((short)0x0123, o, "getAndSetRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)0x4567, "getAndSetRelease short value"); + assertEquals((short)0x4567, x, "getAndSetRelease short value"); } // get and add, add and get @@ -585,27 +583,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(recv, (short)0x0123); short o = (short) vh.getAndAdd(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndAddAcquire(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndAddRelease(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddReleaseshort"); + assertEquals((short)0x0123, o, "getAndAddReleaseshort"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -613,27 +611,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseOr(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseOrAcquire(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseOrRelease(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -641,27 +639,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseAnd(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseAndAcquire(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseAndRelease(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -669,27 +667,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseXor(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseXorAcquire(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { vh.set(recv, (short)0x0123); short o = (short) vh.getAndBitwiseXorRelease(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) vh.get(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } @@ -704,7 +702,7 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.set((short)0x0123); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "set short value"); + assertEquals((short)0x0123, x, "set short value"); } @@ -712,21 +710,21 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.setVolatile((short)0x4567); short x = (short) vh.getVolatile(); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { vh.setRelease((short)0x0123); short x = (short) vh.getAcquire(); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { vh.setOpaque((short)0x4567); short x = (short) vh.getOpaque(); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } vh.set((short)0x0123); @@ -736,56 +734,56 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { boolean r = vh.compareAndSet((short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = vh.compareAndSet((short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) vh.compareAndExchange((short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) vh.compareAndExchange((short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) vh.compareAndExchangeAcquire((short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeAcquire((short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeRelease((short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) vh.compareAndExchangeRelease((short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -796,14 +794,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = vh.weakCompareAndSetPlain((short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -814,14 +812,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { boolean success = vh.weakCompareAndSetAcquire((short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -832,14 +830,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = vh.weakCompareAndSetRelease((short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetRelease short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetRelease short value"); } { @@ -850,14 +848,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short"); } { boolean success = vh.weakCompareAndSet((short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) vh.get(); - assertEquals(x, (short)0x0123, "failing weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSet short value"); } // Compare set and get @@ -865,27 +863,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set((short)0x0123); short o = (short) vh.getAndSet((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndSetAcquire((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetAcquire short"); + assertEquals((short)0x0123, o, "getAndSetAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "getAndSetAcquire short value"); + assertEquals((short)0x4567, x, "getAndSetAcquire short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndSetRelease((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetRelease short"); + assertEquals((short)0x0123, o, "getAndSetRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)0x4567, "getAndSetRelease short value"); + assertEquals((short)0x4567, x, "getAndSetRelease short value"); } // get and add, add and get @@ -893,27 +891,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set((short)0x0123); short o = (short) vh.getAndAdd((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndAddAcquire((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndAddRelease((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddReleaseshort"); + assertEquals((short)0x0123, o, "getAndAddReleaseshort"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -921,27 +919,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseOr((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseOrAcquire((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseOrRelease((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -949,27 +947,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseAnd((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseAndAcquire((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseAndRelease((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -977,27 +975,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseXor((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseXorAcquire((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { vh.set((short)0x0123); short o = (short) vh.getAndBitwiseXorRelease((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) vh.get(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } @@ -1015,7 +1013,7 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.set(array, i, (short)0x0123); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "get short value"); + assertEquals((short)0x0123, x, "get short value"); } @@ -1023,21 +1021,21 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { { vh.setVolatile(array, i, (short)0x4567); short x = (short) vh.getVolatile(array, i); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { vh.setRelease(array, i, (short)0x0123); short x = (short) vh.getAcquire(array, i); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { vh.setOpaque(array, i, (short)0x4567); short x = (short) vh.getOpaque(array, i); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } vh.set(array, i, (short)0x0123); @@ -1047,56 +1045,56 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, (short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = vh.compareAndSet(array, i, (short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) vh.compareAndExchange(array, i, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) vh.compareAndExchange(array, i, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) vh.compareAndExchangeAcquire(array, i, (short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeAcquire(array, i, (short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) vh.compareAndExchangeRelease(array, i, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) vh.compareAndExchangeRelease(array, i, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -1107,14 +1105,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -1125,14 +1123,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -1143,14 +1141,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = vh.weakCompareAndSetRelease(array, i, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetRelease short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetRelease short value"); } { @@ -1161,14 +1159,14 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short"); } { boolean success = vh.weakCompareAndSet(array, i, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x0123, "failing weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSet short value"); } // Compare set and get @@ -1176,27 +1174,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndSet(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndSetAcquire(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetAcquire short"); + assertEquals((short)0x0123, o, "getAndSetAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "getAndSetAcquire short value"); + assertEquals((short)0x4567, x, "getAndSetAcquire short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndSetRelease(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetRelease short"); + assertEquals((short)0x0123, o, "getAndSetRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)0x4567, "getAndSetRelease short value"); + assertEquals((short)0x4567, x, "getAndSetRelease short value"); } // get and add, add and get @@ -1204,27 +1202,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndAdd(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndAddAcquire(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndAddRelease(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddReleaseshort"); + assertEquals((short)0x0123, o, "getAndAddReleaseshort"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -1232,27 +1230,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseOr(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseOrAcquire(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseOrRelease(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -1260,27 +1258,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseAnd(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseAndAcquire(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseAndRelease(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -1288,27 +1286,27 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseXor(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseXorAcquire(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { vh.set(array, i, (short)0x0123); short o = (short) vh.getAndBitwiseXorRelease(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) vh.get(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessString.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessString.java index 8bc30739660..d1a746ba80e 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessString.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessString.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessString + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccessString * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessString - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessString - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessString + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessString + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessString + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessString */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccessString extends VarHandleBaseTest { static final String static_final_v = "foo"; @@ -109,7 +111,7 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccessString.class, "final_v", String.class); @@ -127,8 +129,6 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { vhArrayObject = MethodHandles.arrayElementVarHandle(Object[].class); } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -158,7 +158,8 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -196,8 +197,6 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessString.class)}); @@ -207,16 +206,16 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), String.class); + assertEquals(String.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -243,8 +242,6 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -291,7 +288,8 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -304,26 +302,26 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { // Plain { String x = (String) vh.get(recv); - assertEquals(x, "foo", "get String value"); + assertEquals("foo", x, "get String value"); } // Volatile { String x = (String) vh.getVolatile(recv); - assertEquals(x, "foo", "getVolatile String value"); + assertEquals("foo", x, "getVolatile String value"); } // Lazy { String x = (String) vh.getAcquire(recv); - assertEquals(x, "foo", "getRelease String value"); + assertEquals("foo", x, "getRelease String value"); } // Opaque { String x = (String) vh.getOpaque(recv); - assertEquals(x, "foo", "getOpaque String value"); + assertEquals("foo", x, "getOpaque String value"); } } @@ -399,26 +397,26 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { // Plain { String x = (String) vh.get(); - assertEquals(x, "foo", "get String value"); + assertEquals("foo", x, "get String value"); } // Volatile { String x = (String) vh.getVolatile(); - assertEquals(x, "foo", "getVolatile String value"); + assertEquals("foo", x, "getVolatile String value"); } // Lazy { String x = (String) vh.getAcquire(); - assertEquals(x, "foo", "getRelease String value"); + assertEquals("foo", x, "getRelease String value"); } // Opaque { String x = (String) vh.getOpaque(); - assertEquals(x, "foo", "getOpaque String value"); + assertEquals("foo", x, "getOpaque String value"); } } @@ -495,7 +493,7 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.set(recv, "foo"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "set String value"); + assertEquals("foo", x, "set String value"); } @@ -503,21 +501,21 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.setVolatile(recv, "bar"); String x = (String) vh.getVolatile(recv); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { vh.setRelease(recv, "foo"); String x = (String) vh.getAcquire(recv); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { vh.setOpaque(recv, "bar"); String x = (String) vh.getOpaque(recv); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } vh.set(recv, "foo"); @@ -527,56 +525,56 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, "foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = vh.compareAndSet(recv, "foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) vh.compareAndExchange(recv, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) vh.compareAndExchange(recv, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) vh.compareAndExchangeAcquire(recv, "foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeAcquire(recv, "foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeRelease(recv, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) vh.compareAndExchangeRelease(recv, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -587,14 +585,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = vh.weakCompareAndSetPlain(recv, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -605,14 +603,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { boolean success = vh.weakCompareAndSetAcquire(recv, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -623,14 +621,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = vh.weakCompareAndSetRelease(recv, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetRelease String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "failing weakCompareAndSetRelease String value"); + assertEquals("bar", x, "failing weakCompareAndSetRelease String value"); } { @@ -641,14 +639,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "success weakCompareAndSet String value"); + assertEquals("foo", x, "success weakCompareAndSet String value"); } { boolean success = vh.weakCompareAndSet(recv, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) vh.get(recv); - assertEquals(x, "foo", "failing weakCompareAndSet String value"); + assertEquals("foo", x, "failing weakCompareAndSet String value"); } // Compare set and get @@ -656,27 +654,27 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { vh.set(recv, "foo"); String o = (String) vh.getAndSet(recv, "bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } { vh.set(recv, "foo"); String o = (String) vh.getAndSetAcquire(recv, "bar"); - assertEquals(o, "foo", "getAndSetAcquire String"); + assertEquals("foo", o, "getAndSetAcquire String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "getAndSetAcquire String value"); + assertEquals("bar", x, "getAndSetAcquire String value"); } { vh.set(recv, "foo"); String o = (String) vh.getAndSetRelease(recv, "bar"); - assertEquals(o, "foo", "getAndSetRelease String"); + assertEquals("foo", o, "getAndSetRelease String"); String x = (String) vh.get(recv); - assertEquals(x, "bar", "getAndSetRelease String value"); + assertEquals("bar", x, "getAndSetRelease String value"); } @@ -739,7 +737,7 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.set("foo"); String x = (String) vh.get(); - assertEquals(x, "foo", "set String value"); + assertEquals("foo", x, "set String value"); } @@ -747,21 +745,21 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.setVolatile("bar"); String x = (String) vh.getVolatile(); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { vh.setRelease("foo"); String x = (String) vh.getAcquire(); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { vh.setOpaque("bar"); String x = (String) vh.getOpaque(); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } vh.set("foo"); @@ -771,56 +769,56 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { boolean r = vh.compareAndSet("foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) vh.get(); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = vh.compareAndSet("foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) vh.get(); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) vh.compareAndExchange("bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) vh.get(); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) vh.compareAndExchange("bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) vh.get(); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) vh.compareAndExchangeAcquire("foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) vh.get(); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeAcquire("foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) vh.get(); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeRelease("bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) vh.get(); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) vh.compareAndExchangeRelease("bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) vh.get(); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -831,14 +829,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) vh.get(); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = vh.weakCompareAndSetPlain("foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) vh.get(); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -849,14 +847,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) vh.get(); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { boolean success = vh.weakCompareAndSetAcquire("bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) vh.get(); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) vh.get(); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = vh.weakCompareAndSetRelease("foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetRelease String"); String x = (String) vh.get(); - assertEquals(x, "bar", "failing weakCompareAndSetRelease String value"); + assertEquals("bar", x, "failing weakCompareAndSetRelease String value"); } { @@ -885,14 +883,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) vh.get(); - assertEquals(x, "foo", "success weakCompareAndSet String"); + assertEquals("foo", x, "success weakCompareAndSet String"); } { boolean success = vh.weakCompareAndSet("bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) vh.get(); - assertEquals(x, "foo", "failing weakCompareAndSet String value"); + assertEquals("foo", x, "failing weakCompareAndSet String value"); } // Compare set and get @@ -900,27 +898,27 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { vh.set("foo"); String o = (String) vh.getAndSet("bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) vh.get(); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } { vh.set("foo"); String o = (String) vh.getAndSetAcquire("bar"); - assertEquals(o, "foo", "getAndSetAcquire String"); + assertEquals("foo", o, "getAndSetAcquire String"); String x = (String) vh.get(); - assertEquals(x, "bar", "getAndSetAcquire String value"); + assertEquals("bar", x, "getAndSetAcquire String value"); } { vh.set("foo"); String o = (String) vh.getAndSetRelease("bar"); - assertEquals(o, "foo", "getAndSetRelease String"); + assertEquals("foo", o, "getAndSetRelease String"); String x = (String) vh.get(); - assertEquals(x, "bar", "getAndSetRelease String value"); + assertEquals("bar", x, "getAndSetRelease String value"); } @@ -986,7 +984,7 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.set(array, i, "foo"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "get String value"); + assertEquals("foo", x, "get String value"); } @@ -994,21 +992,21 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { { vh.setVolatile(array, i, "bar"); String x = (String) vh.getVolatile(array, i); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { vh.setRelease(array, i, "foo"); String x = (String) vh.getAcquire(array, i); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { vh.setOpaque(array, i, "bar"); String x = (String) vh.getOpaque(array, i); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } vh.set(array, i, "foo"); @@ -1018,56 +1016,56 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, "foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = vh.compareAndSet(array, i, "foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) vh.compareAndExchange(array, i, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) vh.compareAndExchange(array, i, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) vh.compareAndExchangeAcquire(array, i, "foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeAcquire(array, i, "foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) vh.compareAndExchangeRelease(array, i, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) vh.compareAndExchangeRelease(array, i, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -1078,14 +1076,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -1096,14 +1094,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -1114,14 +1112,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = vh.weakCompareAndSetRelease(array, i, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetRelease String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "failing weakCompareAndSetRelease String value"); + assertEquals("bar", x, "failing weakCompareAndSetRelease String value"); } { @@ -1132,14 +1130,14 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "success weakCompareAndSet String"); + assertEquals("foo", x, "success weakCompareAndSet String"); } { boolean success = vh.weakCompareAndSet(array, i, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) vh.get(array, i); - assertEquals(x, "foo", "failing weakCompareAndSet String value"); + assertEquals("foo", x, "failing weakCompareAndSet String value"); } // Compare set and get @@ -1147,27 +1145,27 @@ public class VarHandleTestAccessString extends VarHandleBaseTest { vh.set(array, i, "foo"); String o = (String) vh.getAndSet(array, i, "bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } { vh.set(array, i, "foo"); String o = (String) vh.getAndSetAcquire(array, i, "bar"); - assertEquals(o, "foo", "getAndSetAcquire String"); + assertEquals("foo", o, "getAndSetAcquire String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "getAndSetAcquire String value"); + assertEquals("bar", x, "getAndSetAcquire String value"); } { vh.set(array, i, "foo"); String o = (String) vh.getAndSetRelease(array, i, "bar"); - assertEquals(o, "foo", "getAndSetRelease String"); + assertEquals("foo", o, "getAndSetRelease String"); String x = (String) vh.get(array, i); - assertEquals(x, "bar", "getAndSetRelease String value"); + assertEquals("bar", x, "getAndSetRelease String value"); } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsChar.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsChar.java index 78c13da45a9..26ac4aab893 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsChar.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsChar.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsChar - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsChar - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsChar + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsChar + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsChar + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsChar */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { static final int SIZE = Character.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -158,17 +159,16 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), char.class); + assertEquals(char.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -230,7 +230,8 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -239,7 +240,6 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -740,7 +740,7 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); char x = (char) vh.get(array, i); - assertEquals(x, VALUE_1, "get char value"); + assertEquals(VALUE_1, x, "get char value"); } } } @@ -759,7 +759,7 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); char x = (char) vh.get(array, i); - assertEquals(x, VALUE_1, "get char value"); + assertEquals(VALUE_1, x, "get char value"); } if (iAligned) { @@ -767,21 +767,21 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); char x = (char) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile char value"); + assertEquals(VALUE_2, x, "setVolatile char value"); } // Lazy { vh.setRelease(array, i, VALUE_1); char x = (char) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease char value"); + assertEquals(VALUE_1, x, "setRelease char value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); char x = (char) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque char value"); + assertEquals(VALUE_2, x, "setOpaque char value"); } @@ -807,26 +807,26 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest { // Plain { char x = (char) vh.get(array, i); - assertEquals(x, v, "get char value"); + assertEquals(v, x, "get char value"); } if (iAligned) { // Volatile { char x = (char) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile char value"); + assertEquals(v, x, "getVolatile char value"); } // Lazy { char x = (char) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease char value"); + assertEquals(v, x, "getRelease char value"); } // Opaque { char x = (char) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque char value"); + assertEquals(v, x, "getOpaque char value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsDouble.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsDouble.java index 331b9073e90..a9e1e603c5d 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsDouble.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsDouble.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsDouble - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsDouble - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsDouble + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsDouble + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsDouble + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsDouble */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { static final int SIZE = Double.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -172,17 +173,16 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), double.class); + assertEquals(double.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -244,7 +244,8 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -253,7 +254,6 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -883,7 +883,7 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "get double value"); + assertEquals(VALUE_1, x, "get double value"); } } } @@ -902,7 +902,7 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "get double value"); + assertEquals(VALUE_1, x, "get double value"); } if (iAligned) { @@ -910,21 +910,21 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); double x = (double) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile double value"); + assertEquals(VALUE_2, x, "setVolatile double value"); } // Lazy { vh.setRelease(array, i, VALUE_1); double x = (double) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease double value"); + assertEquals(VALUE_1, x, "setRelease double value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); double x = (double) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque double value"); + assertEquals(VALUE_2, x, "setOpaque double value"); } vh.set(array, i, VALUE_1); @@ -934,56 +934,56 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2); assertEquals(r, true, "success compareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndSet double value"); + assertEquals(VALUE_2, x, "success compareAndSet double value"); } { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3); assertEquals(r, false, "failing compareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndSet double value"); + assertEquals(VALUE_2, x, "failing compareAndSet double value"); } { double r = (double) vh.compareAndExchange(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchange double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchange double value"); + assertEquals(VALUE_1, x, "success compareAndExchange double value"); } { double r = (double) vh.compareAndExchange(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchange double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchange double value"); + assertEquals(VALUE_1, x, "failing compareAndExchange double value"); } { double r = (double) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2); assertEquals(r, VALUE_1, "success compareAndExchangeAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndExchangeAcquire double value"); + assertEquals(VALUE_2, x, "success compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3); assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire double value"); + assertEquals(VALUE_2, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchangeRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchangeRelease double value"); + assertEquals(VALUE_1, x, "success compareAndExchangeRelease double value"); } { double r = (double) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchangeRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchangeRelease double value"); + assertEquals(VALUE_1, x, "failing compareAndExchangeRelease double value"); } { @@ -994,14 +994,14 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetPlain double value"); + assertEquals(VALUE_2, x, "success weakCompareAndSetPlain double value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetPlain double value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetPlain double value"); } { @@ -1012,14 +1012,14 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSetAcquire double"); + assertEquals(VALUE_1, x, "success weakCompareAndSetAcquire double"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSetAcquire double value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSetAcquire double value"); } { @@ -1030,14 +1030,14 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetRelease double"); + assertEquals(VALUE_2, x, "success weakCompareAndSetRelease double"); } { boolean success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetRelease double value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetRelease double value"); } { @@ -1048,14 +1048,14 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSet double"); + assertEquals(VALUE_1, x, "success weakCompareAndSet double"); } { boolean success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSet double value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSet double value"); } // Compare set and get @@ -1063,27 +1063,27 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); double o = (double) vh.getAndSet(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSet double"); + assertEquals(VALUE_1, o, "getAndSet double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSet double value"); + assertEquals(VALUE_2, x, "getAndSet double value"); } { vh.set(array, i, VALUE_1); double o = (double) vh.getAndSetAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetAcquire double"); + assertEquals(VALUE_1, o, "getAndSetAcquire double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetAcquire double value"); + assertEquals(VALUE_2, x, "getAndSetAcquire double value"); } { vh.set(array, i, VALUE_1); double o = (double) vh.getAndSetRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetRelease double"); + assertEquals(VALUE_1, o, "getAndSetRelease double"); double x = (double) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetRelease double value"); + assertEquals(VALUE_2, x, "getAndSetRelease double value"); } @@ -1109,26 +1109,26 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest { // Plain { double x = (double) vh.get(array, i); - assertEquals(x, v, "get double value"); + assertEquals(v, x, "get double value"); } if (iAligned) { // Volatile { double x = (double) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile double value"); + assertEquals(v, x, "getVolatile double value"); } // Lazy { double x = (double) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease double value"); + assertEquals(v, x, "getRelease double value"); } // Opaque { double x = (double) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque double value"); + assertEquals(v, x, "getOpaque double value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsFloat.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsFloat.java index 908d61dd597..486487518e9 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsFloat.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsFloat.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsFloat - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsFloat - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsFloat + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsFloat + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsFloat + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsFloat */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { static final int SIZE = Float.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -172,17 +173,16 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), float.class); + assertEquals(float.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -244,7 +244,8 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -253,7 +254,6 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -883,7 +883,7 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "get float value"); + assertEquals(VALUE_1, x, "get float value"); } } } @@ -902,7 +902,7 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "get float value"); + assertEquals(VALUE_1, x, "get float value"); } if (iAligned) { @@ -910,21 +910,21 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); float x = (float) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile float value"); + assertEquals(VALUE_2, x, "setVolatile float value"); } // Lazy { vh.setRelease(array, i, VALUE_1); float x = (float) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease float value"); + assertEquals(VALUE_1, x, "setRelease float value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); float x = (float) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque float value"); + assertEquals(VALUE_2, x, "setOpaque float value"); } vh.set(array, i, VALUE_1); @@ -934,56 +934,56 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2); assertEquals(r, true, "success compareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndSet float value"); + assertEquals(VALUE_2, x, "success compareAndSet float value"); } { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3); assertEquals(r, false, "failing compareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndSet float value"); + assertEquals(VALUE_2, x, "failing compareAndSet float value"); } { float r = (float) vh.compareAndExchange(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchange float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchange float value"); + assertEquals(VALUE_1, x, "success compareAndExchange float value"); } { float r = (float) vh.compareAndExchange(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchange float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchange float value"); + assertEquals(VALUE_1, x, "failing compareAndExchange float value"); } { float r = (float) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2); assertEquals(r, VALUE_1, "success compareAndExchangeAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndExchangeAcquire float value"); + assertEquals(VALUE_2, x, "success compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3); assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire float value"); + assertEquals(VALUE_2, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchangeRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchangeRelease float value"); + assertEquals(VALUE_1, x, "success compareAndExchangeRelease float value"); } { float r = (float) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchangeRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchangeRelease float value"); + assertEquals(VALUE_1, x, "failing compareAndExchangeRelease float value"); } { @@ -994,14 +994,14 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetPlain float value"); + assertEquals(VALUE_2, x, "success weakCompareAndSetPlain float value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetPlain float value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetPlain float value"); } { @@ -1012,14 +1012,14 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSetAcquire float"); + assertEquals(VALUE_1, x, "success weakCompareAndSetAcquire float"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSetAcquire float value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSetAcquire float value"); } { @@ -1030,14 +1030,14 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetRelease float"); + assertEquals(VALUE_2, x, "success weakCompareAndSetRelease float"); } { boolean success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetRelease float value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetRelease float value"); } { @@ -1048,14 +1048,14 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSet float"); + assertEquals(VALUE_1, x, "success weakCompareAndSet float"); } { boolean success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSet float value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSet float value"); } // Compare set and get @@ -1063,27 +1063,27 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); float o = (float) vh.getAndSet(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSet float"); + assertEquals(VALUE_1, o, "getAndSet float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSet float value"); + assertEquals(VALUE_2, x, "getAndSet float value"); } { vh.set(array, i, VALUE_1); float o = (float) vh.getAndSetAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetAcquire float"); + assertEquals(VALUE_1, o, "getAndSetAcquire float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetAcquire float value"); + assertEquals(VALUE_2, x, "getAndSetAcquire float value"); } { vh.set(array, i, VALUE_1); float o = (float) vh.getAndSetRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetRelease float"); + assertEquals(VALUE_1, o, "getAndSetRelease float"); float x = (float) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetRelease float value"); + assertEquals(VALUE_2, x, "getAndSetRelease float value"); } @@ -1109,26 +1109,26 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest { // Plain { float x = (float) vh.get(array, i); - assertEquals(x, v, "get float value"); + assertEquals(v, x, "get float value"); } if (iAligned) { // Volatile { float x = (float) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile float value"); + assertEquals(v, x, "getVolatile float value"); } // Lazy { float x = (float) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease float value"); + assertEquals(v, x, "getRelease float value"); } // Opaque { float x = (float) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque float value"); + assertEquals(v, x, "getOpaque float value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsInt.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsInt.java index 791510281c1..ce55c3d5e31 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsInt.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsInt.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsInt - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsInt - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsInt + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsInt + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsInt + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsInt */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { static final int SIZE = Integer.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -190,17 +191,16 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), int.class); + assertEquals(int.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -262,7 +262,8 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -271,7 +272,6 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -1039,7 +1039,7 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "get int value"); + assertEquals(VALUE_1, x, "get int value"); } } } @@ -1058,7 +1058,7 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "get int value"); + assertEquals(VALUE_1, x, "get int value"); } if (iAligned) { @@ -1066,21 +1066,21 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); int x = (int) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile int value"); + assertEquals(VALUE_2, x, "setVolatile int value"); } // Lazy { vh.setRelease(array, i, VALUE_1); int x = (int) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease int value"); + assertEquals(VALUE_1, x, "setRelease int value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); int x = (int) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque int value"); + assertEquals(VALUE_2, x, "setOpaque int value"); } vh.set(array, i, VALUE_1); @@ -1090,56 +1090,56 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2); assertEquals(r, true, "success compareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndSet int value"); + assertEquals(VALUE_2, x, "success compareAndSet int value"); } { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3); assertEquals(r, false, "failing compareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndSet int value"); + assertEquals(VALUE_2, x, "failing compareAndSet int value"); } { int r = (int) vh.compareAndExchange(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchange int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchange int value"); + assertEquals(VALUE_1, x, "success compareAndExchange int value"); } { int r = (int) vh.compareAndExchange(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchange int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchange int value"); + assertEquals(VALUE_1, x, "failing compareAndExchange int value"); } { int r = (int) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2); assertEquals(r, VALUE_1, "success compareAndExchangeAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndExchangeAcquire int value"); + assertEquals(VALUE_2, x, "success compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3); assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire int value"); + assertEquals(VALUE_2, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchangeRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchangeRelease int value"); + assertEquals(VALUE_1, x, "success compareAndExchangeRelease int value"); } { int r = (int) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchangeRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchangeRelease int value"); + assertEquals(VALUE_1, x, "failing compareAndExchangeRelease int value"); } { @@ -1150,14 +1150,14 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetPlain int value"); + assertEquals(VALUE_2, x, "success weakCompareAndSetPlain int value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetPlain int value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetPlain int value"); } { @@ -1168,14 +1168,14 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSetAcquire int"); + assertEquals(VALUE_1, x, "success weakCompareAndSetAcquire int"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSetAcquire int value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSetAcquire int value"); } { @@ -1186,14 +1186,14 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetRelease int"); + assertEquals(VALUE_2, x, "success weakCompareAndSetRelease int"); } { boolean success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetRelease int value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetRelease int value"); } { @@ -1204,14 +1204,14 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSet int"); + assertEquals(VALUE_1, x, "success weakCompareAndSet int"); } { boolean success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSet int value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSet int value"); } // Compare set and get @@ -1219,27 +1219,27 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); int o = (int) vh.getAndSet(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSet int"); + assertEquals(VALUE_1, o, "getAndSet int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSet int value"); + assertEquals(VALUE_2, x, "getAndSet int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndSetAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetAcquire int"); + assertEquals(VALUE_1, o, "getAndSetAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetAcquire int value"); + assertEquals(VALUE_2, x, "getAndSetAcquire int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndSetRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetRelease int"); + assertEquals(VALUE_1, o, "getAndSetRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetRelease int value"); + assertEquals(VALUE_2, x, "getAndSetRelease int value"); } // get and add, add and get @@ -1247,27 +1247,27 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); int o = (int) vh.getAndAdd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAdd int"); + assertEquals(VALUE_1, o, "getAndAdd int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAdd int value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAdd int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndAddAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddAcquire int"); + assertEquals(VALUE_1, o, "getAndAddAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddAcquire int value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddAcquire int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndAddRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddRelease int"); + assertEquals(VALUE_1, o, "getAndAddRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddRelease int value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddRelease int value"); } // get and bitwise or @@ -1275,27 +1275,27 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseOr(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOr int"); + assertEquals(VALUE_1, o, "getAndBitwiseOr int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOr int value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOr int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseOrAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrAcquire int"); + assertEquals(VALUE_1, o, "getAndBitwiseOrAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrAcquire int value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrAcquire int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseOrRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrRelease int"); + assertEquals(VALUE_1, o, "getAndBitwiseOrRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrRelease int value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -1303,27 +1303,27 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseAnd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAnd int"); + assertEquals(VALUE_1, o, "getAndBitwiseAnd int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAnd int value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAnd int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseAndAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndAcquire int"); + assertEquals(VALUE_1, o, "getAndBitwiseAndAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndAcquire int value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndAcquire int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseAndRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndRelease int"); + assertEquals(VALUE_1, o, "getAndBitwiseAndRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndRelease int value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -1331,27 +1331,27 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseXor(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXor int"); + assertEquals(VALUE_1, o, "getAndBitwiseXor int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXor int value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXor int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseXorAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorAcquire int"); + assertEquals(VALUE_1, o, "getAndBitwiseXorAcquire int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorAcquire int value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorAcquire int value"); } { vh.set(array, i, VALUE_1); int o = (int) vh.getAndBitwiseXorRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorRelease int"); + assertEquals(VALUE_1, o, "getAndBitwiseXorRelease int"); int x = (int) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorRelease int value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorRelease int value"); } } } @@ -1375,26 +1375,26 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest { // Plain { int x = (int) vh.get(array, i); - assertEquals(x, v, "get int value"); + assertEquals(v, x, "get int value"); } if (iAligned) { // Volatile { int x = (int) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile int value"); + assertEquals(v, x, "getVolatile int value"); } // Lazy { int x = (int) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease int value"); + assertEquals(v, x, "getRelease int value"); } // Opaque { int x = (int) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque int value"); + assertEquals(v, x, "getOpaque int value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsLong.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsLong.java index 4188a51a559..763703b6079 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsLong.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsLong.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsLong - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsLong - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsLong + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsLong + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsLong + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsLong */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { static final int SIZE = Long.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -190,17 +191,16 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), long.class); + assertEquals(long.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -262,7 +262,8 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -271,7 +272,6 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -1039,7 +1039,7 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "get long value"); + assertEquals(VALUE_1, x, "get long value"); } } } @@ -1058,7 +1058,7 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "get long value"); + assertEquals(VALUE_1, x, "get long value"); } if (iAligned) { @@ -1066,21 +1066,21 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); long x = (long) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile long value"); + assertEquals(VALUE_2, x, "setVolatile long value"); } // Lazy { vh.setRelease(array, i, VALUE_1); long x = (long) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease long value"); + assertEquals(VALUE_1, x, "setRelease long value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); long x = (long) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque long value"); + assertEquals(VALUE_2, x, "setOpaque long value"); } vh.set(array, i, VALUE_1); @@ -1090,56 +1090,56 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2); assertEquals(r, true, "success compareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndSet long value"); + assertEquals(VALUE_2, x, "success compareAndSet long value"); } { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3); assertEquals(r, false, "failing compareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndSet long value"); + assertEquals(VALUE_2, x, "failing compareAndSet long value"); } { long r = (long) vh.compareAndExchange(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchange long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchange long value"); + assertEquals(VALUE_1, x, "success compareAndExchange long value"); } { long r = (long) vh.compareAndExchange(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchange long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchange long value"); + assertEquals(VALUE_1, x, "failing compareAndExchange long value"); } { long r = (long) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2); assertEquals(r, VALUE_1, "success compareAndExchangeAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndExchangeAcquire long value"); + assertEquals(VALUE_2, x, "success compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3); assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire long value"); + assertEquals(VALUE_2, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchangeRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchangeRelease long value"); + assertEquals(VALUE_1, x, "success compareAndExchangeRelease long value"); } { long r = (long) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchangeRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchangeRelease long value"); + assertEquals(VALUE_1, x, "failing compareAndExchangeRelease long value"); } { @@ -1150,14 +1150,14 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetPlain long value"); + assertEquals(VALUE_2, x, "success weakCompareAndSetPlain long value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetPlain long value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetPlain long value"); } { @@ -1168,14 +1168,14 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSetAcquire long"); + assertEquals(VALUE_1, x, "success weakCompareAndSetAcquire long"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSetAcquire long value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSetAcquire long value"); } { @@ -1186,14 +1186,14 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetRelease long"); + assertEquals(VALUE_2, x, "success weakCompareAndSetRelease long"); } { boolean success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetRelease long value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetRelease long value"); } { @@ -1204,14 +1204,14 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSet long"); + assertEquals(VALUE_1, x, "success weakCompareAndSet long"); } { boolean success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSet long value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSet long value"); } // Compare set and get @@ -1219,27 +1219,27 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); long o = (long) vh.getAndSet(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSet long"); + assertEquals(VALUE_1, o, "getAndSet long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSet long value"); + assertEquals(VALUE_2, x, "getAndSet long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndSetAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetAcquire long"); + assertEquals(VALUE_1, o, "getAndSetAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetAcquire long value"); + assertEquals(VALUE_2, x, "getAndSetAcquire long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndSetRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetRelease long"); + assertEquals(VALUE_1, o, "getAndSetRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetRelease long value"); + assertEquals(VALUE_2, x, "getAndSetRelease long value"); } // get and add, add and get @@ -1247,27 +1247,27 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); long o = (long) vh.getAndAdd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAdd long"); + assertEquals(VALUE_1, o, "getAndAdd long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAdd long value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAdd long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndAddAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddAcquire long"); + assertEquals(VALUE_1, o, "getAndAddAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddAcquire long value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddAcquire long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndAddRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddRelease long"); + assertEquals(VALUE_1, o, "getAndAddRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddRelease long value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddRelease long value"); } // get and bitwise or @@ -1275,27 +1275,27 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseOr(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOr long"); + assertEquals(VALUE_1, o, "getAndBitwiseOr long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOr long value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOr long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseOrAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrAcquire long"); + assertEquals(VALUE_1, o, "getAndBitwiseOrAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrAcquire long value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrAcquire long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseOrRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrRelease long"); + assertEquals(VALUE_1, o, "getAndBitwiseOrRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrRelease long value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -1303,27 +1303,27 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseAnd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAnd long"); + assertEquals(VALUE_1, o, "getAndBitwiseAnd long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAnd long value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAnd long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseAndAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndAcquire long"); + assertEquals(VALUE_1, o, "getAndBitwiseAndAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndAcquire long value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndAcquire long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseAndRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndRelease long"); + assertEquals(VALUE_1, o, "getAndBitwiseAndRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndRelease long value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -1331,27 +1331,27 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseXor(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXor long"); + assertEquals(VALUE_1, o, "getAndBitwiseXor long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXor long value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXor long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseXorAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorAcquire long"); + assertEquals(VALUE_1, o, "getAndBitwiseXorAcquire long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorAcquire long value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorAcquire long value"); } { vh.set(array, i, VALUE_1); long o = (long) vh.getAndBitwiseXorRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorRelease long"); + assertEquals(VALUE_1, o, "getAndBitwiseXorRelease long"); long x = (long) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorRelease long value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorRelease long value"); } } } @@ -1375,26 +1375,26 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest { // Plain { long x = (long) vh.get(array, i); - assertEquals(x, v, "get long value"); + assertEquals(v, x, "get long value"); } if (iAligned) { // Volatile { long x = (long) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile long value"); + assertEquals(v, x, "getVolatile long value"); } // Lazy { long x = (long) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease long value"); + assertEquals(v, x, "getRelease long value"); } // Opaque { long x = (long) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque long value"); + assertEquals(v, x, "getOpaque long value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsShort.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsShort.java index 1ecfef0476e..7a3bc069c22 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsShort.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestByteArrayAsShort.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsShort - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsShort - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsShort + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsShort + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAsShort + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAsShort */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { static final int SIZE = Short.BYTES; @@ -107,7 +107,8 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -158,17 +159,16 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), short.class); + assertEquals(short.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -230,7 +230,8 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -239,7 +240,6 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -740,7 +740,7 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); short x = (short) vh.get(array, i); - assertEquals(x, VALUE_1, "get short value"); + assertEquals(VALUE_1, x, "get short value"); } } } @@ -759,7 +759,7 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); short x = (short) vh.get(array, i); - assertEquals(x, VALUE_1, "get short value"); + assertEquals(VALUE_1, x, "get short value"); } if (iAligned) { @@ -767,21 +767,21 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); short x = (short) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile short value"); + assertEquals(VALUE_2, x, "setVolatile short value"); } // Lazy { vh.setRelease(array, i, VALUE_1); short x = (short) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease short value"); + assertEquals(VALUE_1, x, "setRelease short value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); short x = (short) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque short value"); + assertEquals(VALUE_2, x, "setOpaque short value"); } @@ -807,26 +807,26 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest { // Plain { short x = (short) vh.get(array, i); - assertEquals(x, v, "get short value"); + assertEquals(v, x, "get short value"); } if (iAligned) { // Volatile { short x = (short) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile short value"); + assertEquals(v, x, "getVolatile short value"); } // Lazy { short x = (short) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease short value"); + assertEquals(v, x, "getRelease short value"); } // Opaque { short x = (short) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque short value"); + assertEquals(v, x, "getOpaque short value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestExact.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestExact.java index fc706815bce..9960e08a0c7 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestExact.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestExact.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,20 +26,20 @@ * @modules java.base/jdk.internal.access.foreign * @modules java.base/jdk.internal.foreign.layout * - * @run testng/othervm -Xverify:all + * @run junit/othervm -Xverify:all * -Djdk.internal.foreign.SHOULD_ADAPT_HANDLES=false * VarHandleTestExact - * @run testng/othervm -Xverify:all + * @run junit/othervm -Xverify:all * -Djdk.internal.foreign.SHOULD_ADAPT_HANDLES=false * -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true * -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true * VarHandleTestExact - * @run testng/othervm -Xverify:all + * @run junit/othervm -Xverify:all * -Djdk.internal.foreign.SHOULD_ADAPT_HANDLES=false * -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false * -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false * VarHandleTestExact - * @run testng/othervm -Xverify:all + * @run junit/othervm -Xverify:all * -Djdk.internal.foreign.SHOULD_ADAPT_HANDLES=false * -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false * -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true @@ -50,9 +50,6 @@ import java.lang.foreign.Arena; import java.lang.foreign.MemorySegment; import jdk.internal.foreign.layout.ValueLayouts; -import org.testng.SkipException; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; @@ -64,8 +61,13 @@ import java.util.ArrayList; import java.util.List; import java.util.function.Consumer; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestExact { private static class Widget { @@ -90,12 +92,13 @@ public class VarHandleTestExact { final Long aLongField_RO = 1234L; } - @Test(dataProvider = "dataObjectAccess") + @ParameterizedTest + @MethodSource("dataObjectAccess") public void testExactSet(String fieldBaseName, Class fieldType, boolean ro, Object testValue, SetX setter, GetX getter, SetStaticX staticSetter, GetStaticX staticGetter) throws NoSuchFieldException, IllegalAccessException { - if (ro) throw new SkipException("Can not test setter with read only field"); + Assumptions.assumeFalse(ro, "Can not test setter with read only field"); VarHandle vh = MethodHandles.lookup().findVarHandle(Widget.class, fieldBaseName + "_RW", fieldType); Widget w = new Widget(); @@ -105,7 +108,8 @@ public class VarHandleTestExact { ".*\\Qhandle's method type (Widget," + fieldType.getSimpleName() + ")void \\E.*"); } - @Test(dataProvider = "dataObjectAccess") + @ParameterizedTest + @MethodSource("dataObjectAccess") public void testExactGet(String fieldBaseName, Class fieldType, boolean ro, Object testValue, SetX setter, GetX getter, SetStaticX staticSetter, GetStaticX staticGetter) @@ -119,12 +123,13 @@ public class VarHandleTestExact { ".*\\Qhandle's method type (Widget)" + fieldType.getSimpleName() + " \\E.*"); } - @Test(dataProvider = "dataObjectAccess") + @ParameterizedTest + @MethodSource("dataObjectAccess") public void testExactSetStatic(String fieldBaseName, Class fieldType, boolean ro, Object testValue, SetX setter, GetX getter, SetStaticX staticSetter, GetStaticX staticGetter) throws NoSuchFieldException, IllegalAccessException { - if (ro) throw new SkipException("Can not test setter with read only field"); + Assumptions.assumeFalse(ro, "Can not test setter with read only field"); VarHandle vh = MethodHandles.lookup().findStaticVarHandle(Widget.class, fieldBaseName + "_SRW", fieldType); doTest(vh, @@ -133,7 +138,8 @@ public class VarHandleTestExact { ".*\\Qhandle's method type (" + fieldType.getSimpleName() + ")void \\E.*"); } - @Test(dataProvider = "dataObjectAccess") + @ParameterizedTest + @MethodSource("dataObjectAccess") public void testExactGetStatic(String fieldBaseName, Class fieldType, boolean ro, Object testValue, SetX setter, GetX getter, SetStaticX staticSetter, GetStaticX staticGetter) @@ -146,7 +152,8 @@ public class VarHandleTestExact { ".*\\Qhandle's method type ()" + fieldType.getSimpleName() + " \\E.*"); } - @Test(dataProvider = "dataSetArray") + @ParameterizedTest + @MethodSource("dataSetArray") public void testExactArraySet(Class arrayClass, Object testValue, SetArrayX setter) { VarHandle vh = MethodHandles.arrayElementVarHandle(arrayClass); Object arr = Array.newInstance(arrayClass.componentType(), 1); @@ -157,7 +164,8 @@ public class VarHandleTestExact { ".*\\Qhandle's method type (" + arrayClass.getSimpleName() + ",int," + arrayClass.componentType().getSimpleName() + ")void \\E.*"); } - @Test(dataProvider = "dataSetBuffer") + @ParameterizedTest + @MethodSource("dataSetBuffer") public void testExactBufferSet(Class arrayClass, Object testValue, SetBufferX setter) { VarHandle vh = MethodHandles.byteBufferViewVarHandle(arrayClass, ByteOrder.nativeOrder()); ByteBuffer buff = ByteBuffer.allocateDirect(8); @@ -168,7 +176,8 @@ public class VarHandleTestExact { ".*\\Qhandle's method type (ByteBuffer,int," + arrayClass.componentType().getSimpleName() + ")void \\E.*"); } - @Test(dataProvider = "dataSetMemorySegment") + @ParameterizedTest + @MethodSource("dataSetMemorySegment") public void testExactSegmentSet(Class carrier, Object testValue, SetSegmentX setter) { VarHandle vh = ValueLayouts.valueLayout(carrier, ByteOrder.nativeOrder()).varHandle(); try (Arena arena = Arena.ofConfined()) { @@ -265,7 +274,6 @@ public class VarHandleTestExact { cases.add(new Object[] { carrier, testValue, setter }); } - @DataProvider public static Object[][] dataObjectAccess() { List cases = new ArrayList<>(); @@ -334,7 +342,6 @@ public class VarHandleTestExact { return cases.toArray(Object[][]::new); } - @DataProvider public static Object[][] dataSetArray() { List cases = new ArrayList<>(); @@ -355,7 +362,6 @@ public class VarHandleTestExact { return cases.toArray(Object[][]::new); } - @DataProvider public static Object[][] dataSetBuffer() { List cases = new ArrayList<>(); @@ -373,7 +379,6 @@ public class VarHandleTestExact { return cases.toArray(Object[][]::new); } - @DataProvider public static Object[][] dataSetMemorySegment() { List cases = new ArrayList<>(); diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessBoolean.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessBoolean.java index 14d5c05d3b8..6540693a906 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessBoolean.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessBoolean.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessBoolean + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessBoolean */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { static final boolean static_final_v = true; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessBoolean.class, "final_v", boolean.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(boolean[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessBoolean recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "set boolean value"); + assertEquals(true, x, "set boolean value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, false); boolean x = (boolean) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, true); boolean x = (boolean) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, false); boolean x = (boolean) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } hs.get(TestAccessMode.SET).invokeExact(recv, true); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, true, false); assertEquals(success, false, "failing weakCompareAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "failing weakCompareAndSetRelease boolean value"); + assertEquals(false, x, "failing weakCompareAndSetRelease boolean value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "success weakCompareAndSet boolean"); + assertEquals(true, x, "success weakCompareAndSet boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, true, "failing weakCompareAndSet boolean value"); + assertEquals(true, x, "failing weakCompareAndSet boolean value"); } // Compare set and get { boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } @@ -300,27 +298,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -328,27 +326,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -356,27 +354,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } @@ -396,7 +394,7 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(true); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "set boolean value"); + assertEquals(true, x, "set boolean value"); } @@ -404,21 +402,21 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(false); boolean x = (boolean) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(true); boolean x = (boolean) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(false); boolean x = (boolean) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } hs.get(TestAccessMode.SET).invokeExact(true); @@ -428,56 +426,56 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -489,14 +487,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -508,7 +506,7 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { @@ -516,7 +514,7 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact(false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -528,14 +526,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(true, false); assertEquals(success, false, "failing weakCompareAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "failing weakCompareAndSetRelease boolean value"); + assertEquals(false, x, "failing weakCompareAndSetRelease boolean value"); } { @@ -547,14 +545,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "success weakCompareAndSet boolean"); + assertEquals(true, x, "success weakCompareAndSet boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, true, "failing weakCompareAndSetRe boolean value"); + assertEquals(true, x, "failing weakCompareAndSetRe boolean value"); } // Compare set and get @@ -562,9 +560,9 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET).invokeExact(false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } // Compare set and get @@ -572,9 +570,9 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(false); - assertEquals(o, true, "getAndSetAcquire boolean"); + assertEquals(true, o, "getAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "getAndSetAcquire boolean value"); + assertEquals(false, x, "getAndSetAcquire boolean value"); } // Compare set and get @@ -582,9 +580,9 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(false); - assertEquals(o, true, "getAndSetRelease boolean"); + assertEquals(true, o, "getAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, false, "getAndSetRelease boolean value"); + assertEquals(false, x, "getAndSetRelease boolean value"); } @@ -593,27 +591,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -621,27 +619,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -649,27 +647,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } @@ -692,7 +690,7 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "get boolean value"); + assertEquals(true, x, "get boolean value"); } @@ -700,21 +698,21 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, false); boolean x = (boolean) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, false, "setVolatile boolean value"); + assertEquals(false, x, "setVolatile boolean value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, true); boolean x = (boolean) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, true, "setRelease boolean value"); + assertEquals(true, x, "setRelease boolean value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, false); boolean x = (boolean) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, false, "setOpaque boolean value"); + assertEquals(false, x, "setOpaque boolean value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, true); @@ -724,56 +722,56 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, true, false); assertEquals(r, true, "success compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "success compareAndSet boolean value"); + assertEquals(false, x, "success compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, true, false); assertEquals(r, false, "failing compareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "failing compareAndSet boolean value"); + assertEquals(false, x, "failing compareAndSet boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, false, true); assertEquals(r, false, "success compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "success compareAndExchange boolean value"); + assertEquals(true, x, "success compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, false, false); assertEquals(r, true, "failing compareAndExchange boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "failing compareAndExchange boolean value"); + assertEquals(true, x, "failing compareAndExchange boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, true, false); assertEquals(r, true, "success compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "success compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "success compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, true, false); assertEquals(r, false, "failing compareAndExchangeAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "failing compareAndExchangeAcquire boolean value"); + assertEquals(false, x, "failing compareAndExchangeAcquire boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, false, true); assertEquals(r, false, "success compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "success compareAndExchangeRelease boolean value"); + assertEquals(true, x, "success compareAndExchangeRelease boolean value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, false, false); assertEquals(r, true, "failing compareAndExchangeRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "failing compareAndExchangeRelease boolean value"); + assertEquals(true, x, "failing compareAndExchangeRelease boolean value"); } { @@ -785,14 +783,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "success weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "success weakCompareAndSetPlain boolean value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, true, false); assertEquals(success, false, "failing weakCompareAndSetPlain boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "failing weakCompareAndSetPlain boolean value"); + assertEquals(false, x, "failing weakCompareAndSetPlain boolean value"); } { @@ -804,14 +802,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "success weakCompareAndSetAcquire boolean"); + assertEquals(true, x, "success weakCompareAndSetAcquire boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, false, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(true, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -823,14 +821,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "success weakCompareAndSetRelease boolean"); + assertEquals(false, x, "success weakCompareAndSetRelease boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, true, false); assertEquals(success, false, "failing weakCompareAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "failing weakCompareAndSetAcquire boolean value"); + assertEquals(false, x, "failing weakCompareAndSetAcquire boolean value"); } { @@ -842,14 +840,14 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "success weakCompareAndSet boolean"); + assertEquals(true, x, "success weakCompareAndSet boolean"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, false, false); assertEquals(success, false, "failing weakCompareAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, true, "failing weakCompareAndSet boolean value"); + assertEquals(true, x, "failing weakCompareAndSet boolean value"); } // Compare set and get @@ -857,27 +855,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, false); - assertEquals(o, true, "getAndSet boolean"); + assertEquals(true, o, "getAndSet boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "getAndSet boolean value"); + assertEquals(false, x, "getAndSet boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, false); - assertEquals(o, true, "getAndSetAcquire boolean"); + assertEquals(true, o, "getAndSetAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "getAndSetAcquire boolean value"); + assertEquals(false, x, "getAndSetAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, false); - assertEquals(o, true, "getAndSetRelease boolean"); + assertEquals(true, o, "getAndSetRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, false, "getAndSetRelease boolean value"); + assertEquals(false, x, "getAndSetRelease boolean value"); } @@ -886,27 +884,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseOr boolean"); + assertEquals(true, o, "getAndBitwiseOr boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOr boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOr boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseOrAcquire boolean"); + assertEquals(true, o, "getAndBitwiseOrAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrAcquire boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseOrRelease boolean"); + assertEquals(true, o, "getAndBitwiseOrRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true | false), "getAndBitwiseOrRelease boolean value"); + assertEquals((boolean)(true | false), x, "getAndBitwiseOrRelease boolean value"); } // get and bitwise and @@ -914,27 +912,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseAnd boolean"); + assertEquals(true, o, "getAndBitwiseAnd boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAnd boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAnd boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseAndAcquire boolean"); + assertEquals(true, o, "getAndBitwiseAndAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndAcquire boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseAndRelease boolean"); + assertEquals(true, o, "getAndBitwiseAndRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true & false), "getAndBitwiseAndRelease boolean value"); + assertEquals((boolean)(true & false), x, "getAndBitwiseAndRelease boolean value"); } // get and bitwise xor @@ -942,27 +940,27 @@ public class VarHandleTestMethodHandleAccessBoolean extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseXor boolean"); + assertEquals(true, o, "getAndBitwiseXor boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXor boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXor boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseXorAcquire boolean"); + assertEquals(true, o, "getAndBitwiseXorAcquire boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorAcquire boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorAcquire boolean value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, true); boolean o = (boolean) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, false); - assertEquals(o, true, "getAndBitwiseXorRelease boolean"); + assertEquals(true, o, "getAndBitwiseXorRelease boolean"); boolean x = (boolean) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (boolean)(true ^ false), "getAndBitwiseXorRelease boolean value"); + assertEquals((boolean)(true ^ false), x, "getAndBitwiseXorRelease boolean value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessByte.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessByte.java index 5b3eafba63b..6f7f54a57f5 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessByte.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessByte.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessByte + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessByte */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { static final byte static_final_v = (byte)0x01; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessByte.class, "final_v", byte.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(byte[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessByte recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "set byte value"); + assertEquals((byte)0x01, x, "set byte value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, (byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, (byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, (byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, (byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, (byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, (byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, (byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetRelease byte value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSet byte value"); } // Compare set and get { byte o = (byte) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddRelease byte"); + assertEquals((byte)0x01, o, "getAndAddRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -327,27 +325,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -355,27 +353,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -383,27 +381,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "set byte value"); + assertEquals((byte)0x01, x, "set byte value"); } @@ -426,21 +424,21 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact((byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact((byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact((byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } hs.get(TestAccessMode.SET).invokeExact((byte)0x01); @@ -450,56 +448,56 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact((byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact((byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact((byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact((byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact((byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact((byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact((byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact((byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -511,14 +509,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact((byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -530,7 +528,7 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { @@ -538,7 +536,7 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact((byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -550,14 +548,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact((byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetRelease byte value"); } { @@ -569,14 +567,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact((byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetRe byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetRe byte value"); } // Compare set and get @@ -584,9 +582,9 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } // Compare set and get @@ -594,9 +592,9 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetAcquire byte"); + assertEquals((byte)0x01, o, "getAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "getAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "getAndSetAcquire byte value"); } // Compare set and get @@ -604,9 +602,9 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetRelease byte"); + assertEquals((byte)0x01, o, "getAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)0x23, "getAndSetRelease byte value"); + assertEquals((byte)0x23, x, "getAndSetRelease byte value"); } // get and add, add and get @@ -614,27 +612,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddRelease byte"); + assertEquals((byte)0x01, o, "getAndAddRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -642,27 +640,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -670,27 +668,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -698,27 +696,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact((byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact((byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } @@ -736,7 +734,7 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "get byte value"); + assertEquals((byte)0x01, x, "get byte value"); } @@ -744,21 +742,21 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, (byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, (byte)0x23, "setVolatile byte value"); + assertEquals((byte)0x23, x, "setVolatile byte value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, (byte)0x01); byte x = (byte) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, (byte)0x01, "setRelease byte value"); + assertEquals((byte)0x01, x, "setRelease byte value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, (byte)0x23); byte x = (byte) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, (byte)0x23, "setOpaque byte value"); + assertEquals((byte)0x23, x, "setOpaque byte value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); @@ -768,56 +766,56 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, (byte)0x01, (byte)0x23); assertEquals(r, true, "success compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "success compareAndSet byte value"); + assertEquals((byte)0x23, x, "success compareAndSet byte value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, (byte)0x01, (byte)0x45); assertEquals(r, false, "failing compareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "failing compareAndSet byte value"); + assertEquals((byte)0x23, x, "failing compareAndSet byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "success compareAndExchange byte value"); + assertEquals((byte)0x01, x, "success compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchange byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "failing compareAndExchange byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchange byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, (byte)0x01, (byte)0x23); assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "success compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, (byte)0x01, (byte)0x45); assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value"); + assertEquals((byte)0x23, x, "failing compareAndExchangeAcquire byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, (byte)0x23, (byte)0x01); assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "success compareAndExchangeRelease byte value"); } { byte r = (byte) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, (byte)0x23, (byte)0x45); assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value"); + assertEquals((byte)0x01, x, "failing compareAndExchangeRelease byte value"); } { @@ -829,14 +827,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "success weakCompareAndSetPlain byte value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetPlain byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetPlain byte value"); } { @@ -848,14 +846,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSetAcquire byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte"); + assertEquals((byte)0x23, x, "success weakCompareAndSetRelease byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, (byte)0x01, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "failing weakCompareAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "failing weakCompareAndSetAcquire byte value"); } { @@ -886,14 +884,14 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "success weakCompareAndSet byte"); + assertEquals((byte)0x01, x, "success weakCompareAndSet byte"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, (byte)0x23, (byte)0x45); assertEquals(success, false, "failing weakCompareAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value"); + assertEquals((byte)0x01, x, "failing weakCompareAndSet byte value"); } // Compare set and get @@ -901,27 +899,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSet byte"); + assertEquals((byte)0x01, o, "getAndSet byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "getAndSet byte value"); + assertEquals((byte)0x23, x, "getAndSet byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetAcquire byte"); + assertEquals((byte)0x01, o, "getAndSetAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "getAndSetAcquire byte value"); + assertEquals((byte)0x23, x, "getAndSetAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndSetRelease byte"); + assertEquals((byte)0x01, o, "getAndSetRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)0x23, "getAndSetRelease byte value"); + assertEquals((byte)0x23, x, "getAndSetRelease byte value"); } // get and add, add and get @@ -929,27 +927,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAdd byte"); + assertEquals((byte)0x01, o, "getAndAdd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAdd byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddAcquire byte"); + assertEquals((byte)0x01, o, "getAndAddAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndAddRelease byte"); + assertEquals((byte)0x01, o, "getAndAddRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value"); + assertEquals((byte)((byte)0x01 + (byte)0x23), x, "getAndAddRelease byte value"); } // get and bitwise or @@ -957,27 +955,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOr byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOr byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOr byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseOrRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value"); + assertEquals((byte)((byte)0x01 | (byte)0x23), x, "getAndBitwiseOrRelease byte value"); } // get and bitwise and @@ -985,27 +983,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAnd byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAnd byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseAndRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value"); + assertEquals((byte)((byte)0x01 & (byte)0x23), x, "getAndBitwiseAndRelease byte value"); } // get and bitwise xor @@ -1013,27 +1011,27 @@ public class VarHandleTestMethodHandleAccessByte extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXor byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXor byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXor byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorAcquire byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorAcquire byte value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (byte)0x01); byte o = (byte) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, (byte)0x23); - assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte"); + assertEquals((byte)0x01, o, "getAndBitwiseXorRelease byte"); byte x = (byte) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value"); + assertEquals((byte)((byte)0x01 ^ (byte)0x23), x, "getAndBitwiseXorRelease byte value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessChar.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessChar.java index d191b507366..3e31ee282ff 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessChar.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessChar.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessChar + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessChar */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { static final char static_final_v = '\u0123'; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessChar.class, "final_v", char.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(char[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessChar recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "set char value"); + assertEquals('\u0123', x, "set char value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, '\u4567'); char x = (char) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, '\u0123'); char x = (char) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, '\u4567'); char x = (char) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, '\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, '\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, '\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, '\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "failing weakCompareAndSetRelease char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "success weakCompareAndSet char"); + assertEquals('\u0123', x, "success weakCompareAndSet char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u0123', "failing weakCompareAndSet char value"); + assertEquals('\u0123', x, "failing weakCompareAndSet char value"); } // Compare set and get { char o = (char) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndAddRelease char"); + assertEquals('\u0123', o, "getAndAddRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -327,27 +325,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -355,27 +353,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -383,27 +381,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "set char value"); + assertEquals('\u0123', x, "set char value"); } @@ -426,21 +424,21 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact('\u4567'); char x = (char) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact('\u0123'); char x = (char) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact('\u4567'); char x = (char) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } hs.get(TestAccessMode.SET).invokeExact('\u0123'); @@ -450,56 +448,56 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact('\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact('\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact('\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact('\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact('\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact('\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact('\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact('\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -511,14 +509,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact('\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -530,7 +528,7 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { @@ -538,7 +536,7 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact('\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -550,14 +548,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact('\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "failing weakCompareAndSetRelease char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value"); } { @@ -569,14 +567,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "success weakCompareAndSet char"); + assertEquals('\u0123', x, "success weakCompareAndSet char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact('\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u0123', "failing weakCompareAndSetRe char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetRe char value"); } // Compare set and get @@ -584,9 +582,9 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } // Compare set and get @@ -594,9 +592,9 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndSetAcquire char"); + assertEquals('\u0123', o, "getAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "getAndSetAcquire char value"); + assertEquals('\u4567', x, "getAndSetAcquire char value"); } // Compare set and get @@ -604,9 +602,9 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndSetRelease char"); + assertEquals('\u0123', o, "getAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, '\u4567', "getAndSetRelease char value"); + assertEquals('\u4567', x, "getAndSetRelease char value"); } // get and add, add and get @@ -614,27 +612,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndAddRelease char"); + assertEquals('\u0123', o, "getAndAddRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -642,27 +640,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -670,27 +668,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -698,27 +696,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact('\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact('\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } @@ -736,7 +734,7 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "get char value"); + assertEquals('\u0123', x, "get char value"); } @@ -744,21 +742,21 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, '\u4567'); char x = (char) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, '\u4567', "setVolatile char value"); + assertEquals('\u4567', x, "setVolatile char value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, '\u0123'); char x = (char) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, '\u0123', "setRelease char value"); + assertEquals('\u0123', x, "setRelease char value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, '\u4567'); char x = (char) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, '\u4567', "setOpaque char value"); + assertEquals('\u4567', x, "setOpaque char value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); @@ -768,56 +766,56 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, '\u0123', '\u4567'); assertEquals(r, true, "success compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "success compareAndSet char value"); + assertEquals('\u4567', x, "success compareAndSet char value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, '\u0123', '\u89AB'); assertEquals(r, false, "failing compareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "failing compareAndSet char value"); + assertEquals('\u4567', x, "failing compareAndSet char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "success compareAndExchange char value"); + assertEquals('\u0123', x, "success compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchange char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "failing compareAndExchange char value"); + assertEquals('\u0123', x, "failing compareAndExchange char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, '\u0123', '\u4567'); assertEquals(r, '\u0123', "success compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "success compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "success compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, '\u0123', '\u89AB'); assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "failing compareAndExchangeAcquire char value"); + assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, '\u4567', '\u0123'); assertEquals(r, '\u4567', "success compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "success compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "success compareAndExchangeRelease char value"); } { char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, '\u4567', '\u89AB'); assertEquals(r, '\u0123', "failing compareAndExchangeRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "failing compareAndExchangeRelease char value"); + assertEquals('\u0123', x, "failing compareAndExchangeRelease char value"); } { @@ -829,14 +827,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "success weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "success weakCompareAndSetPlain char value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetPlain char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "failing weakCompareAndSetPlain char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value"); } { @@ -848,14 +846,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "success weakCompareAndSetAcquire char"); + assertEquals('\u0123', x, "success weakCompareAndSetAcquire char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "success weakCompareAndSetRelease char"); + assertEquals('\u4567', x, "success weakCompareAndSetRelease char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, '\u0123', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "failing weakCompareAndSetAcquire char value"); + assertEquals('\u4567', x, "failing weakCompareAndSetAcquire char value"); } { @@ -886,14 +884,14 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "success weakCompareAndSet char"); + assertEquals('\u0123', x, "success weakCompareAndSet char"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, '\u4567', '\u89AB'); assertEquals(success, false, "failing weakCompareAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u0123', "failing weakCompareAndSet char value"); + assertEquals('\u0123', x, "failing weakCompareAndSet char value"); } // Compare set and get @@ -901,27 +899,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSet char"); + assertEquals('\u0123', o, "getAndSet char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "getAndSet char value"); + assertEquals('\u4567', x, "getAndSet char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSetAcquire char"); + assertEquals('\u0123', o, "getAndSetAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "getAndSetAcquire char value"); + assertEquals('\u4567', x, "getAndSetAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndSetRelease char"); + assertEquals('\u0123', o, "getAndSetRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, '\u4567', "getAndSetRelease char value"); + assertEquals('\u4567', x, "getAndSetRelease char value"); } // get and add, add and get @@ -929,27 +927,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAdd char"); + assertEquals('\u0123', o, "getAndAdd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAdd char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAddAcquire char"); + assertEquals('\u0123', o, "getAndAddAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndAddRelease char"); + assertEquals('\u0123', o, "getAndAddRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value"); + assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value"); } // get and bitwise or @@ -957,27 +955,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOr char"); + assertEquals('\u0123', o, "getAndBitwiseOr char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseOrAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseOrRelease char"); + assertEquals('\u0123', o, "getAndBitwiseOrRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value"); + assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value"); } // get and bitwise and @@ -985,27 +983,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAnd char"); + assertEquals('\u0123', o, "getAndBitwiseAnd char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseAndAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseAndRelease char"); + assertEquals('\u0123', o, "getAndBitwiseAndRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value"); + assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value"); } // get and bitwise xor @@ -1013,27 +1011,27 @@ public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXor char"); + assertEquals('\u0123', o, "getAndBitwiseXor char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char"); + assertEquals('\u0123', o, "getAndBitwiseXorAcquire char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123'); char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, '\u4567'); - assertEquals(o, '\u0123', "getAndBitwiseXorRelease char"); + assertEquals('\u0123', o, "getAndBitwiseXorRelease char"); char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value"); + assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessDouble.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessDouble.java index fe0455d2375..056d45478ed 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessDouble.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessDouble.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessDouble + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessDouble */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { static final double static_final_v = 1.0d; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessDouble.class, "final_v", double.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(double[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessDouble recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0d); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "set double value"); + assertEquals(1.0d, x, "set double value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, 2.0d); double x = (double) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, 1.0d); double x = (double) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, 2.0d); double x = (double) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } hs.get(TestAccessMode.SET).invokeExact(recv, 1.0d); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "failing weakCompareAndSetRelease double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetRelease double value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "success weakCompareAndSet double"); + assertEquals(1.0d, x, "success weakCompareAndSet double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0d, "failing weakCompareAndSet double value"); + assertEquals(1.0d, x, "failing weakCompareAndSet double value"); } // Compare set and get { double o = (double) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, 2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, 2.0d); - assertEquals(o, 1.0d, "getAndAddRelease double"); + assertEquals(1.0d, o, "getAndAddRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } @@ -340,7 +338,7 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(1.0d); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "set double value"); + assertEquals(1.0d, x, "set double value"); } @@ -348,21 +346,21 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(2.0d); double x = (double) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(1.0d); double x = (double) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(2.0d); double x = (double) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } hs.get(TestAccessMode.SET).invokeExact(1.0d); @@ -372,56 +370,56 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -433,14 +431,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -452,7 +450,7 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { @@ -460,7 +458,7 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact(2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -472,14 +470,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "failing weakCompareAndSetRelease double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetRelease double value"); } { @@ -491,14 +489,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "success weakCompareAndSet double"); + assertEquals(1.0d, x, "success weakCompareAndSet double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0d, "failing weakCompareAndSetRe double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetRe double value"); } // Compare set and get @@ -506,9 +504,9 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } // Compare set and get @@ -516,9 +514,9 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndSetAcquire double"); + assertEquals(1.0d, o, "getAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "getAndSetAcquire double value"); + assertEquals(2.0d, x, "getAndSetAcquire double value"); } // Compare set and get @@ -526,9 +524,9 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndSetRelease double"); + assertEquals(1.0d, o, "getAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0d, "getAndSetRelease double value"); + assertEquals(2.0d, x, "getAndSetRelease double value"); } // get and add, add and get @@ -536,27 +534,27 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { hs.get(TestAccessMode.SET).invokeExact(1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(2.0d); - assertEquals(o, 1.0d, "getAndAddRelease double"); + assertEquals(1.0d, o, "getAndAddRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } @@ -580,7 +578,7 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "get double value"); + assertEquals(1.0d, x, "get double value"); } @@ -588,21 +586,21 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 2.0d); double x = (double) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, 2.0d, "setVolatile double value"); + assertEquals(2.0d, x, "setVolatile double value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 1.0d); double x = (double) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, 1.0d, "setRelease double value"); + assertEquals(1.0d, x, "setRelease double value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 2.0d); double x = (double) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, 2.0d, "setOpaque double value"); + assertEquals(2.0d, x, "setOpaque double value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); @@ -612,56 +610,56 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 1.0d, 2.0d); assertEquals(r, true, "success compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "success compareAndSet double value"); + assertEquals(2.0d, x, "success compareAndSet double value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 1.0d, 3.0d); assertEquals(r, false, "failing compareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "failing compareAndSet double value"); + assertEquals(2.0d, x, "failing compareAndSet double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "success compareAndExchange double value"); + assertEquals(1.0d, x, "success compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchange double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "failing compareAndExchange double value"); + assertEquals(1.0d, x, "failing compareAndExchange double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 1.0d, 2.0d); assertEquals(r, 1.0d, "success compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "success compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 1.0d, 3.0d); assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value"); + assertEquals(2.0d, x, "failing compareAndExchangeAcquire double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 2.0d, 1.0d); assertEquals(r, 2.0d, "success compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "success compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "success compareAndExchangeRelease double value"); } { double r = (double) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 2.0d, 3.0d); assertEquals(r, 1.0d, "failing compareAndExchangeRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value"); + assertEquals(1.0d, x, "failing compareAndExchangeRelease double value"); } { @@ -673,14 +671,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "success weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "success weakCompareAndSetPlain double value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetPlain double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "failing weakCompareAndSetPlain double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetPlain double value"); } { @@ -692,14 +690,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "success weakCompareAndSetAcquire double"); + assertEquals(1.0d, x, "success weakCompareAndSetAcquire double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(1.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -711,14 +709,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "success weakCompareAndSetRelease double"); + assertEquals(2.0d, x, "success weakCompareAndSetRelease double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 1.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "failing weakCompareAndSetAcquire double value"); + assertEquals(2.0d, x, "failing weakCompareAndSetAcquire double value"); } { @@ -730,14 +728,14 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "success weakCompareAndSet double"); + assertEquals(1.0d, x, "success weakCompareAndSet double"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 2.0d, 3.0d); assertEquals(success, false, "failing weakCompareAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0d, "failing weakCompareAndSet double value"); + assertEquals(1.0d, x, "failing weakCompareAndSet double value"); } // Compare set and get @@ -745,27 +743,27 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSet double"); + assertEquals(1.0d, o, "getAndSet double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "getAndSet double value"); + assertEquals(2.0d, x, "getAndSet double value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSetAcquire double"); + assertEquals(1.0d, o, "getAndSetAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "getAndSetAcquire double value"); + assertEquals(2.0d, x, "getAndSetAcquire double value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndSetRelease double"); + assertEquals(1.0d, o, "getAndSetRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0d, "getAndSetRelease double value"); + assertEquals(2.0d, x, "getAndSetRelease double value"); } // get and add, add and get @@ -773,27 +771,27 @@ public class VarHandleTestMethodHandleAccessDouble extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAdd double"); + assertEquals(1.0d, o, "getAndAdd double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAdd double value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAddAcquire double"); + assertEquals(1.0d, o, "getAndAddAcquire double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddAcquire double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddAcquire double value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0d); double o = (double) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, 2.0d); - assertEquals(o, 1.0d, "getAndAddRelease double"); + assertEquals(1.0d, o, "getAndAddRelease double"); double x = (double) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (double)(1.0d + 2.0d), "getAndAddRelease double value"); + assertEquals((double)(1.0d + 2.0d), x, "getAndAddRelease double value"); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessFloat.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessFloat.java index 256e4723eec..98eb72301cb 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessFloat.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessFloat.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessFloat + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessFloat */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { static final float static_final_v = 1.0f; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessFloat.class, "final_v", float.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(float[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessFloat recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0f); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "set float value"); + assertEquals(1.0f, x, "set float value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, 2.0f); float x = (float) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, 1.0f); float x = (float) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, 2.0f); float x = (float) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } hs.get(TestAccessMode.SET).invokeExact(recv, 1.0f); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "failing weakCompareAndSetRelease float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetRelease float value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "success weakCompareAndSet float"); + assertEquals(1.0f, x, "success weakCompareAndSet float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 1.0f, "failing weakCompareAndSet float value"); + assertEquals(1.0f, x, "failing weakCompareAndSet float value"); } // Compare set and get { float o = (float) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, 2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, 2.0f); - assertEquals(o, 1.0f, "getAndAddRelease float"); + assertEquals(1.0f, o, "getAndAddRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } @@ -340,7 +338,7 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(1.0f); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "set float value"); + assertEquals(1.0f, x, "set float value"); } @@ -348,21 +346,21 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(2.0f); float x = (float) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(1.0f); float x = (float) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(2.0f); float x = (float) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } hs.get(TestAccessMode.SET).invokeExact(1.0f); @@ -372,56 +370,56 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -433,14 +431,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -452,7 +450,7 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { @@ -460,7 +458,7 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact(2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -472,14 +470,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "failing weakCompareAndSetRelease float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetRelease float value"); } { @@ -491,14 +489,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "success weakCompareAndSet float"); + assertEquals(1.0f, x, "success weakCompareAndSet float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 1.0f, "failing weakCompareAndSetRe float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetRe float value"); } // Compare set and get @@ -506,9 +504,9 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } // Compare set and get @@ -516,9 +514,9 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndSetAcquire float"); + assertEquals(1.0f, o, "getAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "getAndSetAcquire float value"); + assertEquals(2.0f, x, "getAndSetAcquire float value"); } // Compare set and get @@ -526,9 +524,9 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndSetRelease float"); + assertEquals(1.0f, o, "getAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 2.0f, "getAndSetRelease float value"); + assertEquals(2.0f, x, "getAndSetRelease float value"); } // get and add, add and get @@ -536,27 +534,27 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { hs.get(TestAccessMode.SET).invokeExact(1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(2.0f); - assertEquals(o, 1.0f, "getAndAddRelease float"); + assertEquals(1.0f, o, "getAndAddRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } @@ -580,7 +578,7 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "get float value"); + assertEquals(1.0f, x, "get float value"); } @@ -588,21 +586,21 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 2.0f); float x = (float) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, 2.0f, "setVolatile float value"); + assertEquals(2.0f, x, "setVolatile float value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 1.0f); float x = (float) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, 1.0f, "setRelease float value"); + assertEquals(1.0f, x, "setRelease float value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 2.0f); float x = (float) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, 2.0f, "setOpaque float value"); + assertEquals(2.0f, x, "setOpaque float value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); @@ -612,56 +610,56 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 1.0f, 2.0f); assertEquals(r, true, "success compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "success compareAndSet float value"); + assertEquals(2.0f, x, "success compareAndSet float value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 1.0f, 3.0f); assertEquals(r, false, "failing compareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "failing compareAndSet float value"); + assertEquals(2.0f, x, "failing compareAndSet float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "success compareAndExchange float value"); + assertEquals(1.0f, x, "success compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchange float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "failing compareAndExchange float value"); + assertEquals(1.0f, x, "failing compareAndExchange float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 1.0f, 2.0f); assertEquals(r, 1.0f, "success compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "success compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 1.0f, 3.0f); assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value"); + assertEquals(2.0f, x, "failing compareAndExchangeAcquire float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 2.0f, 1.0f); assertEquals(r, 2.0f, "success compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "success compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "success compareAndExchangeRelease float value"); } { float r = (float) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 2.0f, 3.0f); assertEquals(r, 1.0f, "failing compareAndExchangeRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value"); + assertEquals(1.0f, x, "failing compareAndExchangeRelease float value"); } { @@ -673,14 +671,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "success weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "success weakCompareAndSetPlain float value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetPlain float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "failing weakCompareAndSetPlain float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetPlain float value"); } { @@ -692,14 +690,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "success weakCompareAndSetAcquire float"); + assertEquals(1.0f, x, "success weakCompareAndSetAcquire float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(1.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -711,14 +709,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "success weakCompareAndSetRelease float"); + assertEquals(2.0f, x, "success weakCompareAndSetRelease float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 1.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "failing weakCompareAndSetAcquire float value"); + assertEquals(2.0f, x, "failing weakCompareAndSetAcquire float value"); } { @@ -730,14 +728,14 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "success weakCompareAndSet float"); + assertEquals(1.0f, x, "success weakCompareAndSet float"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 2.0f, 3.0f); assertEquals(success, false, "failing weakCompareAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 1.0f, "failing weakCompareAndSet float value"); + assertEquals(1.0f, x, "failing weakCompareAndSet float value"); } // Compare set and get @@ -745,27 +743,27 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSet float"); + assertEquals(1.0f, o, "getAndSet float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "getAndSet float value"); + assertEquals(2.0f, x, "getAndSet float value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSetAcquire float"); + assertEquals(1.0f, o, "getAndSetAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "getAndSetAcquire float value"); + assertEquals(2.0f, x, "getAndSetAcquire float value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndSetRelease float"); + assertEquals(1.0f, o, "getAndSetRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 2.0f, "getAndSetRelease float value"); + assertEquals(2.0f, x, "getAndSetRelease float value"); } // get and add, add and get @@ -773,27 +771,27 @@ public class VarHandleTestMethodHandleAccessFloat extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAdd float"); + assertEquals(1.0f, o, "getAndAdd float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAdd float value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAddAcquire float"); + assertEquals(1.0f, o, "getAndAddAcquire float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddAcquire float value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 1.0f); float o = (float) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, 2.0f); - assertEquals(o, 1.0f, "getAndAddRelease float"); + assertEquals(1.0f, o, "getAndAddRelease float"); float x = (float) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value"); + assertEquals((float)(1.0f + 2.0f), x, "getAndAddRelease float value"); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessInt.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessInt.java index d8558e0b070..920d8453bab 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessInt.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessInt.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessInt + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessInt */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { static final int static_final_v = 0x01234567; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessInt.class, "final_v", int.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(int[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessInt recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "set int value"); + assertEquals(0x01234567, x, "set int value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, 0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, 0x01234567); int x = (int) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, 0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetRelease int value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "success weakCompareAndSet int"); + assertEquals(0x01234567, x, "success weakCompareAndSet int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x01234567, "failing weakCompareAndSet int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSet int value"); } // Compare set and get { int o = (int) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddRelease int"); + assertEquals(0x01234567, o, "getAndAddRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -327,27 +325,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -355,27 +353,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -383,27 +381,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "set int value"); + assertEquals(0x01234567, x, "set int value"); } @@ -426,21 +424,21 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(0x01234567); int x = (int) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } hs.get(TestAccessMode.SET).invokeExact(0x01234567); @@ -450,56 +448,56 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -511,14 +509,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -530,7 +528,7 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { @@ -538,7 +536,7 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact(0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -550,14 +548,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetRelease int value"); } { @@ -569,14 +567,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "success weakCompareAndSet int"); + assertEquals(0x01234567, x, "success weakCompareAndSet int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x01234567, "failing weakCompareAndSetRe int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetRe int value"); } // Compare set and get @@ -584,9 +582,9 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } // Compare set and get @@ -594,9 +592,9 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetAcquire int"); + assertEquals(0x01234567, o, "getAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "getAndSetAcquire int value"); } // Compare set and get @@ -604,9 +602,9 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetRelease int"); + assertEquals(0x01234567, o, "getAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "getAndSetRelease int value"); } // get and add, add and get @@ -614,27 +612,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddRelease int"); + assertEquals(0x01234567, o, "getAndAddRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -642,27 +640,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -670,27 +668,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -698,27 +696,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } @@ -736,7 +734,7 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "get int value"); + assertEquals(0x01234567, x, "get int value"); } @@ -744,21 +742,21 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "setVolatile int value"); + assertEquals(0x89ABCDEF, x, "setVolatile int value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 0x01234567); int x = (int) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, 0x01234567, "setRelease int value"); + assertEquals(0x01234567, x, "setRelease int value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 0x89ABCDEF); int x = (int) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "setOpaque int value"); + assertEquals(0x89ABCDEF, x, "setOpaque int value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); @@ -768,56 +766,56 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 0x01234567, 0x89ABCDEF); assertEquals(r, true, "success compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "success compareAndSet int value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 0x01234567, 0xCAFEBABE); assertEquals(r, false, "failing compareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndSet int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "success compareAndExchange int value"); + assertEquals(0x01234567, x, "success compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchange int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "failing compareAndExchange int value"); + assertEquals(0x01234567, x, "failing compareAndExchange int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 0x01234567, 0x89ABCDEF); assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "success compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 0x01234567, 0xCAFEBABE); assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing compareAndExchangeAcquire int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 0x89ABCDEF, 0x01234567); assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "success compareAndExchangeRelease int value"); } { int r = (int) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); + assertEquals(0x01234567, x, "failing compareAndExchangeRelease int value"); } { @@ -829,14 +827,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetPlain int value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetPlain int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetPlain int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetPlain int value"); } { @@ -848,14 +846,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "success weakCompareAndSetAcquire int"); + assertEquals(0x01234567, x, "success weakCompareAndSetAcquire int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSetAcquire int value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "success weakCompareAndSetRelease int"); + assertEquals(0x89ABCDEF, x, "success weakCompareAndSetRelease int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 0x01234567, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "failing weakCompareAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "failing weakCompareAndSetAcquire int value"); } { @@ -886,14 +884,14 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "success weakCompareAndSet int"); + assertEquals(0x01234567, x, "success weakCompareAndSet int"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 0x89ABCDEF, 0xCAFEBABE); assertEquals(success, false, "failing weakCompareAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x01234567, "failing weakCompareAndSet int value"); + assertEquals(0x01234567, x, "failing weakCompareAndSet int value"); } // Compare set and get @@ -901,27 +899,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSet int"); + assertEquals(0x01234567, o, "getAndSet int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSet int value"); + assertEquals(0x89ABCDEF, x, "getAndSet int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetAcquire int"); + assertEquals(0x01234567, o, "getAndSetAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); + assertEquals(0x89ABCDEF, x, "getAndSetAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndSetRelease int"); + assertEquals(0x01234567, o, "getAndSetRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); + assertEquals(0x89ABCDEF, x, "getAndSetRelease int value"); } // get and add, add and get @@ -929,27 +927,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAdd int"); + assertEquals(0x01234567, o, "getAndAdd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAdd int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddAcquire int"); + assertEquals(0x01234567, o, "getAndAddAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndAddRelease int"); + assertEquals(0x01234567, o, "getAndAddRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); + assertEquals((int)(0x01234567 + 0x89ABCDEF), x, "getAndAddRelease int value"); } // get and bitwise or @@ -957,27 +955,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOr int"); + assertEquals(0x01234567, o, "getAndBitwiseOr int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOr int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseOrAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseOrRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); + assertEquals((int)(0x01234567 | 0x89ABCDEF), x, "getAndBitwiseOrRelease int value"); } // get and bitwise and @@ -985,27 +983,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); + assertEquals(0x01234567, o, "getAndBitwiseAnd int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAnd int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseAndAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseAndRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); + assertEquals((int)(0x01234567 & 0x89ABCDEF), x, "getAndBitwiseAndRelease int value"); } // get and bitwise xor @@ -1013,27 +1011,27 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXor int"); + assertEquals(0x01234567, o, "getAndBitwiseXor int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXor int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); + assertEquals(0x01234567, o, "getAndBitwiseXorAcquire int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorAcquire int value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567); int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, 0x89ABCDEF); - assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); + assertEquals(0x01234567, o, "getAndBitwiseXorRelease int"); int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); + assertEquals((int)(0x01234567 ^ 0x89ABCDEF), x, "getAndBitwiseXorRelease int value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessLong.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessLong.java index 0e73063395d..90f6dd12c47 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessLong.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessLong.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessLong + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessLong */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { static final long static_final_v = 0x0123456789ABCDEFL; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessLong.class, "final_v", long.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(long[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessLong recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "set long value"); + assertEquals(0x0123456789ABCDEFL, x, "set long value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, 0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, 0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, 0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetRelease long value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSet long value"); } // Compare set and get { long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -327,27 +325,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -355,27 +353,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -383,27 +381,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "set long value"); + assertEquals(0x0123456789ABCDEFL, x, "set long value"); } @@ -426,21 +424,21 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); @@ -450,56 +448,56 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -511,14 +509,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -530,7 +528,7 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { @@ -538,7 +536,7 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -550,14 +548,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetRelease long value"); } { @@ -569,14 +567,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetRe long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetRe long value"); } // Compare set and get @@ -584,9 +582,9 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } // Compare set and get @@ -594,9 +592,9 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetAcquire long value"); } // Compare set and get @@ -604,9 +602,9 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetRelease long value"); } // get and add, add and get @@ -614,27 +612,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -642,27 +640,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -670,27 +668,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -698,27 +696,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } @@ -736,7 +734,7 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "get long value"); + assertEquals(0x0123456789ABCDEFL, x, "get long value"); } @@ -744,21 +742,21 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setVolatile long value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 0x0123456789ABCDEFL); long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "setRelease long value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "setOpaque long value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); @@ -768,56 +766,56 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, true, "success compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndSet long value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, false, "failing compareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndSet long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchange long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL); assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing compareAndExchangeAcquire long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL); assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "success compareAndExchangeRelease long value"); } { long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing compareAndExchangeRelease long value"); } { @@ -829,14 +827,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetPlain long value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetPlain long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetPlain long value"); } { @@ -848,14 +846,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSetAcquire long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long"); + assertEquals(0xCAFEBABECAFEBABEL, x, "success weakCompareAndSetRelease long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "failing weakCompareAndSetAcquire long value"); } { @@ -886,14 +884,14 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long"); + assertEquals(0x0123456789ABCDEFL, x, "success weakCompareAndSet long"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL); assertEquals(success, false, "failing weakCompareAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value"); + assertEquals(0x0123456789ABCDEFL, x, "failing weakCompareAndSet long value"); } // Compare set and get @@ -901,27 +899,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSet long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSet long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndSetRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value"); + assertEquals(0xCAFEBABECAFEBABEL, x, "getAndSetRelease long value"); } // get and add, add and get @@ -929,27 +927,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAdd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAdd long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndAddRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndAddRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), x, "getAndAddRelease long value"); } // get and bitwise or @@ -957,27 +955,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOr long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOr long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseOrRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), x, "getAndBitwiseOrRelease long value"); } // get and bitwise and @@ -985,27 +983,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAnd long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAnd long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseAndRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), x, "getAndBitwiseAndRelease long value"); } // get and bitwise xor @@ -1013,27 +1011,27 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXor long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXor long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorAcquire long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorAcquire long value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL); long o = (long) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL); - assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long"); + assertEquals(0x0123456789ABCDEFL, o, "getAndBitwiseXorRelease long"); long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value"); + assertEquals((long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), x, "getAndBitwiseXorRelease long value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessShort.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessShort.java index 8fb23d7dc55..d8f548fe2d6 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessShort.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessShort.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessShort + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessShort */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { static final short static_final_v = (short)0x0123; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessShort.class, "final_v", short.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(short[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessShort recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "set short value"); + assertEquals((short)0x0123, x, "set short value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, (short)0x4567); short x = (short) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, (short)0x0123); short x = (short) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, (short)0x4567); short x = (short) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, (short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, (short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, (short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, (short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetRelease short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetRelease short value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x0123, "failing weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSet short value"); } // Compare set and get { short o = (short) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } // get and add, add and get @@ -299,27 +297,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddRelease short"); + assertEquals((short)0x0123, o, "getAndAddRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -327,27 +325,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -355,27 +353,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -383,27 +381,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } @@ -418,7 +416,7 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "set short value"); + assertEquals((short)0x0123, x, "set short value"); } @@ -426,21 +424,21 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact((short)0x4567); short x = (short) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact((short)0x0123); short x = (short) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact((short)0x4567); short x = (short) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } hs.get(TestAccessMode.SET).invokeExact((short)0x0123); @@ -450,56 +448,56 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact((short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact((short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact((short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact((short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact((short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact((short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact((short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact((short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -511,14 +509,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact((short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -530,7 +528,7 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { @@ -538,7 +536,7 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact((short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -550,14 +548,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact((short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetRelease short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetRelease short value"); } { @@ -569,14 +567,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact((short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetRe short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetRe short value"); } // Compare set and get @@ -584,9 +582,9 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } // Compare set and get @@ -594,9 +592,9 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetAcquire short"); + assertEquals((short)0x0123, o, "getAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "getAndSetAcquire short value"); + assertEquals((short)0x4567, x, "getAndSetAcquire short value"); } // Compare set and get @@ -604,9 +602,9 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetRelease short"); + assertEquals((short)0x0123, o, "getAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)0x4567, "getAndSetRelease short value"); + assertEquals((short)0x4567, x, "getAndSetRelease short value"); } // get and add, add and get @@ -614,27 +612,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddRelease short"); + assertEquals((short)0x0123, o, "getAndAddRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -642,27 +640,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -670,27 +668,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -698,27 +696,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact((short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact((short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } @@ -736,7 +734,7 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "get short value"); + assertEquals((short)0x0123, x, "get short value"); } @@ -744,21 +742,21 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, (short)0x4567); short x = (short) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, (short)0x4567, "setVolatile short value"); + assertEquals((short)0x4567, x, "setVolatile short value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, (short)0x0123); short x = (short) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, (short)0x0123, "setRelease short value"); + assertEquals((short)0x0123, x, "setRelease short value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, (short)0x4567); short x = (short) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, (short)0x4567, "setOpaque short value"); + assertEquals((short)0x4567, x, "setOpaque short value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); @@ -768,56 +766,56 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, (short)0x0123, (short)0x4567); assertEquals(r, true, "success compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "success compareAndSet short value"); + assertEquals((short)0x4567, x, "success compareAndSet short value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, (short)0x0123, (short)0x89AB); assertEquals(r, false, "failing compareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "failing compareAndSet short value"); + assertEquals((short)0x4567, x, "failing compareAndSet short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "success compareAndExchange short value"); + assertEquals((short)0x0123, x, "success compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchange short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "failing compareAndExchange short value"); + assertEquals((short)0x0123, x, "failing compareAndExchange short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, (short)0x0123, (short)0x4567); assertEquals(r, (short)0x0123, "success compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "success compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "success compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, (short)0x0123, (short)0x89AB); assertEquals(r, (short)0x4567, "failing compareAndExchangeAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "failing compareAndExchangeAcquire short value"); + assertEquals((short)0x4567, x, "failing compareAndExchangeAcquire short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, (short)0x4567, (short)0x0123); assertEquals(r, (short)0x4567, "success compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "success compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "success compareAndExchangeRelease short value"); } { short r = (short) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, (short)0x4567, (short)0x89AB); assertEquals(r, (short)0x0123, "failing compareAndExchangeRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "failing compareAndExchangeRelease short value"); + assertEquals((short)0x0123, x, "failing compareAndExchangeRelease short value"); } { @@ -829,14 +827,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "success weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "success weakCompareAndSetPlain short value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetPlain short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetPlain short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetPlain short value"); } { @@ -848,14 +846,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "success weakCompareAndSetAcquire short"); + assertEquals((short)0x0123, x, "success weakCompareAndSetAcquire short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSetAcquire short value"); } { @@ -867,14 +865,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "success weakCompareAndSetRelease short"); + assertEquals((short)0x4567, x, "success weakCompareAndSetRelease short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, (short)0x0123, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "failing weakCompareAndSetAcquire short value"); + assertEquals((short)0x4567, x, "failing weakCompareAndSetAcquire short value"); } { @@ -886,14 +884,14 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "success weakCompareAndSet short"); + assertEquals((short)0x0123, x, "success weakCompareAndSet short"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, (short)0x4567, (short)0x89AB); assertEquals(success, false, "failing weakCompareAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x0123, "failing weakCompareAndSet short value"); + assertEquals((short)0x0123, x, "failing weakCompareAndSet short value"); } // Compare set and get @@ -901,27 +899,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSet short"); + assertEquals((short)0x0123, o, "getAndSet short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "getAndSet short value"); + assertEquals((short)0x4567, x, "getAndSet short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetAcquire short"); + assertEquals((short)0x0123, o, "getAndSetAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "getAndSetAcquire short value"); + assertEquals((short)0x4567, x, "getAndSetAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndSetRelease short"); + assertEquals((short)0x0123, o, "getAndSetRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)0x4567, "getAndSetRelease short value"); + assertEquals((short)0x4567, x, "getAndSetRelease short value"); } // get and add, add and get @@ -929,27 +927,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAdd short"); + assertEquals((short)0x0123, o, "getAndAdd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAdd short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAdd short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddAcquire short"); + assertEquals((short)0x0123, o, "getAndAddAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddAcquire short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndAddRelease short"); + assertEquals((short)0x0123, o, "getAndAddRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 + (short)0x4567), "getAndAddRelease short value"); + assertEquals((short)((short)0x0123 + (short)0x4567), x, "getAndAddRelease short value"); } // get and bitwise or @@ -957,27 +955,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOr short"); + assertEquals((short)0x0123, o, "getAndBitwiseOr short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOr short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOr short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrAcquire short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseOrRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseOrRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 | (short)0x4567), "getAndBitwiseOrRelease short value"); + assertEquals((short)((short)0x0123 | (short)0x4567), x, "getAndBitwiseOrRelease short value"); } // get and bitwise and @@ -985,27 +983,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAnd short"); + assertEquals((short)0x0123, o, "getAndBitwiseAnd short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAnd short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAnd short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndAcquire short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseAndRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseAndRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 & (short)0x4567), "getAndBitwiseAndRelease short value"); + assertEquals((short)((short)0x0123 & (short)0x4567), x, "getAndBitwiseAndRelease short value"); } // get and bitwise xor @@ -1013,27 +1011,27 @@ public class VarHandleTestMethodHandleAccessShort extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXor short"); + assertEquals((short)0x0123, o, "getAndBitwiseXor short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXor short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXor short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorAcquire short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorAcquire short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorAcquire short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorAcquire short value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, (short)0x0123); short o = (short) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, (short)0x4567); - assertEquals(o, (short)0x0123, "getAndBitwiseXorRelease short"); + assertEquals((short)0x0123, o, "getAndBitwiseXorRelease short"); short x = (short) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, (short)((short)0x0123 ^ (short)0x4567), "getAndBitwiseXorRelease short value"); + assertEquals((short)((short)0x0123 ^ (short)0x4567), x, "getAndBitwiseXorRelease short value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessString.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessString.java index 8ccede760c9..35723f63d27 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessString.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessString.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessString + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessString */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { static final String static_final_v = "foo"; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccessString.class, "final_v", String.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(String[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, "foo"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "set String value"); + assertEquals("foo", x, "set String value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, "bar"); String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, "foo"); String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, "bar"); String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } hs.get(TestAccessMode.SET).invokeExact(recv, "foo"); @@ -158,56 +156,56 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, "foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, "foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, "foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, "foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -219,14 +217,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -238,14 +236,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -257,14 +255,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "failing weakCompareAndSetRelease String value"); + assertEquals("bar", x, "failing weakCompareAndSetRelease String value"); } { @@ -276,22 +274,22 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "success weakCompareAndSet String"); + assertEquals("foo", x, "success weakCompareAndSet String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "foo", "failing weakCompareAndSet String value"); + assertEquals("foo", x, "failing weakCompareAndSet String value"); } // Compare set and get { String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, "bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } @@ -318,7 +316,7 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact("foo"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "set String value"); + assertEquals("foo", x, "set String value"); } @@ -326,21 +324,21 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact("bar"); String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact("foo"); String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact("bar"); String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } hs.get(TestAccessMode.SET).invokeExact("foo"); @@ -350,56 +348,56 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact("foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact("foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact("bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact("bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact("foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact("foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact("bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact("bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -411,14 +409,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact("foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -430,7 +428,7 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { @@ -438,7 +436,7 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact("bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -450,14 +448,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact("foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "failing weakCompareAndSetRelease String value"); + assertEquals("bar", x, "failing weakCompareAndSetRelease String value"); } { @@ -469,14 +467,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "success weakCompareAndSet String"); + assertEquals("foo", x, "success weakCompareAndSet String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact("bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "foo", "failing weakCompareAndSetRe String value"); + assertEquals("foo", x, "failing weakCompareAndSetRe String value"); } // Compare set and get @@ -484,9 +482,9 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact("foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact("bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } // Compare set and get @@ -494,9 +492,9 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact("foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact("bar"); - assertEquals(o, "foo", "getAndSetAcquire String"); + assertEquals("foo", o, "getAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "getAndSetAcquire String value"); + assertEquals("bar", x, "getAndSetAcquire String value"); } // Compare set and get @@ -504,9 +502,9 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact("foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact("bar"); - assertEquals(o, "foo", "getAndSetRelease String"); + assertEquals("foo", o, "getAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, "bar", "getAndSetRelease String value"); + assertEquals("bar", x, "getAndSetRelease String value"); } @@ -536,7 +534,7 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "get String value"); + assertEquals("foo", x, "get String value"); } @@ -544,21 +542,21 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, "bar"); String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, "bar", "setVolatile String value"); + assertEquals("bar", x, "setVolatile String value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, "foo"); String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, "foo", "setRelease String value"); + assertEquals("foo", x, "setRelease String value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, "bar"); String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, "bar", "setOpaque String value"); + assertEquals("bar", x, "setOpaque String value"); } hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); @@ -568,56 +566,56 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, "foo", "bar"); assertEquals(r, true, "success compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "success compareAndSet String value"); + assertEquals("bar", x, "success compareAndSet String value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, "foo", "baz"); assertEquals(r, false, "failing compareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "failing compareAndSet String value"); + assertEquals("bar", x, "failing compareAndSet String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "success compareAndExchange String value"); + assertEquals("foo", x, "success compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchange String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "failing compareAndExchange String value"); + assertEquals("foo", x, "failing compareAndExchange String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, "foo", "bar"); assertEquals(r, "foo", "success compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); + assertEquals("bar", x, "success compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, "foo", "baz"); assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); + assertEquals("bar", x, "failing compareAndExchangeAcquire String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, "bar", "foo"); assertEquals(r, "bar", "success compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "success compareAndExchangeRelease String value"); + assertEquals("foo", x, "success compareAndExchangeRelease String value"); } { String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, "bar", "baz"); assertEquals(r, "foo", "failing compareAndExchangeRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); + assertEquals("foo", x, "failing compareAndExchangeRelease String value"); } { @@ -629,14 +627,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "success weakCompareAndSetPlain String value"); + assertEquals("bar", x, "success weakCompareAndSetPlain String value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetPlain String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "failing weakCompareAndSetPlain String value"); + assertEquals("bar", x, "failing weakCompareAndSetPlain String value"); } { @@ -648,14 +646,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "success weakCompareAndSetAcquire String"); + assertEquals("foo", x, "success weakCompareAndSetAcquire String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "failing weakCompareAndSetAcquire String value"); + assertEquals("foo", x, "failing weakCompareAndSetAcquire String value"); } { @@ -667,14 +665,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "success weakCompareAndSetRelease String"); + assertEquals("bar", x, "success weakCompareAndSetRelease String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, "foo", "baz"); assertEquals(success, false, "failing weakCompareAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "failing weakCompareAndSetAcquire String value"); + assertEquals("bar", x, "failing weakCompareAndSetAcquire String value"); } { @@ -686,14 +684,14 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "success weakCompareAndSet String"); + assertEquals("foo", x, "success weakCompareAndSet String"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, "bar", "baz"); assertEquals(success, false, "failing weakCompareAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "foo", "failing weakCompareAndSet String value"); + assertEquals("foo", x, "failing weakCompareAndSet String value"); } // Compare set and get @@ -701,27 +699,27 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, "bar"); - assertEquals(o, "foo", "getAndSet String"); + assertEquals("foo", o, "getAndSet String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "getAndSet String value"); + assertEquals("bar", x, "getAndSet String value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, "bar"); - assertEquals(o, "foo", "getAndSetAcquire String"); + assertEquals("foo", o, "getAndSetAcquire String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "getAndSetAcquire String value"); + assertEquals("bar", x, "getAndSetAcquire String value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); String o = (String) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, "bar"); - assertEquals(o, "foo", "getAndSetRelease String"); + assertEquals("foo", o, "getAndSetRelease String"); String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, "bar", "getAndSetRelease String value"); + assertEquals("bar", x, "getAndSetRelease String value"); } diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeBoolean.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeBoolean.java index eb6327d4c55..b10466a1fc7 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeBoolean.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeBoolean.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeBoolean - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeBoolean - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeBoolean - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeBoolean + * @run junit/othervm VarHandleTestMethodTypeBoolean + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeBoolean + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeBoolean + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeBoolean */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { static final boolean static_final_v = true; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeBoolean.class, "final_v", boolean.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(boolean[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeBoolean recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeByte.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeByte.java index 08b834699af..ce8686ebd74 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeByte.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeByte.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeByte - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeByte - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeByte - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeByte + * @run junit/othervm VarHandleTestMethodTypeByte + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeByte + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeByte + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeByte */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeByte extends VarHandleBaseTest { static final byte static_final_v = (byte)0x01; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeByte extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeByte.class, "final_v", byte.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeByte extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(byte[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeByte extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeByte extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeByte recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeChar.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeChar.java index 25aa62825b7..d89af7f212c 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeChar.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeChar.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeChar - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeChar - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeChar - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeChar + * @run junit/othervm VarHandleTestMethodTypeChar + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeChar + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeChar + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeChar */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeChar extends VarHandleBaseTest { static final char static_final_v = '\u0123'; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeChar extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeChar.class, "final_v", char.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeChar extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(char[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeChar extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeChar extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeChar recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeDouble.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeDouble.java index c3f8d22435b..0363a996ceb 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeDouble.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeDouble.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeDouble - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeDouble - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeDouble - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeDouble + * @run junit/othervm VarHandleTestMethodTypeDouble + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeDouble + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeDouble + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeDouble */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeDouble extends VarHandleBaseTest { static final double static_final_v = 1.0d; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeDouble extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeDouble.class, "final_v", double.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeDouble extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(double[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeDouble extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeDouble extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeDouble recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeFloat.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeFloat.java index 0d05270b3ac..c8b965e41df 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeFloat.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeFloat.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeFloat - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeFloat - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeFloat - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeFloat + * @run junit/othervm VarHandleTestMethodTypeFloat + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeFloat + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeFloat + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeFloat */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeFloat extends VarHandleBaseTest { static final float static_final_v = 1.0f; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeFloat extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeFloat.class, "final_v", float.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeFloat extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(float[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeFloat extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeFloat extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeFloat recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeInt.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeInt.java index a431c0a889e..e09427c55c7 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeInt.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeInt.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeInt - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeInt - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeInt - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeInt + * @run junit/othervm VarHandleTestMethodTypeInt + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeInt + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeInt + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeInt */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeInt extends VarHandleBaseTest { static final int static_final_v = 0x01234567; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeInt extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeInt.class, "final_v", int.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeInt extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(int[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeInt extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeInt extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeInt recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeLong.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeLong.java index 53b9257d700..5944e935877 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeLong.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeLong.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeLong - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeLong - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeLong - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeLong + * @run junit/othervm VarHandleTestMethodTypeLong + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeLong + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeLong + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeLong */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeLong extends VarHandleBaseTest { static final long static_final_v = 0x0123456789ABCDEFL; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeLong extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeLong.class, "final_v", long.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeLong extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(long[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeLong extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeLong extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeLong recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeShort.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeShort.java index 10dd5832c9b..fdb30ee88aa 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeShort.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeShort.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeShort - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeShort - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeShort - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeShort + * @run junit/othervm VarHandleTestMethodTypeShort + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeShort + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeShort + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeShort */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeShort extends VarHandleBaseTest { static final short static_final_v = (short)0x0123; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeShort extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeShort.class, "final_v", short.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeShort extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(short[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeShort extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeShort extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeShort recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeString.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeString.java index d823a21d69f..2a5284ca36e 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeString.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestMethodTypeString.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodTypeString - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeString - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeString - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeString + * @run junit/othervm VarHandleTestMethodTypeString + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeString + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeString + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeString */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodTypeString extends VarHandleBaseTest { static final String static_final_v = "foo"; @@ -63,7 +63,7 @@ public class VarHandleTestMethodTypeString extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodTypeString.class, "final_v", String.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodTypeString extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle(String[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodTypeString extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodTypeString extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeString recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestReflection.java b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestReflection.java index b20e18d263e..2c22fd5595b 100644 --- a/test/jdk/java/lang/invoke/VarHandles/VarHandleTestReflection.java +++ b/test/jdk/java/lang/invoke/VarHandles/VarHandleTestReflection.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,11 +23,9 @@ /* * @test - * @run testng VarHandleTestReflection + * @run junit VarHandleTestReflection */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandleInfo; @@ -36,11 +34,16 @@ import java.lang.invoke.VarHandle; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.stream.Stream; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import static org.junit.jupiter.api.Assertions.assertThrows; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestReflection extends VarHandleBaseTest { String string; - @DataProvider public static Object[][] accessModesProvider() { return Stream.of(VarHandle.AccessMode.values()). map(am -> new Object[]{am}). @@ -52,17 +55,19 @@ public class VarHandleTestReflection extends VarHandleBaseTest { findVarHandle(VarHandleTestReflection.class, "string", String.class); } - @Test(dataProvider = "accessModesProvider", expectedExceptions = IllegalArgumentException.class) + @ParameterizedTest + @MethodSource("accessModesProvider") public void methodInvocationArgumentMismatch(VarHandle.AccessMode accessMode) throws Exception { VarHandle v = handle(); // Try a reflective invoke using a Method, with no arguments Method vhm = VarHandle.class.getMethod(accessMode.methodName(), Object[].class); - vhm.invoke(v, new Object[]{}); + assertThrows(IllegalArgumentException.class, () -> vhm.invoke(v, new Object[]{})); } - @Test(dataProvider = "accessModesProvider") + @ParameterizedTest + @MethodSource("accessModesProvider") public void methodInvocationMatchingArguments(VarHandle.AccessMode accessMode) throws Exception { VarHandle v = handle(); @@ -70,17 +75,15 @@ public class VarHandleTestReflection extends VarHandleBaseTest { Method vhm = VarHandle.class.getMethod(accessMode.methodName(), Object[].class); Object arg = new Object[0]; - try { - vhm.invoke(v, arg); - } catch (InvocationTargetException e) { - if (!(e.getCause() instanceof UnsupportedOperationException)) { - throw new RuntimeException("expected UnsupportedOperationException but got: " - + e.getCause().getClass().getName(), e); - } + var e = assertThrows(InvocationTargetException.class, () -> vhm.invoke(v, arg)); + if (!(e.getCause() instanceof UnsupportedOperationException)) { + throw new RuntimeException("expected UnsupportedOperationException but got: " + + e.getCause().getClass().getName(), e); } } - @Test(dataProvider = "accessModesProvider", expectedExceptions = UnsupportedOperationException.class) + @ParameterizedTest + @MethodSource("accessModesProvider") public void methodHandleInvoke(VarHandle.AccessMode accessMode) throws Throwable { VarHandle v = handle(); @@ -90,10 +93,13 @@ public class VarHandleTestReflection extends VarHandleBaseTest { VarHandle.class.getMethod(accessMode.methodName(), Object[].class)); // Use invoke to avoid WrongMethodTypeException for // non-signature-polymorphic return types - Object o = (Object) mh.invoke(v, new Object[]{}); + assertThrows(UnsupportedOperationException.class, () -> { + Object o = (Object) mh.invoke(v, new Object[]{}); + }); } - @Test(dataProvider = "accessModesProvider", expectedExceptions = IllegalArgumentException.class) + @ParameterizedTest + @MethodSource("accessModesProvider") public void methodInvocationFromMethodInfo(VarHandle.AccessMode accessMode) throws Exception { VarHandle v = handle(); @@ -104,10 +110,13 @@ public class VarHandleTestReflection extends VarHandleBaseTest { VarHandle.class.getMethod(accessMode.methodName(), Object[].class)); MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh); Method im = info.reflectAs(Method.class, MethodHandles.lookup()); - im.invoke(v, new Object[]{}); + assertThrows(IllegalArgumentException.class, () -> { + im.invoke(v, new Object[]{}); + }); } - @Test(dataProvider = "accessModesProvider", expectedExceptions = IllegalArgumentException.class) + @ParameterizedTest + @MethodSource("accessModesProvider") public void reflectAsFromVarHandleInvoker(VarHandle.AccessMode accessMode) throws Exception { VarHandle v = handle(); @@ -116,10 +125,11 @@ public class VarHandleTestReflection extends VarHandleBaseTest { MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh); - info.reflectAs(Method.class, MethodHandles.lookup()); + assertThrows(IllegalArgumentException.class, () -> info.reflectAs(Method.class, MethodHandles.lookup())); } - @Test(dataProvider = "accessModesProvider", expectedExceptions = IllegalArgumentException.class) + @ParameterizedTest + @MethodSource("accessModesProvider") public void reflectAsFromFindVirtual(VarHandle.AccessMode accessMode) throws Exception { VarHandle v = handle(); @@ -128,6 +138,6 @@ public class VarHandleTestReflection extends VarHandleBaseTest { MethodHandleInfo info = MethodHandles.lookup().revealDirect(mh); - info.reflectAs(Method.class, MethodHandles.lookup()); + assertThrows(IllegalArgumentException.class, () -> info.reflectAs(Method.class, MethodHandles.lookup())); } } diff --git a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestAccess.java.template b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestAccess.java.template index f3c90c5e8cc..b18dbb6e1b0 100644 --- a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestAccess.java.template +++ b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestAccess.java.template @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,28 +23,30 @@ /* * @test - * @run testng/othervm -Diters=10 -Xint VarHandleTestAccess$Type$ + * @run junit/othervm -Diters=10 -Xint VarHandleTestAccess$Type$ * * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds * - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccess$Type$ - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccess$Type$ - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccess$Type$ + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccess$Type$ + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccess$Type$ + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccess$Type$ */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { static final $type$ static_final_v = $value1$; @@ -115,7 +117,7 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { return vhs.toArray(new VarHandle[0]); } - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestAccess$Type$.class, "final_v", $type$.class); @@ -135,8 +137,6 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { #end[String] } - - @DataProvider public Object[][] varHandlesProvider() throws Exception { List vhs = new ArrayList<>(); vhs.add(vhField); @@ -166,7 +166,8 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("varHandlesProvider") public void testIsAccessModeSupported(VarHandle vh) { assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET)); assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET)); @@ -236,8 +237,6 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { #end[Bitwise] } - - @DataProvider public Object[][] typesProvider() throws Exception { List types = new ArrayList<>(); types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccess$Type$.class)}); @@ -247,16 +246,16 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { return types.stream().toArray(Object[][]::new); } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), $type$.class); + assertEquals($type$.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - @Test public void testLookupInstanceToStatic() { checkIAE("Lookup of static final field to instance final field", () -> { @@ -283,8 +282,6 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { }); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -335,7 +332,8 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -348,26 +346,26 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { // Plain { $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "get $type$ value"); + assertEquals($value1$, x, "get $type$ value"); } // Volatile { $type$ x = ($type$) vh.getVolatile(recv); - assertEquals(x, $value1$, "getVolatile $type$ value"); + assertEquals($value1$, x, "getVolatile $type$ value"); } // Lazy { $type$ x = ($type$) vh.getAcquire(recv); - assertEquals(x, $value1$, "getRelease $type$ value"); + assertEquals($value1$, x, "getRelease $type$ value"); } // Opaque { $type$ x = ($type$) vh.getOpaque(recv); - assertEquals(x, $value1$, "getOpaque $type$ value"); + assertEquals($value1$, x, "getOpaque $type$ value"); } } @@ -492,26 +490,26 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { // Plain { $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "get $type$ value"); + assertEquals($value1$, x, "get $type$ value"); } // Volatile { $type$ x = ($type$) vh.getVolatile(); - assertEquals(x, $value1$, "getVolatile $type$ value"); + assertEquals($value1$, x, "getVolatile $type$ value"); } // Lazy { $type$ x = ($type$) vh.getAcquire(); - assertEquals(x, $value1$, "getRelease $type$ value"); + assertEquals($value1$, x, "getRelease $type$ value"); } // Opaque { $type$ x = ($type$) vh.getOpaque(); - assertEquals(x, $value1$, "getOpaque $type$ value"); + assertEquals($value1$, x, "getOpaque $type$ value"); } } @@ -637,7 +635,7 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.set(recv, $value1$); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "set $type$ value"); + assertEquals($value1$, x, "set $type$ value"); } @@ -645,21 +643,21 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.setVolatile(recv, $value2$); $type$ x = ($type$) vh.getVolatile(recv); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { vh.setRelease(recv, $value1$); $type$ x = ($type$) vh.getAcquire(recv); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { vh.setOpaque(recv, $value2$); $type$ x = ($type$) vh.getOpaque(recv); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -670,56 +668,56 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { boolean r = vh.compareAndSet(recv, $value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = vh.compareAndSet(recv, $value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(recv, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(recv, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(recv, $value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(recv, $value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(recv, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(recv, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -730,14 +728,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = vh.weakCompareAndSetPlain(recv, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -748,14 +746,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = vh.weakCompareAndSetAcquire(recv, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -766,14 +764,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = vh.weakCompareAndSetRelease(recv, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "failing weakCompareAndSetRelease $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -784,14 +782,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "success weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "success weakCompareAndSet $type$ value"); } { boolean success = vh.weakCompareAndSet(recv, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value1$, "failing weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get @@ -799,27 +797,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndSet(recv, $value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndSetAcquire(recv, $value2$); - assertEquals(o, $value1$, "getAndSetAcquire $type$"); + assertEquals($value1$, o, "getAndSetAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "getAndSetAcquire $type$ value"); + assertEquals($value2$, x, "getAndSetAcquire $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndSetRelease(recv, $value2$); - assertEquals(o, $value1$, "getAndSetRelease $type$"); + assertEquals($value1$, o, "getAndSetRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, $value2$, "getAndSetRelease $type$ value"); + assertEquals($value2$, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -829,27 +827,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndAdd(recv, $value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndAddAcquire(recv, $value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndAddRelease(recv, $value2$); - assertEquals(o, $value1$, "getAndAddRelease$type$"); + assertEquals($value1$, o, "getAndAddRelease$type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -859,27 +857,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseOr(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseOrAcquire(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseOrRelease(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -887,27 +885,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseAnd(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseAndAcquire(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseAndRelease(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -915,27 +913,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseXor(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseXorAcquire(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { vh.set(recv, $value1$); $type$ o = ($type$) vh.getAndBitwiseXorRelease(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) vh.get(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } @@ -1046,7 +1044,7 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.set($value1$); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "set $type$ value"); + assertEquals($value1$, x, "set $type$ value"); } @@ -1054,21 +1052,21 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.setVolatile($value2$); $type$ x = ($type$) vh.getVolatile(); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { vh.setRelease($value1$); $type$ x = ($type$) vh.getAcquire(); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { vh.setOpaque($value2$); $type$ x = ($type$) vh.getOpaque(); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -1079,56 +1077,56 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { boolean r = vh.compareAndSet($value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = vh.compareAndSet($value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange($value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange($value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire($value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire($value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease($value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease($value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -1139,14 +1137,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = vh.weakCompareAndSetPlain($value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -1157,14 +1155,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = vh.weakCompareAndSetAcquire($value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -1175,14 +1173,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = vh.weakCompareAndSetRelease($value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "failing weakCompareAndSetRelease $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -1193,14 +1191,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "success weakCompareAndSet $type$"); + assertEquals($value1$, x, "success weakCompareAndSet $type$"); } { boolean success = vh.weakCompareAndSet($value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value1$, "failing weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get @@ -1208,27 +1206,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set($value1$); $type$ o = ($type$) vh.getAndSet($value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndSetAcquire($value2$); - assertEquals(o, $value1$, "getAndSetAcquire $type$"); + assertEquals($value1$, o, "getAndSetAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "getAndSetAcquire $type$ value"); + assertEquals($value2$, x, "getAndSetAcquire $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndSetRelease($value2$); - assertEquals(o, $value1$, "getAndSetRelease $type$"); + assertEquals($value1$, o, "getAndSetRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, $value2$, "getAndSetRelease $type$ value"); + assertEquals($value2$, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -1238,27 +1236,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set($value1$); $type$ o = ($type$) vh.getAndAdd($value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndAddAcquire($value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndAddRelease($value2$); - assertEquals(o, $value1$, "getAndAddRelease$type$"); + assertEquals($value1$, o, "getAndAddRelease$type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -1268,27 +1266,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseOr($value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseOrAcquire($value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseOrRelease($value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -1296,27 +1294,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseAnd($value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseAndAcquire($value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseAndRelease($value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -1324,27 +1322,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseXor($value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseXorAcquire($value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { vh.set($value1$); $type$ o = ($type$) vh.getAndBitwiseXorRelease($value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) vh.get(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } @@ -1458,7 +1456,7 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.set(array, i, $value1$); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "get $type$ value"); + assertEquals($value1$, x, "get $type$ value"); } @@ -1466,21 +1464,21 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { { vh.setVolatile(array, i, $value2$); $type$ x = ($type$) vh.getVolatile(array, i); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { vh.setRelease(array, i, $value1$); $type$ x = ($type$) vh.getAcquire(array, i); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { vh.setOpaque(array, i, $value2$); $type$ x = ($type$) vh.getOpaque(array, i); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -1491,56 +1489,56 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { boolean r = vh.compareAndSet(array, i, $value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = vh.compareAndSet(array, i, $value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(array, i, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(array, i, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, $value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, $value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -1551,14 +1549,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -1569,14 +1567,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -1587,14 +1585,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = vh.weakCompareAndSetRelease(array, i, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "failing weakCompareAndSetRelease $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -1605,14 +1603,14 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "success weakCompareAndSet $type$"); + assertEquals($value1$, x, "success weakCompareAndSet $type$"); } { boolean success = vh.weakCompareAndSet(array, i, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value1$, "failing weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get @@ -1620,27 +1618,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndSet(array, i, $value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndSetAcquire(array, i, $value2$); - assertEquals(o, $value1$, "getAndSetAcquire $type$"); + assertEquals($value1$, o, "getAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "getAndSetAcquire $type$ value"); + assertEquals($value2$, x, "getAndSetAcquire $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndSetRelease(array, i, $value2$); - assertEquals(o, $value1$, "getAndSetRelease $type$"); + assertEquals($value1$, o, "getAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, $value2$, "getAndSetRelease $type$ value"); + assertEquals($value2$, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -1650,27 +1648,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndAdd(array, i, $value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndAddAcquire(array, i, $value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndAddRelease(array, i, $value2$); - assertEquals(o, $value1$, "getAndAddRelease$type$"); + assertEquals($value1$, o, "getAndAddRelease$type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -1680,27 +1678,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseOr(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -1708,27 +1706,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseAnd(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -1736,27 +1734,27 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseXor(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { vh.set(array, i, $value1$); $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } diff --git a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestByteArrayView.java.template b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestByteArrayView.java.template index c21709d6d37..9a40bfb2780 100644 --- a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestByteArrayView.java.template +++ b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestByteArrayView.java.template @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,25 +26,25 @@ * @bug 8154556 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAs$Type$ - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAs$Type$ - * @run testng/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAs$Type$ + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAs$Type$ + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestByteArrayAs$Type$ + * @run junit/othervm/timeout=360 -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestByteArrayAs$Type$ */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; -import java.util.Arrays; -import java.util.EnumSet; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { static final int SIZE = $BoxType$.BYTES; @@ -111,7 +111,8 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } } - @Test(dataProvider = "varHandlesProvider") + @ParameterizedTest + @MethodSource("VarHandleBaseByteArrayTest#varHandlesProvider") public void testIsAccessModeSupported(VarHandleSource vhs) { VarHandle vh = vhs.s; @@ -206,17 +207,16 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { #end[Bitwise] } - @Test(dataProvider = "typesProvider") + @ParameterizedTest + @MethodSource("typesProvider") public void testTypes(VarHandle vh, List> pts) { - assertEquals(vh.varType(), $type$.class); + assertEquals($type$.class, vh.varType()); - assertEquals(vh.coordinateTypes(), pts); + assertEquals(pts, vh.coordinateTypes()); testTypes(vh); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -278,7 +278,8 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -287,7 +288,6 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } } - static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) { VarHandle vh = vhs.s; byte[] array = null; @@ -1272,7 +1272,7 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "get $type$ value"); + assertEquals(VALUE_1, x, "get $type$ value"); } } } @@ -1291,7 +1291,7 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { { vh.set(array, i, VALUE_1); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "get $type$ value"); + assertEquals(VALUE_1, x, "get $type$ value"); } if (iAligned) { @@ -1299,21 +1299,21 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { { vh.setVolatile(array, i, VALUE_2); $type$ x = ($type$) vh.getVolatile(array, i); - assertEquals(x, VALUE_2, "setVolatile $type$ value"); + assertEquals(VALUE_2, x, "setVolatile $type$ value"); } // Lazy { vh.setRelease(array, i, VALUE_1); $type$ x = ($type$) vh.getAcquire(array, i); - assertEquals(x, VALUE_1, "setRelease $type$ value"); + assertEquals(VALUE_1, x, "setRelease $type$ value"); } // Opaque { vh.setOpaque(array, i, VALUE_2); $type$ x = ($type$) vh.getOpaque(array, i); - assertEquals(x, VALUE_2, "setOpaque $type$ value"); + assertEquals(VALUE_2, x, "setOpaque $type$ value"); } #if[CAS] @@ -1324,56 +1324,56 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndSet $type$ value"); + assertEquals(VALUE_2, x, "success compareAndSet $type$ value"); } { boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndSet $type$ value"); + assertEquals(VALUE_2, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchange $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchange $type$ value"); + assertEquals(VALUE_1, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchange(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchange $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchange $type$ value"); + assertEquals(VALUE_1, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2); assertEquals(r, VALUE_1, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "success compareAndExchangeAcquire $type$ value"); + assertEquals(VALUE_2, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3); assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire $type$ value"); + assertEquals(VALUE_2, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1); assertEquals(r, VALUE_2, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "success compareAndExchangeRelease $type$ value"); + assertEquals(VALUE_1, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3); assertEquals(r, VALUE_1, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "failing compareAndExchangeRelease $type$ value"); + assertEquals(VALUE_1, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -1384,14 +1384,14 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetPlain $type$ value"); + assertEquals(VALUE_2, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetPlain $type$ value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -1402,14 +1402,14 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSetAcquire $type$"); + assertEquals(VALUE_1, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -1420,14 +1420,14 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "success weakCompareAndSetRelease $type$"); + assertEquals(VALUE_2, x, "success weakCompareAndSetRelease $type$"); } { boolean success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_3); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "failing weakCompareAndSetRelease $type$ value"); + assertEquals(VALUE_2, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -1438,14 +1438,14 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "success weakCompareAndSet $type$"); + assertEquals(VALUE_1, x, "success weakCompareAndSet $type$"); } { boolean success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_3); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1, "failing weakCompareAndSet $type$ value"); + assertEquals(VALUE_1, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get @@ -1453,27 +1453,27 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndSet(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSet $type$"); + assertEquals(VALUE_1, o, "getAndSet $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSet $type$ value"); + assertEquals(VALUE_2, x, "getAndSet $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndSetAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetAcquire $type$"); + assertEquals(VALUE_1, o, "getAndSetAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetAcquire $type$ value"); + assertEquals(VALUE_2, x, "getAndSetAcquire $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndSetRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndSetRelease $type$"); + assertEquals(VALUE_1, o, "getAndSetRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_2, "getAndSetRelease $type$ value"); + assertEquals(VALUE_2, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -1483,27 +1483,27 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndAdd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAdd $type$"); + assertEquals(VALUE_1, o, "getAndAdd $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAdd $type$ value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAdd $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndAddAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddAcquire $type$"); + assertEquals(VALUE_1, o, "getAndAddAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddAcquire $type$ value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddAcquire $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndAddRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndAddRelease $type$"); + assertEquals(VALUE_1, o, "getAndAddRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 + VALUE_2, "getAndAddRelease $type$ value"); + assertEquals(VALUE_1 + VALUE_2, x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -1513,27 +1513,27 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseOr(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOr $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOr $type$ value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOr $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrAcquire $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrAcquire $type$ value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrAcquire $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseOrRelease $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrRelease $type$ value"); + assertEquals(VALUE_1 | VALUE_2, x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -1541,27 +1541,27 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseAnd(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAnd $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAnd $type$ value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAnd $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndAcquire $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndAcquire $type$ value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndAcquire $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseAndRelease $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndRelease $type$ value"); + assertEquals(VALUE_1 & VALUE_2, x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -1569,27 +1569,27 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseXor(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXor $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXor $type$ value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXor $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorAcquire $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorAcquire $type$ value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorAcquire $type$ value"); } { vh.set(array, i, VALUE_1); $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, i, VALUE_2); - assertEquals(o, VALUE_1, "getAndBitwiseXorRelease $type$"); + assertEquals(VALUE_1, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) vh.get(array, i); - assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorRelease $type$ value"); + assertEquals(VALUE_1 ^ VALUE_2, x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } @@ -1614,26 +1614,26 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest { // Plain { $type$ x = ($type$) vh.get(array, i); - assertEquals(x, v, "get $type$ value"); + assertEquals(v, x, "get $type$ value"); } if (iAligned) { // Volatile { $type$ x = ($type$) vh.getVolatile(array, i); - assertEquals(x, v, "getVolatile $type$ value"); + assertEquals(v, x, "getVolatile $type$ value"); } // Lazy { $type$ x = ($type$) vh.getAcquire(array, i); - assertEquals(x, v, "getRelease $type$ value"); + assertEquals(v, x, "getRelease $type$ value"); } // Opaque { $type$ x = ($type$) vh.getOpaque(array, i); - assertEquals(x, v, "getOpaque $type$ value"); + assertEquals(v, x, "getOpaque $type$ value"); } } } diff --git a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodHandleAccess.java.template b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodHandleAccess.java.template index 4a9fa7c4fe8..a347b232d7e 100644 --- a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodHandleAccess.java.template +++ b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodHandleAccess.java.template @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,22 @@ * @test * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations * to hit compilation thresholds - * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccess$Type$ + * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccess$Type$ */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { static final $type$ static_final_v = $value1$; @@ -60,7 +60,7 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodHandleAccess$Type$.class, "final_v", $type$.class); @@ -77,8 +77,6 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle($type$[].class); } - - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -111,7 +109,8 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -120,13 +119,12 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } } - static void testInstanceField(VarHandleTestMethodHandleAccess$Type$ recv, Handles hs) throws Throwable { // Plain { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "set $type$ value"); + assertEquals($value1$, x, "set $type$ value"); } @@ -134,21 +132,21 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, $value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, $value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, $value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -159,56 +157,56 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, $value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, $value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, $value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, $value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -220,14 +218,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -239,14 +237,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -258,14 +256,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "failing weakCompareAndSetRelease $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -277,22 +275,22 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "success weakCompareAndSet $type$"); + assertEquals($value1$, x, "success weakCompareAndSet $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value1$, "failing weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get { $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } #end[CAS] @@ -302,27 +300,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndAddRelease $type$"); + assertEquals($value1$, o, "getAndAddRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -332,27 +330,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -360,27 +358,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -388,27 +386,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(recv, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } @@ -457,7 +455,7 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "set $type$ value"); + assertEquals($value1$, x, "set $type$ value"); } @@ -465,21 +463,21 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact($value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact($value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact($value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -490,56 +488,56 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact($value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact($value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact($value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact($value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact($value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact($value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact($value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact($value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -551,14 +549,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact($value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -570,7 +568,7 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { @@ -578,7 +576,7 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { boolean success = (boolean) mh.invokeExact($value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -590,14 +588,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact($value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "failing weakCompareAndSetRelease $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value"); } { @@ -609,14 +607,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "success weakCompareAndSet $type$"); + assertEquals($value1$, x, "success weakCompareAndSet $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact($value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value1$, "failing weakCompareAndSetRe $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetRe $type$ value"); } // Compare set and get @@ -624,9 +622,9 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET).invokeExact($value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } // Compare set and get @@ -634,9 +632,9 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndSetAcquire $type$"); + assertEquals($value1$, o, "getAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "getAndSetAcquire $type$ value"); + assertEquals($value2$, x, "getAndSetAcquire $type$ value"); } // Compare set and get @@ -644,9 +642,9 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndSetRelease $type$"); + assertEquals($value1$, o, "getAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, $value2$, "getAndSetRelease $type$ value"); + assertEquals($value2$, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -656,27 +654,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD).invokeExact($value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndAddRelease $type$"); + assertEquals($value1$, o, "getAndAddRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -686,27 +684,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -714,27 +712,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -742,27 +740,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact($value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact($value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } @@ -814,7 +812,7 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "get $type$ value"); + assertEquals($value1$, x, "get $type$ value"); } @@ -822,21 +820,21 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { { hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, $value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); - assertEquals(x, $value2$, "setVolatile $type$ value"); + assertEquals($value2$, x, "setVolatile $type$ value"); } // Lazy { hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, $value1$); $type$ x = ($type$) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); - assertEquals(x, $value1$, "setRelease $type$ value"); + assertEquals($value1$, x, "setRelease $type$ value"); } // Opaque { hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, $value2$); $type$ x = ($type$) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); - assertEquals(x, $value2$, "setOpaque $type$ value"); + assertEquals($value2$, x, "setOpaque $type$ value"); } #if[CAS] @@ -847,56 +845,56 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, $value1$, $value2$); assertEquals(r, true, "success compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "success compareAndSet $type$ value"); + assertEquals($value2$, x, "success compareAndSet $type$ value"); } { boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, $value1$, $value3$); assertEquals(r, false, "failing compareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "failing compareAndSet $type$ value"); + assertEquals($value2$, x, "failing compareAndSet $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "success compareAndExchange $type$ value"); + assertEquals($value1$, x, "success compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchange $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "failing compareAndExchange $type$ value"); + assertEquals($value1$, x, "failing compareAndExchange $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, $value1$, $value2$); assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, $value1$, $value3$); assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value"); + assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, $value2$, $value1$); assertEquals(r, $value2$, "success compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value"); } { $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, $value2$, $value3$); assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value"); + assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value"); } { @@ -908,14 +906,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "success weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetPlain $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "failing weakCompareAndSetPlain $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value"); } { @@ -927,14 +925,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "success weakCompareAndSetAcquire $type$"); + assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -946,14 +944,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "success weakCompareAndSetRelease $type$"); + assertEquals($value2$, x, "success weakCompareAndSetRelease $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, $value1$, $value3$); assertEquals(success, false, "failing weakCompareAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "failing weakCompareAndSetAcquire $type$ value"); + assertEquals($value2$, x, "failing weakCompareAndSetAcquire $type$ value"); } { @@ -965,14 +963,14 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { } assertEquals(success, true, "success weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "success weakCompareAndSet $type$"); + assertEquals($value1$, x, "success weakCompareAndSet $type$"); } { boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, $value2$, $value3$); assertEquals(success, false, "failing weakCompareAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value1$, "failing weakCompareAndSet $type$ value"); + assertEquals($value1$, x, "failing weakCompareAndSet $type$ value"); } // Compare set and get @@ -980,27 +978,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndSet $type$"); + assertEquals($value1$, o, "getAndSet $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "getAndSet $type$ value"); + assertEquals($value2$, x, "getAndSet $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndSetAcquire $type$"); + assertEquals($value1$, o, "getAndSetAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "getAndSetAcquire $type$ value"); + assertEquals($value2$, x, "getAndSetAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndSetRelease $type$"); + assertEquals($value1$, o, "getAndSetRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, $value2$, "getAndSetRelease $type$ value"); + assertEquals($value2$, x, "getAndSetRelease $type$ value"); } #end[CAS] @@ -1010,27 +1008,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndAdd $type$"); + assertEquals($value1$, o, "getAndAdd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndAddAcquire $type$"); + assertEquals($value1$, o, "getAndAddAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndAddRelease $type$"); + assertEquals($value1$, o, "getAndAddRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value"); + assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value"); } #end[AtomicAdd] @@ -1040,27 +1038,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOr $type$"); + assertEquals($value1$, o, "getAndBitwiseOr $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseOrRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value"); + assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value"); } // get and bitwise and @@ -1068,27 +1066,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAnd $type$"); + assertEquals($value1$, o, "getAndBitwiseAnd $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseAndRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value"); + assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value"); } // get and bitwise xor @@ -1096,27 +1094,27 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXor $type$"); + assertEquals($value1$, o, "getAndBitwiseXor $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$"); + assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value"); } { hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$); $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, $value2$); - assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$"); + assertEquals($value1$, o, "getAndBitwiseXorRelease $type$"); $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i); - assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value"); + assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value"); } #end[Bitwise] } diff --git a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodType.java.template b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodType.java.template index 85ecf9bb95c..77531cc309f 100644 --- a/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodType.java.template +++ b/test/jdk/java/lang/invoke/VarHandles/X-VarHandleTestMethodType.java.template @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,26 +24,26 @@ /* * @test * @bug 8156486 - * @run testng/othervm VarHandleTestMethodType$Type$ - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodType$Type$ - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodType$Type$ - * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodType$Type$ + * @run junit/othervm VarHandleTestMethodType$Type$ + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodType$Type$ + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodType$Type$ + * @run junit/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodType$Type$ */ -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.invoke.VarHandle; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import static org.testng.Assert.*; - import static java.lang.invoke.MethodType.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class VarHandleTestMethodType$Type$ extends VarHandleBaseTest { static final $type$ static_final_v = $value1$; @@ -63,7 +63,7 @@ public class VarHandleTestMethodType$Type$ extends VarHandleBaseTest { VarHandle vhArray; - @BeforeClass + @BeforeAll public void setup() throws Exception { vhFinalField = MethodHandles.lookup().findVarHandle( VarHandleTestMethodType$Type$.class, "final_v", $type$.class); @@ -80,7 +80,6 @@ public class VarHandleTestMethodType$Type$ extends VarHandleBaseTest { vhArray = MethodHandles.arrayElementVarHandle($type$[].class); } - @DataProvider public Object[][] accessTestCaseProvider() throws Exception { List> cases = new ArrayList<>(); @@ -115,7 +114,8 @@ public class VarHandleTestMethodType$Type$ extends VarHandleBaseTest { return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); } - @Test(dataProvider = "accessTestCaseProvider") + @ParameterizedTest + @MethodSource("accessTestCaseProvider") public void testAccess(String desc, AccessTestCase atc) throws Throwable { T t = atc.get(); int iters = atc.requiresLoop() ? ITERS : 1; @@ -124,7 +124,6 @@ public class VarHandleTestMethodType$Type$ extends VarHandleBaseTest { } } - static void testInstanceFieldWrongMethodType(VarHandleTestMethodType$Type$ recv, VarHandle vh) throws Throwable { // Get // Incorrect argument types diff --git a/test/jdk/java/lang/invoke/VarHandles/accessibility/TestFieldLookupAccessibility.java b/test/jdk/java/lang/invoke/VarHandles/accessibility/TestFieldLookupAccessibility.java index 343b15a1caf..11cd6ec233c 100644 --- a/test/jdk/java/lang/invoke/VarHandles/accessibility/TestFieldLookupAccessibility.java +++ b/test/jdk/java/lang/invoke/VarHandles/accessibility/TestFieldLookupAccessibility.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,14 +27,11 @@ * @compile TestFieldLookupAccessibility.java * pkg/A.java pkg/B_extends_A.java pkg/C.java * pkg/subpkg/B_extends_A.java pkg/subpkg/C.java - * @run testng/othervm --enable-final-field-mutation=ALL-UNNAMED -DwriteAccess=true TestFieldLookupAccessibility - * @run testng/othervm --illegal-final-field-mutation=deny -DwriteAccess=false TestFieldLookupAccessibility + * @run junit/othervm --enable-final-field-mutation=ALL-UNNAMED -DwriteAccess=true TestFieldLookupAccessibility + * @run junit/othervm --illegal-final-field-mutation=deny -DwriteAccess=false TestFieldLookupAccessibility */ -import static org.testng.Assert.*; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; +import static org.junit.jupiter.api.Assertions.*; import pkg.B_extends_A; import java.lang.invoke.MethodHandles; @@ -48,11 +45,14 @@ import java.util.Map; import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class TestFieldLookupAccessibility { static boolean writeAccess; - @BeforeClass + @BeforeAll static void setup() { String s = System.getProperty("writeAccess"); assertNotNull(s); @@ -188,8 +188,7 @@ public class TestFieldLookupAccessibility { } } - @DataProvider - public Object[][] lookupProvider() throws Exception { + public static Object[][] lookupProvider() throws Exception { Stream> baseCases = Stream.of( // Look up from same package List.of(pkg.A.class, pkg.A.lookup(), pkg.A.inaccessibleFields()), @@ -215,7 +214,8 @@ public class TestFieldLookupAccessibility { return pl.toArray(); } - @Test(dataProvider = "lookupProvider") + @ParameterizedTest + @MethodSource("lookupProvider") public void test(FieldLookup fl, Class src, MethodHandles.Lookup l, Set inaccessibleFields) { // Add to the expected failures all inaccessible fields due to accessibility modifiers Set expected = fl.inaccessibleFields(inaccessibleFields); @@ -240,10 +240,10 @@ public class TestFieldLookupAccessibility { collect(Collectors.toSet()); if (!actualFieldNames.equals(expected)) { if (actualFieldNames.isEmpty()) { - assertEquals(actualFieldNames, expected, "No accessibility failures:"); + assertEquals(expected, actualFieldNames, "No accessibility failures:"); } else { - assertEquals(actualFieldNames, expected, "Accessibility failures differ:"); + assertEquals(expected, actualFieldNames, "Accessibility failures differ:"); } } else { diff --git a/test/jdk/java/lang/invoke/WrongMethodTypeTest.java b/test/jdk/java/lang/invoke/WrongMethodTypeTest.java index be0c59e0d77..32cbfc545ce 100644 --- a/test/jdk/java/lang/invoke/WrongMethodTypeTest.java +++ b/test/jdk/java/lang/invoke/WrongMethodTypeTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -21,8 +21,9 @@ * questions. */ -/* @test 8299183 - * @run testng WrongMethodTypeTest +/* @test + * @bug 8299183 + * @run junit WrongMethodTypeTest */ import java.lang.invoke.MethodHandle; @@ -33,9 +34,10 @@ import java.lang.invoke.WrongMethodTypeException; import static java.lang.invoke.MethodType.methodType; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; public class WrongMethodTypeTest { static final Lookup LOOKUP = MethodHandles.lookup(); @@ -43,13 +45,11 @@ public class WrongMethodTypeTest { @Test public void checkExactType() throws Throwable { String expectedMessage = "handle's method type (int)int but found ()boolean"; - try { - MethodHandle mh = LOOKUP.findStatic(WrongMethodTypeTest.class, "m", methodType(int.class, int.class)); + MethodHandle mh = LOOKUP.findStatic(WrongMethodTypeTest.class, "m", methodType(int.class, int.class)); + var ex = assertThrows(WrongMethodTypeException.class, () -> { boolean b = (boolean)mh.invokeExact(); - fail("Expected WrongMethodTypeException"); - } catch (WrongMethodTypeException ex) { - assertEquals(expectedMessage, ex.getMessage()); - } + }); + assertEquals(expectedMessage, ex.getMessage()); } @Test @@ -57,11 +57,10 @@ public class WrongMethodTypeTest { String expectedMessage = "handle's method type ()int but found ()Void"; VarHandle vh = LOOKUP.findStaticVarHandle(WrongMethodTypeTest.class, "x", int.class) .withInvokeExactBehavior(); - try { + var ex = assertThrows(WrongMethodTypeException.class, () -> { Void o = (Void) vh.get(); - } catch (WrongMethodTypeException ex) { - assertEquals(expectedMessage, ex.getMessage()); - } + }); + assertEquals(expectedMessage, ex.getMessage()); } @Test @@ -69,11 +68,10 @@ public class WrongMethodTypeTest { String expectedMessage = "handle's method type (WrongMethodTypeTest)boolean but found (WrongMethodTypeTest)int"; VarHandle vh = LOOKUP.findVarHandle(WrongMethodTypeTest.class, "y", boolean.class) .withInvokeExactBehavior(); - try { + var ex = assertThrows(WrongMethodTypeException.class, () -> { int o = (int) vh.get(new WrongMethodTypeTest()); - } catch (WrongMethodTypeException ex) { - assertEquals(expectedMessage, ex.getMessage()); - } + }); + assertEquals(expectedMessage, ex.getMessage()); } static int m(int x) { diff --git a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestAccessClass.java b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestAccessClass.java index 083a357a430..23893655c0a 100644 --- a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestAccessClass.java +++ b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestAccessClass.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* @test * @bug 8150782 8207027 8266269 * @compile TestAccessClass.java TestCls.java p/Foo.java q/Bar.java - * @run testng/othervm -ea -esa test.java.lang.invoke.TestAccessClass + * @run junit/othervm -ea -esa test.java.lang.invoke.TestAccessClass */ package test.java.lang.invoke; @@ -36,9 +36,11 @@ import q.Bar; import static java.lang.invoke.MethodHandles.*; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; public class TestAccessClass { @@ -68,17 +70,19 @@ public class TestAccessClass { assertEquals(Class1[].class, aClass); } - @DataProvider - Object[][] illegalAccessAccess() { + static Object[][] illegalAccessAccess() { return new Object[][] { {publicLookup(), Class1.class}, {publicLookup(), TestCls.getPrivateSIC()} }; } - @Test(dataProvider = "illegalAccessAccess", expectedExceptions = {IllegalAccessException.class}) + @ParameterizedTest + @MethodSource("illegalAccessAccess") public void illegalAccessExceptionTest(Lookup lookup, Class klass) throws IllegalAccessException { - lookup.accessClass(klass); + assertThrows(IllegalAccessException.class, () -> { + lookup.accessClass(klass); + }); } @Test @@ -98,8 +102,8 @@ public class TestAccessClass { mh.invoke(null); } - @Test(expectedExceptions = {NullPointerException.class}) + @Test public void illegalArgument() throws IllegalAccessException { - lookup().accessClass(null); + assertThrows(NullPointerException.class, () -> lookup().accessClass(null)); } } diff --git a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestFindClass.java b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestFindClass.java index 54674729fe3..94ec3c54b4f 100644 --- a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestFindClass.java +++ b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestFindClass.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* @test * @bug 8150782 8207027 8266269 * @compile TestFindClass.java TestCls.java p/Foo.java q/Bar.java - * @run testng/othervm -ea -esa test.java.lang.invoke.TestFindClass + * @run junit/othervm -ea -esa test.java.lang.invoke.TestFindClass */ package test.java.lang.invoke; @@ -34,9 +34,11 @@ import q.Bar; import static java.lang.invoke.MethodHandles.*; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import org.testng.annotations.*; +import static org.junit.jupiter.api.Assertions.*; public class TestFindClass { @@ -68,13 +70,12 @@ public class TestFindClass { assertEquals(Class1[].class, aClass); } - @Test(expectedExceptions = {ClassNotFoundException.class}) + @Test public void classNotFoundExceptionTest() throws IllegalAccessException, ClassNotFoundException { - lookup().findClass(PACKAGE_PREFIX + "TestFindClass$NonExistent"); + assertThrows(ClassNotFoundException.class, () -> lookup().findClass(PACKAGE_PREFIX + "TestFindClass$NonExistent")); } - @DataProvider - Object[][] illegalAccessFind() { + static Object[][] illegalAccessFind() { return new Object[][] { {publicLookup(), PACKAGE_PREFIX + "TestFindClass$Class1"}, {publicLookup(), PACKAGE_PREFIX + "TestCls$PrivateSIC"} @@ -84,9 +85,10 @@ public class TestFindClass { /** * Assertion: @throws IllegalAccessException if the class is not accessible, using the allowed access modes. */ - @Test(dataProvider = "illegalAccessFind", expectedExceptions = {ClassNotFoundException.class}) + @ParameterizedTest + @MethodSource("illegalAccessFind") public void illegalAccessExceptionTest(Lookup lookup, String className) throws IllegalAccessException, ClassNotFoundException { - lookup.findClass(className); + assertThrows(ClassNotFoundException.class, () -> lookup.findClass(className)); } @Test @@ -104,8 +106,8 @@ public class TestFindClass { lookup().findClass("[Lp.Foo$T;"); } - @Test(expectedExceptions = {NullPointerException.class}) + @Test public void illegalArgument() throws IllegalAccessException, ClassNotFoundException { - lookup().findClass(null); + assertThrows(NullPointerException.class, () -> lookup().findClass(null)); } } diff --git a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestLookup.java b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestLookup.java index 555213bedcc..b0f2e00adbc 100644 --- a/test/jdk/java/lang/invoke/accessClassAndFindClass/TestLookup.java +++ b/test/jdk/java/lang/invoke/accessClassAndFindClass/TestLookup.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,15 +23,15 @@ /* @test * @compile TestLookup.java TestCls.java - * @run testng/othervm -ea -esa test.java.lang.invoke.TestLookup + * @run junit/othervm -ea -esa test.java.lang.invoke.TestLookup */ package test.java.lang.invoke; -import org.testng.annotations.Test; - import static java.lang.invoke.MethodHandles.*; -import static org.testng.AssertJUnit.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; public class TestLookup { @@ -43,10 +43,10 @@ public class TestLookup { assertNull(lookup2.lookupClass().getClassLoader()); } - @Test(expectedExceptions = {ClassNotFoundException.class}) + @Test public void testPublicCannotLoadUserClass() throws IllegalAccessException, ClassNotFoundException { Lookup lookup = publicLookup(); - lookup.findClass("test.java.lang.invoke.TestCls"); + assertThrows(ClassNotFoundException.class, () -> lookup.findClass("test.java.lang.invoke.TestCls")); } @Test diff --git a/test/jdk/java/lang/invoke/callerSensitive/CallerSensitiveAccess.java b/test/jdk/java/lang/invoke/callerSensitive/CallerSensitiveAccess.java index a6359162629..67aa90ba99c 100644 --- a/test/jdk/java/lang/invoke/callerSensitive/CallerSensitiveAccess.java +++ b/test/jdk/java/lang/invoke/callerSensitive/CallerSensitiveAccess.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* @test * @bug 8196830 8235351 8257874 * @modules java.base/jdk.internal.reflect - * @run testng/othervm CallerSensitiveAccess + * @run junit/othervm CallerSensitiveAccess * @summary Check Lookup findVirtual, findStatic and unreflect behavior with * caller sensitive methods with focus on AccessibleObject.setAccessible */ @@ -50,17 +50,16 @@ import java.util.stream.Stream; import jdk.internal.reflect.CallerSensitive; -import org.testng.annotations.DataProvider; -import org.testng.annotations.NoInjection; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class CallerSensitiveAccess { /** * Caller sensitive methods in APIs exported by java.base. */ - @DataProvider(name = "callerSensitiveMethods") static Object[][] callerSensitiveMethods() { try (Stream stream = callerSensitiveMethods(Object.class.getModule())) { return stream.map(m -> new Object[]{m, shortDescription(m)}) @@ -72,34 +71,35 @@ public class CallerSensitiveAccess { * Using publicLookup, attempt to use findVirtual or findStatic to obtain a * method handle to a caller sensitive method. */ - @Test(dataProvider = "callerSensitiveMethods", - expectedExceptions = IllegalAccessException.class) - public void testPublicLookupFind(@NoInjection Method method, String desc) throws Exception { + @ParameterizedTest + @MethodSource("callerSensitiveMethods") + public void testPublicLookupFind(Method method, String desc) throws Exception { Lookup lookup = MethodHandles.publicLookup(); Class refc = method.getDeclaringClass(); String name = method.getName(); MethodType mt = MethodType.methodType(method.getReturnType(), method.getParameterTypes()); - if (Modifier.isStatic(method.getModifiers())) { - lookup.findStatic(refc, name, mt); - } else { - lookup.findVirtual(refc, name, mt); - } + assertThrows(IllegalAccessException.class, () -> { + if (Modifier.isStatic(method.getModifiers())) { + lookup.findStatic(refc, name, mt); + } else { + lookup.findVirtual(refc, name, mt); + } + }); } /** * Using publicLookup, attempt to use unreflect to obtain a method handle to a * caller sensitive method. */ - @Test(dataProvider = "callerSensitiveMethods", - expectedExceptions = IllegalAccessException.class) - public void testPublicLookupUnreflect(@NoInjection Method method, String desc) throws Exception { - MethodHandles.publicLookup().unreflect(method); + @ParameterizedTest + @MethodSource("callerSensitiveMethods") + public void testPublicLookupUnreflect(Method method, String desc) throws Exception { + assertThrows(IllegalAccessException.class, () -> MethodHandles.publicLookup().unreflect(method)); } /** * public accessible caller sensitive methods in APIs exported by java.base. */ - @DataProvider(name = "accessibleCallerSensitiveMethods") static Object[][] accessibleCallerSensitiveMethods() { try (Stream stream = callerSensitiveMethods(Object.class.getModule())) { return stream @@ -114,41 +114,43 @@ public class CallerSensitiveAccess { * Using publicLookup, attempt to use unreflect to obtain a method handle to a * caller sensitive method. */ - @Test(dataProvider = "accessibleCallerSensitiveMethods", - expectedExceptions = IllegalAccessException.class) - public void testLookupUnreflect(@NoInjection Method method, String desc) throws Exception { - MethodHandles.publicLookup().unreflect(method); + @ParameterizedTest + @MethodSource("accessibleCallerSensitiveMethods") + public void testLookupUnreflect(Method method, String desc) throws Exception { + assertThrows(IllegalAccessException.class, () -> MethodHandles.publicLookup().unreflect(method)); } /** * Using a Lookup with no original access that can't lookup caller-sensitive * method */ - @Test(dataProvider = "callerSensitiveMethods", - expectedExceptions = IllegalAccessException.class) - public void testLookupNoOriginalAccessFind(@NoInjection Method method, String desc) throws Exception { + @ParameterizedTest + @MethodSource("callerSensitiveMethods") + public void testLookupNoOriginalAccessFind(Method method, String desc) throws Exception { Lookup lookup = MethodHandles.lookup().dropLookupMode(Lookup.ORIGINAL); assertTrue(lookup.hasFullPrivilegeAccess()); Class refc = method.getDeclaringClass(); String name = method.getName(); MethodType mt = MethodType.methodType(method.getReturnType(), method.getParameterTypes()); - if (Modifier.isStatic(method.getModifiers())) { - lookup.findStatic(refc, name, mt); - } else { - lookup.findVirtual(refc, name, mt); - } + assertThrows(IllegalAccessException.class, () -> { + if (Modifier.isStatic(method.getModifiers())) { + lookup.findStatic(refc, name, mt); + } else { + lookup.findVirtual(refc, name, mt); + } + }); } /** * Using a Lookup with no original access that can't unreflect caller-sensitive * method */ - @Test(dataProvider = "callerSensitiveMethods", - expectedExceptions = IllegalAccessException.class) - public void testLookupNoOriginalAccessUnreflect(@NoInjection Method method, String desc) throws Exception { + @ParameterizedTest + @MethodSource("callerSensitiveMethods") + public void testLookupNoOriginalAccessUnreflect(Method method, String desc) throws Exception { Lookup lookup = MethodHandles.lookup().dropLookupMode(Lookup.ORIGINAL); assertTrue(lookup.hasFullPrivilegeAccess()); - lookup.unreflect(method); + assertThrows(IllegalAccessException.class, () -> lookup.unreflect(method)); } // -- Test method handles to setAccessible -- @@ -156,21 +158,12 @@ public class CallerSensitiveAccess { private int aField; Field accessibleField() { - try { - return getClass().getDeclaredField("aField"); - } catch (NoSuchFieldException e) { - fail(); - return null; - } + var clazz = getClass(); + return assertDoesNotThrow(() -> clazz.getDeclaredField("aField")); } Field inaccessibleField() { - try { - return String.class.getDeclaredField("hash"); - } catch (NoSuchFieldException e) { - fail(); - return null; - } + return assertDoesNotThrow(() -> String.class.getDeclaredField("hash")); } void findAndInvokeSetAccessible(Class refc, Field f) throws Throwable { @@ -215,23 +208,23 @@ public class CallerSensitiveAccess { * Create a method handle to setAccessible and attempt to use it to suppress * access to an inaccessible member. */ - @Test(expectedExceptions = InaccessibleObjectException.class) + @Test public void testSetAccessible5() throws Throwable { - findAndInvokeSetAccessible(AccessibleObject.class, inaccessibleField()); + assertThrows(InaccessibleObjectException.class, () -> findAndInvokeSetAccessible(AccessibleObject.class, inaccessibleField())); } - @Test(expectedExceptions = InaccessibleObjectException.class) + @Test public void testSetAccessible6() throws Throwable { - findAndInvokeSetAccessible(Field.class, inaccessibleField()); + assertThrows(InaccessibleObjectException.class, () -> findAndInvokeSetAccessible(Field.class, inaccessibleField())); } - @Test(expectedExceptions = InaccessibleObjectException.class) + @Test public void testSetAccessible7() throws Throwable { Method m = AccessibleObject.class.getMethod("setAccessible", boolean.class); - unreflectAndInvokeSetAccessible(m, inaccessibleField()); + assertThrows(InaccessibleObjectException.class, () -> unreflectAndInvokeSetAccessible(m, inaccessibleField())); } - @Test(expectedExceptions = InaccessibleObjectException.class) + @Test public void testSetAccessible8() throws Throwable { Method m = Field.class.getMethod("setAccessible", boolean.class); - unreflectAndInvokeSetAccessible(m, inaccessibleField()); + assertThrows(InaccessibleObjectException.class, () -> unreflectAndInvokeSetAccessible(m, inaccessibleField())); } @@ -241,7 +234,6 @@ public class CallerSensitiveAccess { * Custom AccessibleObject objects. One class overrides setAccessible, the other * does not override this method. */ - @DataProvider(name = "customAccessibleObjects") static Object[][] customAccessibleObjectClasses() { return new Object[][] { { new S1() }, { new S2() } }; } @@ -271,20 +263,20 @@ public class CallerSensitiveAccess { * Using publicLookup, create a method handle to setAccessible and invoke it * on a custom AccessibleObject object. */ - @Test(expectedExceptions = IllegalAccessException.class) + @Test public void testPublicLookupSubclass1() throws Throwable { // S1 does not override setAccessible - findAndInvokeSetAccessible(MethodHandles.publicLookup(), new S1()); + assertThrows(IllegalAccessException.class, () -> findAndInvokeSetAccessible(MethodHandles.publicLookup(), new S1())); } @Test public void testPublicLookupSubclass2() throws Throwable { // S2 overrides setAccessible findAndInvokeSetAccessible(MethodHandles.publicLookup(), new S2()); } - @Test(expectedExceptions = IllegalAccessException.class) + @Test public void testPublicLookupSubclass3() throws Throwable { // S1 does not override setAccessible - unreflectAndInvokeSetAccessible(MethodHandles.publicLookup(), new S1()); + assertThrows(IllegalAccessException.class, () -> unreflectAndInvokeSetAccessible(MethodHandles.publicLookup(), new S1())); } @Test public void testPublicLookupSubclass4() throws Throwable { @@ -296,11 +288,13 @@ public class CallerSensitiveAccess { * Using a full power lookup, create a method handle to setAccessible and * invoke it on a custom AccessibleObject object. */ - @Test(dataProvider = "customAccessibleObjects") + @ParameterizedTest + @MethodSource("customAccessibleObjectClasses") public void testLookupSubclass1(AccessibleObject obj) throws Throwable { findAndInvokeSetAccessible(MethodHandles.lookup(), obj); } - @Test(dataProvider = "customAccessibleObjects") + @ParameterizedTest + @MethodSource("customAccessibleObjectClasses") public void testLookupSubclass2(AccessibleObject obj) throws Throwable { unreflectAndInvokeSetAccessible(MethodHandles.lookup(), obj); } @@ -309,13 +303,13 @@ public class CallerSensitiveAccess { * Using a full power lookup, create a method handle to setAccessible on a * sub-class of AccessibleObject and then attempt to invoke it on a Field object. */ - @Test(dataProvider = "customAccessibleObjects", - expectedExceptions = ClassCastException.class) + @ParameterizedTest + @MethodSource("customAccessibleObjectClasses") public void testLookupSubclass3(AccessibleObject obj) throws Throwable { MethodType mt = MethodType.methodType(void.class, boolean.class); Lookup lookup = MethodHandles.lookup(); MethodHandle mh = lookup.findVirtual(obj.getClass(), "setAccessible", mt); - mh.invoke(accessibleField(), true); // should throw ClassCastException + assertThrows(ClassCastException.class, () -> mh.invoke(accessibleField(), true)); } /** @@ -333,29 +327,29 @@ public class CallerSensitiveAccess { mh.invoke(f, true); assertTrue(f.isAccessible()); } - @Test(expectedExceptions = InaccessibleObjectException.class) + @Test public void testLookupSubclass5() throws Throwable { // S1 does not override setAccessible Method m = S1.class.getMethod("setAccessible", boolean.class); assertTrue(m.getDeclaringClass() == AccessibleObject.class); MethodHandle mh = MethodHandles.lookup().unreflect(m); - mh.invoke(inaccessibleField(), true); // should throw InaccessibleObjectException + assertThrows(InaccessibleObjectException.class, () -> mh.invoke(inaccessibleField(), true)); } - @Test(expectedExceptions = ClassCastException.class) + @Test public void testLookupSubclass6() throws Throwable { // S2 overrides setAccessible Method m = S2.class.getMethod("setAccessible", boolean.class); assertTrue(m.getDeclaringClass() == S2.class); MethodHandle mh = MethodHandles.lookup().unreflect(m); - mh.invoke(accessibleField(), true); // should throw ClassCastException + assertThrows(ClassCastException.class, () -> mh.invoke(accessibleField(), true)); } - @Test(expectedExceptions = ClassCastException.class) + @Test public void testLookupSubclass7() throws Throwable { // S2 overrides setAccessible Method m = S2.class.getMethod("setAccessible", boolean.class); assertTrue(m.getDeclaringClass() == S2.class); MethodHandle mh = MethodHandles.lookup().unreflect(m); - mh.invoke(inaccessibleField(), true); // should throw ClassCastException + assertThrows(ClassCastException.class, () -> mh.invoke(inaccessibleField(), true)); } /** @@ -373,7 +367,7 @@ public class CallerSensitiveAccess { // Field::getInt mh = MethodHandles.lookup().findVirtual(Field.class, "getInt", MethodType.methodType(int.class, Object.class)); int value = (int)mh.invokeExact(f, (Object)null); - assertTrue(value == 5); + assertEquals(5, value); } private static class Inner { @@ -400,7 +394,7 @@ public class CallerSensitiveAccess { * exported by a named module. */ static Stream callerSensitiveMethods(Module module) { - assert module.isNamed(); + assertTrue(module.isNamed()); ModuleReference mref = module.getLayer().configuration() .findModule(module.getName()) .orElseThrow(() -> new RuntimeException()) diff --git a/test/jdk/java/lang/invoke/condy/BootstrapMethodJumboArgsTest.java b/test/jdk/java/lang/invoke/condy/BootstrapMethodJumboArgsTest.java index 0357afce668..4a2ad3f3091 100644 --- a/test/jdk/java/lang/invoke/condy/BootstrapMethodJumboArgsTest.java +++ b/test/jdk/java/lang/invoke/condy/BootstrapMethodJumboArgsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,12 +27,10 @@ * @summary Test bootstrap methods throwing an exception * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng BootstrapMethodJumboArgsTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 BootstrapMethodJumboArgsTest + * @run junit BootstrapMethodJumboArgsTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 BootstrapMethodJumboArgsTest */ -import org.testng.Assert; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.invoke.ConstantCallSite; @@ -43,6 +41,10 @@ import java.util.stream.IntStream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + public class BootstrapMethodJumboArgsTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); @@ -93,7 +95,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } { @@ -103,7 +105,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } { @@ -113,7 +115,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object.class, Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } } @@ -128,7 +130,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } { @@ -138,7 +140,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } { @@ -148,7 +150,7 @@ public class BootstrapMethodJumboArgsTest { Object.class, Object.class, Object.class, Object[].class), expected); Object[] actual = (Object[]) mh.invoke(); - Assert.assertEquals(actual, expected); + assertArrayEquals(expected, actual); } } } diff --git a/test/jdk/java/lang/invoke/condy/CondyBSMException.java b/test/jdk/java/lang/invoke/condy/CondyBSMException.java index 7aa25c5cd95..1c9f867bc8b 100644 --- a/test/jdk/java/lang/invoke/condy/CondyBSMException.java +++ b/test/jdk/java/lang/invoke/condy/CondyBSMException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,12 +27,10 @@ * @summary Test bootstrap methods throwing an exception * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyBSMException - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMException + * @run junit CondyBSMException + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMException */ -import org.testng.Assert; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.invoke.MethodHandle; @@ -41,6 +39,10 @@ import java.lang.reflect.Constructor; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class CondyBSMException { @Test @@ -70,26 +72,17 @@ public class CondyBSMException { static void test(String message, Class... ts) { MethodHandle mh = thrower(message, ts[ts.length - 1]); - Throwable caught = null; - try { - mh.invoke(); - } catch (Throwable t) { - caught = t; - } - - if (caught == null) { - Assert.fail("Throwable expected"); - } + Throwable caught = assertThrows(Throwable.class, mh::invoke); String actualMessage = null; for (int i = 0; i < ts.length; i++) { + int level = i; + assertInstanceOf(ts[i], caught, () -> "Level %d".formatted(level)); actualMessage = caught.getMessage(); - Assert.assertNotNull(caught); - Assert.assertTrue(ts[i].isAssignableFrom(caught.getClass())); caught = caught.getCause(); } - Assert.assertEquals(actualMessage, message); + assertEquals(message, actualMessage); } static Throwable throwingBsm(MethodHandles.Lookup l, String name, Class type) throws Throwable { diff --git a/test/jdk/java/lang/invoke/condy/CondyBSMInvocation.java b/test/jdk/java/lang/invoke/condy/CondyBSMInvocation.java index e9050126a79..897ee40b444 100644 --- a/test/jdk/java/lang/invoke/condy/CondyBSMInvocation.java +++ b/test/jdk/java/lang/invoke/condy/CondyBSMInvocation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,13 +27,10 @@ * @summary Test basic invocation of bootstrap methods * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyBSMInvocation - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMInvocation + * @run junit CondyBSMInvocation + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMInvocation */ - -import org.testng.Assert; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.constant.ConstantDesc; @@ -48,6 +45,10 @@ import java.util.stream.Stream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class CondyBSMInvocation { static final MethodHandles.Lookup L = MethodHandles.lookup(); @@ -59,11 +60,7 @@ public class CondyBSMInvocation { "bsm", methodType(Object.class) ); - try { - mh.invoke(); - Assert.fail("NoSuchMethodError expected to be thrown"); - } catch (NoSuchMethodError e) { - } + assertThrows(NoSuchMethodError.class, mh::invoke); } static MethodHandle[] bsms(String bsmName) { @@ -114,11 +111,7 @@ public class CondyBSMInvocation { "shape_bsm", bsm.type() ); - try { - Object r = mh.invoke(); - Assert.fail("BootstrapMethodError expected to be thrown for " + bsm); - } catch (BootstrapMethodError e) { - } + assertThrows(BootstrapMethodError.class, mh::invoke); } } @@ -139,11 +132,7 @@ public class CondyBSMInvocation { "sig_bsm", bsm.type() ); - try { - Object r = mh.invoke(); - Assert.fail("BootstrapMethodError expected to be thrown for " + bsm); - } catch (BootstrapMethodError e) { - } + assertThrows(BootstrapMethodError.class, mh::invoke); } } @@ -202,7 +191,7 @@ public class CondyBSMInvocation { static void assertAll(Object... as) { for (int i = 0; i < as.length; i++) { - Assert.assertEquals(as[i], i); + assertEquals(i, as[i]); } } @@ -219,7 +208,7 @@ public class CondyBSMInvocation { ); Object r = mh.invoke(); - Assert.assertEquals(r, Integer.toString(n)); + assertEquals(Integer.toString(n), r); } { @@ -231,7 +220,7 @@ public class CondyBSMInvocation { ); Object r = mh.invoke(); - Assert.assertEquals(r, Integer.toString(9)); + assertEquals(Integer.toString(9), r); } } @@ -248,13 +237,8 @@ public class CondyBSMInvocation { IntStream.range(0, n - 1).boxed().toArray(ConstantDesc[]::new) ); - try { - Object r = mh.invoke(); - Assert.fail("BootstrapMethodError expected to be thrown for arrity " + n); - } catch (BootstrapMethodError e) { - Throwable t = e.getCause(); - Assert.assertTrue(WrongMethodTypeException.class.isAssignableFrom(t.getClass())); - } + var e = assertThrows(BootstrapMethodError.class, mh::invoke); + assertInstanceOf(WrongMethodTypeException.class, e.getCause()); } } } diff --git a/test/jdk/java/lang/invoke/condy/CondyBSMValidationTest.java b/test/jdk/java/lang/invoke/condy/CondyBSMValidationTest.java index d255202866f..e6c2aacea63 100644 --- a/test/jdk/java/lang/invoke/condy/CondyBSMValidationTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyBSMValidationTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,28 +27,29 @@ * @summary Test invalid name in name and type * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyBSMValidationTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMValidationTest + * @run junit CondyBSMValidationTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyBSMValidationTest */ -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; -import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.util.stream.Stream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class CondyBSMValidationTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); static final String BSM_TYPE = methodType(Object.class, MethodHandles.Lookup.class, String.class, Object.class) .toMethodDescriptorString(); - @DataProvider - public Object[][] invalidSignaturesProvider() throws Exception { + public static Object[][] invalidSignaturesProvider() throws Exception { return Stream.of(BSM_TYPE.replace("(", ""), BSM_TYPE.replace(")", ""), BSM_TYPE.replace("(", "").replace(")", ""), @@ -57,15 +58,13 @@ public class CondyBSMValidationTest { .map(e -> new Object[]{e}).toArray(Object[][]::new); } - @Test(dataProvider = "invalidSignaturesProvider") + @ParameterizedTest + @MethodSource("invalidSignaturesProvider") public void testInvalidBSMSignature(String sig) throws Exception { - try { - MethodHandle mh = InstructionHelper.ldcDynamicConstant( - L, "name", "Ljava/lang/Object;", - "bsm", sig - ); - } catch (IllegalArgumentException e) { - Assert.assertTrue(e.getMessage().contains("Bad method descriptor")); - } + var e = assertThrows(IllegalArgumentException.class, () -> InstructionHelper.ldcDynamicConstant( + L, "name", "Ljava/lang/Object;", + "bsm", sig + )); + assertTrue(e.getMessage().contains("Bad method descriptor")); } } diff --git a/test/jdk/java/lang/invoke/condy/CondyInterfaceWithOverpassMethods.java b/test/jdk/java/lang/invoke/condy/CondyInterfaceWithOverpassMethods.java index 9fd35ed21f0..fe477d87657 100644 --- a/test/jdk/java/lang/invoke/condy/CondyInterfaceWithOverpassMethods.java +++ b/test/jdk/java/lang/invoke/condy/CondyInterfaceWithOverpassMethods.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,20 +27,20 @@ * @summary Test for an interface using condy with default overpass methods * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyInterfaceWithOverpassMethods - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyInterfaceWithOverpassMethods + * @run junit CondyInterfaceWithOverpassMethods + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyInterfaceWithOverpassMethods */ import java.lang.classfile.ClassFile; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.constant.*; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; -@Test +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + public class CondyInterfaceWithOverpassMethods { interface A { int a(); @@ -52,14 +52,14 @@ public class CondyInterfaceWithOverpassMethods { // Generated class with methods containing condy ldc - Class gc; + static Class gc; public static Object bsm(MethodHandles.Lookup l, String name, Class type) { return name; } - @BeforeClass - public void generateClass() throws Exception { + @BeforeAll + public static void generateClass() throws Exception { // interface B extends A { // // Overpass for method A.a // diff --git a/test/jdk/java/lang/invoke/condy/CondyNameValidationTest.java b/test/jdk/java/lang/invoke/condy/CondyNameValidationTest.java index 6178b85236b..b380c28dc94 100644 --- a/test/jdk/java/lang/invoke/condy/CondyNameValidationTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyNameValidationTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,13 +27,10 @@ * @summary Test invalid name in name and type * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyNameValidationTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyNameValidationTest + * @run junit CondyNameValidationTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyNameValidationTest */ -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.invoke.MethodHandle; @@ -43,12 +40,17 @@ import java.util.stream.Stream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class CondyNameValidationTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); static final MethodType BSM_TYPE = methodType(Object.class, MethodHandles.Lookup.class, String.class, Object.class); - @DataProvider - public Object[][] invalidNamesProvider() { + public static Object[][] invalidNamesProvider() { return Stream.of( new Object[]{"", "zero-length member name"}, new Object[]{".", "Invalid member name"}, @@ -59,26 +61,24 @@ public class CondyNameValidationTest { .toArray(Object[][]::new); } - @Test(dataProvider = "invalidNamesProvider") + @ParameterizedTest + @MethodSource("invalidNamesProvider") public void testInvalidNames(String name, String errMessContent) throws Exception { - try { - MethodHandle mh = InstructionHelper.ldcDynamicConstant( - L, name, Object.class, - "bsm", BSM_TYPE - ); - } catch (IllegalArgumentException e) { - Assert.assertTrue(e.getMessage().contains(errMessContent)); - } + var e = assertThrows(IllegalArgumentException.class, () -> InstructionHelper.ldcDynamicConstant( + L, name, Object.class, + "bsm", BSM_TYPE + )); + assertTrue(e.getMessage().contains(errMessContent)); } - @DataProvider - public Object[][] validNamesProvider() throws Exception { + public static Object[][] validNamesProvider() throws Exception { return Stream.of("", "") .map(e -> new Object[]{e}).toArray(Object[][]::new); } - @Test(dataProvider = "validNamesProvider") + @ParameterizedTest + @MethodSource("validNamesProvider") public void testValidNames(String name) throws Exception { MethodHandle mh = InstructionHelper.ldcDynamicConstant( L, name, Object.class, diff --git a/test/jdk/java/lang/invoke/condy/CondyNestedTest.java b/test/jdk/java/lang/invoke/condy/CondyNestedTest.java index 8eb71ec93a3..192bbeaa46f 100644 --- a/test/jdk/java/lang/invoke/condy/CondyNestedTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyNestedTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,24 +26,25 @@ * @bug 8186046 * @summary Test nested dynamic constant declarations that are recursive * @compile CondyNestedTest_Code.jcod - * @run testng CondyNestedTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyNestedTest + * @run junit CondyNestedTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyNestedTest */ -import org.testng.Assert; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandles; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class CondyNestedTest { static final Class[] THROWABLES = {InvocationTargetException.class, StackOverflowError.class}; private static final MethodHandles.Lookup L = MethodHandles.lookup(); - Class c; + static Class c; // static final MethodHandles.Lookup L = MethodHandles.lookup(); // @@ -243,28 +244,17 @@ public class CondyNestedTest { // } static void test(Method m, Class... ts) { - Throwable caught = null; - try { - m.invoke(null); - } catch (Throwable t) { - caught = t; - } + Throwable caught = assertThrows(Throwable.class, () -> m.invoke(null)); - if (caught == null) { - Assert.fail("Throwable expected"); - } - - String actualMessage = null; for (int i = 0; i < ts.length; i++) { - actualMessage = caught.getMessage(); - Assert.assertNotNull(caught); - Assert.assertTrue(ts[i].isAssignableFrom(caught.getClass())); + int level = i; + assertInstanceOf(ts[i], caught, () -> "Level %d".formatted(level)); caught = caught.getCause(); } } - @BeforeClass - public void findClass() throws Exception { + @BeforeAll + public static void findClass() throws Exception { c = Class.forName("CondyNestedTest_Code"); } diff --git a/test/jdk/java/lang/invoke/condy/CondyRepeatFailedResolution.java b/test/jdk/java/lang/invoke/condy/CondyRepeatFailedResolution.java index 7ef5c610150..b7ccb4944fb 100644 --- a/test/jdk/java/lang/invoke/condy/CondyRepeatFailedResolution.java +++ b/test/jdk/java/lang/invoke/condy/CondyRepeatFailedResolution.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -26,28 +26,28 @@ * @bug 8186211 * @summary Test basic invocation of multiple ldc's of the same dynamic constant that fail resolution * @library /java/lang/invoke/common - * @run testng CondyRepeatFailedResolution - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyRepeatFailedResolution + * @run junit CondyRepeatFailedResolution + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyRepeatFailedResolution */ import java.lang.classfile.ClassFile; -import org.testng.Assert; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; - import java.lang.constant.*; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -@Test +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class CondyRepeatFailedResolution { // Counter used to determine if a given BSM is invoked more than once static int bsm_called = 0; // Generated class with methods containing condy ldc - Class gc; + static Class gc; // Bootstrap method used to represent primitive values // that cannot be represented directly in the constant pool, @@ -90,8 +90,8 @@ public class CondyRepeatFailedResolution { } } - @BeforeClass - public void generateClass() throws Exception { + @BeforeAll + public static void generateClass() throws Exception { String genClassName = CondyRepeatFailedResolution.class.getSimpleName() + "$Code"; String bsmClassDesc = CondyRepeatFailedResolution.class.descriptorString(); String bsmMethodName = "intConversion"; @@ -319,29 +319,21 @@ public class CondyRepeatFailedResolution { Method m = gc.getDeclaredMethod(name); bsm_called = 0; - try { + InvocationTargetException e1 = assertThrows(InvocationTargetException.class, () -> { Object r1 = m.invoke(null); - Assert.fail("InvocationTargetException expected to be thrown after first invocation"); - } catch (InvocationTargetException e1) { - // bsm_called should have been incremented prior to the exception - Assert.assertEquals(bsm_called, 1); - Assert.assertTrue(e1.getCause() instanceof BootstrapMethodError); - // Try invoking method again to ensure that the bootstrap - // method is not invoked twice and a resolution failure - // results. - try { - Object r2 = m.invoke(null); - Assert.fail("InvocationTargetException expected to be thrown after second invocation"); - } catch (InvocationTargetException e2) { - // bsm_called should remain at 1 since the bootstrap - // method should not have been invoked. - Assert.assertEquals(bsm_called, 1); - Assert.assertTrue(e2.getCause() instanceof BootstrapMethodError); - } catch (Throwable t2) { - Assert.fail("InvocationTargetException expected to be thrown"); - } - } catch (Throwable t1) { - Assert.fail("InvocationTargetException expected to be thrown"); - } + }); + // bsm_called should have been incremented prior to the exception + assertEquals(1, bsm_called); + assertInstanceOf(BootstrapMethodError.class, e1.getCause()); + // Try invoking method again to ensure that the bootstrap + // method is not invoked twice and a resolution failure + // results. + InvocationTargetException e2 = assertThrows(InvocationTargetException.class, () -> { + Object r2 = m.invoke(null); + }); + // bsm_called should remain at 1 since the bootstrap + // method should not have been invoked. + assertEquals(1, bsm_called); + assertInstanceOf(BootstrapMethodError.class, e2.getCause()); } } diff --git a/test/jdk/java/lang/invoke/condy/CondyReturnPrimitiveTest.java b/test/jdk/java/lang/invoke/condy/CondyReturnPrimitiveTest.java index d6c0748c97c..4c0dd42a1a2 100644 --- a/test/jdk/java/lang/invoke/condy/CondyReturnPrimitiveTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyReturnPrimitiveTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,22 +25,23 @@ * @test * @bug 8186046 * @summary Test for condy BSMs returning primitive values or null - * @run testng CondyReturnPrimitiveTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyReturnPrimitiveTest + * @run junit CondyReturnPrimitiveTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyReturnPrimitiveTest */ import java.lang.classfile.ClassFile; -import org.testng.Assert; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; - import java.lang.constant.*; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.reflect.Method; import java.util.concurrent.atomic.AtomicInteger; -@Test +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; + public class CondyReturnPrimitiveTest { // Counter for number of BSM calls // Use of an AtomicInteger is not strictly necessary in this test @@ -49,7 +50,7 @@ public class CondyReturnPrimitiveTest { // constant so care should be taken if a BSM operates on shared state static final AtomicInteger callCount = new AtomicInteger(); // Generated class with methods containing condy ldc - Class gc; + static Class gc; // Bootstrap method used to represent primitive values // that cannot be represented directly in the constant pool, @@ -90,8 +91,8 @@ public class CondyReturnPrimitiveTest { } } - @BeforeClass - public void generateClass() throws Exception { + @BeforeAll + public static void generateClass() throws Exception { String genClassName = CondyReturnPrimitiveTest.class.getSimpleName() + "$Code"; String bsmClassDesc = CondyReturnPrimitiveTest.class.descriptorString(); String bsmMethodName = "intConversion"; @@ -293,7 +294,7 @@ public class CondyReturnPrimitiveTest { // Ensure when run a second time that the bootstrap method is not // invoked and the constants are cached testConstants(); - Assert.assertEquals(callCount.get(), expectedCallCount); + assertEquals(expectedCallCount, callCount.get()); } @Test @@ -318,11 +319,16 @@ public class CondyReturnPrimitiveTest { testConstant("S", Short.MAX_VALUE); testConstant("Z_F", false); testConstant("Z_T", true); - testConstant("null", null); + testConstant("null", (Object) null); } void testConstant(String name, Object expected) throws Exception { Method m = gc.getDeclaredMethod(name); - Assert.assertEquals(m.invoke(null), expected); + assertEquals(expected, m.invoke(null)); + } + + void testConstant(String name, Object[] expected) throws Exception { + Method m = gc.getDeclaredMethod(name); + assertArrayEquals(expected, (Object[]) m.invoke(null)); } } diff --git a/test/jdk/java/lang/invoke/condy/CondyStaticArgumentsTest.java b/test/jdk/java/lang/invoke/condy/CondyStaticArgumentsTest.java index ba3d0e81488..075eaf4e844 100644 --- a/test/jdk/java/lang/invoke/condy/CondyStaticArgumentsTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyStaticArgumentsTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,12 +27,10 @@ * @summary Test bootstrap arguments for condy * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyStaticArgumentsTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyStaticArgumentsTest + * @run junit CondyStaticArgumentsTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyStaticArgumentsTest */ -import org.testng.Assert; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.constant.*; @@ -44,6 +42,9 @@ import java.util.StringJoiner; import java.util.stream.Stream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; public class CondyStaticArgumentsTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); @@ -109,7 +110,7 @@ public class CondyStaticArgumentsTest { mhi.getName(), MethodTypeDesc.ofDescriptor(mhi.getMethodType().descriptorString())) ); - Assert.assertEquals(mh.invoke(), "constant-name-String-1-2-3.0-4.0-Number-something-(int,long,float,double)void-11"); + assertEquals("constant-name-String-1-2-3.0-4.0-Number-something-(int,long,float,double)void-11", mh.invoke()); } static MathContext mathContext(MethodHandles.Lookup l, String value, Class type) { @@ -161,7 +162,7 @@ public class CondyStaticArgumentsTest { ) ) ); - Assert.assertEquals(mh.invoke(), "big-decimal-math-context-String-3.141593-7"); + assertEquals("big-decimal-math-context-String-3.141593-7", mh.invoke()); } @@ -194,7 +195,7 @@ public class CondyStaticArgumentsTest { InstructionHelper.classDesc(MathContext.class) ) )); - Assert.assertEquals(mh.invoke(), "big-decimal-math-context-()Ljava/lang/String;-3.141593-7"); + assertEquals("big-decimal-math-context-()Ljava/lang/String;-3.141593-7", mh.invoke()); } private static DirectMethodHandleDesc directMhDesc(String methodName) { diff --git a/test/jdk/java/lang/invoke/condy/CondyTypeValidationTest.java b/test/jdk/java/lang/invoke/condy/CondyTypeValidationTest.java index c44179ce13c..4429468bd34 100644 --- a/test/jdk/java/lang/invoke/condy/CondyTypeValidationTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyTypeValidationTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,12 +27,9 @@ * @summary Test invalid name in name and type * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyTypeValidationTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyTypeValidationTest */ -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.invoke.MethodHandle; @@ -43,14 +40,18 @@ import java.util.stream.Collectors; import java.util.stream.Stream; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; public class CondyTypeValidationTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); static final String BSM_TYPE = methodType(Object.class, MethodHandles.Lookup.class, String.class, Object.class) .toMethodDescriptorString(); - @DataProvider - public Object[][] invalidTypesProvider() { + public static Object[][] invalidTypesProvider() { return Stream.of( // ByteCode API checks for the following invalid types // "", @@ -66,20 +67,19 @@ public class CondyTypeValidationTest { ).toArray(Object[][]::new); } - @Test(dataProvider = "invalidTypesProvider") + @ParameterizedTest + @MethodSource("invalidTypesProvider") public void testInvalidTypes(String type, String errMessContent) throws Exception { - try { + var e = assertThrows(IllegalArgumentException.class, () -> { MethodHandle mh = InstructionHelper.ldcDynamicConstant( L, "name", type, "bsm", BSM_TYPE ); - } catch (IllegalArgumentException e) { - Assert.assertTrue(e.getMessage().contains(errMessContent)); - } + }); + assertTrue(e.getMessage().contains(errMessContent)); } - @DataProvider - public Object[][] validTypesProvider() { + public static Object[][] validTypesProvider() { List t = new ArrayList<>(List.of("B", "C", "D", "F", "I", "J", "Ljava/lang/Object;", "S", "Z")); int l = t.size(); for (int i = 0; i < l; i++) { @@ -90,7 +90,8 @@ public class CondyTypeValidationTest { .map(e -> new Object[]{e}).toArray(Object[][]::new); } - @Test(dataProvider = "validTypesProvider") + @ParameterizedTest + @MethodSource("validTypesProvider") public void testValidTypes(String type) throws Exception { MethodHandle mh = InstructionHelper.ldcDynamicConstant( L, "name", type, diff --git a/test/jdk/java/lang/invoke/condy/CondyWithGarbageTest.java b/test/jdk/java/lang/invoke/condy/CondyWithGarbageTest.java index 5e301a193dd..a00f93b69b7 100644 --- a/test/jdk/java/lang/invoke/condy/CondyWithGarbageTest.java +++ b/test/jdk/java/lang/invoke/condy/CondyWithGarbageTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,21 +27,20 @@ * @summary Stress test ldc to ensure HotSpot correctly manages oop maps * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyWithGarbageTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyWithGarbageTest + * @run junit CondyWithGarbageTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyWithGarbageTest */ - import java.lang.classfile.ClassFile; import java.lang.classfile.CodeBuilder; -import org.testng.Assert; -import org.testng.annotations.Test; - import java.lang.constant.*; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertTrue; import static test.java.lang.invoke.lib.InstructionHelper.classDesc; public class CondyWithGarbageTest { @@ -54,7 +53,7 @@ public class CondyWithGarbageTest { for (int i = 0; i < 100000; i++) { l += +((String) mh.invoke()).length(); } - Assert.assertTrue(l > 0); + assertTrue(l > 0); } public static Object bsmString(MethodHandles.Lookup l, @@ -133,7 +132,7 @@ public class CondyWithGarbageTest { for (int i = 0; i < 100000; i++) { l += +((String) mh.invoke()).length(); } - Assert.assertTrue(l > 0); + assertTrue(l > 0); } public static Object bsmStringArray(MethodHandles.Lookup l, diff --git a/test/jdk/java/lang/invoke/condy/CondyWrongType.java b/test/jdk/java/lang/invoke/condy/CondyWrongType.java index 42c69e8ab7d..1c00da922fe 100644 --- a/test/jdk/java/lang/invoke/condy/CondyWrongType.java +++ b/test/jdk/java/lang/invoke/condy/CondyWrongType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,13 +27,10 @@ * @summary Test bootstrap methods returning the wrong type * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng CondyWrongType - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyWrongType + * @run junit CondyWrongType + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyWrongType */ -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; import test.java.lang.invoke.lib.InstructionHelper; import java.lang.invoke.MethodHandle; @@ -46,11 +43,15 @@ import java.util.List; import java.util.Map; import static java.lang.invoke.MethodType.methodType; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.*; public class CondyWrongType { - @DataProvider - public Object[][] primitivesProvider() throws Exception { + public static Object[][] primitivesProvider() throws Exception { Map> typeMap = Map.of( "B", byte.class, "C", char.class, @@ -81,7 +82,8 @@ public class CondyWrongType { return cases.stream().toArray(Object[][]::new); } - @Test(dataProvider = "primitivesProvider") + @ParameterizedTest + @MethodSource("primitivesProvider") public void testPrimitives(String name, String type, boolean pass) { test(name, type, pass); } @@ -106,27 +108,12 @@ public class CondyWrongType { static void test(String name, String type, boolean pass) { MethodHandle mh = caster(name, type); - Throwable caught = null; - try { - mh.invoke(); - } catch (Throwable t) { - caught = t; + if (pass) { + assertDoesNotThrow(() -> mh.invoke()); + } else { + Throwable caught = assertThrows(BootstrapMethodError.class, () -> mh.invoke()); + assertInstanceOf(ClassCastException.class, caught.getCause()); } - - if (caught == null) { - if (pass) { - return; - } else { - Assert.fail("Throwable expected"); - } - } else if (pass) { - Assert.fail("Throwable not expected"); - } - - Assert.assertTrue(BootstrapMethodError.class.isAssignableFrom(caught.getClass())); - caught = caught.getCause(); - Assert.assertNotNull(caught); - Assert.assertTrue(ClassCastException.class.isAssignableFrom(caught.getClass())); } static Object bsm(MethodHandles.Lookup l, String name, Class type) { diff --git a/test/jdk/java/lang/invoke/condy/ConstantBootstrapsTest.java b/test/jdk/java/lang/invoke/condy/ConstantBootstrapsTest.java index 829f26704f9..cef5a17eda1 100644 --- a/test/jdk/java/lang/invoke/condy/ConstantBootstrapsTest.java +++ b/test/jdk/java/lang/invoke/condy/ConstantBootstrapsTest.java @@ -27,27 +27,31 @@ * @summary Test dynamic constant bootstraps * @library /java/lang/invoke/common * @build test.java.lang.invoke.lib.InstructionHelper - * @run testng ConstantBootstrapsTest - * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 ConstantBootstrapsTest + * @run junit ConstantBootstrapsTest + * @run junit/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 ConstantBootstrapsTest */ -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import test.java.lang.invoke.lib.InstructionHelper; - import java.lang.constant.ConstantDescs; import java.lang.constant.DirectMethodHandleDesc; import java.lang.constant.MethodHandleDesc; -import java.lang.invoke.*; +import java.lang.invoke.ConstantBootstraps; +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.MethodType; +import java.lang.invoke.VarHandle; +import java.lang.invoke.WrongMethodTypeException; import java.math.BigInteger; import java.util.Collection; import java.util.List; import java.util.Map; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertNull; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import test.java.lang.invoke.lib.InstructionHelper; + +import static org.junit.jupiter.api.Assertions.*; -@Test public class ConstantBootstrapsTest { static final MethodHandles.Lookup L = MethodHandles.lookup(); @@ -56,6 +60,7 @@ public class ConstantBootstrapsTest { appendParameterTypes(params); } + @Test public void testNullConstant() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant(L, "_", Object.class, ConstantBootstraps.class, "nullConstant", lookupMT(Object.class)); @@ -66,12 +71,13 @@ public class ConstantBootstrapsTest { assertNull(handle.invoke()); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testNullConstantPrimitiveClass() { - ConstantBootstraps.nullConstant(MethodHandles.lookup(), null, int.class); + assertThrows(IllegalArgumentException.class, () -> ConstantBootstraps.nullConstant(MethodHandles.lookup(), null, int.class)); } + @Test public void testPrimitiveClass() throws Throwable { var pm = Map.of( "I", int.class, @@ -88,69 +94,73 @@ public class ConstantBootstrapsTest { for (var desc : pm.keySet()) { var handle = InstructionHelper.ldcDynamicConstant(L, desc, Class.class, ConstantBootstraps.class, "primitiveClass", lookupMT(Class.class)); - assertEquals(handle.invoke(), pm.get(desc)); + assertEquals(pm.get(desc), handle.invoke()); } } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testPrimitiveClassNullName() { - ConstantBootstraps.primitiveClass(MethodHandles.lookup(), null, Class.class); + assertThrows(NullPointerException.class, () -> ConstantBootstraps.primitiveClass(MethodHandles.lookup(), null, Class.class)); } - @Test(expectedExceptions = NullPointerException.class) + @Test public void testPrimitiveClassNullType() { - ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "I", null); + assertThrows(NullPointerException.class, () -> ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "I", null)); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testPrimitiveClassEmptyName() { - ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "", Class.class); + assertThrows(IllegalArgumentException.class, () -> ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "", Class.class)); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testPrimitiveClassWrongNameChar() { - ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "L", Class.class); + assertThrows(IllegalArgumentException.class, () -> ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "L", Class.class)); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testPrimitiveClassWrongNameString() { - ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "Ljava/lang/Object;", Class.class); + assertThrows(IllegalArgumentException.class, () -> ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "Ljava/lang/Object;", Class.class)); } + @Test public void testEnumConstant() throws Throwable { for (var v : StackWalker.Option.values()) { var handle = InstructionHelper.ldcDynamicConstant(L, v.name(), StackWalker.Option.class, ConstantBootstraps.class, "enumConstant", lookupMT(Enum.class)); - assertEquals(handle.invoke(), v); + assertEquals(v, handle.invoke()); } } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void testEnumConstantUnknown() { - ConstantBootstraps.enumConstant(MethodHandles.lookup(), "DOES_NOT_EXIST", StackWalker.Option.class); + assertThrows(IllegalArgumentException.class, () -> ConstantBootstraps.enumConstant(MethodHandles.lookup(), "DOES_NOT_EXIST", StackWalker.Option.class)); } + @Test public void testGetStaticDecl() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant(L, "TYPE", Class.class, ConstantBootstraps.class, "getStaticFinal", lookupMT(Object.class, Class.class), InstructionHelper.classDesc(Integer.class)); - assertEquals(handle.invoke(), int.class); + assertEquals(int.class, handle.invoke()); } + @Test public void testGetStaticSelf() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant(L, "MAX_VALUE", int.class, ConstantBootstraps.class, "getStaticFinal", lookupMT(Object.class)); - assertEquals(handle.invoke(), Integer.MAX_VALUE); + assertEquals(Integer.MAX_VALUE, handle.invoke()); handle = InstructionHelper.ldcDynamicConstant(L, "ZERO", BigInteger.class, ConstantBootstraps.class, "getStaticFinal", lookupMT(Object.class)); - assertEquals(handle.invoke(), BigInteger.ZERO); + assertEquals(BigInteger.ZERO, handle.invoke()); } + @Test public void testInvoke() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant( L, "_", List.class, @@ -159,9 +169,10 @@ public class ConstantBootstrapsTest { MethodType.methodType(List.class, Object[].class).toMethodDescriptorString()), 1, 2, 3, 4 ); - assertEquals(handle.invoke(), List.of(1, 2, 3, 4)); + assertEquals(List.of(1, 2, 3, 4), handle.invoke()); } + @Test public void testInvokeAsType() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant( L, "_", int.class, @@ -170,9 +181,10 @@ public class ConstantBootstrapsTest { MethodType.methodType(Integer.class, String.class).toMethodDescriptorString()), "42" ); - assertEquals(handle.invoke(), 42); + assertEquals(42, handle.invoke()); } + @Test public void testInvokeAsTypeVariableArity() throws Throwable { // The constant type is Collection but the invoke return type is List var handle = InstructionHelper.ldcDynamicConstant( @@ -182,21 +194,21 @@ public class ConstantBootstrapsTest { MethodType.methodType(List.class, Object[].class).toMethodDescriptorString()), 1, 2, 3, 4 ); - assertEquals(handle.invoke(), List.of(1, 2, 3, 4)); + assertEquals(List.of(1, 2, 3, 4), handle.invoke()); } - @Test(expectedExceptions = ClassCastException.class) + @Test public void testInvokeAsTypeClassCast() throws Throwable { - ConstantBootstraps.invoke(MethodHandles.lookup(), "_", String.class, + assertThrows(ClassCastException.class, () -> ConstantBootstraps.invoke(MethodHandles.lookup(), "_", String.class, MethodHandles.lookup().findStatic(Integer.class, "valueOf", MethodType.methodType(Integer.class, String.class)), - "42"); + "42")); } - @Test(expectedExceptions = WrongMethodTypeException.class) + @Test public void testInvokeAsTypeWrongReturnType() throws Throwable { - ConstantBootstraps.invoke(MethodHandles.lookup(), "_", short.class, + assertThrows(WrongMethodTypeException.class, () -> ConstantBootstraps.invoke(MethodHandles.lookup(), "_", short.class, MethodHandles.lookup().findStatic(Integer.class, "parseInt", MethodType.methodType(int.class, String.class)), - "42"); + "42")); } @@ -205,6 +217,7 @@ public class ConstantBootstrapsTest { public static String sf; } + @Test public void testVarHandleField() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant( L, "f", VarHandle.class, @@ -214,10 +227,11 @@ public class ConstantBootstrapsTest { ); var vhandle = (VarHandle) handle.invoke(); - assertEquals(vhandle.varType(), String.class); - assertEquals(vhandle.coordinateTypes(), List.of(X.class)); + assertEquals(String.class, vhandle.varType()); + assertEquals(List.of(X.class), vhandle.coordinateTypes()); } + @Test public void testVarHandleStaticField() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant( L, "sf", VarHandle.class, @@ -227,10 +241,11 @@ public class ConstantBootstrapsTest { ); var vhandle = (VarHandle) handle.invoke(); - assertEquals(vhandle.varType(), String.class); - assertEquals(vhandle.coordinateTypes(), List.of()); + assertEquals(String.class, vhandle.varType()); + assertEquals(List.of(), vhandle.coordinateTypes()); } + @Test public void testVarHandleArray() throws Throwable { var handle = InstructionHelper.ldcDynamicConstant( L, "_", VarHandle.class, @@ -239,11 +254,10 @@ public class ConstantBootstrapsTest { ); var vhandle = (VarHandle) handle.invoke(); - assertEquals(vhandle.varType(), String.class); - assertEquals(vhandle.coordinateTypes(), List.of(String[].class, int.class)); + assertEquals(String.class, vhandle.varType()); + assertEquals(List.of(String[].class, int.class), vhandle.coordinateTypes()); } - @DataProvider public static Object[][] cceCasts() { return new Object[][]{ { void.class, null }, @@ -252,12 +266,12 @@ public class ConstantBootstrapsTest { }; } - @Test(dataProvider = "cceCasts", expectedExceptions = ClassCastException.class) + @ParameterizedTest + @MethodSource("cceCasts") public void testBadCasts(Class dstType, Object value) { - ConstantBootstraps.explicitCast(null, null, dstType, value); + assertThrows(ClassCastException.class, () -> ConstantBootstraps.explicitCast(null, null, dstType, value)); } - @DataProvider public static Object[][] validCasts() { Object o = new Object(); return new Object[][]{ @@ -278,9 +292,10 @@ public class ConstantBootstrapsTest { }; } - @Test(dataProvider = "validCasts") + @ParameterizedTest + @MethodSource("validCasts") public void testSuccessfulCasts(Class dstType, Object value, Object expected) { Object actual = ConstantBootstraps.explicitCast(null, null, dstType, value); - assertEquals(actual, expected); + assertEquals(expected, actual); } } diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/BasicTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/BasicTest.java index 379ae765a6b..097e7c782a5 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/BasicTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/BasicTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -31,7 +31,7 @@ * BadClassFileVersion.jcod * @build jdk.test.lib.Utils * jdk.test.lib.compiler.CompilerUtils - * @run testng/othervm BasicTest + * @run junit/othervm BasicTest */ import java.io.File; @@ -52,16 +52,16 @@ import java.util.stream.Stream; import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.Utils; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import static java.lang.classfile.ClassFile.*; import static java.lang.constant.ConstantDescs.CD_Enum; import static java.lang.constant.ConstantDescs.CD_Object; import static java.lang.invoke.MethodHandles.lookup; import static java.lang.invoke.MethodHandles.Lookup.ClassOption.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; interface HiddenTest { void test(); @@ -75,7 +75,7 @@ public class BasicTest { private static byte[] hiddenClassBytes; - @BeforeTest + @BeforeAll static void setup() throws IOException { compileSources(SRC_DIR, CLASSES_DIR); hiddenClassBytes = Files.readAllBytes(CLASSES_DIR.resolve("HiddenClass.class")); @@ -114,9 +114,9 @@ public class BasicTest { Class[] intfs = c.getInterfaces(); assertTrue(c.isHidden()); assertFalse(c.isPrimitive()); - assertTrue(intfs.length == 1); - assertTrue(intfs[0] == HiddenTest.class); - assertTrue(c.getCanonicalName() == null); + assertEquals(1, intfs.length); + assertSame(HiddenTest.class, intfs[0]); + assertNull(c.getCanonicalName()); String hcName = "HiddenClass"; String hcSuffix = "0x[0-9a-f]+"; @@ -143,7 +143,7 @@ public class BasicTest { Object array = Array.newInstance(type, 2); Class arrayType = array.getClass(); assertTrue(arrayType.isArray()); - assertTrue(Array.getLength(array) == 2); + assertEquals(2, Array.getLength(array)); assertFalse(arrayType.isHidden()); String hcName = "HiddenClass"; @@ -152,11 +152,11 @@ public class BasicTest { assertTrue(arrayType.descriptorString().matches("\\[" + "L" + hcName + "." + hcSuffix + ";")); assertTrue(arrayType.getComponentType().isHidden()); - assertTrue(arrayType.getComponentType() == type); + assertSame(type, arrayType.getComponentType()); Object t = type.newInstance(); Array.set(array, 0, t); Object o = Array.get(array, 0); - assertTrue(o == t); + assertSame(t, o); } private void checkSetAccessible(Class c, String name, Class... ptypes) throws Exception { @@ -170,13 +170,8 @@ public class BasicTest { @Test public void testLambda() throws Throwable { HiddenTest t = (HiddenTest)defineHiddenClass("Lambda").newInstance(); - try { - t.test(); - } catch (Error e) { - if (!e.getMessage().equals("thrown by " + t.getClass().getName())) { - throw e; - } - } + var e = assertThrows(Error.class, t::test); + assertEquals("thrown by " + t.getClass().getName(), e.getMessage()); } // Define a hidden class that uses lambda and contains its implementation @@ -184,13 +179,8 @@ public class BasicTest { @Test public void testHiddenLambda() throws Throwable { HiddenTest t = (HiddenTest)defineHiddenClass("HiddenLambda").newInstance(); - try { - t.test(); - } catch (Error e) { - if (!e.getMessage().equals("thrown by " + t.getClass().getName())) { - throw e; - } - } + var e = assertThrows(Error.class, t::test); + assertEquals("thrown by " + t.getClass().getName(), e.getMessage()); } // Verify the nest host and nest members of a hidden class and hidden nestmate class @@ -206,19 +196,18 @@ public class BasicTest { // test nest membership and reflection API assertTrue(host.isNestmateOf(member)); - assertTrue(host.getNestHost() == host); + assertSame(host, host.getNestHost()); // getNestHost and getNestMembers return the same value when calling // on a nest member and the nest host - assertTrue(member.getNestHost() == host.getNestHost()); - assertTrue(Arrays.equals(member.getNestMembers(), host.getNestMembers())); + assertSame(host.getNestHost(), member.getNestHost()); + assertArrayEquals(member.getNestMembers(), host.getNestMembers()); // getNestMembers includes the nest host that can be a hidden class but // only includes static nest members - assertTrue(host.getNestMembers().length == 1); - assertTrue(host.getNestMembers()[0] == host); + assertEquals(1, host.getNestMembers().length); + assertSame(host, host.getNestMembers()[0]); } - @DataProvider(name = "hiddenClasses") - private Object[][] hiddenClasses() { + private static Object[][] hiddenClasses() { return new Object[][] { new Object[] { "HiddenInterface", false }, new Object[] { "AbstractClass", false }, @@ -240,7 +229,8 @@ public class BasicTest { * is not useful as it cannot be referenced and an outer/inner class * when defined as a hidden effectively becomes a final top-level class. */ - @Test(dataProvider = "hiddenClasses") + @ParameterizedTest + @MethodSource("hiddenClasses") public void defineHiddenClass(String name, boolean nestmate) throws Exception { byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve(name + ".class")); Class hc; @@ -252,13 +242,12 @@ public class BasicTest { hc = lookup().defineHiddenClass(bytes, false).lookupClass(); host = hc; } - assertTrue(hc.getNestHost() == host); - assertTrue(hc.getNestMembers().length == 1); - assertTrue(hc.getNestMembers()[0] == host); + assertSame(host, hc.getNestHost()); + assertEquals(1, hc.getNestMembers().length); + assertSame(host, hc.getNestMembers()[0]); } - @DataProvider(name = "emptyClasses") - private Object[][] emptyClasses() { + private static Object[][] emptyClasses() { return new Object[][] { new Object[] { "EmptyHiddenSynthetic", ACC_SYNTHETIC }, new Object[] { "EmptyHiddenEnum", ACC_ENUM }, @@ -276,7 +265,8 @@ public class BasicTest { * enum class containing constants of its type should not be a hidden * class. */ - @Test(dataProvider = "emptyClasses") + @ParameterizedTest + @MethodSource("emptyClasses") public void emptyHiddenClass(String name, int accessFlags) throws Exception { byte[] bytes = (accessFlags == ACC_ENUM) ? classBytes(name, CD_Enum, accessFlags) : classBytes(name, accessFlags); @@ -316,7 +306,7 @@ public class BasicTest { throw new IllegalArgumentException("unexpected access flag: " + accessFlags); } assertTrue(hc.isHidden()); - assertTrue(hc.getModifiers() == (ACC_PUBLIC|accessFlags)); + assertEquals(hc.getModifiers(), ACC_PUBLIC | accessFlags); assertFalse(hc.isLocalClass()); assertFalse(hc.isMemberClass()); assertFalse(hc.isAnonymousClass()); @@ -324,8 +314,7 @@ public class BasicTest { } // These class files can't be defined as hidden classes - @DataProvider(name = "cantBeHiddenClasses") - private Object[][] cantBeHiddenClasses() { + private static Object[][] cantBeHiddenClasses() { return new Object[][] { // a hidden class can't be a field's declaring type // enum class with static final HiddenEnum[] $VALUES: @@ -342,10 +331,11 @@ public class BasicTest { /* * These class files */ - @Test(dataProvider = "cantBeHiddenClasses", expectedExceptions = NoClassDefFoundError.class) + @ParameterizedTest + @MethodSource("cantBeHiddenClasses") public void failToDeriveAsHiddenClass(String name) throws Exception { byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve(name + ".class")); - Class hc = lookup().defineHiddenClass(bytes, false).lookupClass(); + assertThrows(NoClassDefFoundError.class, () -> lookup().defineHiddenClass(bytes, false).lookupClass()); } /* @@ -361,22 +351,17 @@ public class BasicTest { Class c = t.getClass(); Class[] intfs = c.getInterfaces(); - assertTrue(intfs.length == 1); - assertTrue(intfs[0] == HiddenTest.class); + assertEquals(1, intfs.length); + assertSame(HiddenTest.class, intfs[0]); - try { - // this would cause loading of class HiddenCantReflect and NCDFE due - // to error during verification - c.getDeclaredMethods(); - } catch (NoClassDefFoundError e) { - Throwable x = e.getCause(); - if (x == null || !(x instanceof ClassNotFoundException && x.getMessage().contains("HiddenCantReflect"))) { - throw e; - } + var e = assertThrows(NoClassDefFoundError.class, c::getDeclaredMethods); + Throwable x = e.getCause(); + if (x == null || !(x instanceof ClassNotFoundException && x.getMessage().contains("HiddenCantReflect"))) { + throw e; } } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void cantDefineModule() throws Throwable { Path src = Paths.get("module-info.java"); Path dir = CLASSES_DIR.resolve("m"); @@ -384,35 +369,34 @@ public class BasicTest { compileSources(src, dir); byte[] bytes = Files.readAllBytes(dir.resolve("module-info.class")); - lookup().defineHiddenClass(bytes, false); + assertThrows(IllegalArgumentException.class, () -> lookup().defineHiddenClass(bytes, false)); } - @Test(expectedExceptions = { IllegalArgumentException.class }) + @Test public void cantDefineClassInAnotherPackage() throws Throwable { Path src = Paths.get("ClassInAnotherPackage.java"); Files.write(src, List.of("package p;", "public class ClassInAnotherPackage {}"), StandardCharsets.UTF_8); compileSources(src, CLASSES_DIR); byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve("p").resolve("ClassInAnotherPackage.class")); - lookup().defineHiddenClass(bytes, false); + assertThrows(IllegalArgumentException.class, () -> lookup().defineHiddenClass(bytes, false)); } - @Test(expectedExceptions = { IllegalAccessException.class }) + @Test public void lessPrivilegedLookup() throws Throwable { Lookup lookup = lookup().dropLookupMode(Lookup.PRIVATE); - lookup.defineHiddenClass(hiddenClassBytes, false); + assertThrows(IllegalAccessException.class, () -> lookup.defineHiddenClass(hiddenClassBytes, false)); } - @Test(expectedExceptions = { UnsupportedClassVersionError.class }) + @Test public void badClassFileVersion() throws Throwable { Path dir = Paths.get(System.getProperty("test.classes", ".")); byte[] bytes = Files.readAllBytes(dir.resolve("BadClassFileVersion.class")); - lookup().defineHiddenClass(bytes, false); + assertThrows(UnsupportedClassVersionError.class, () -> lookup().defineHiddenClass(bytes, false)); } // malformed class files - @DataProvider(name = "malformedClassFiles") - private Object[][] malformedClassFiles() throws IOException { + private static Object[][] malformedClassFiles() throws IOException { Path dir = Paths.get(System.getProperty("test.classes", ".")); return new Object[][] { // `this_class` has invalid CP entry @@ -424,13 +408,13 @@ public class BasicTest { }; } - @Test(dataProvider = "malformedClassFiles", expectedExceptions = ClassFormatError.class) + @ParameterizedTest + @MethodSource("malformedClassFiles") public void badClassFile(byte[] bytes) throws Throwable { - lookup().defineHiddenClass(bytes, false); + assertThrows(ClassFormatError.class, () -> lookup().defineHiddenClass(bytes, false)); } - @DataProvider(name = "nestedTypesOrAnonymousClass") - private Object[][] nestedTypesOrAnonymousClass() { + private static Object[][] nestedTypesOrAnonymousClass() { return new Object[][] { // class file with bad InnerClasses or EnclosingMethod attribute new Object[] { "Outer", null }, @@ -440,7 +424,8 @@ public class BasicTest { }; } - @Test(dataProvider = "nestedTypesOrAnonymousClass") + @ParameterizedTest + @MethodSource("nestedTypesOrAnonymousClass") public void hasInnerClassesOrEnclosingMethodAttribute(String className, String badDeclaringClassName) throws Throwable { byte[] bytes = Files.readAllBytes(CLASSES_10_DIR.resolve(className + ".class")); Class hc = lookup().defineHiddenClass(bytes, false).lookupClass(); @@ -460,21 +445,22 @@ public class BasicTest { byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve("Outer.class")); Class hc = lookup().defineHiddenClass(bytes, false).lookupClass(); assertHiddenClass(hc); - assertTrue(hc.getNestHost() == hc); + assertSame(hc, hc.getNestHost()); Class[] members = hc.getNestMembers(); - assertTrue(members.length == 1 && members[0] == hc); + assertEquals(1, members.length); + assertSame(hc, members[0]); } // a hidden class with bad InnerClasses or EnclosingMethod attribute private void hiddenClassWithBadAttribute(Class hc, String badDeclaringClassName) { assertTrue(hc.isHidden()); - assertTrue(hc.getCanonicalName() == null); + assertNull(hc.getCanonicalName()); assertTrue(hc.getName().contains("/")); if (badDeclaringClassName == null) { // the following reflection API assumes a good name in InnerClasses // or EnclosingMethod attribute can successfully be resolved. - assertTrue(hc.getSimpleName().length() > 0); + assertFalse(hc.getSimpleName().isEmpty()); assertFalse(hc.isAnonymousClass()); assertFalse(hc.isLocalClass()); assertFalse(hc.isMemberClass()); @@ -483,43 +469,34 @@ public class BasicTest { } // validation of nest membership - assertTrue(hc.getNestHost() == hc); + assertSame(hc, hc.getNestHost()); // validate the static nest membership Class[] members = hc.getNestMembers(); - assertTrue(members.length == 1 && members[0] == hc); + assertEquals(1, members.length); + assertSame(hc, members[0]); } // Class::getSimpleName, Class::isMemberClass private void declaringClassNotFound(Class c, String cn) { - try { - // fail to find declaring/enclosing class - c.isMemberClass(); - assertTrue(false); - } catch (NoClassDefFoundError e) { - if (!e.getMessage().equals(cn)) { - throw e; - } + var e = assertThrows(NoClassDefFoundError.class, c::isMemberClass); + if (!e.getMessage().equals(cn)) { + throw e; } - try { - // fail to find declaring/enclosing class - c.getSimpleName(); - assertTrue(false); - } catch (NoClassDefFoundError e) { - if (!e.getMessage().equals(cn)) { - throw e; - } + e = assertThrows(NoClassDefFoundError.class, c::getSimpleName); + if (!e.getMessage().equals(cn)) { + throw e; } } private static void singletonNest(Class hc) { - assertTrue(hc.getNestHost() == hc); - assertTrue(hc.getNestMembers().length == 1); - assertTrue(hc.getNestMembers()[0] == hc); + assertSame(hc, hc.getNestHost()); + assertEquals(1, hc.getNestMembers().length); + assertSame(hc, hc.getNestMembers()[0]); } private static void assertHiddenClass(Class hc) { assertTrue(hc.isHidden()); - assertTrue(hc.getCanonicalName() == null); + assertNull(hc.getCanonicalName()); assertTrue(hc.getName().contains("/")); assertFalse(hc.isAnonymousClass()); assertFalse(hc.isLocalClass()); diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/HiddenNestmateTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/HiddenNestmateTest.java index e026a7a1387..a71029dd229 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/HiddenNestmateTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/HiddenNestmateTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,7 +25,7 @@ * @test * @library /test/lib * @build HiddenNestmateTest - * @run testng/othervm HiddenNestmateTest + * @run junit/othervm HiddenNestmateTest */ import java.lang.classfile.ClassFile; @@ -37,9 +37,6 @@ import java.lang.reflect.AccessFlag; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.stream.Stream; -import java.util.Arrays; - -import org.testng.annotations.Test; import static java.lang.constant.ConstantDescs.CD_Object; import static java.lang.constant.ConstantDescs.CD_int; @@ -48,7 +45,8 @@ import static java.lang.constant.ConstantDescs.MTD_void; import static java.lang.invoke.MethodHandles.Lookup.ClassOption.*; import static java.lang.invoke.MethodHandles.Lookup.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class HiddenNestmateTest { private static final ClassDesc CD_HiddenNestmateTest = HiddenNestmateTest.class.describeConstable().orElseThrow(); @@ -61,12 +59,12 @@ public class HiddenNestmateTest { Class hiddenClass = lookup.lookupClass(); Class nestHost = hiddenClass.getNestHost(); assertTrue(hiddenClass.isHidden()); - assertTrue(nestHost == MethodHandles.lookup().lookupClass()); + assertSame(MethodHandles.lookup().lookupClass(), nestHost); // hidden nestmate is not listed in the return array of getNestMembers assertTrue(Stream.of(nestHost.getNestMembers()).noneMatch(k -> k == hiddenClass)); assertTrue(hiddenClass.isNestmateOf(lookup.lookupClass())); - assertTrue(Arrays.equals(hiddenClass.getNestMembers(), nestHost.getNestMembers())); + assertArrayEquals(nestHost.getNestMembers(), hiddenClass.getNestMembers()); } /* @@ -78,23 +76,19 @@ public class HiddenNestmateTest { Lookup lookup = MethodHandles.lookup().defineHiddenClass(bytes, false); Class c = lookup.lookupClass(); assertTrue(lookup.hasFullPrivilegeAccess()); - assertTrue((lookup.lookupModes() & ORIGINAL) == ORIGINAL); - assertTrue(c.getNestHost() == c); // host of its own nest + assertEquals(ORIGINAL, lookup.lookupModes() & ORIGINAL); + assertSame(c, c.getNestHost()); // host of its own nest assertTrue(c.isHidden()); // invoke int test(HiddenNestmateTest o) via MethodHandle MethodHandle ctor = lookup.findConstructor(c, MethodType.methodType(void.class)); MethodHandle mh = lookup.findVirtual(c, "test", MethodType.methodType(int.class, HiddenNestmateTest.class)); - try { + assertThrows(IllegalAccessError.class, () -> { int x = (int) mh.bindTo(ctor.invoke()).invokeExact(this); - throw new RuntimeException("should fail when accessing HiddenNestmateTest.privMethod()"); - } catch (IllegalAccessError e) {} + }); // invoke int test(HiddenNestmateTest o) - try { - int x1 = testInjectedClass(c); - throw new RuntimeException("should fail when accessing HiddenNestmateTest.privMethod()"); - } catch (IllegalAccessError e) {} + assertThrows(IllegalAccessError.class, () -> testInjectedClass(c)); } /* @@ -111,11 +105,11 @@ public class HiddenNestmateTest { MethodHandle ctor = lookup.findConstructor(c, MethodType.methodType(void.class)); MethodHandle mh = lookup.findVirtual(c, "test", MethodType.methodType(int.class, HiddenNestmateTest.class)); int x = (int)mh.bindTo(ctor.invoke()).invokeExact( this); - assertTrue(x == privMethod()); + assertEquals(privMethod(), x); // invoke int test(HiddenNestmateTest o) int x1 = testInjectedClass(c); - assertTrue(x1 == privMethod()); + assertEquals(privMethod(), x1); } /* @@ -131,10 +125,10 @@ public class HiddenNestmateTest { /* * Fail to create a hidden class if dropping PRIVATE lookup mode */ - @Test(expectedExceptions = IllegalAccessException.class) + @Test public void noPrivateLookupAccess() throws Throwable { Lookup lookup = MethodHandles.lookup().dropLookupMode(Lookup.PRIVATE); - lookup.defineHiddenClass(bytes, false, NESTMATE); + assertThrows(IllegalAccessException.class, () -> lookup.defineHiddenClass(bytes, false, NESTMATE)); } public void teleportToNestmate() throws Throwable { @@ -143,8 +137,8 @@ public class HiddenNestmateTest { // Teleport to a hidden nestmate Lookup lc = MethodHandles.lookup().in(lookup.lookupClass()); - assertTrue((lc.lookupModes() & PRIVATE) != 0); - assertTrue((lc.lookupModes() & ORIGINAL) == 0); + assertNotEquals(0, lc.lookupModes() & PRIVATE); + assertEquals(0, lc.lookupModes() & ORIGINAL); Lookup lc2 = lc.defineHiddenClass(bytes, false, NESTMATE); assertNestmate(lc2); @@ -153,9 +147,9 @@ public class HiddenNestmateTest { /* * Fail to create a hidden class in a different package from the lookup class' package */ - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void notSamePackage() throws Throwable { - MethodHandles.lookup().defineHiddenClass(classBytes("p/HiddenInjected"), false, NESTMATE); + assertThrows(IllegalArgumentException.class, () -> MethodHandles.lookup().defineHiddenClass(classBytes("p/HiddenInjected"), false, NESTMATE)); } /* diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/LambdaNestedInnerTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/LambdaNestedInnerTest.java index 9e3c8a8b318..7524e67bf9e 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/LambdaNestedInnerTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/LambdaNestedInnerTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,7 +25,7 @@ * @test * @summary define a lambda proxy class whose target class has an invalid * nest membership - * @run testng/othervm p.LambdaNestedInnerTest + * @run junit/othervm p.LambdaNestedInnerTest */ package p; @@ -41,11 +41,10 @@ import java.util.Arrays; import java.util.Set; import java.util.stream.Collectors; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; - import static java.nio.file.StandardCopyOption.REPLACE_EXISTING; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class LambdaNestedInnerTest { private static final String INNER_CLASSNAME = "p.LambdaNestedInnerTest$Inner"; @@ -68,7 +67,7 @@ public class LambdaNestedInnerTest { lambda1.run(); } - // testng may not be visible to this class + // junit may not be visible to this class private static void assertTrue(boolean x) { if (!x) { throw new AssertionError("expected true but found false"); @@ -79,8 +78,8 @@ public class LambdaNestedInnerTest { } } - @BeforeTest - public void setup() throws IOException { + @BeforeAll + public static void setup() throws IOException { String filename = INNER_CLASSNAME.replace('.', File.separatorChar) + ".class"; Path src = Paths.get(System.getProperty("test.classes"), filename); Path dest = Paths.get(DIR, filename); @@ -93,9 +92,9 @@ public class LambdaNestedInnerTest { Class inner = Class.forName(INNER_CLASSNAME); // inner class is a nest member of LambdaNestedInnerTest Class nestHost = inner.getNestHost(); - assertTrue(nestHost == LambdaNestedInnerTest.class); + assertSame(LambdaNestedInnerTest.class, nestHost); Set> members = Arrays.stream(nestHost.getNestMembers()).collect(Collectors.toSet()); - assertEquals(members, Set.of(nestHost, inner, TestLoader.class)); + assertEquals(Set.of(nestHost, inner, TestLoader.class), members); // spin lambda proxy hidden class Runnable runnable = (Runnable) inner.newInstance(); @@ -107,8 +106,8 @@ public class LambdaNestedInnerTest { URL[] urls = new URL[] { Paths.get(DIR).toUri().toURL() }; URLClassLoader loader = new URLClassLoader(urls, null); Class inner = loader.loadClass(INNER_CLASSNAME); - assertTrue(inner.getClassLoader() == loader); - assertTrue(inner.getNestHost() == inner); // linkage error ignored + assertSame(loader, inner.getClassLoader()); + assertSame(inner, inner.getNestHost()); // linkage error ignored Runnable runnable = (Runnable) inner.newInstance(); // this validates the lambda proxy class @@ -125,8 +124,8 @@ public class LambdaNestedInnerTest { TestLoader loader = new TestLoader(urls); Class inner = loader.loadClass(INNER_CLASSNAME); - assertTrue(inner.getClassLoader() == loader); - assertTrue(inner.getNestHost() == inner); // linkage error ignored. + assertSame(loader, inner.getClassLoader()); + assertSame(inner, inner.getNestHost()); // linkage error ignored. Runnable runnable = (Runnable) inner.newInstance(); // this validates the lambda proxy class diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/PreviewHiddenClass.java b/test/jdk/java/lang/invoke/defineHiddenClass/PreviewHiddenClass.java index fddbb348517..bd6c87808fe 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/PreviewHiddenClass.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/PreviewHiddenClass.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -29,7 +29,7 @@ * @requires !java.enablePreview * @build jdk.test.lib.Utils * jdk.test.lib.compiler.CompilerUtils - * @run testng PreviewHiddenClass + * @run junit PreviewHiddenClass * @summary verify UnsupportedClassVersionError thrown when defining a hidden class * with preview minor version but --enable-preview is not set * @comment This test itself cannot enablePreview, or hidden class definition @@ -46,15 +46,15 @@ import java.nio.file.Paths; import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.Utils; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class PreviewHiddenClass { private static final Path SRC_DIR = Paths.get(Utils.TEST_SRC, "src"); private static final Path CLASSES_DIR = Paths.get("classes"); - @Test(expectedExceptions = { UnsupportedClassVersionError.class }) + @Test public void previewNotEnabled() throws Exception { // compile a class with --enable-preview Path sourceFile = SRC_DIR.resolve("HiddenInterface.java"); @@ -67,7 +67,7 @@ public class PreviewHiddenClass { byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve("HiddenInterface.class")); var dis = new DataInputStream(new ByteArrayInputStream(bytes)); dis.skipBytes(4); // 0xCAFEBABE - assertEquals(dis.readUnsignedShort(), 65535); // Minor version - MethodHandles.lookup().defineHiddenClass(bytes, false); + assertEquals(65535, dis.readUnsignedShort()); // Minor version + assertThrows(UnsupportedClassVersionError.class, () -> MethodHandles.lookup().defineHiddenClass(bytes, false)); } } diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/StaticInvocableTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/StaticInvocableTest.java index 1c95caa97d3..ac0a29c247d 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/StaticInvocableTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/StaticInvocableTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,7 +27,7 @@ * @summary hidden class members can't be statically invocable * @modules java.base/jdk.internal.misc * @build java.base/* - * @run testng StaticInvocableTest + * @run junit StaticInvocableTest */ import java.lang.classfile.ClassFile; @@ -38,7 +38,6 @@ import java.lang.invoke.MethodHandles.Lookup; import java.lang.invoke.MethodType; import java.lang.invoke.LookupHelper; import java.lang.reflect.AccessFlag; -import org.testng.annotations.Test; import static java.lang.classfile.ClassFile.ACC_PUBLIC; import static java.lang.classfile.ClassFile.ACC_STATIC; @@ -46,6 +45,7 @@ import static java.lang.constant.ConstantDescs.CD_Object; import static java.lang.constant.ConstantDescs.CD_int; import static java.lang.constant.ConstantDescs.INIT_NAME; import static java.lang.constant.ConstantDescs.MTD_void; +import org.junit.jupiter.api.Test; public class StaticInvocableTest { public static void main(String[] args) throws Throwable { diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/TypeDescriptorTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/TypeDescriptorTest.java index e60cb8a5782..575eac1ccd1 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/TypeDescriptorTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/TypeDescriptorTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -21,10 +21,10 @@ * questions. */ -/** +/* * @test * @bug 8242013 - * @run testng/othervm test.TypeDescriptorTest + * @run junit/othervm test.TypeDescriptorTest * @summary Test TypeDescriptor::descriptorString for hidden classes which * cannot be used to produce ConstantDesc via ClassDesc or * MethodTypeDesc factory methods @@ -42,9 +42,10 @@ import java.nio.file.Files; import java.nio.file.Paths; import static java.lang.invoke.MethodType.*; -import org.testng.annotations.Test; -import org.testng.annotations.DataProvider; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class TypeDescriptorTest { private static final Lookup HC_LOOKUP = defineHiddenClass(); @@ -61,8 +62,7 @@ public class TypeDescriptorTest { } } - @DataProvider(name = "constables") - private Object[][] constables() throws Exception { + private static Object[][] constables() throws Exception { Class hcArray = Array.newInstance(HC, 1).getClass(); return new Object[][] { new Object[] { HC }, @@ -79,7 +79,8 @@ public class TypeDescriptorTest { * Hidden classes have no nominal descriptor. * Constable::describeConstable returns empty optional. */ - @Test(dataProvider = "constables") + @ParameterizedTest + @MethodSource("constables") public void noNominalDescriptor(Constable constable) { assertTrue(constable.describeConstable().isEmpty()); } @@ -90,27 +91,13 @@ public class TypeDescriptorTest { */ @Test public void testClassDesc() { - try { - ClassDesc.ofDescriptor(HC.descriptorString()); - assertFalse(true); - } catch (IllegalArgumentException e) {} - - try { - ClassDesc.ofDescriptor(HC.getName()); - assertFalse(true); - } catch (IllegalArgumentException e) {} - try { - ClassDesc.of(HC.getPackageName(), HC.getSimpleName()); - assertFalse(true); - } catch (IllegalArgumentException e) {} - try { - ClassDesc.of(HC.getName()); - assertFalse(true); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> ClassDesc.ofDescriptor(HC.descriptorString())); + assertThrows(IllegalArgumentException.class, () -> ClassDesc.ofDescriptor(HC.getName())); + assertThrows(IllegalArgumentException.class, () -> ClassDesc.of(HC.getPackageName(), HC.getSimpleName())); + assertThrows(IllegalArgumentException.class, () -> ClassDesc.of(HC.getName())); } - @DataProvider(name = "typeDescriptors") - private Object[][] typeDescriptors() throws Exception { + private static Object[][] typeDescriptors() throws Exception { Class hcArray = Array.newInstance(HC, 1, 1).getClass(); return new Object[][] { new Object[] { HC, "Ltest/HiddenClass.0x[0-9a-f]+;"}, @@ -124,26 +111,20 @@ public class TypeDescriptorTest { /* * Hidden classes have no nominal type descriptor */ - @Test(dataProvider = "typeDescriptors") + @ParameterizedTest + @MethodSource("typeDescriptors") public void testTypeDescriptor(TypeDescriptor td, String regex) throws Exception { String desc = td.descriptorString(); assertTrue(desc.matches(regex)); if (td instanceof Class) { - try { - ClassDesc.ofDescriptor(desc); - assertFalse(true); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> ClassDesc.ofDescriptor(desc)); } else if (td instanceof MethodType) { - try { - MethodTypeDesc.ofDescriptor(desc); - assertFalse(true); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> MethodTypeDesc.ofDescriptor(desc)); } } - @DataProvider(name = "methodTypes") - private Object[][] methodTypes() throws Exception { + private static Object[][] methodTypes() throws Exception { Class hcArray = Array.newInstance(HC, 1, 1).getClass(); return new Object[][] { new Object[] { methodType(HC), "\\(\\)Ltest/HiddenClass.0x[0-9a-f]+;" }, @@ -155,15 +136,13 @@ public class TypeDescriptorTest { /* * Test MethodType::toMethodDescriptorString with MethodType referencing to hidden class */ - @Test(dataProvider = "methodTypes") + @ParameterizedTest + @MethodSource("methodTypes") public void testToMethodDescriptorString(MethodType mtype, String regex) throws Exception { String desc = mtype.toMethodDescriptorString(); assertTrue(desc.matches(regex)); - try { - MethodType.fromMethodDescriptorString(desc, TypeDescriptorTest.class.getClassLoader()); - assertFalse(true); - } catch (IllegalArgumentException e) {} + assertThrows(IllegalArgumentException.class, () -> MethodType.fromMethodDescriptorString(desc, TypeDescriptorTest.class.getClassLoader())); } } diff --git a/test/jdk/java/lang/invoke/defineHiddenClass/UnloadingTest.java b/test/jdk/java/lang/invoke/defineHiddenClass/UnloadingTest.java index b016b2f6899..45728f2ed79 100644 --- a/test/jdk/java/lang/invoke/defineHiddenClass/UnloadingTest.java +++ b/test/jdk/java/lang/invoke/defineHiddenClass/UnloadingTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,7 +27,7 @@ * @modules jdk.compiler * @library /test/lib/ * @build jdk.test.lib.util.ForceGC - * @run testng/othervm UnloadingTest + * @run junit/othervm UnloadingTest */ import java.io.IOException; @@ -48,18 +48,16 @@ import jdk.test.lib.util.ForceGC; import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.Utils; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; - -import static java.lang.invoke.MethodHandles.lookup; import static java.lang.invoke.MethodHandles.Lookup.ClassOption.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class UnloadingTest { private static final Path CLASSES_DIR = Paths.get("classes"); private static byte[] hiddenClassBytes; - @BeforeTest + @BeforeAll static void setup() throws IOException { Path src = Paths.get(Utils.TEST_SRC, "src", "LookupHelper.java"); if (!CompilerUtils.compile(src, CLASSES_DIR)) { @@ -116,7 +114,7 @@ public class UnloadingTest { // keep a strong reference to the nest member class Class member = unloaders[1].weakRef.get(); - assertTrue(member != null); + assertNotNull(member); // nest host and member will not be unloaded assertFalse(unloaders[0].tryUnload()); assertFalse(unloaders[1].tryUnload()); @@ -180,7 +178,7 @@ public class UnloadingTest { } else { hc = lookup.defineHiddenClass(hiddenClassBytes, false).lookupClass(); } - assertTrue(hc.getClassLoader() == lookup.lookupClass().getClassLoader()); + assertSame(lookup.lookupClass().getClassLoader(), hc.getClassLoader()); return new HiddenClassUnloader(hc); } @@ -202,7 +200,7 @@ public class UnloadingTest { } else { member = hostLookup.defineHiddenClass(hiddenClassBytes, false, NESTMATE).lookupClass(); } - assertTrue(member.getNestHost() == host); + assertSame(host, member.getNestHost()); return new HiddenClassUnloader[] { new HiddenClassUnloader(host), new HiddenClassUnloader(member) }; } diff --git a/test/jdk/java/lang/invoke/findSpecial/FindSpecialTest.java b/test/jdk/java/lang/invoke/findSpecial/FindSpecialTest.java index 9b6622a7e9c..5bb7f67c000 100644 --- a/test/jdk/java/lang/invoke/findSpecial/FindSpecialTest.java +++ b/test/jdk/java/lang/invoke/findSpecial/FindSpecialTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -21,12 +21,12 @@ * questions. */ -/** +/* * @test * @bug 8209005 8209078 * @library /test/lib * @build m1/* FindSpecialTest - * @run testng/othervm FindSpecialTest + * @run junit/othervm FindSpecialTest * @summary Test findSpecial and unreflectSpecial of the declaring class * of the method and the special caller are not in the same module * as the lookup class. @@ -39,7 +39,7 @@ import java.nio.file.Paths; import static jdk.test.lib.process.ProcessTools.*; -import org.testng.annotations.Test; +import org.junit.jupiter.api.Test; public class FindSpecialTest { static final String TEST_CLASSES = System.getProperty("test.classes", "."); @@ -51,7 +51,7 @@ public class FindSpecialTest { * Run test.FindSpecial in unnamed module */ @Test - public static void callerInUnnamedModule() throws Throwable { + public void callerInUnnamedModule() throws Throwable { Path m1 = Paths.get(TEST_CLASSES, "modules", TEST_MODULE); if (Files.notExists(m1)) { throw new Error(m1 + " not exist"); @@ -66,7 +66,7 @@ public class FindSpecialTest { * Run test.FindSpecial in a named module */ @Test - public static void callerInNamedModule() throws Throwable { + public void callerInNamedModule() throws Throwable { Path modules = Paths.get(TEST_CLASSES, "modules"); if (Files.notExists(modules)) { throw new Error(modules + " not exist"); diff --git a/test/jdk/java/lang/invoke/lambda/LambdaFileEncodingSerialization.java b/test/jdk/java/lang/invoke/lambda/LambdaFileEncodingSerialization.java index 1f950ffce7e..6c505ddf471 100644 --- a/test/jdk/java/lang/invoke/lambda/LambdaFileEncodingSerialization.java +++ b/test/jdk/java/lang/invoke/lambda/LambdaFileEncodingSerialization.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -21,36 +21,33 @@ * questions. */ -/** +/* * @test * @bug 8248231 * @summary Test to verify lambda serialization uses the correct UTF-8 encoding * @library /test/lib * @build jdk.test.lib.JDKToolFinder * jdk.test.lib.process.ProcessTools - * @run testng LambdaFileEncodingSerialization + * @run junit LambdaFileEncodingSerialization */ import java.io.File; -import java.io.BufferedReader; -import java.io.InputStreamReader; -import java.io.IOException; import java.util.List; import java.util.Map; import java.util.Arrays; import java.util.ArrayList; -import org.testng.annotations.Test; -import static org.testng.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import jdk.test.lib.JDKToolFinder; import jdk.test.lib.process.ProcessTools; +import org.junit.jupiter.api.Test; public class LambdaFileEncodingSerialization { private static final String TEST_NAME = "TestLambdaFileEncodingSerialization"; @Test - public static void testDeserializeLambdaEncoding() throws Throwable { + public void testDeserializeLambdaEncoding() throws Throwable { String javac = JDKToolFinder.getTestJDKTool("javac"); String java = JDKToolFinder.getTestJDKTool("java"); diff --git a/test/jdk/java/lang/invoke/lambda/LambdaHiddenCaller.java b/test/jdk/java/lang/invoke/lambda/LambdaHiddenCaller.java index aed19e6ca17..0dbdff79230 100644 --- a/test/jdk/java/lang/invoke/lambda/LambdaHiddenCaller.java +++ b/test/jdk/java/lang/invoke/lambda/LambdaHiddenCaller.java @@ -29,8 +29,7 @@ import java.util.function.IntSupplier; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.*; /* * @test @@ -62,7 +61,7 @@ public class LambdaHiddenCaller { void testSerializableLambda() { var is = hiddenCaller.callSerializableLambda(); assertEquals(42, is.getAsInt()); - assertTrue(Serializable.class.isAssignableFrom(is.getClass())); + assertInstanceOf(Serializable.class, is); // We do not guarantee serialization functionalities yet } } diff --git a/test/jdk/java/lang/invoke/lambda/LogGeneratedClassesTest.java b/test/jdk/java/lang/invoke/lambda/LogGeneratedClassesTest.java index 60c85753d72..eb013bf01f3 100644 --- a/test/jdk/java/lang/invoke/lambda/LogGeneratedClassesTest.java +++ b/test/jdk/java/lang/invoke/lambda/LogGeneratedClassesTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -29,7 +29,7 @@ * @library /java/nio/file * @modules jdk.compiler * jdk.zipfs - * @run testng LogGeneratedClassesTest + * @run junit LogGeneratedClassesTest * @summary tests logging generated classes for lambda */ import java.io.IOException; @@ -45,24 +45,24 @@ import java.nio.file.attribute.PosixFileAttributeView; import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.process.OutputAnalyzer; -import org.testng.annotations.AfterClass; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; -import org.testng.SkipException; import static java.nio.file.attribute.PosixFilePermissions.*; import static jdk.test.lib.process.ProcessTools.*; -import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertTrue; +import org.junit.jupiter.api.AfterAll; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class LogGeneratedClassesTest { static final Path DUMP_LAMBDA_PROXY_CLASS_FILES = Path.of("DUMP_LAMBDA_PROXY_CLASS_FILES"); static final Path CLASSES = Path.of("classes").toAbsolutePath(); - String longFQCN; + static String longFQCN; - @BeforeClass - public void setup() throws IOException { + @BeforeAll + public static void setup() throws IOException { final List scratch = new ArrayList<>(); scratch.clear(); scratch.add("package com.example;"); @@ -102,8 +102,8 @@ public class LogGeneratedClassesTest { CompilerUtils.compile(Path.of("."), CLASSES); } - @AfterClass - public void cleanup() throws IOException { + @AfterAll + public static void cleanup() throws IOException { Files.delete(Paths.get("TestLambda.java")); Files.delete(Paths.get("LongPackageName.java")); TestUtil.removeAll(DUMP_LAMBDA_PROXY_CLASS_FILES); @@ -132,12 +132,11 @@ public class LogGeneratedClassesTest { executeProcess(pb).shouldHaveExitValue(0); // 2 our own class files. We don't care about the others - assertEquals(Files.find( - dumpDir, - 99, - (p, a) -> p.startsWith(dumpDir.resolve("com/example")) - && a.isRegularFile()).count(), - 2, "Two lambda captured"); + assertEquals(2, Files.find( + dumpDir, + 99, + (p, a) -> p.startsWith(dumpDir.resolve("com/example")) + && a.isRegularFile()).count(), "Two lambda captured"); } @Test @@ -155,12 +154,11 @@ public class LogGeneratedClassesTest { executeProcess(pb).shouldHaveExitValue(0); // The dump directory will be created if not exist - assertEquals(Files.find( - dumpDir, - 99, - (p, a) -> p.startsWith(dumpDir.resolve("com/example")) - && a.isRegularFile()).count(), - 2, "Two lambda captured"); + assertEquals(2, Files.find( + dumpDir, + 99, + (p, a) -> p.startsWith(dumpDir.resolve("com/example")) + && a.isRegularFile()).count(), "Two lambda captured"); } @Test @@ -208,12 +206,10 @@ public class LogGeneratedClassesTest { try { fs = Files.getFileStore(Paths.get(".")); } catch (IOException e) { - throw new SkipException("WARNING: IOException occurred: " + e + ", Skipping testDumpDirNotWritable test."); - } - if (!fs.supportsFileAttributeView(PosixFileAttributeView.class)) { - // No easy way to setup readonly directory without POSIX - throw new SkipException("WARNING: POSIX is not supported. Skipping testDumpDirNotWritable test."); + Assumptions.assumeTrue(false, "WARNING: IOException occurred: " + e + ", Skipping testDumpDirNotWritable test."); + return; } + Assumptions.assumeFalse(!fs.supportsFileAttributeView(PosixFileAttributeView.class), "WARNING: POSIX is not supported. Skipping testDumpDirNotWritable test."); // No easy way to setup readonly directory without POSIX Path testDir = Path.of("readOnly"); Path dumpDir = testDir.resolve(DUMP_LAMBDA_PROXY_CLASS_FILES); @@ -221,11 +217,8 @@ public class LogGeneratedClassesTest { Files.createDirectory(dumpDir, asFileAttribute(fromString("r-xr-xr-x"))); try { - if (isWriteableDirectory(dumpDir)) { - // Skipping the test: it's allowed to write into read-only directory - // (e.g. current user is super user). - throw new SkipException("WARNING: The dump directory is writeable. Skipping testDumpDirNotWritable test."); - } + Assumptions.assumeFalse(isWriteableDirectory(dumpDir), "WARNING: The dump directory is writeable. Skipping testDumpDirNotWritable test."); // Skipping the test: it's allowed to write into read-only directory + // (e.g. current user is super user). ProcessBuilder pb = createLimitedTestJavaProcessBuilder( "-cp", CLASSES.toString(), @@ -251,10 +244,9 @@ public class LogGeneratedClassesTest { longFQCN).directory(testDir.toFile()); OutputAnalyzer outputAnalyzer = executeProcess(pb); outputAnalyzer.shouldHaveExitValue(0); - assertEquals(outputAnalyzer.asLines().stream() - .filter(s -> s.startsWith("WARNING: Exception")) - .count(), - 2, "show error each capture"); + assertEquals(2, outputAnalyzer.asLines().stream() + .filter(s -> s.startsWith("WARNING: Exception")) + .count(), "show error each capture"); // dumpLong/DUMP_LAMBDA_PROXY_CLASS_FILES/com/example/nonsense/nonsense Path dumpPath = dumpDir.resolve("com/example/nonsense"); Predicate filter = p -> p.getParent() == null || dumpPath.startsWith(p) || p.startsWith(dumpPath); @@ -269,8 +261,8 @@ public class LogGeneratedClassesTest { } }); } - assertEquals(Files.walk(dumpDir) + assertEquals(5, Files.walk(dumpDir) .filter(filter) - .count(), 5, "Two lambda captured failed to log"); + .count(), "Two lambda captured failed to log"); } } diff --git a/test/jdk/java/lang/invoke/lambda/invokeSpecial/InvokeSpecialMethodTest.java b/test/jdk/java/lang/invoke/lambda/invokeSpecial/InvokeSpecialMethodTest.java index bf1db0f822e..4b74d05f270 100644 --- a/test/jdk/java/lang/invoke/lambda/invokeSpecial/InvokeSpecialMethodTest.java +++ b/test/jdk/java/lang/invoke/lambda/invokeSpecial/InvokeSpecialMethodTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,22 +24,22 @@ /* * @test * @bug 8274848 - * @run testng InvokeSpecialMethodTest + * @run junit InvokeSpecialMethodTest * @summary ensure REF_invokeSpecial on a non-private implementation method * behaves as if `super::m` is invoked regardless of its access flag */ -import org.testng.Assert; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.CallSite; import java.lang.invoke.LambdaMetafactory; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + import static java.lang.invoke.MethodType.methodType; +import static org.junit.jupiter.api.Assertions.assertEquals; public class InvokeSpecialMethodTest { static class MethodTest { @@ -95,8 +95,7 @@ public class InvokeSpecialMethodTest { String get(); } - @DataProvider - public Object[][] methodProvider() { + public static Object[][] methodProvider() { return new Object[][]{ {MethodTest.M_PUBLIC, "test_public"}, {MethodTest.M_PROTECTED, "test_protected"}, @@ -104,7 +103,8 @@ public class InvokeSpecialMethodTest { }; } - @Test(dataProvider = "methodProvider") + @ParameterizedTest + @MethodSource("methodProvider") void test(MethodHandle implMethod, String expected) throws Throwable { testMetafactory(implMethod, expected); testAltMetafactory(implMethod, expected); @@ -117,7 +117,7 @@ public class InvokeSpecialMethodTest { MethodTest o = new MethodTest.SubClass(); StringFactory factory = (StringFactory) cs.dynamicInvoker().invokeExact(o); String actual = factory.get(); - Assert.assertEquals(actual, expected); + assertEquals(expected, actual); } static void testAltMetafactory(MethodHandle implMethod, String expected) throws Throwable { @@ -128,6 +128,6 @@ public class InvokeSpecialMethodTest { MethodTest o = new MethodTest.SubClass(); StringFactory factory = (StringFactory) cs.dynamicInvoker().invokeExact(o); String actual = factory.get(); - Assert.assertEquals(actual, expected); + assertEquals(expected, actual); } } diff --git a/test/jdk/java/lang/invoke/lambda/superProtectedMethod/InheritedProtectedMethod.java b/test/jdk/java/lang/invoke/lambda/superProtectedMethod/InheritedProtectedMethod.java index a5cf6f68c50..fc730d790ac 100644 --- a/test/jdk/java/lang/invoke/lambda/superProtectedMethod/InheritedProtectedMethod.java +++ b/test/jdk/java/lang/invoke/lambda/superProtectedMethod/InheritedProtectedMethod.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -28,7 +28,7 @@ * @library /test/lib * @build jdk.test.lib.Utils * jdk.test.lib.compiler.CompilerUtils - * @run testng/othervm InheritedProtectedMethod + * @run junit/othervm InheritedProtectedMethod * @summary Test method reference to a method inherited from its * superclass in a different package. Such method's modifier * is changed from public to protected. @@ -37,10 +37,6 @@ import jdk.test.lib.compiler.CompilerUtils; import jdk.test.lib.Utils; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.io.IOException; import java.lang.reflect.Method; import java.net.URL; @@ -48,13 +44,15 @@ import java.net.URLClassLoader; import java.nio.file.Path; import java.nio.file.Paths; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class InheritedProtectedMethod { private static final Path SRC_DIR = Paths.get(Utils.TEST_SRC, "src"); private static final Path CLASSES_DIR = Paths.get("classes"); - @BeforeTest + @BeforeAll static void setup() throws IOException { assertTrue(CompilerUtils.compile(SRC_DIR, CLASSES_DIR)); @@ -64,13 +62,13 @@ public class InheritedProtectedMethod { } @Test - public static void run() throws Exception { + public void run() throws Exception { URLClassLoader loader = new URLClassLoader("loader", new URL[]{ CLASSES_DIR.toUri().toURL()}, ClassLoader.getPlatformClassLoader()); Class methodInvokeClass = Class.forName("MethodInvoker", false, loader); Method invokeMethod = methodInvokeClass.getMethod("invoke"); String result = (String)invokeMethod.invoke(null); - assertEquals(result, "protected inherited method"); + assertEquals("protected inherited method", result); } } diff --git a/test/jdk/java/lang/invoke/lambda/superProtectedMethod/ProtectedMethodInOtherPackage.java b/test/jdk/java/lang/invoke/lambda/superProtectedMethod/ProtectedMethodInOtherPackage.java index 666ba5c254b..980114149a8 100644 --- a/test/jdk/java/lang/invoke/lambda/superProtectedMethod/ProtectedMethodInOtherPackage.java +++ b/test/jdk/java/lang/invoke/lambda/superProtectedMethod/ProtectedMethodInOtherPackage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* * @test * @bug 8227415 8254975 8270056 - * @run testng/othervm p.ProtectedMethodInOtherPackage + * @run junit/othervm p.ProtectedMethodInOtherPackage * @summary method reference to a protected method inherited from its * superclass in a different runtime package where * lambda proxy class has no access to it. @@ -47,12 +47,12 @@ import java.nio.file.Path; import java.nio.file.Paths; import java.util.function.Function; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class ProtectedMethodInOtherPackage { @Test - public static void remotePackageSameLoader() { + public void remotePackageSameLoader() { Sub_I sub = new Sub_I(); sub.test(Paths.get("test")); } @@ -76,14 +76,14 @@ public class ProtectedMethodInOtherPackage { } @Test - public static void splitPackage() throws Throwable { + public void splitPackage() throws Throwable { ClassLoader parent = new Loader("loader-A", null, A.class); ClassLoader loader = new Loader("loader-B", parent, B.class); Class aClass = Class.forName(A.class.getName(), false, loader); Class bClass = Class.forName(B.class.getName(), false, loader); - assertTrue(aClass.getClassLoader() == parent); - assertTrue(bClass.getClassLoader() == loader); - assertEquals(aClass.getPackageName(), bClass.getPackageName()); + assertSame(parent, aClass.getClassLoader()); + assertSame(loader, bClass.getClassLoader()); + assertEquals(bClass.getPackageName(), aClass.getPackageName()); Object b = bClass.getDeclaredConstructor().newInstance(); @@ -102,14 +102,14 @@ public class ProtectedMethodInOtherPackage { } @Test - public static void protectedStaticMethodInSplitPackage() throws Throwable { + public void protectedStaticMethodInSplitPackage() throws Throwable { ClassLoader parent = new Loader("loader-A1", null, A1.class); ClassLoader loader = new Loader("loader-B1", parent, B1.class); Class aClass1 = Class.forName(A1.class.getName(), false, loader); Class bClass1 = Class.forName(B1.class.getName(), false, loader); - assertTrue(aClass1.getClassLoader() == parent); - assertTrue(bClass1.getClassLoader() == loader); - assertEquals(aClass1.getPackageName(), bClass1.getPackageName()); + assertSame(parent, aClass1.getClassLoader()); + assertSame(loader, bClass1.getClassLoader()); + assertEquals(bClass1.getPackageName(), aClass1.getPackageName()); // verify subclass can access a static protected method inherited from // its superclass in a split package diff --git a/test/jdk/java/lang/invoke/lookup/ChainedLookupTest.java b/test/jdk/java/lang/invoke/lookup/ChainedLookupTest.java index 0e81c6a9eec..15a46e6ca2c 100644 --- a/test/jdk/java/lang/invoke/lookup/ChainedLookupTest.java +++ b/test/jdk/java/lang/invoke/lookup/ChainedLookupTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ /* * @test * @bug 8013527 - * @run testng/othervm ChainedLookupTest + * @run junit/othervm ChainedLookupTest * @summary Test MethodHandles.lookup method to produce the Lookup object with * proper lookup class if invoked through reflection and method handle. */ @@ -33,11 +33,11 @@ import java.lang.invoke.*; import java.lang.invoke.MethodHandles.Lookup; import java.lang.reflect.Method; -import org.testng.annotations.Test; import static java.lang.invoke.MethodHandles.*; import static java.lang.invoke.MethodType.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class ChainedLookupTest { /** @@ -121,7 +121,7 @@ public class ChainedLookupTest { } void test(Lookup lookup, String msg) throws Throwable { - assertTrue(lookup.lookupClass() == ChainedLookupTest.class); + assertSame(ChainedLookupTest.class, lookup.lookupClass()); assertTrue(lookup.hasFullPrivilegeAccess()); MethodHandle mh = lookup.findStatic(lookup.lookupClass(), "say", methodType(void.class, String.class)); diff --git a/test/jdk/java/lang/invoke/lookup/LookupClassTest.java b/test/jdk/java/lang/invoke/lookup/LookupClassTest.java index 205bd3d893e..5970d0331dd 100644 --- a/test/jdk/java/lang/invoke/lookup/LookupClassTest.java +++ b/test/jdk/java/lang/invoke/lookup/LookupClassTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,44 +25,44 @@ * @test * @bug 8173975 * @summary Lookup::in throws IAE if the target class is a primitive class or array class - * @run testng/othervm LookupClassTest + * @run junit/othervm LookupClassTest */ import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; public class LookupClassTest { private static final LookupClassTest[] ARRAY = new LookupClassTest[0]; - @BeforeTest - public void test() { + @BeforeAll + public static void test() { assertTrue(ARRAY.getClass().isArray()); assertSamePackage(MethodHandles.lookup(), ARRAY.getClass()); assertSamePackage(MethodHandles.publicLookup(), int.class); } - private void assertSamePackage(Lookup lookup, Class targetClass) { - assertEquals(lookup.lookupClass().getPackageName(), targetClass.getPackageName()); + private static void assertSamePackage(Lookup lookup, Class targetClass) { + assertEquals(targetClass.getPackageName(), lookup.lookupClass().getPackageName()); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void arrayLookupClass() { Lookup lookup = MethodHandles.lookup(); - lookup.in(ARRAY.getClass()); + assertThrows(IllegalArgumentException.class, () -> lookup.in(ARRAY.getClass())); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void primitiveLookupClass() { Lookup lookup = MethodHandles.publicLookup(); - lookup.in(int.class); + assertThrows(IllegalArgumentException.class, () -> lookup.in(int.class)); } - @Test(expectedExceptions = IllegalArgumentException.class) + @Test public void voidLookupClass() { Lookup lookup = MethodHandles.publicLookup(); - lookup.in(void.class); + assertThrows(IllegalArgumentException.class, () -> lookup.in(void.class)); } } diff --git a/test/jdk/java/lang/invoke/lookup/SpecialStatic.java b/test/jdk/java/lang/invoke/lookup/SpecialStatic.java index 31ded727d66..3ff99b9dfda 100644 --- a/test/jdk/java/lang/invoke/lookup/SpecialStatic.java +++ b/test/jdk/java/lang/invoke/lookup/SpecialStatic.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2014, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -25,7 +25,7 @@ * @bug 8032400 * @summary JSR292: invokeSpecial: InternalError attempting to lookup a method * @compile -XDignore.symbol.file SpecialStatic.java - * @run testng test.java.lang.invoke.lookup.SpecialStatic + * @run junit test.java.lang.invoke.lookup.SpecialStatic */ package test.java.lang.invoke.lookup; @@ -38,13 +38,13 @@ import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.reflect.AccessFlag; -import org.testng.annotations.*; import static java.lang.classfile.ClassFile.ACC_PUBLIC; import static java.lang.classfile.ClassFile.ACC_STATIC; import static java.lang.constant.ConstantDescs.*; import static java.lang.constant.DirectMethodHandleDesc.Kind.SPECIAL; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; /** * Test case: @@ -105,7 +105,7 @@ public class SpecialStatic { public void testConstant() throws Throwable { MethodHandle mh = (MethodHandle)t3.getDeclaredMethod("getMethodHandle").invoke(null); int result = (int)mh.invoke(t3.newInstance()); - assertEquals(result, 1); // T1.m should be invoked. + assertEquals(1, result); // T1.m should be invoked. } @Test @@ -113,7 +113,7 @@ public class SpecialStatic { MethodHandles.Lookup lookup = (MethodHandles.Lookup)t3.getDeclaredMethod("getLookup").invoke(null); MethodHandle mh = lookup.findSpecial(t1, "m", MethodType.methodType(int.class), t3); int result = (int)mh.invoke(t3.newInstance()); - assertEquals(result, 1); // T1.m should be invoked. + assertEquals(1, result); // T1.m should be invoked. } public static byte[] dumpT1() { diff --git a/test/jdk/java/lang/invoke/modules/Driver.java b/test/jdk/java/lang/invoke/modules/Driver.java index 5c00de3ad47..11c44280309 100644 --- a/test/jdk/java/lang/invoke/modules/Driver.java +++ b/test/jdk/java/lang/invoke/modules/Driver.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -21,9 +21,9 @@ * questions. */ -/** +/* * @test * @build m1/* m2/* Unnamed - * @run testng/othervm m1/p1.Main + * @run junit/othervm m1/p1.Main * @summary Basic test case for module access checks and Lookup.in. */ diff --git a/test/jdk/java/lang/invoke/modules/Driver1.java b/test/jdk/java/lang/invoke/modules/Driver1.java index 654ee04c9e0..4ef7130ff94 100644 --- a/test/jdk/java/lang/invoke/modules/Driver1.java +++ b/test/jdk/java/lang/invoke/modules/Driver1.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -21,11 +21,11 @@ * questions. */ -/** +/* * @test * @bug 8173978 * @build m3/* m4/* m5/* Unnamed Unnamed1 - * @run testng/othervm m3/jdk.test.ModuleAccessTest + * @run junit/othervm m3/jdk.test.ModuleAccessTest * @summary Basic test case for module access checks and Lookup.in and * MethodHandles.privateLookupIn */ diff --git a/test/jdk/java/lang/invoke/modules/m1/module-info.java b/test/jdk/java/lang/invoke/modules/m1/module-info.java index db03841b4d0..ecd133ae6a1 100644 --- a/test/jdk/java/lang/invoke/modules/m1/module-info.java +++ b/test/jdk/java/lang/invoke/modules/m1/module-info.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -22,6 +22,6 @@ */ module m1 { requires m2; - requires org.testng; + requires org.junit.platform.console.standalone; exports p1; } diff --git a/test/jdk/java/lang/invoke/modules/m1/p1/Main.java b/test/jdk/java/lang/invoke/modules/m1/p1/Main.java index 0a4d2fff1db..5a2a7c91999 100644 --- a/test/jdk/java/lang/invoke/modules/m1/p1/Main.java +++ b/test/jdk/java/lang/invoke/modules/m1/p1/Main.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -30,26 +30,24 @@ import java.lang.invoke.MethodType; import static java.lang.invoke.MethodHandles.Lookup.*; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.Test; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; /** * Basic test case for module access checks and Lookup.in. */ - -@Test public class Main { - private Class p1_Type1; // m1, exported - private Class p2_Type2; // m1, not exported - private Class q1_Type1; // m2, exported - private Class q2_Type2; // m2, not exported - private Class signalClass; // java.base, not exported - private Class unnamedClass; // class in unnamed module + private static Class p1_Type1; // m1, exported + private static Class p2_Type2; // m1, not exported + private static Class q1_Type1; // m2, exported + private static Class q2_Type2; // m2, not exported + private static Class signalClass; // java.base, not exported + private static Class unnamedClass; // class in unnamed module - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { try { p1_Type1 = Class.forName("p1.Type1"); p2_Type2 = Class.forName("p2.Type2"); @@ -64,15 +62,15 @@ public class Main { // check setup Module m1 = ModuleLayer.boot().findModule("m1").orElse(null); assertNotNull(m1); - assertTrue(p1_Type1.getModule() == m1); - assertTrue(p2_Type2.getModule() == m1); + assertSame(m1, p1_Type1.getModule()); + assertSame(m1, p2_Type2.getModule()); assertTrue(m1.isExported("p1")); assertFalse(m1.isExported("p2")); Module m2 = ModuleLayer.boot().findModule("m2").orElse(null); assertNotNull(m2); - assertTrue(q1_Type1.getModule() == m2); - assertTrue(q2_Type2.getModule() == m2); + assertSame(m2, q1_Type1.getModule()); + assertSame(m2, q2_Type2.getModule()); assertTrue(m2.isExported("q1")); assertFalse(m2.isExported("q2")); @@ -91,9 +89,10 @@ public class Main { * [A2] can access public types in packages exported by modules that m1 reads * [A3] cannot access public types in non-exported modules of modules that m1 reads */ + @Test public void testLookup() throws Exception { Lookup lookup = MethodHandles.lookup(); - assertTrue((lookup.lookupModes() & MODULE) == MODULE); // [A0] + assertEquals(MODULE, lookup.lookupModes() & MODULE); // [A0] // m1 findConstructor(lookup, p1_Type1, void.class); // [A1] @@ -116,9 +115,10 @@ public class Main { * * [A0] module and public access is not lost */ + @Test public void testToSameModule() throws Exception { Lookup lookup = MethodHandles.lookup().in(p2_Type2); - assertTrue(lookup.lookupModes() == (MODULE|PUBLIC)); // [A0] + assertEquals(MODULE | PUBLIC, lookup.lookupModes()); // [A0] // m1 findConstructor(lookup, p1_Type1, void.class); @@ -142,15 +142,16 @@ public class Main { * [A0] has PUBLIC access if accessible; otherwise no access * [A1] old lookup class becomes previous lookup class */ + @Test public void testFromNamedToNamedModule() throws Exception { // m2/q1_Type1 is accessible to m1 whereas m2/q_Type2 is not accessible Lookup lookup = MethodHandles.lookup().in(q1_Type1); - assertTrue(lookup.lookupModes() == PUBLIC); // [A0] - assertTrue(lookup.previousLookupClass() == Main.class); // [A1] + assertEquals(PUBLIC, lookup.lookupModes()); // [A0] + assertSame(Main.class, lookup.previousLookupClass()); // [A1] Lookup lookup2 = MethodHandles.lookup().in(q2_Type2); - assertTrue(lookup2.lookupModes() == 0); // [A0] - assertTrue(lookup2.previousLookupClass() == Main.class); // [A1] + assertEquals(0, lookup2.lookupModes()); // [A0] + assertSame(Main.class, lookup2.previousLookupClass()); // [A1] // m1 findConstructorExpectingIAE(lookup, p1_Type1, void.class); @@ -185,9 +186,10 @@ public class Main { * * [A0] has PUBLIC access */ + @Test public void testFromNamedToUnnamedModule() throws Exception { Lookup lookup = MethodHandles.lookup().in(unnamedClass); - assertTrue(lookup.lookupModes() == PUBLIC); // [A0] + assertEquals(PUBLIC, lookup.lookupModes()); // [A0] // m1 findConstructor(lookup, p1_Type1, void.class); // p1 is exported @@ -210,10 +212,11 @@ public class Main { * * [A0] retains PUBLIC access */ + @Test public void testFromUnnamedToNamedModule() throws Exception { Lookup lookup = MethodHandles.lookup(); lookup = MethodHandles.privateLookupIn(unnamedClass, lookup).in(p1_Type1); - assertTrue(lookup.lookupModes() == PUBLIC); // A0 + assertEquals(PUBLIC, lookup.lookupModes()); // A0 // m1 findConstructor(lookup, p1_Type1, void.class); @@ -236,9 +239,10 @@ public class Main { * * [A0] has UNCONDITIONAL access */ + @Test public void testPublicLookup() throws Exception { Lookup lookup = MethodHandles.publicLookup(); - assertTrue(lookup.lookupModes() == UNCONDITIONAL); // A0 + assertEquals(UNCONDITIONAL, lookup.lookupModes()); // A0 // m1 findConstructor(lookup, p1_Type1, void.class); @@ -261,9 +265,10 @@ public class Main { * * [A0] has UNCONDITIONAL access */ + @Test public void testPublicLookupToBaseModule() throws Exception { Lookup lookup = MethodHandles.publicLookup().in(String.class); - assertTrue(lookup.lookupModes() == UNCONDITIONAL); // A0 + assertEquals(UNCONDITIONAL, lookup.lookupModes()); // A0 // m1 findConstructor(lookup, p1_Type1, void.class); @@ -287,9 +292,10 @@ public class Main { * * [A0] has UNCONDITIONAL access */ + @Test public void testPublicLookupToAccessibleTypeInNamedModule() throws Exception { Lookup lookup = MethodHandles.publicLookup().in(p1_Type1); - assertTrue(lookup.lookupModes() == UNCONDITIONAL); // A0 + assertEquals(UNCONDITIONAL, lookup.lookupModes()); // A0 // m1 findConstructor(lookup, p1_Type1, void.class); @@ -312,9 +318,10 @@ public class Main { * * [A0] has no access */ + @Test public void testPublicLookupToInaccessibleTypeInNamedModule() throws Exception { Lookup lookup = MethodHandles.publicLookup().in(p2_Type2); - assertTrue(lookup.lookupModes() == 0); // A0 + assertEquals(0, lookup.lookupModes()); // A0 // m1 findConstructorExpectingIAE(lookup, p1_Type1, void.class); @@ -337,9 +344,10 @@ public class Main { * * [A0] has UNCONDITIONAL access */ + @Test public void testPublicLookupToUnnamedModule() throws Exception { Lookup lookup = MethodHandles.publicLookup().in(unnamedClass); - assertTrue(lookup.lookupModes() == UNCONDITIONAL); // A0 + assertEquals(UNCONDITIONAL, lookup.lookupModes()); // A0 // m1 findConstructor(lookup, p1_Type1, void.class); @@ -366,10 +374,7 @@ public class Main { Class clazz, Class rtype, Class... ptypes) throws Exception { - try { - findConstructor(lookup, clazz, rtype, ptypes); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> findConstructor(lookup, clazz, rtype, ptypes)); } /** diff --git a/test/jdk/java/lang/invoke/modules/m3/jdk/test/ModuleAccessTest.java b/test/jdk/java/lang/invoke/modules/m3/jdk/test/ModuleAccessTest.java index 6a1e8efe103..235c712926d 100644 --- a/test/jdk/java/lang/invoke/modules/m3/jdk/test/ModuleAccessTest.java +++ b/test/jdk/java/lang/invoke/modules/m3/jdk/test/ModuleAccessTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,15 +23,12 @@ package jdk.test; -import org.testng.annotations.BeforeTest; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; - import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodHandles.Lookup; import java.lang.invoke.MethodType; +import java.lang.management.ThreadMXBean; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Map; @@ -42,7 +39,11 @@ import java.util.stream.Stream; import e1.CrackM5Access; import static java.lang.invoke.MethodHandles.Lookup.*; -import static org.testng.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class ModuleAccessTest { static ModuleLookup m3; @@ -55,8 +56,8 @@ public class ModuleAccessTest { static Class unnamed; static Class unnamed1; - @BeforeTest - public void setup() throws Exception { + @BeforeAll + public static void setup() throws Exception { m3 = new ModuleLookup("m3", 'C'); m4 = new ModuleLookup("m4", 'D'); m5 = new ModuleLookup("m5", 'E'); @@ -76,8 +77,7 @@ public class ModuleAccessTest { CrackM5Access.addReads(unnamed.getModule()); } - @DataProvider(name = "samePackage") - public Object[][] samePackage() throws Exception { + public static Object[][] samePackage() throws Exception { return new Object[][] { { m3.lookup, m3.type2 }, { privLookupIn, m3.type1 }, @@ -93,7 +93,8 @@ public class ModuleAccessTest { * [A1] no change in previous lookup class * [A2] PROTECTED, PRIVATE and ORIGINAL are dropped */ - @Test(dataProvider = "samePackage") + @ParameterizedTest + @MethodSource("samePackage") public void testLookupInSamePackage(Lookup lookup, Class targetClass) throws Exception { Class lookupClass = lookup.lookupClass(); Lookup lookup2 = lookup.in(targetClass); @@ -105,8 +106,7 @@ public class ModuleAccessTest { assertTrue(lookup2.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|ORIGINAL))); // [A2] } - @DataProvider(name = "sameModule") - public Object[][] sameModule() throws Exception { + public static Object[][] sameModule() throws Exception { return new Object[][] { { m3.lookup, m3.type3}, { privLookupIn, m3.type3}, @@ -121,20 +121,20 @@ public class ModuleAccessTest { * [A1] no change in previous lookup class * [A2] PROTECTED, PRIVATE, PACKAGE and ORIGINAL are dropped */ - @Test(dataProvider = "sameModule") + @ParameterizedTest + @MethodSource("sameModule") public void testLookupInSameModule(Lookup lookup, Class targetClass) throws Exception { Class lookupClass = lookup.lookupClass(); Lookup lookup2 = lookup.in(targetClass); - assertTrue(lookupClass.getPackage() != targetClass.getPackage()); - assertTrue(lookupClass.getModule() == targetClass.getModule()); - assertTrue(lookup2.lookupClass() == targetClass); // [A0] - assertTrue(lookup2.previousLookupClass() == lookup.previousLookupClass()); // [A1] - assertTrue(lookup2.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|PACKAGE|ORIGINAL))); // [A2] + assertNotSame(targetClass.getPackage(), lookupClass.getPackage()); + assertSame(targetClass.getModule(), lookupClass.getModule()); + assertSame(targetClass, lookup2.lookupClass()); // [A0] + assertSame(lookup.previousLookupClass(), lookup2.previousLookupClass()); // [A1] + assertEquals(lookup.lookupModes() & ~(PROTECTED | PRIVATE | PACKAGE | ORIGINAL), lookup2.lookupModes()); // [A2] } - @DataProvider(name = "anotherModule") - public Object[][] anotherModule() throws Exception { + public static Object[][] anotherModule() throws Exception { return new Object[][] { { m3.lookup, m4.type1, m5, m5.accessibleTypesTo(m3.module, m4.module) }, { m4.lookup, m5.type2, m3, m3.accessibleTypesTo(m4.module, m5.module) }, @@ -154,21 +154,22 @@ public class ModuleAccessTest { * [A5] can access public types in m1 exported to m0 * [A6] can access public types in m2 exported to m0 and m1 */ - @Test(dataProvider = "anotherModule") + @ParameterizedTest + @MethodSource("anotherModule") public void testLookupInAnotherModule(Lookup lookup, Class targetClass, ModuleLookup m2, Set> otherTypes) throws Exception { Class lookupClass = lookup.lookupClass(); Module m0 = lookupClass.getModule(); Module m1 = targetClass.getModule(); - assertTrue(m0 != m1); + assertNotSame(m1, m0); assertTrue(m0.canRead(m1)); assertTrue(m1.isExported(targetClass.getPackageName(), m0)); Lookup lookup2 = lookup.in(targetClass); - assertTrue(lookup2.lookupClass() == targetClass); // [A0] - assertTrue(lookup2.previousLookupClass() == lookup.lookupClass()); // [A1] - assertTrue(lookup2.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|PACKAGE|MODULE|ORIGINAL))); // [A2] + assertSame(targetClass, lookup2.lookupClass()); // [A0] + assertSame(lookup.lookupClass(), lookup2.previousLookupClass()); // [A1] + assertEquals(lookup.lookupModes() & ~(PROTECTED | PRIVATE | PACKAGE | MODULE | ORIGINAL), lookup2.lookupModes()); // [A2] // [A3] no access to module internal type in m0 // [A4] if m1 reads m0, @@ -207,7 +208,7 @@ public class ModuleAccessTest { // [A5] can access public types exported from m2 unconditionally // [A5] can access public types exported from m2 to m0 and m1 for (Class type : otherTypes) { - assertTrue(type.getModule() == m2.module); + assertSame(m2.module, type.getModule()); testAccess(lookup2, type); } @@ -215,10 +216,7 @@ public class ModuleAccessTest { for (Class type : Set.of(m2.type1, m2.type2, m2.type3)) { if (!otherTypes.contains(type)) { // type is accessible to this lookup - try { - lookup2.accessClass(type); - assertTrue(false); - } catch (IllegalAccessException e) {} + assertThrows(IllegalAccessException.class, () -> lookup2.accessClass(type)); findConstructorExpectingIAE(lookup2, type, void.class); } @@ -227,7 +225,7 @@ public class ModuleAccessTest { public void testAccess(Lookup lookup, Class type) throws Exception { // type is accessible to this lookup - assertTrue(lookup.accessClass(type) == type); + assertSame(type, lookup.accessClass(type)); // can find constructor findConstructor(lookup, type, void.class); @@ -237,28 +235,27 @@ public class ModuleAccessTest { Module m2 = type.getModule(); assertTrue(m0 != m1 && m0 != null); - assertTrue((lookup.lookupModes() & MODULE) == 0); + assertEquals(0, lookup.lookupModes() & MODULE); assertTrue(m0 != m2 || m1 != m2); MethodHandles.Lookup lookup2 = lookup.in(type); if (m2 == m1) { // the same module of the lookup class - assertTrue(lookup2.lookupClass() == type); - assertTrue(lookup2.previousLookupClass() == lookup.previousLookupClass()); + assertSame(type, lookup2.lookupClass()); + assertSame(lookup.previousLookupClass(), lookup2.previousLookupClass()); } else if (m2 == m0) { // hop back to the module of the previous lookup class - assertTrue(lookup2.lookupClass() == type); - assertTrue(lookup2.previousLookupClass() == lookup.lookupClass()); + assertSame(type, lookup2.lookupClass()); + assertSame(lookup.lookupClass(), lookup2.previousLookupClass()); } else { // hop to a third module - assertTrue(lookup2.lookupClass() == type); - assertTrue(lookup2.previousLookupClass() == lookup.lookupClass()); - assertTrue(lookup2.lookupModes() == 0); + assertSame(type, lookup2.lookupClass()); + assertSame(lookup.lookupClass(), lookup2.previousLookupClass()); + assertEquals(0, lookup2.lookupModes()); } } - @DataProvider(name = "thirdModule") - public Object[][] thirdModule() throws Exception { + public static Object[][] thirdModule() throws Exception { return new Object[][] { { m3.lookup, m4.type1, m5.type1}, { m3.lookup, m4.type2, m5.type1}, @@ -273,7 +270,8 @@ public class ModuleAccessTest { * [A1] c1 becomes previous lookup class * [A2] all access bits are dropped */ - @Test(dataProvider = "thirdModule") + @ParameterizedTest + @MethodSource("thirdModule") public void testLookupInThirdModule(Lookup lookup, Class c1, Class c2) throws Exception { Class c0 = lookup.lookupClass(); Module m0 = c0.getModule(); @@ -287,18 +285,17 @@ public class ModuleAccessTest { assertTrue(m2.isExported(c2.getPackageName(), m0) && m2.isExported(c2.getPackageName(), m1)); Lookup lookup1 = lookup.in(c1); - assertTrue(lookup1.lookupClass() == c1); - assertTrue(lookup1.previousLookupClass() == c0); - assertTrue(lookup1.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|PACKAGE|MODULE|ORIGINAL))); + assertSame(c1, lookup1.lookupClass()); + assertSame(c0, lookup1.previousLookupClass()); + assertEquals(lookup.lookupModes() & ~(PROTECTED | PRIVATE | PACKAGE | MODULE | ORIGINAL), lookup1.lookupModes()); Lookup lookup2 = lookup1.in(c2); - assertTrue(lookup2.lookupClass() == c2); // [A0] - assertTrue(lookup2.previousLookupClass() == c1); // [A1] - assertTrue(lookup2.lookupModes() == 0, lookup2.toString()); // [A2] + assertSame(c2, lookup2.lookupClass()); // [A0] + assertSame(c1, lookup2.previousLookupClass()); // [A1] + assertEquals(0, lookup2.lookupModes(), lookup2.toString()); // [A2] } - @DataProvider(name = "privLookupIn") - public Object[][] privLookupIn() throws Exception { + public static Object[][] privLookupIn() throws Exception { return new Object[][] { { m3.lookup, m4.type1 }, { m3.lookup, m5.type1 }, @@ -316,24 +313,22 @@ public class ModuleAccessTest { * [A2] the lookup class becomes previous lookup class * [A3] IAE thrown if lookup has no MODULE access */ - @Test(dataProvider = "privLookupIn") + @ParameterizedTest + @MethodSource("privLookupIn") public void testPrivateLookupIn(Lookup lookup, Class targetClass) throws Exception { Module m0 = lookup.lookupClass().getModule(); Module m1 = targetClass.getModule(); // privateLookupIn from m0 to m1 - assertTrue(m0 != m1); + assertNotSame(m1, m0); assertTrue(m1.isOpen(targetClass.getPackageName(), m0)); Lookup privLookup1 = MethodHandles.privateLookupIn(targetClass, lookup); - assertTrue(privLookup1.lookupModes() == (PROTECTED|PRIVATE|PACKAGE|PUBLIC)); // [A0] - assertTrue(privLookup1.lookupClass() == targetClass); // [A1] - assertTrue(privLookup1.previousLookupClass() == lookup.lookupClass()); // [A2] + assertEquals(PROTECTED | PRIVATE | PACKAGE | PUBLIC, privLookup1.lookupModes()); // [A0] + assertSame(targetClass, privLookup1.lookupClass()); // [A1] + assertSame(lookup.lookupClass(), privLookup1.previousLookupClass()); // [A2] // privLookup1 has no MODULE access; can't do privateLookupIn - try { - Lookup privLookup2 = MethodHandles.privateLookupIn(targetClass, privLookup1); // [A3] - assertFalse(privLookup2 != null); - } catch (IllegalAccessException e) {} + assertThrows(IllegalAccessException.class, () -> MethodHandles.privateLookupIn(targetClass, privLookup1)); // [A3] } /** @@ -343,9 +338,9 @@ public class ModuleAccessTest { public void testPrivateLookupAccess() throws Exception { Class staticsClass = e1.Statics.class; Lookup privLookup1 = MethodHandles.privateLookupIn(staticsClass, m4.lookup); - assertTrue((privLookup1.lookupModes() & MODULE) == 0); - assertTrue(privLookup1.lookupClass() == staticsClass); - assertTrue(privLookup1.previousLookupClass() == m4.lookup.lookupClass()); + assertEquals(0, (privLookup1.lookupModes() & MODULE)); + assertSame(staticsClass, privLookup1.lookupClass()); + assertSame(m4.lookup.lookupClass(), privLookup1.previousLookupClass()); // access private member and default package member in m5 MethodType mtype = MethodType.methodType(void.class); @@ -365,12 +360,9 @@ public class ModuleAccessTest { // lose private access Lookup privLookup2 = MethodHandles.privateLookupIn(m5.type1, m4.lookup); Lookup lookup = privLookup2.in(staticsClass); - assertTrue((lookup.lookupModes() & PRIVATE) == 0); + assertEquals(0, lookup.lookupModes() & PRIVATE); MethodHandle mh3 = lookup.findStatic(staticsClass, "packageMethod", mtype); - try { - lookup.findStatic(staticsClass, "privateMethod", mtype); - assertTrue(false); - } catch (IllegalAccessException e) {} + assertThrows(IllegalAccessException.class, () -> lookup.findStatic(staticsClass, "privateMethod", mtype)); } /** @@ -380,16 +372,16 @@ public class ModuleAccessTest { @Test public void testDropLookupMode() throws Exception { Lookup lookup = MethodHandles.privateLookupIn(m5.type1, m4.lookup); - assertTrue((lookup.lookupModes() & MODULE) == 0); + assertEquals(0, lookup.lookupModes() & MODULE); Lookup lookup1 = lookup.dropLookupMode(PRIVATE); - assertTrue(lookup1.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE))); + assertEquals(lookup1.lookupModes(), lookup.lookupModes() & ~(PROTECTED | PRIVATE)); Lookup lookup2 = lookup.dropLookupMode(PACKAGE); - assertTrue(lookup2.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|PACKAGE))); + assertEquals(lookup2.lookupModes(), lookup.lookupModes() & ~(PROTECTED | PRIVATE | PACKAGE)); Lookup lookup3 = lookup.dropLookupMode(MODULE); - assertTrue(lookup3.lookupModes() == (lookup.lookupModes() & ~(PROTECTED|PRIVATE|PACKAGE))); + assertEquals(lookup3.lookupModes(), lookup.lookupModes() & ~(PROTECTED | PRIVATE | PACKAGE)); Lookup lookup4 = lookup.dropLookupMode(PUBLIC); - assertTrue(lookup4.lookupModes() == 0); + assertEquals(0, lookup4.lookupModes()); } @@ -406,11 +398,8 @@ public class ModuleAccessTest { // drop MODULE access i.e. only PUBLIC access Lookup lookup = privLookup.dropLookupMode(MODULE); - assertTrue(lookup.lookupModes() == PUBLIC); - try { - MethodHandle mh2 = lookup.findStatic(nonPUblicType, "publicStatic", mtype); - assertFalse(mh2 != null); - } catch (IllegalAccessException e) {} + assertEquals(PUBLIC, lookup.lookupModes()); + assertThrows(IllegalAccessException.class, () -> lookup.findStatic(nonPUblicType, "publicStatic", mtype)); } @Test @@ -421,21 +410,18 @@ public class ModuleAccessTest { Lookup pub3 = pub2.in(java.lang.management.ThreadMXBean.class); Lookup pub4 = pub3.dropLookupMode(UNCONDITIONAL); - assertTrue(publicLookup.lookupClass() == Object.class); - assertTrue(publicLookup.lookupModes() == UNCONDITIONAL); - assertTrue(pub1.lookupClass() == m3.type1); - assertTrue(pub1.lookupModes() == UNCONDITIONAL); - assertTrue(pub2.lookupClass() == String.class); - assertTrue(pub2.lookupModes() == UNCONDITIONAL); - assertTrue(pub3.lookupClass() == java.lang.management.ThreadMXBean.class); - assertTrue(pub3.lookupModes() == UNCONDITIONAL); - assertTrue(pub4.lookupModes() == 0); + assertSame(Object.class, publicLookup.lookupClass()); + assertEquals(UNCONDITIONAL, publicLookup.lookupModes()); + assertSame(m3.type1, pub1.lookupClass()); + assertEquals(UNCONDITIONAL, pub1.lookupModes()); + assertSame(String.class, pub2.lookupClass()); + assertEquals(UNCONDITIONAL, pub2.lookupModes()); + assertSame(ThreadMXBean.class, pub3.lookupClass()); + assertEquals(UNCONDITIONAL, pub3.lookupModes()); + assertEquals(0, pub4.lookupModes()); // publicLookup has no MODULE access; can't do privateLookupIn - try { - Lookup pub5 = MethodHandles.privateLookupIn(m4.type1, pub1); - assertFalse(pub5 != null); - } catch (IllegalAccessException e) {} + assertThrows(IllegalAccessException.class, () -> MethodHandles.privateLookupIn(m4.type1, pub1)); } static class ModuleLookup { @@ -548,10 +534,7 @@ public class ModuleAccessTest { Class clazz, Class rtype, Class... ptypes) throws Exception { - try { - MethodHandle mh = findConstructor(lookup, clazz, rtype, ptypes); - assertTrue(false); - } catch (IllegalAccessException expected) { } + assertThrows(IllegalAccessException.class, () -> findConstructor(lookup, clazz, rtype, ptypes)); } /** diff --git a/test/jdk/java/lang/invoke/modules/m3/module-info.java b/test/jdk/java/lang/invoke/modules/m3/module-info.java index 1f47c42c196..c9d8fab20a5 100644 --- a/test/jdk/java/lang/invoke/modules/m3/module-info.java +++ b/test/jdk/java/lang/invoke/modules/m3/module-info.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -24,7 +24,7 @@ module m3 { requires m4; requires m5; - requires org.testng; + requires org.junit.platform.console.standalone; requires java.management; exports c1; opens c2 to m5;