Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
jdk/test/java/lang/invoke/VarHandles/VarHandleTestMethodHandleAccessLong.java
changeset 39470 d6f8b4a85fb0
parent 38429 0fd11baf20c3
child 39472 6df82f4c63ac
equal deleted inserted replaced
39323:271a3038d6ab 39470:d6f8b4a85fb0 
    37 import java.util.List;
 
    37 import java.util.List;
 
    38 
    38 
    39 import static org.testng.Assert.*;
 
    39 import static org.testng.Assert.*;
 
    40 
    40 
    41 public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest {
 
    41 public class VarHandleTestMethodHandleAccessLong extends VarHandleBaseTest {
 
    42     static final long static_final_v = 1L;
 
    42     static final long static_final_v = 0x0123456789ABCDEFL;
 
    43 
    43 
    44     static long static_v;
 
    44     static long static_v;
 
    45 
    45 
    46     final long final_v = 1L;
 
    46     final long final_v = 0x0123456789ABCDEFL;
 
    47 
    47 
    48     long v;
 
    48     long v;
 
    49 
    49 
    50     VarHandle vhFinalField;
 
    50     VarHandle vhFinalField;
 
    51 
    51 
   119 
   119 
   120 
   120 
   121     static void testInstanceField(VarHandleTestMethodHandleAccessLong recv, Handles hs) throws Throwable {
 
   121     static void testInstanceField(VarHandleTestMethodHandleAccessLong recv, Handles hs) throws Throwable {
 
   122         // Plain
 
   122         // Plain
 
   123         {
 
   123         {
 
   124             hs.get(TestAccessMode.SET).invokeExact(recv, 1L);
 
   124             hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL);
 
   125             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   125             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   126             assertEquals(x, 1L, "set long value");
 
   126             assertEquals(x, 0x0123456789ABCDEFL, "set long value");
 
   127         }
 
   127         }
 
   128 
   128 
   129 
   129 
   130         // Volatile
 
   130         // Volatile
 
   131         {
 
   131         {
 
   132             hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, 2L);
 
   132             hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, 0xCAFEBABECAFEBABEL);
 
   133             long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv);
 
   133             long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv);
 
   134             assertEquals(x, 2L, "setVolatile long value");
 
   134             assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value");
 
   135         }
 
   135         }
 
   136 
   136 
   137         // Lazy
 
   137         // Lazy
 
   138         {
 
   138         {
 
   139             hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, 1L);
 
   139             hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, 0x0123456789ABCDEFL);
 
   140             long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv);
 
   140             long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv);
 
   141             assertEquals(x, 1L, "setRelease long value");
 
   141             assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value");
 
   142         }
 
   142         }
 
   143 
   143 
   144         // Opaque
 
   144         // Opaque
 
   145         {
 
   145         {
 
   146             hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, 2L);
 
   146             hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, 0xCAFEBABECAFEBABEL);
 
   147             long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv);
 
   147             long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv);
 
   148             assertEquals(x, 2L, "setOpaque long value");
 
   148             assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value");
 
   149         }
 
   149         }
 
   150 
   150 
   151         hs.get(TestAccessMode.SET).invokeExact(recv, 1L);
 
   151         hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL);
 
   152 
   152 
   153         // Compare
 
   153         // Compare
 
   154         {
 
   154         {
 
   155             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 1L, 2L);
 
   155             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   156             assertEquals(r, true, "success compareAndSet long");
 
   156             assertEquals(r, true, "success compareAndSet long");
 
   157             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   157             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   158             assertEquals(x, 2L, "success compareAndSet long value");
 
   158             assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value");
 
   159         }
 
   159         }
 
   160 
   160 
   161         {
 
   161         {
 
   162             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 1L, 3L);
 
   162             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 
   163             assertEquals(r, false, "failing compareAndSet long");
 
   163             assertEquals(r, false, "failing compareAndSet long");
 
   164             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   164             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   165             assertEquals(x, 2L, "failing compareAndSet long value");
 
   165             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value");
 
   166         }
 
   166         }
 
   167 
   167 
   168         {
 
   168         {
 
   169             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(recv, 2L, 1L);
 
   169             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   170             assertEquals(r, 2L, "success compareAndExchangeVolatile long");
 
   170             assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeVolatile long");
 
   171             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   171             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   172             assertEquals(x, 1L, "success compareAndExchangeVolatile long value");
 
   172             assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeVolatile long value");
 
   173         }
 
   173         }
 
   174 
   174 
   175         {
 
   175         {
 
   176             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(recv, 2L, 3L);
 
   176             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 
   177             assertEquals(r, 1L, "failing compareAndExchangeVolatile long");
 
   177             assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeVolatile long");
 
   178             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   178             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   179             assertEquals(x, 1L, "failing compareAndExchangeVolatile long value");
 
   179             assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeVolatile long value");
 
   180         }
 
   180         }
 
   181 
   181 
   182         {
 
   182         {
 
   183             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 1L, 2L);
 
   183             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   184             assertEquals(r, 1L, "success compareAndExchangeAcquire long");
 
   184             assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long");
 
   185             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   185             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   186             assertEquals(x, 2L, "success compareAndExchangeAcquire long value");
 
   186             assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value");
 
   187         }
 
   187         }
 
   188 
   188 
   189         {
 
   189         {
 
   190             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 1L, 3L);
 
   190             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 
   191             assertEquals(r, 2L, "failing compareAndExchangeAcquire long");
 
   191             assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long");
 
   192             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   192             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   193             assertEquals(x, 2L, "failing compareAndExchangeAcquire long value");
 
   193             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value");
 
   194         }
 
   194         }
 
   195 
   195 
   196         {
 
   196         {
 
   197             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 2L, 1L);
 
   197             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   198             assertEquals(r, 2L, "success compareAndExchangeRelease long");
 
   198             assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long");
 
   199             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   199             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   200             assertEquals(x, 1L, "success compareAndExchangeRelease long value");
 
   200             assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value");
 
   201         }
 
   201         }
 
   202 
   202 
   203         {
 
   203         {
 
   204             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 2L, 3L);
 
   204             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 
   205             assertEquals(r, 1L, "failing compareAndExchangeRelease long");
 
   205             assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long");
 
   206             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   206             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   207             assertEquals(x, 1L, "failing compareAndExchangeRelease long value");
 
   207             assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value");
 
   208         }
 
   208         }
 
   209 
   209 
   210         {
 
   210         {
 
   211             boolean success = false;
 
   211             boolean success = false;
 
   212             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   212             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   213                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 1L, 2L);
 
   213                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   214             }
 
   214             }
 
   215             assertEquals(success, true, "weakCompareAndSet long");
 
   215             assertEquals(success, true, "weakCompareAndSet long");
 
   216             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   216             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   217             assertEquals(x, 2L, "weakCompareAndSet long value");
 
   217             assertEquals(x, 0xCAFEBABECAFEBABEL, "weakCompareAndSet long value");
 
   218         }
 
   218         }
 
   219 
   219 
   220         {
 
   220         {
 
   221             boolean success = false;
 
   221             boolean success = false;
 
   222             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   222             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   223                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 2L, 1L);
 
   223                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   224             }
 
   224             }
 
   225             assertEquals(success, true, "weakCompareAndSetAcquire long");
 
   225             assertEquals(success, true, "weakCompareAndSetAcquire long");
 
   226             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   226             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   227             assertEquals(x, 1L, "weakCompareAndSetAcquire long");
 
   227             assertEquals(x, 0x0123456789ABCDEFL, "weakCompareAndSetAcquire long");
 
   228         }
 
   228         }
 
   229 
   229 
   230         {
 
   230         {
 
   231             boolean success = false;
 
   231             boolean success = false;
 
   232             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   232             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   233                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 1L, 2L);
 
   233                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   234             }
 
   234             }
 
   235             assertEquals(success, true, "weakCompareAndSetRelease long");
 
   235             assertEquals(success, true, "weakCompareAndSetRelease long");
 
   236             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   236             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   237             assertEquals(x, 2L, "weakCompareAndSetRelease long");
 
   237             assertEquals(x, 0xCAFEBABECAFEBABEL, "weakCompareAndSetRelease long");
 
   238         }
 
   238         }
 
   239 
   239 
   240         {
 
   240         {
 
   241             boolean success = false;
 
   241             boolean success = false;
 
   242             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   242             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   243                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_VOLATILE).invokeExact(recv, 2L, 1L);
 
   243                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_VOLATILE).invokeExact(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   244             }
 
   244             }
 
   245             assertEquals(success, true, "weakCompareAndSetVolatile long");
 
   245             assertEquals(success, true, "weakCompareAndSetVolatile long");
 
   246             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   246             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   247             assertEquals(x, 1L, "weakCompareAndSetVolatile long");
 
   247             assertEquals(x, 0x0123456789ABCDEFL, "weakCompareAndSetVolatile long");
 
   248         }
 
   248         }
 
   249 
   249 
   250         // Compare set and get
 
   250         // Compare set and get
 
   251         {
 
   251         {
 
   252             long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, 2L);
 
   252             long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, 0xCAFEBABECAFEBABEL);
 
   253             assertEquals(o, 1L, "getAndSet long");
 
   253             assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long");
 
   254             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   254             long x = (long) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   255             assertEquals(x, 2L, "getAndSet long value");
 
   255             assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value");
 
   256         }
 
   256         }
 
   257 
   257 
   258         hs.get(TestAccessMode.SET).invokeExact(recv, 1L);
 
   258         hs.get(TestAccessMode.SET).invokeExact(recv, 0x0123456789ABCDEFL);
 
   259 
   259 
   260         // get and add, add and get
 
   260         // get and add, add and get
 
   261         {
 
   261         {
 
   262             long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, 3L);
 
   262             long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, 0xDEADBEEFDEADBEEFL);
 
   263             assertEquals(o, 1L, "getAndAdd long");
 
   263             assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long");
 
   264             long c = (long) hs.get(TestAccessMode.ADD_AND_GET).invokeExact(recv, 3L);
 
   264             long c = (long) hs.get(TestAccessMode.ADD_AND_GET).invokeExact(recv, 0xDEADBEEFDEADBEEFL);
 
   265             assertEquals(c, 1L + 3L + 3L, "getAndAdd long value");
 
   265             assertEquals(c, (long)(0x0123456789ABCDEFL + 0xDEADBEEFDEADBEEFL + 0xDEADBEEFDEADBEEFL), "getAndAdd long value");
 
   266         }
 
   266         }
 
   267     }
 
   267     }
 
   268 
   268 
   269     static void testInstanceFieldUnsupported(VarHandleTestMethodHandleAccessLong recv, Handles hs) throws Throwable {
 
   269     static void testInstanceFieldUnsupported(VarHandleTestMethodHandleAccessLong recv, Handles hs) throws Throwable {
 
   270 
   270 
   272 
   272 
   273 
   273 
   274     static void testStaticField(Handles hs) throws Throwable {
 
   274     static void testStaticField(Handles hs) throws Throwable {
 
   275         // Plain
 
   275         // Plain
 
   276         {
 
   276         {
 
   277             hs.get(TestAccessMode.SET).invokeExact(1L);
 
   277             hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL);
 
   278             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   278             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   279             assertEquals(x, 1L, "set long value");
 
   279             assertEquals(x, 0x0123456789ABCDEFL, "set long value");
 
   280         }
 
   280         }
 
   281 
   281 
   282 
   282 
   283         // Volatile
 
   283         // Volatile
 
   284         {
 
   284         {
 
   285             hs.get(TestAccessMode.SET_VOLATILE).invokeExact(2L);
 
   285             hs.get(TestAccessMode.SET_VOLATILE).invokeExact(0xCAFEBABECAFEBABEL);
 
   286             long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact();
 
   286             long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact();
 
   287             assertEquals(x, 2L, "setVolatile long value");
 
   287             assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value");
 
   288         }
 
   288         }
 
   289 
   289 
   290         // Lazy
 
   290         // Lazy
 
   291         {
 
   291         {
 
   292             hs.get(TestAccessMode.SET_RELEASE).invokeExact(1L);
 
   292             hs.get(TestAccessMode.SET_RELEASE).invokeExact(0x0123456789ABCDEFL);
 
   293             long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact();
 
   293             long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact();
 
   294             assertEquals(x, 1L, "setRelease long value");
 
   294             assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value");
 
   295         }
 
   295         }
 
   296 
   296 
   297         // Opaque
 
   297         // Opaque
 
   298         {
 
   298         {
 
   299             hs.get(TestAccessMode.SET_OPAQUE).invokeExact(2L);
 
   299             hs.get(TestAccessMode.SET_OPAQUE).invokeExact(0xCAFEBABECAFEBABEL);
 
   300             long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact();
 
   300             long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact();
 
   301             assertEquals(x, 2L, "setOpaque long value");
 
   301             assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value");
 
   302         }
 
   302         }
 
   303 
   303 
   304         hs.get(TestAccessMode.SET).invokeExact(1L);
 
   304         hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL);
 
   305 
   305 
   306         // Compare
 
   306         // Compare
 
   307         {
 
   307         {
 
   308             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(1L, 2L);
 
   308             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   309             assertEquals(r, true, "success compareAndSet long");
 
   309             assertEquals(r, true, "success compareAndSet long");
 
   310             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   310             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   311             assertEquals(x, 2L, "success compareAndSet long value");
 
   311             assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value");
 
   312         }
 
   312         }
 
   313 
   313 
   314         {
 
   314         {
 
   315             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(1L, 3L);
 
   315             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 
   316             assertEquals(r, false, "failing compareAndSet long");
 
   316             assertEquals(r, false, "failing compareAndSet long");
 
   317             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   317             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   318             assertEquals(x, 2L, "failing compareAndSet long value");
 
   318             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value");
 
   319         }
 
   319         }
 
   320 
   320 
   321         {
 
   321         {
 
   322             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(2L, 1L);
 
   322             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   323             assertEquals(r, 2L, "success compareAndExchangeVolatile long");
 
   323             assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeVolatile long");
 
   324             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   324             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   325             assertEquals(x, 1L, "success compareAndExchangeVolatile long value");
 
   325             assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeVolatile long value");
 
   326         }
 
   326         }
 
   327 
   327 
   328         {
 
   328         {
 
   329             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(2L, 3L);
 
   329             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 
   330             assertEquals(r, 1L, "failing compareAndExchangeVolatile long");
 
   330             assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeVolatile long");
 
   331             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   331             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   332             assertEquals(x, 1L, "failing compareAndExchangeVolatile long value");
 
   332             assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeVolatile long value");
 
   333         }
 
   333         }
 
   334 
   334 
   335         {
 
   335         {
 
   336             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(1L, 2L);
 
   336             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   337             assertEquals(r, 1L, "success compareAndExchangeAcquire long");
 
   337             assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long");
 
   338             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   338             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   339             assertEquals(x, 2L, "success compareAndExchangeAcquire long value");
 
   339             assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value");
 
   340         }
 
   340         }
 
   341 
   341 
   342         {
 
   342         {
 
   343             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(1L, 3L);
 
   343             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 
   344             assertEquals(r, 2L, "failing compareAndExchangeAcquire long");
 
   344             assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long");
 
   345             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   345             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   346             assertEquals(x, 2L, "failing compareAndExchangeAcquire long value");
 
   346             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value");
 
   347         }
 
   347         }
 
   348 
   348 
   349         {
 
   349         {
 
   350             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(2L, 1L);
 
   350             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   351             assertEquals(r, 2L, "success compareAndExchangeRelease long");
 
   351             assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long");
 
   352             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   352             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   353             assertEquals(x, 1L, "success compareAndExchangeRelease long value");
 
   353             assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value");
 
   354         }
 
   354         }
 
   355 
   355 
   356         {
 
   356         {
 
   357             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(2L, 3L);
 
   357             long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 
   358             assertEquals(r, 1L, "failing compareAndExchangeRelease long");
 
   358             assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long");
 
   359             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   359             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   360             assertEquals(x, 1L, "failing compareAndExchangeRelease long value");
 
   360             assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value");
 
   361         }
 
   361         }
 
   362 
   362 
   363         {
 
   363         {
 
   364             boolean success = false;
 
   364             boolean success = false;
 
   365             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   365             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   366                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(1L, 2L);
 
   366                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   367             }
 
   367             }
 
   368             assertEquals(success, true, "weakCompareAndSet long");
 
   368             assertEquals(success, true, "weakCompareAndSet long");
 
   369             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   369             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   370             assertEquals(x, 2L, "weakCompareAndSet long value");
 
   370             assertEquals(x, 0xCAFEBABECAFEBABEL, "weakCompareAndSet long value");
 
   371         }
 
   371         }
 
   372 
   372 
   373         {
 
   373         {
 
   374             boolean success = false;
 
   374             boolean success = false;
 
   375             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   375             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   376                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(2L, 1L);
 
   376                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   377             }
 
   377             }
 
   378             assertEquals(success, true, "weakCompareAndSetAcquire long");
 
   378             assertEquals(success, true, "weakCompareAndSetAcquire long");
 
   379             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   379             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   380             assertEquals(x, 1L, "weakCompareAndSetAcquire long");
 
   380             assertEquals(x, 0x0123456789ABCDEFL, "weakCompareAndSetAcquire long");
 
   381         }
 
   381         }
 
   382 
   382 
   383         {
 
   383         {
 
   384             boolean success = false;
 
   384             boolean success = false;
 
   385             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   385             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   386                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(1L, 2L);
 
   386                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   387             }
 
   387             }
 
   388             assertEquals(success, true, "weakCompareAndSetRelease long");
 
   388             assertEquals(success, true, "weakCompareAndSetRelease long");
 
   389             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   389             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   390             assertEquals(x, 2L, "weakCompareAndSetRelease long");
 
   390             assertEquals(x, 0xCAFEBABECAFEBABEL, "weakCompareAndSetRelease long");
 
   391         }
 
   391         }
 
   392 
   392 
   393         {
 
   393         {
 
   394             boolean success = false;
 
   394             boolean success = false;
 
   395             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   395             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   396                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_VOLATILE).invokeExact(2L, 1L);
 
   396                 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_VOLATILE).invokeExact(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   397             }
 
   397             }
 
   398             assertEquals(success, true, "weakCompareAndSetVolatile long");
 
   398             assertEquals(success, true, "weakCompareAndSetVolatile long");
 
   399             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   399             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   400             assertEquals(x, 1L, "weakCompareAndSetVolatile long");
 
   400             assertEquals(x, 0x0123456789ABCDEFL, "weakCompareAndSetVolatile long");
 
   401         }
 
   401         }
 
   402 
   402 
   403         // Compare set and get
 
   403         // Compare set and get
 
   404         {
 
   404         {
 
   405             long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact( 2L);
 
   405             long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact( 0xCAFEBABECAFEBABEL);
 
   406             assertEquals(o, 1L, "getAndSet long");
 
   406             assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long");
 
   407             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   407             long x = (long) hs.get(TestAccessMode.GET).invokeExact();
 
   408             assertEquals(x, 2L, "getAndSet long value");
 
   408             assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value");
 
   409         }
 
   409         }
 
   410 
   410 
   411         hs.get(TestAccessMode.SET).invokeExact(1L);
 
   411         hs.get(TestAccessMode.SET).invokeExact(0x0123456789ABCDEFL);
 
   412 
   412 
   413         // get and add, add and get
 
   413         // get and add, add and get
 
   414         {
 
   414         {
 
   415             long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact( 3L);
 
   415             long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact( 0xDEADBEEFDEADBEEFL);
 
   416             assertEquals(o, 1L, "getAndAdd long");
 
   416             assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long");
 
   417             long c = (long) hs.get(TestAccessMode.ADD_AND_GET).invokeExact(3L);
 
   417             long c = (long) hs.get(TestAccessMode.ADD_AND_GET).invokeExact(0xDEADBEEFDEADBEEFL);
 
   418             assertEquals(c, 1L + 3L + 3L, "getAndAdd long value");
 
   418             assertEquals(c, (long)(0x0123456789ABCDEFL + 0xDEADBEEFDEADBEEFL + 0xDEADBEEFDEADBEEFL), "getAndAdd long value");
 
   419         }
 
   419         }
 
   420     }
 
   420     }
 
   421 
   421 
   422     static void testStaticFieldUnsupported(Handles hs) throws Throwable {
 
   422     static void testStaticFieldUnsupported(Handles hs) throws Throwable {
 
   423 
   423 
   428         long[] array = new long[10];
 
   428         long[] array = new long[10];
 
   429 
   429 
   430         for (int i = 0; i < array.length; i++) {
 
   430         for (int i = 0; i < array.length; i++) {
 
   431             // Plain
 
   431             // Plain
 
   432             {
 
   432             {
 
   433                 hs.get(TestAccessMode.SET).invokeExact(array, i, 1L);
 
   433                 hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL);
 
   434                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   434                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   435                 assertEquals(x, 1L, "get long value");
 
   435                 assertEquals(x, 0x0123456789ABCDEFL, "get long value");
 
   436             }
 
   436             }
 
   437 
   437 
   438 
   438 
   439             // Volatile
 
   439             // Volatile
 
   440             {
 
   440             {
 
   441                 hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 2L);
 
   441                 hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 0xCAFEBABECAFEBABEL);
 
   442                 long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i);
 
   442                 long x = (long) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i);
 
   443                 assertEquals(x, 2L, "setVolatile long value");
 
   443                 assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value");
 
   444             }
 
   444             }
 
   445 
   445 
   446             // Lazy
 
   446             // Lazy
 
   447             {
 
   447             {
 
   448                 hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 1L);
 
   448                 hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 0x0123456789ABCDEFL);
 
   449                 long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i);
 
   449                 long x = (long) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i);
 
   450                 assertEquals(x, 1L, "setRelease long value");
 
   450                 assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value");
 
   451             }
 
   451             }
 
   452 
   452 
   453             // Opaque
 
   453             // Opaque
 
   454             {
 
   454             {
 
   455                 hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 2L);
 
   455                 hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 0xCAFEBABECAFEBABEL);
 
   456                 long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i);
 
   456                 long x = (long) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i);
 
   457                 assertEquals(x, 2L, "setOpaque long value");
 
   457                 assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value");
 
   458             }
 
   458             }
 
   459 
   459 
   460             hs.get(TestAccessMode.SET).invokeExact(array, i, 1L);
 
   460             hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL);
 
   461 
   461 
   462             // Compare
 
   462             // Compare
 
   463             {
 
   463             {
 
   464                 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 1L, 2L);
 
   464                 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   465                 assertEquals(r, true, "success compareAndSet long");
 
   465                 assertEquals(r, true, "success compareAndSet long");
 
   466                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   466                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   467                 assertEquals(x, 2L, "success compareAndSet long value");
 
   467                 assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value");
 
   468             }
 
   468             }
 
   469 
   469 
   470             {
 
   470             {
 
   471                 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 1L, 3L);
 
   471                 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 
   472                 assertEquals(r, false, "failing compareAndSet long");
 
   472                 assertEquals(r, false, "failing compareAndSet long");
 
   473                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   473                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   474                 assertEquals(x, 2L, "failing compareAndSet long value");
 
   474                 assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value");
 
   475             }
 
   475             }
 
   476 
   476 
   477             {
 
   477             {
 
   478                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(array, i, 2L, 1L);
 
   478                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   479                 assertEquals(r, 2L, "success compareAndExchangeVolatile long");
 
   479                 assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeVolatile long");
 
   480                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   480                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   481                 assertEquals(x, 1L, "success compareAndExchangeVolatile long value");
 
   481                 assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeVolatile long value");
 
   482             }
 
   482             }
 
   483 
   483 
   484             {
 
   484             {
 
   485                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(array, i, 2L, 3L);
 
   485                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 
   486                 assertEquals(r, 1L, "failing compareAndExchangeVolatile long");
 
   486                 assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeVolatile long");
 
   487                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   487                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   488                 assertEquals(x, 1L, "failing compareAndExchangeVolatile long value");
 
   488                 assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeVolatile long value");
 
   489             }
 
   489             }
 
   490 
   490 
   491             {
 
   491             {
 
   492                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 1L, 2L);
 
   492                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   493                 assertEquals(r, 1L, "success compareAndExchangeAcquire long");
 
   493                 assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long");
 
   494                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   494                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   495                 assertEquals(x, 2L, "success compareAndExchangeAcquire long value");
 
   495                 assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value");
 
   496             }
 
   496             }
 
   497 
   497 
   498             {
 
   498             {
 
   499                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 1L, 3L);
 
   499                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 
   500                 assertEquals(r, 2L, "failing compareAndExchangeAcquire long");
 
   500                 assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long");
 
   501                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   501                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   502                 assertEquals(x, 2L, "failing compareAndExchangeAcquire long value");
 
   502                 assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value");
 
   503             }
 
   503             }
 
   504 
   504 
   505             {
 
   505             {
 
   506                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 2L, 1L);
 
   506                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   507                 assertEquals(r, 2L, "success compareAndExchangeRelease long");
 
   507                 assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long");
 
   508                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   508                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   509                 assertEquals(x, 1L, "success compareAndExchangeRelease long value");
 
   509                 assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value");
 
   510             }
 
   510             }
 
   511 
   511 
   512             {
 
   512             {
 
   513                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 2L, 3L);
 
   513                 long r = (long) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 
   514                 assertEquals(r, 1L, "failing compareAndExchangeRelease long");
 
   514                 assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long");
 
   515                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   515                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   516                 assertEquals(x, 1L, "failing compareAndExchangeRelease long value");
 
   516                 assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value");
 
   517             }
 
   517             }
 
   518 
   518 
   519             {
 
   519             {
 
   520                 boolean success = false;
 
   520                 boolean success = false;
 
   521                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   521                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   522                     success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 1L, 2L);
 
   522                     success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   523                 }
 
   523                 }
 
   524                 assertEquals(success, true, "weakCompareAndSet long");
 
   524                 assertEquals(success, true, "weakCompareAndSet long");
 
   525                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   525                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   526                 assertEquals(x, 2L, "weakCompareAndSet long value");
 
   526                 assertEquals(x, 0xCAFEBABECAFEBABEL, "weakCompareAndSet long value");
 
   527             }
 
   527             }
 
   528 
   528 
   529             {
 
   529             {
 
   530                 boolean success = false;
 
   530                 boolean success = false;
 
   531                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   531                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   532                     success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 2L, 1L);
 
   532                     success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   533                 }
 
   533                 }
 
   534                 assertEquals(success, true, "weakCompareAndSetAcquire long");
 
   534                 assertEquals(success, true, "weakCompareAndSetAcquire long");
 
   535                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   535                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   536                 assertEquals(x, 1L, "weakCompareAndSetAcquire long");
 
   536                 assertEquals(x, 0x0123456789ABCDEFL, "weakCompareAndSetAcquire long");
 
   537             }
 
   537             }
 
   538 
   538 
   539             {
 
   539             {
 
   540                 boolean success = false;
 
   540                 boolean success = false;
 
   541                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   541                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   542                     success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, 1L, 2L);
 
   542                     success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   543                 }
 
   543                 }
 
   544                 assertEquals(success, true, "weakCompareAndSetRelease long");
 
   544                 assertEquals(success, true, "weakCompareAndSetRelease long");
 
   545                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   545                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   546                 assertEquals(x, 2L, "weakCompareAndSetRelease long");
 
   546                 assertEquals(x, 0xCAFEBABECAFEBABEL, "weakCompareAndSetRelease long");
 
   547             }
 
   547             }
 
   548 
   548 
   549             {
 
   549             {
 
   550                 boolean success = false;
 
   550                 boolean success = false;
 
   551                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   551                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
   552                     success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_VOLATILE).invokeExact(array, i, 2L, 1L);
 
   552                     success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_VOLATILE).invokeExact(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   553                 }
 
   553                 }
 
   554                 assertEquals(success, true, "weakCompareAndSetVolatile long");
 
   554                 assertEquals(success, true, "weakCompareAndSetVolatile long");
 
   555                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   555                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   556                 assertEquals(x, 1L, "weakCompareAndSetVolatile long");
 
   556                 assertEquals(x, 0x0123456789ABCDEFL, "weakCompareAndSetVolatile long");
 
   557             }
 
   557             }
 
   558 
   558 
   559             // Compare set and get
 
   559             // Compare set and get
 
   560             {
 
   560             {
 
   561                 long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 2L);
 
   561                 long o = (long) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 0xCAFEBABECAFEBABEL);
 
   562                 assertEquals(o, 1L, "getAndSet long");
 
   562                 assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long");
 
   563                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   563                 long x = (long) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   564                 assertEquals(x, 2L, "getAndSet long value");
 
   564                 assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value");
 
   565             }
 
   565             }
 
   566 
   566 
   567             hs.get(TestAccessMode.SET).invokeExact(array, i, 1L);
 
   567             hs.get(TestAccessMode.SET).invokeExact(array, i, 0x0123456789ABCDEFL);
 
   568 
   568 
   569             // get and add, add and get
 
   569             // get and add, add and get
 
   570             {
 
   570             {
 
   571                 long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 3L);
 
   571                 long o = (long) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 0xDEADBEEFDEADBEEFL);
 
   572                 assertEquals(o, 1L, "getAndAdd long");
 
   572                 assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long");
 
   573                 long c = (long) hs.get(TestAccessMode.ADD_AND_GET).invokeExact(array, i, 3L);
 
   573                 long c = (long) hs.get(TestAccessMode.ADD_AND_GET).invokeExact(array, i, 0xDEADBEEFDEADBEEFL);
 
   574                 assertEquals(c, 1L + 3L + 3L, "getAndAdd long value");
 
   574                 assertEquals(c, (long)(0x0123456789ABCDEFL + 0xDEADBEEFDEADBEEFL + 0xDEADBEEFDEADBEEFL), "getAndAdd long value");
 
   575             }
 
   575             }
 
   576         }
 
   576         }
 
   577     }
 
   577     }
 
   578 
   578 
   579     static void testArrayUnsupported(Handles hs) throws Throwable {
 
   579     static void testArrayUnsupported(Handles hs) throws Throwable {
 
   595                 });
 
   595                 });
 
   596             }
 
   596             }
 
   597 
   597 
   598             for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
 
   598             for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
 
   599                 checkIOOBE(am, () -> {
 
   599                 checkIOOBE(am, () -> {
 
   600                     hs.get(am).invokeExact(array, ci, 1L);
 
   600                     hs.get(am).invokeExact(array, ci, 0x0123456789ABCDEFL);
 
   601                 });
 
   601                 });
 
   602             }
 
   602             }
 
   603 
   603 
   604             for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
 
   604             for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
 
   605                 checkIOOBE(am, () -> {
 
   605                 checkIOOBE(am, () -> {
 
   606                     boolean r = (boolean) hs.get(am).invokeExact(array, ci, 1L, 2L);
 
   606                     boolean r = (boolean) hs.get(am).invokeExact(array, ci, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 
   607                 });
 
   607                 });
 
   608             }
 
   608             }
 
   609 
   609 
   610             for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
 
   610             for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
 
   611                 checkIOOBE(am, () -> {
 
   611                 checkIOOBE(am, () -> {
 
   612                     long r = (long) hs.get(am).invokeExact(array, ci, 2L, 1L);
 
   612                     long r = (long) hs.get(am).invokeExact(array, ci, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 
   613                 });
 
   613                 });
 
   614             }
 
   614             }
 
   615 
   615 
   616             for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
 
   616             for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
 
   617                 checkIOOBE(am, () -> {
 
   617                 checkIOOBE(am, () -> {
 
   618                     long o = (long) hs.get(am).invokeExact(array, ci, 1L);
 
   618                     long o = (long) hs.get(am).invokeExact(array, ci, 0x0123456789ABCDEFL);
 
   619                 });
 
   619                 });
 
   620             }
 
   620             }
 
   621 
   621 
   622             for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
 
   622             for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
 
   623                 checkIOOBE(am, () -> {
 
   623                 checkIOOBE(am, () -> {
 
   624                     long o = (long) hs.get(am).invokeExact(array, ci, 3L);
 
   624                     long o = (long) hs.get(am).invokeExact(array, ci, 0xDEADBEEFDEADBEEFL);
 
   625                 });
 
   625                 });
 
   626             }
 
   626             }
 
   627         }
 
   627         }
 
   628     }
 
   628     }
 
   629 }
 
   629 }
jdk-sandbox