8155739: [TESTBUG] VarHandles/Unsafe tests for weakCAS should allow spurious failures
Reviewed-by: psandoz, vlivanov, simonis
This commit is contained in:
parent
c7f8bb25dd
commit
4f53885343
jdk/test/java/lang/invoke/VarHandles
VarHandleBaseTest.javaVarHandleTestAccessBoolean.javaVarHandleTestAccessByte.javaVarHandleTestAccessChar.javaVarHandleTestAccessDouble.javaVarHandleTestAccessFloat.javaVarHandleTestAccessInt.javaVarHandleTestAccessLong.javaVarHandleTestAccessShort.javaVarHandleTestAccessString.javaVarHandleTestByteArrayAsChar.javaVarHandleTestByteArrayAsDouble.javaVarHandleTestByteArrayAsFloat.javaVarHandleTestByteArrayAsInt.javaVarHandleTestByteArrayAsLong.javaVarHandleTestByteArrayAsShort.javaVarHandleTestMethodHandleAccessInt.javaVarHandleTestMethodHandleAccessLong.javaVarHandleTestMethodHandleAccessString.javaX-VarHandleTestAccess.java.templateX-VarHandleTestByteArrayView.java.templateX-VarHandleTestMethodHandleAccess.java.template
@ -40,6 +40,7 @@ import static org.testng.Assert.*;
|
||||
|
||||
abstract class VarHandleBaseTest {
|
||||
static final int ITERS = Integer.getInteger("iters", 1);
|
||||
static final int WEAK_ATTEMPTS = Integer.getInteger("weakAttempts", 10);
|
||||
|
||||
interface ThrowingRunnable {
|
||||
void run() throws Throwable;
|
||||
@ -474,4 +475,4 @@ abstract class VarHandleBaseTest {
|
||||
assertEquals(mt.parameterType(mt.parameterCount() - 1), vh.varType());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
@ -402,22 +401,31 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(recv, 1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSet int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(recv, 1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet int");
|
||||
int x = (int) vh.get(recv);
|
||||
assertEquals(x, 2, "weakCompareAndSet int value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(recv, 2, 1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(recv, 2, 1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire int");
|
||||
int x = (int) vh.get(recv);
|
||||
assertEquals(x, 1, "weakCompareAndSetAcquire int");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(recv, 1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(recv, 1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease int");
|
||||
int x = (int) vh.get(recv);
|
||||
assertEquals(x, 2, "weakCompareAndSetRelease int");
|
||||
}
|
||||
@ -536,22 +544,31 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSet(1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSet int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet int");
|
||||
int x = (int) vh.get();
|
||||
assertEquals(x, 2, "weakCompareAndSet int value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSetAcquire(2, 1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(2, 1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire int");
|
||||
int x = (int) vh.get();
|
||||
assertEquals(x, 1, "weakCompareAndSetAcquire int");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSetRelease( 1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease int");
|
||||
int x = (int) vh.get();
|
||||
assertEquals(x, 2, "weakCompareAndSetRelease int");
|
||||
}
|
||||
@ -673,22 +690,31 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, 1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSet int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, 1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet int");
|
||||
int x = (int) vh.get(array, i);
|
||||
assertEquals(x, 2, "weakCompareAndSet int value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, 2, 1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, 2, 1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire int");
|
||||
int x = (int) vh.get(array, i);
|
||||
assertEquals(x, 1, "weakCompareAndSetAcquire int");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, 1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, 1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease int");
|
||||
int x = (int) vh.get(array, i);
|
||||
assertEquals(x, 2, "weakCompareAndSetRelease int");
|
||||
}
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
@ -402,22 +401,31 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(recv, 1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSet long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(recv, 1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet long");
|
||||
long x = (long) vh.get(recv);
|
||||
assertEquals(x, 2L, "weakCompareAndSet long value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(recv, 2L, 1L);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(recv, 2L, 1L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire long");
|
||||
long x = (long) vh.get(recv);
|
||||
assertEquals(x, 1L, "weakCompareAndSetAcquire long");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(recv, 1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(recv, 1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease long");
|
||||
long x = (long) vh.get(recv);
|
||||
assertEquals(x, 2L, "weakCompareAndSetRelease long");
|
||||
}
|
||||
@ -536,22 +544,31 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSet(1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSet long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet long");
|
||||
long x = (long) vh.get();
|
||||
assertEquals(x, 2L, "weakCompareAndSet long value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSetAcquire(2L, 1L);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(2L, 1L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire long");
|
||||
long x = (long) vh.get();
|
||||
assertEquals(x, 1L, "weakCompareAndSetAcquire long");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSetRelease( 1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease long");
|
||||
long x = (long) vh.get();
|
||||
assertEquals(x, 2L, "weakCompareAndSetRelease long");
|
||||
}
|
||||
@ -673,22 +690,31 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, 1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSet long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, 1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet long");
|
||||
long x = (long) vh.get(array, i);
|
||||
assertEquals(x, 2L, "weakCompareAndSet long value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, 2L, 1L);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, 2L, 1L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire long");
|
||||
long x = (long) vh.get(array, i);
|
||||
assertEquals(x, 1L, "weakCompareAndSetAcquire long");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, 1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, 1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease long");
|
||||
long x = (long) vh.get(array, i);
|
||||
assertEquals(x, 2L, "weakCompareAndSetRelease long");
|
||||
}
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessString extends VarHandleBaseTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
@ -416,22 +415,31 @@ public class VarHandleTestAccessString extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(recv, "foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSet String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(recv, "foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet String");
|
||||
String x = (String) vh.get(recv);
|
||||
assertEquals(x, "bar", "weakCompareAndSet String value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(recv, "bar", "foo");
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(recv, "bar", "foo");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire String");
|
||||
String x = (String) vh.get(recv);
|
||||
assertEquals(x, "foo", "weakCompareAndSetAcquire String");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(recv, "foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSetRelease String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(recv, "foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease String");
|
||||
String x = (String) vh.get(recv);
|
||||
assertEquals(x, "bar", "weakCompareAndSetRelease String");
|
||||
}
|
||||
@ -548,22 +556,31 @@ public class VarHandleTestAccessString extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSet("foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSet String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet("foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet String");
|
||||
String x = (String) vh.get();
|
||||
assertEquals(x, "bar", "weakCompareAndSet String value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSetAcquire("bar", "foo");
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire("bar", "foo");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire String");
|
||||
String x = (String) vh.get();
|
||||
assertEquals(x, "foo", "weakCompareAndSetAcquire String");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSetRelease( "foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSetRelease String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease("foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease String");
|
||||
String x = (String) vh.get();
|
||||
assertEquals(x, "bar", "weakCompareAndSetRelease String");
|
||||
}
|
||||
@ -683,22 +700,31 @@ public class VarHandleTestAccessString extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, "foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSet String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, "foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet String");
|
||||
String x = (String) vh.get(array, i);
|
||||
assertEquals(x, "bar", "weakCompareAndSet String value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, "bar", "foo");
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, "bar", "foo");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire String");
|
||||
String x = (String) vh.get(array, i);
|
||||
assertEquals(x, "foo", "weakCompareAndSetAcquire String");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, "foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSetRelease String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, "foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease String");
|
||||
String x = (String) vh.get(array, i);
|
||||
assertEquals(x, "bar", "weakCompareAndSetRelease String");
|
||||
}
|
||||
|
@ -93,7 +93,6 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -93,7 +93,6 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
@ -678,22 +677,31 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSet double");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet double");
|
||||
double x = (double) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSet double value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire double");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire double");
|
||||
double x = (double) vh.get(array, i);
|
||||
assertEquals(x, VALUE_1, "weakCompareAndSetAcquire double");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease double");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease double");
|
||||
double x = (double) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSetRelease double");
|
||||
}
|
||||
@ -811,22 +819,31 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSet double");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet double");
|
||||
double x = (double) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSet double value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire double");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire double");
|
||||
double x = (double) vh.get(array, i);
|
||||
assertEquals(x, VALUE_1, "weakCompareAndSetAcquire double");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease double");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease double");
|
||||
double x = (double) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSetRelease double");
|
||||
}
|
||||
|
@ -93,7 +93,6 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
@ -678,22 +677,31 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSet float");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet float");
|
||||
float x = (float) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSet float value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire float");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire float");
|
||||
float x = (float) vh.get(array, i);
|
||||
assertEquals(x, VALUE_1, "weakCompareAndSetAcquire float");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease float");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease float");
|
||||
float x = (float) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSetRelease float");
|
||||
}
|
||||
@ -811,22 +819,31 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSet float");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet float");
|
||||
float x = (float) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSet float value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire float");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire float");
|
||||
float x = (float) vh.get(array, i);
|
||||
assertEquals(x, VALUE_1, "weakCompareAndSetAcquire float");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease float");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease float");
|
||||
float x = (float) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSetRelease float");
|
||||
}
|
||||
|
@ -93,7 +93,6 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
@ -692,22 +691,31 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSet int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet int");
|
||||
int x = (int) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSet int value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire int");
|
||||
int x = (int) vh.get(array, i);
|
||||
assertEquals(x, VALUE_1, "weakCompareAndSetAcquire int");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease int");
|
||||
int x = (int) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSetRelease int");
|
||||
}
|
||||
@ -834,22 +842,31 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSet int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet int");
|
||||
int x = (int) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSet int value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire int");
|
||||
int x = (int) vh.get(array, i);
|
||||
assertEquals(x, VALUE_1, "weakCompareAndSetAcquire int");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease int");
|
||||
int x = (int) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSetRelease int");
|
||||
}
|
||||
|
@ -93,7 +93,6 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
@ -692,22 +691,31 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSet long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet long");
|
||||
long x = (long) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSet long value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire long");
|
||||
long x = (long) vh.get(array, i);
|
||||
assertEquals(x, VALUE_1, "weakCompareAndSetAcquire long");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease long");
|
||||
long x = (long) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSetRelease long");
|
||||
}
|
||||
@ -834,22 +842,31 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSet long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet long");
|
||||
long x = (long) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSet long value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire long");
|
||||
long x = (long) vh.get(array, i);
|
||||
assertEquals(x, VALUE_1, "weakCompareAndSetAcquire long");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease long");
|
||||
long x = (long) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSetRelease long");
|
||||
}
|
||||
|
@ -93,7 +93,6 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -208,22 +208,31 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSet int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet int");
|
||||
int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, 2, "weakCompareAndSet int value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 2, 1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 2, 1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire int");
|
||||
int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, 1, "weakCompareAndSetAcquire int");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease int");
|
||||
int x = (int) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, 2, "weakCompareAndSetRelease int");
|
||||
}
|
||||
@ -342,22 +351,31 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSet int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet int");
|
||||
int x = (int) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, 2, "weakCompareAndSet int value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(2, 1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(2, 1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire int");
|
||||
int x = (int) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, 1, "weakCompareAndSetAcquire int");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact( 1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease int");
|
||||
int x = (int) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, 2, "weakCompareAndSetRelease int");
|
||||
}
|
||||
@ -479,22 +497,31 @@ public class VarHandleTestMethodHandleAccessInt extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSet int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet int");
|
||||
int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, 2, "weakCompareAndSet int value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 2, 1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 2, 1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire int");
|
||||
int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, 1, "weakCompareAndSetAcquire int");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, 1, 2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease int");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, 1, 2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease int");
|
||||
int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, 2, "weakCompareAndSetRelease int");
|
||||
}
|
||||
|
@ -208,22 +208,31 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSet long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet long");
|
||||
long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, 2L, "weakCompareAndSet long value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 2L, 1L);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 2L, 1L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire long");
|
||||
long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, 1L, "weakCompareAndSetAcquire long");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease long");
|
||||
long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, 2L, "weakCompareAndSetRelease long");
|
||||
}
|
||||
@ -342,22 +351,31 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSet long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet long");
|
||||
long x = (long) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, 2L, "weakCompareAndSet long value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(2L, 1L);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(2L, 1L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire long");
|
||||
long x = (long) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, 1L, "weakCompareAndSetAcquire long");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact( 1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease long");
|
||||
long x = (long) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, 2L, "weakCompareAndSetRelease long");
|
||||
}
|
||||
@ -479,22 +497,31 @@ public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSet long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet long");
|
||||
long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, 2L, "weakCompareAndSet long value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 2L, 1L);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 2L, 1L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire long");
|
||||
long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, 1L, "weakCompareAndSetAcquire long");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, 1L, 2L);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease long");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, 1L, 2L);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease long");
|
||||
long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, 2L, "weakCompareAndSetRelease long");
|
||||
}
|
||||
|
@ -208,22 +208,31 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, "foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSet String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, "foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet String");
|
||||
String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, "bar", "weakCompareAndSet String value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, "bar", "foo");
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, "bar", "foo");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire String");
|
||||
String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, "foo", "weakCompareAndSetAcquire String");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, "foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSetRelease String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, "foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease String");
|
||||
String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, "bar", "weakCompareAndSetRelease String");
|
||||
}
|
||||
@ -338,22 +347,31 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact("foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSet String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact("foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet String");
|
||||
String x = (String) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, "bar", "weakCompareAndSet String value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact("bar", "foo");
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact("bar", "foo");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire String");
|
||||
String x = (String) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, "foo", "weakCompareAndSetAcquire String");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact( "foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSetRelease String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact("foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease String");
|
||||
String x = (String) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, "bar", "weakCompareAndSetRelease String");
|
||||
}
|
||||
@ -471,22 +489,31 @@ public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, "foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSet String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, "foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet String");
|
||||
String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, "bar", "weakCompareAndSet String value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, "bar", "foo");
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, "bar", "foo");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire String");
|
||||
String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, "foo", "weakCompareAndSetAcquire String");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, "foo", "bar");
|
||||
assertEquals(r, true, "weakCompareAndSetRelease String");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, "foo", "bar");
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease String");
|
||||
String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, "bar", "weakCompareAndSetRelease String");
|
||||
}
|
||||
|
@ -494,22 +494,31 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(recv, $value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSet $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(recv, $value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet $type$");
|
||||
$type$ x = ($type$) vh.get(recv);
|
||||
assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(recv, $value2$, $value1$);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(recv, $value2$, $value1$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire $type$");
|
||||
$type$ x = ($type$) vh.get(recv);
|
||||
assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease $type$");
|
||||
$type$ x = ($type$) vh.get(recv);
|
||||
assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
|
||||
}
|
||||
@ -670,22 +679,31 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSet($value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSet $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet($value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet $type$");
|
||||
$type$ x = ($type$) vh.get();
|
||||
assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSetAcquire($value2$, $value1$);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire($value2$, $value1$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire $type$");
|
||||
$type$ x = ($type$) vh.get();
|
||||
assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) vh.weakCompareAndSetRelease( $value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease($value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease $type$");
|
||||
$type$ x = ($type$) vh.get();
|
||||
assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
|
||||
}
|
||||
@ -849,22 +867,31 @@ public class VarHandleTestAccess$Type$ extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, $value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSet $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, $value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet $type$");
|
||||
$type$ x = ($type$) vh.get(array, i);
|
||||
assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, $value2$, $value1$);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, $value2$, $value1$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire $type$");
|
||||
$type$ x = ($type$) vh.get(array, i);
|
||||
assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, $value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, $value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease $type$");
|
||||
$type$ x = ($type$) vh.get(array, i);
|
||||
assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
|
||||
}
|
||||
|
@ -848,22 +848,31 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSet $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet $type$");
|
||||
$type$ x = ($type$) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSet $type$ value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire $type$");
|
||||
$type$ x = ($type$) vh.get(array, i);
|
||||
assertEquals(x, VALUE_1, "weakCompareAndSetAcquire $type$");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease $type$");
|
||||
$type$ x = ($type$) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSetRelease $type$");
|
||||
}
|
||||
@ -994,22 +1003,31 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSet $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSet(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet $type$");
|
||||
$type$ x = ($type$) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSet $type$ value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire $type$");
|
||||
$type$ x = ($type$) vh.get(array, i);
|
||||
assertEquals(x, VALUE_1, "weakCompareAndSetAcquire $type$");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease $type$");
|
||||
$type$ x = ($type$) vh.get(array, i);
|
||||
assertEquals(x, VALUE_2, "weakCompareAndSetRelease $type$");
|
||||
}
|
||||
|
@ -209,22 +209,31 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, $value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSet $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, $value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet $type$");
|
||||
$type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, $value2$, $value1$);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, $value2$, $value1$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire $type$");
|
||||
$type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, $value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, $value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease $type$");
|
||||
$type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
|
||||
assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
|
||||
}
|
||||
@ -373,22 +382,31 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact($value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSet $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact($value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet $type$");
|
||||
$type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact($value2$, $value1$);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact($value2$, $value1$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire $type$");
|
||||
$type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact( $value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact($value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease $type$");
|
||||
$type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
|
||||
assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
|
||||
}
|
||||
@ -540,22 +558,31 @@ public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest {
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, $value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSet $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, $value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSet $type$");
|
||||
$type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, $value2$, $value1$);
|
||||
assertEquals(r, true, "weakCompareAndSetAcquire $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, $value2$, $value1$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetAcquire $type$");
|
||||
$type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
|
||||
}
|
||||
|
||||
{
|
||||
boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, $value1$, $value2$);
|
||||
assertEquals(r, true, "weakCompareAndSetRelease $type$");
|
||||
boolean success = false;
|
||||
for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
|
||||
success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, $value1$, $value2$);
|
||||
}
|
||||
assertEquals(success, true, "weakCompareAndSetRelease $type$");
|
||||
$type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
|
||||
assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
|
||||
}
|
||||
|
Loading…
x
Reference in New Issue
Block a user