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/VarHandleTestMethodHandleAccessString.java
changeset 37343 35a2231828a7
parent 36934 590fc47a0aeb
child 37719 add11bc0e6e2
child 38355 674cfd9b90cf
equal deleted inserted replaced
37342:3f54fbfc2706 37343:35a2231828a7 
   119 
   119 
   120 
   120 
   121     static void testInstanceField(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable {
 
   121     static void testInstanceField(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable {
 
   122         // Plain
 
   122         // Plain
 
   123         {
 
   123         {
 
   124             hs.get(TestAccessMode.set).invokeExact(recv, "foo");
 
   124             hs.get(TestAccessMode.SET).invokeExact(recv, "foo");
 
   125             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   125             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   126             assertEquals(x, "foo", "set String value");
 
   126             assertEquals(x, "foo", "set String value");
 
   127         }
 
   127         }
 
   128 
   128 
   129 
   129 
   130         // Volatile
 
   130         // Volatile
 
   131         {
 
   131         {
 
   132             hs.get(TestAccessMode.setVolatile).invokeExact(recv, "bar");
 
   132             hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, "bar");
 
   133             String x = (String) hs.get(TestAccessMode.getVolatile).invokeExact(recv);
 
   133             String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv);
 
   134             assertEquals(x, "bar", "setVolatile String value");
 
   134             assertEquals(x, "bar", "setVolatile String value");
 
   135         }
 
   135         }
 
   136 
   136 
   137         // Lazy
 
   137         // Lazy
 
   138         {
 
   138         {
 
   139             hs.get(TestAccessMode.setRelease).invokeExact(recv, "foo");
 
   139             hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, "foo");
 
   140             String x = (String) hs.get(TestAccessMode.getAcquire).invokeExact(recv);
 
   140             String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv);
 
   141             assertEquals(x, "foo", "setRelease String value");
 
   141             assertEquals(x, "foo", "setRelease String value");
 
   142         }
 
   142         }
 
   143 
   143 
   144         // Opaque
 
   144         // Opaque
 
   145         {
 
   145         {
 
   146             hs.get(TestAccessMode.setOpaque).invokeExact(recv, "bar");
 
   146             hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, "bar");
 
   147             String x = (String) hs.get(TestAccessMode.getOpaque).invokeExact(recv);
 
   147             String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv);
 
   148             assertEquals(x, "bar", "setOpaque String value");
 
   148             assertEquals(x, "bar", "setOpaque String value");
 
   149         }
 
   149         }
 
   150 
   150 
   151         hs.get(TestAccessMode.set).invokeExact(recv, "foo");
 
   151         hs.get(TestAccessMode.SET).invokeExact(recv, "foo");
 
   152 
   152 
   153         // Compare
 
   153         // Compare
 
   154         {
 
   154         {
 
   155             boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact(recv, "foo", "bar");
 
   155             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, "foo", "bar");
 
   156             assertEquals(r, true, "success compareAndSet String");
 
   156             assertEquals(r, true, "success compareAndSet String");
 
   157             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   157             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   158             assertEquals(x, "bar", "success compareAndSet String value");
 
   158             assertEquals(x, "bar", "success compareAndSet String value");
 
   159         }
 
   159         }
 
   160 
   160 
   161         {
 
   161         {
 
   162             boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact(recv, "foo", "baz");
 
   162             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, "foo", "baz");
 
   163             assertEquals(r, false, "failing compareAndSet String");
 
   163             assertEquals(r, false, "failing compareAndSet String");
 
   164             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   164             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   165             assertEquals(x, "bar", "failing compareAndSet String value");
 
   165             assertEquals(x, "bar", "failing compareAndSet String value");
 
   166         }
 
   166         }
 
   167 
   167 
   168         {
 
   168         {
 
   169             String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact(recv, "bar", "foo");
 
   169             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(recv, "bar", "foo");
 
   170             assertEquals(r, "bar", "success compareAndExchangeVolatile String");
 
   170             assertEquals(r, "bar", "success compareAndExchangeVolatile String");
 
   171             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   171             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   172             assertEquals(x, "foo", "success compareAndExchangeVolatile String value");
 
   172             assertEquals(x, "foo", "success compareAndExchangeVolatile String value");
 
   173         }
 
   173         }
 
   174 
   174 
   175         {
 
   175         {
 
   176             String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact(recv, "bar", "baz");
 
   176             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(recv, "bar", "baz");
 
   177             assertEquals(r, "foo", "failing compareAndExchangeVolatile String");
 
   177             assertEquals(r, "foo", "failing compareAndExchangeVolatile String");
 
   178             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   178             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   179             assertEquals(x, "foo", "failing compareAndExchangeVolatile String value");
 
   179             assertEquals(x, "foo", "failing compareAndExchangeVolatile String value");
 
   180         }
 
   180         }
 
   181 
   181 
   182         {
 
   182         {
 
   183             String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact(recv, "foo", "bar");
 
   183             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, "foo", "bar");
 
   184             assertEquals(r, "foo", "success compareAndExchangeAcquire String");
 
   184             assertEquals(r, "foo", "success compareAndExchangeAcquire String");
 
   185             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   185             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   186             assertEquals(x, "bar", "success compareAndExchangeAcquire String value");
 
   186             assertEquals(x, "bar", "success compareAndExchangeAcquire String value");
 
   187         }
 
   187         }
 
   188 
   188 
   189         {
 
   189         {
 
   190             String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact(recv, "foo", "baz");
 
   190             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, "foo", "baz");
 
   191             assertEquals(r, "bar", "failing compareAndExchangeAcquire String");
 
   191             assertEquals(r, "bar", "failing compareAndExchangeAcquire String");
 
   192             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   192             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   193             assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");
 
   193             assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");
 
   194         }
 
   194         }
 
   195 
   195 
   196         {
 
   196         {
 
   197             String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact(recv, "bar", "foo");
 
   197             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, "bar", "foo");
 
   198             assertEquals(r, "bar", "success compareAndExchangeRelease String");
 
   198             assertEquals(r, "bar", "success compareAndExchangeRelease String");
 
   199             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   199             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   200             assertEquals(x, "foo", "success compareAndExchangeRelease String value");
 
   200             assertEquals(x, "foo", "success compareAndExchangeRelease String value");
 
   201         }
 
   201         }
 
   202 
   202 
   203         {
 
   203         {
 
   204             String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact(recv, "bar", "baz");
 
   204             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, "bar", "baz");
 
   205             assertEquals(r, "foo", "failing compareAndExchangeRelease String");
 
   205             assertEquals(r, "foo", "failing compareAndExchangeRelease String");
 
   206             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   206             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   207             assertEquals(x, "foo", "failing compareAndExchangeRelease String value");
 
   207             assertEquals(x, "foo", "failing compareAndExchangeRelease String value");
 
   208         }
 
   208         }
 
   209 
   209 
   210         {
 
   210         {
 
   211             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSet).invokeExact(recv, "foo", "bar");
 
   211             boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, "foo", "bar");
 
   212             assertEquals(r, true, "weakCompareAndSet String");
 
   212             assertEquals(r, true, "weakCompareAndSet String");
 
   213             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   213             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   214             assertEquals(x, "bar", "weakCompareAndSet String value");
 
   214             assertEquals(x, "bar", "weakCompareAndSet String value");
 
   215         }
 
   215         }
 
   216 
   216 
   217         {
 
   217         {
 
   218             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetAcquire).invokeExact(recv, "bar", "foo");
 
   218             boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, "bar", "foo");
 
   219             assertEquals(r, true, "weakCompareAndSetAcquire String");
 
   219             assertEquals(r, true, "weakCompareAndSetAcquire String");
 
   220             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   220             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   221             assertEquals(x, "foo", "weakCompareAndSetAcquire String");
 
   221             assertEquals(x, "foo", "weakCompareAndSetAcquire String");
 
   222         }
 
   222         }
 
   223 
   223 
   224         {
 
   224         {
 
   225             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetRelease).invokeExact(recv, "foo", "bar");
 
   225             boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, "foo", "bar");
 
   226             assertEquals(r, true, "weakCompareAndSetRelease String");
 
   226             assertEquals(r, true, "weakCompareAndSetRelease String");
 
   227             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   227             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   228             assertEquals(x, "bar", "weakCompareAndSetRelease String");
 
   228             assertEquals(x, "bar", "weakCompareAndSetRelease String");
 
   229         }
 
   229         }
 
   230 
   230 
   231         // Compare set and get
 
   231         // Compare set and get
 
   232         {
 
   232         {
 
   233             String o = (String) hs.get(TestAccessMode.getAndSet).invokeExact(recv, "foo");
 
   233             String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, "foo");
 
   234             assertEquals(o, "bar", "getAndSet String");
 
   234             assertEquals(o, "bar", "getAndSet String");
 
   235             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);
 
   235             String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
 
   236             assertEquals(x, "foo", "getAndSet String value");
 
   236             assertEquals(x, "foo", "getAndSet String value");
 
   237         }
 
   237         }
 
   238 
   238 
   239     }
 
   239     }
 
   240 
   240 
   241     static void testInstanceFieldUnsupported(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable {
 
   241     static void testInstanceFieldUnsupported(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable {
 
   242 
   242 
   243         for (TestAccessMode am : testAccessModesOfType(TestAccessType.getAndAdd)) {
 
   243         for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
 
   244             checkUOE(am, () -> {
 
   244             checkUOE(am, () -> {
 
   245                 String r = (String) hs.get(am).invokeExact(recv, "foo");
 
   245                 String r = (String) hs.get(am).invokeExact(recv, "foo");
 
   246             });
 
   246             });
 
   247         }
 
   247         }
 
   248     }
 
   248     }
 
   249 
   249 
   250 
   250 
   251     static void testStaticField(Handles hs) throws Throwable {
 
   251     static void testStaticField(Handles hs) throws Throwable {
 
   252         // Plain
 
   252         // Plain
 
   253         {
 
   253         {
 
   254             hs.get(TestAccessMode.set).invokeExact("foo");
 
   254             hs.get(TestAccessMode.SET).invokeExact("foo");
 
   255             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   255             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   256             assertEquals(x, "foo", "set String value");
 
   256             assertEquals(x, "foo", "set String value");
 
   257         }
 
   257         }
 
   258 
   258 
   259 
   259 
   260         // Volatile
 
   260         // Volatile
 
   261         {
 
   261         {
 
   262             hs.get(TestAccessMode.setVolatile).invokeExact("bar");
 
   262             hs.get(TestAccessMode.SET_VOLATILE).invokeExact("bar");
 
   263             String x = (String) hs.get(TestAccessMode.getVolatile).invokeExact();
 
   263             String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact();
 
   264             assertEquals(x, "bar", "setVolatile String value");
 
   264             assertEquals(x, "bar", "setVolatile String value");
 
   265         }
 
   265         }
 
   266 
   266 
   267         // Lazy
 
   267         // Lazy
 
   268         {
 
   268         {
 
   269             hs.get(TestAccessMode.setRelease).invokeExact("foo");
 
   269             hs.get(TestAccessMode.SET_RELEASE).invokeExact("foo");
 
   270             String x = (String) hs.get(TestAccessMode.getAcquire).invokeExact();
 
   270             String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact();
 
   271             assertEquals(x, "foo", "setRelease String value");
 
   271             assertEquals(x, "foo", "setRelease String value");
 
   272         }
 
   272         }
 
   273 
   273 
   274         // Opaque
 
   274         // Opaque
 
   275         {
 
   275         {
 
   276             hs.get(TestAccessMode.setOpaque).invokeExact("bar");
 
   276             hs.get(TestAccessMode.SET_OPAQUE).invokeExact("bar");
 
   277             String x = (String) hs.get(TestAccessMode.getOpaque).invokeExact();
 
   277             String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact();
 
   278             assertEquals(x, "bar", "setOpaque String value");
 
   278             assertEquals(x, "bar", "setOpaque String value");
 
   279         }
 
   279         }
 
   280 
   280 
   281         hs.get(TestAccessMode.set).invokeExact("foo");
 
   281         hs.get(TestAccessMode.SET).invokeExact("foo");
 
   282 
   282 
   283         // Compare
 
   283         // Compare
 
   284         {
 
   284         {
 
   285             boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact("foo", "bar");
 
   285             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact("foo", "bar");
 
   286             assertEquals(r, true, "success compareAndSet String");
 
   286             assertEquals(r, true, "success compareAndSet String");
 
   287             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   287             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   288             assertEquals(x, "bar", "success compareAndSet String value");
 
   288             assertEquals(x, "bar", "success compareAndSet String value");
 
   289         }
 
   289         }
 
   290 
   290 
   291         {
 
   291         {
 
   292             boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact("foo", "baz");
 
   292             boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact("foo", "baz");
 
   293             assertEquals(r, false, "failing compareAndSet String");
 
   293             assertEquals(r, false, "failing compareAndSet String");
 
   294             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   294             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   295             assertEquals(x, "bar", "failing compareAndSet String value");
 
   295             assertEquals(x, "bar", "failing compareAndSet String value");
 
   296         }
 
   296         }
 
   297 
   297 
   298         {
 
   298         {
 
   299             String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact("bar", "foo");
 
   299             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact("bar", "foo");
 
   300             assertEquals(r, "bar", "success compareAndExchangeVolatile String");
 
   300             assertEquals(r, "bar", "success compareAndExchangeVolatile String");
 
   301             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   301             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   302             assertEquals(x, "foo", "success compareAndExchangeVolatile String value");
 
   302             assertEquals(x, "foo", "success compareAndExchangeVolatile String value");
 
   303         }
 
   303         }
 
   304 
   304 
   305         {
 
   305         {
 
   306             String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact("bar", "baz");
 
   306             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact("bar", "baz");
 
   307             assertEquals(r, "foo", "failing compareAndExchangeVolatile String");
 
   307             assertEquals(r, "foo", "failing compareAndExchangeVolatile String");
 
   308             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   308             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   309             assertEquals(x, "foo", "failing compareAndExchangeVolatile String value");
 
   309             assertEquals(x, "foo", "failing compareAndExchangeVolatile String value");
 
   310         }
 
   310         }
 
   311 
   311 
   312         {
 
   312         {
 
   313             String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact("foo", "bar");
 
   313             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact("foo", "bar");
 
   314             assertEquals(r, "foo", "success compareAndExchangeAcquire String");
 
   314             assertEquals(r, "foo", "success compareAndExchangeAcquire String");
 
   315             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   315             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   316             assertEquals(x, "bar", "success compareAndExchangeAcquire String value");
 
   316             assertEquals(x, "bar", "success compareAndExchangeAcquire String value");
 
   317         }
 
   317         }
 
   318 
   318 
   319         {
 
   319         {
 
   320             String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact("foo", "baz");
 
   320             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact("foo", "baz");
 
   321             assertEquals(r, "bar", "failing compareAndExchangeAcquire String");
 
   321             assertEquals(r, "bar", "failing compareAndExchangeAcquire String");
 
   322             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   322             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   323             assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");
 
   323             assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");
 
   324         }
 
   324         }
 
   325 
   325 
   326         {
 
   326         {
 
   327             String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact("bar", "foo");
 
   327             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact("bar", "foo");
 
   328             assertEquals(r, "bar", "success compareAndExchangeRelease String");
 
   328             assertEquals(r, "bar", "success compareAndExchangeRelease String");
 
   329             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   329             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   330             assertEquals(x, "foo", "success compareAndExchangeRelease String value");
 
   330             assertEquals(x, "foo", "success compareAndExchangeRelease String value");
 
   331         }
 
   331         }
 
   332 
   332 
   333         {
 
   333         {
 
   334             String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact("bar", "baz");
 
   334             String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact("bar", "baz");
 
   335             assertEquals(r, "foo", "failing compareAndExchangeRelease String");
 
   335             assertEquals(r, "foo", "failing compareAndExchangeRelease String");
 
   336             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   336             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   337             assertEquals(x, "foo", "failing compareAndExchangeRelease String value");
 
   337             assertEquals(x, "foo", "failing compareAndExchangeRelease String value");
 
   338         }
 
   338         }
 
   339 
   339 
   340         {
 
   340         {
 
   341             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSet).invokeExact("foo", "bar");
 
   341             boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact("foo", "bar");
 
   342             assertEquals(r, true, "weakCompareAndSet String");
 
   342             assertEquals(r, true, "weakCompareAndSet String");
 
   343             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   343             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   344             assertEquals(x, "bar", "weakCompareAndSet String value");
 
   344             assertEquals(x, "bar", "weakCompareAndSet String value");
 
   345         }
 
   345         }
 
   346 
   346 
   347         {
 
   347         {
 
   348             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetAcquire).invokeExact("bar", "foo");
 
   348             boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact("bar", "foo");
 
   349             assertEquals(r, true, "weakCompareAndSetAcquire String");
 
   349             assertEquals(r, true, "weakCompareAndSetAcquire String");
 
   350             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   350             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   351             assertEquals(x, "foo", "weakCompareAndSetAcquire String");
 
   351             assertEquals(x, "foo", "weakCompareAndSetAcquire String");
 
   352         }
 
   352         }
 
   353 
   353 
   354         {
 
   354         {
 
   355             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetRelease).invokeExact( "foo", "bar");
 
   355             boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact( "foo", "bar");
 
   356             assertEquals(r, true, "weakCompareAndSetRelease String");
 
   356             assertEquals(r, true, "weakCompareAndSetRelease String");
 
   357             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   357             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   358             assertEquals(x, "bar", "weakCompareAndSetRelease String");
 
   358             assertEquals(x, "bar", "weakCompareAndSetRelease String");
 
   359         }
 
   359         }
 
   360 
   360 
   361         // Compare set and get
 
   361         // Compare set and get
 
   362         {
 
   362         {
 
   363             String o = (String) hs.get(TestAccessMode.getAndSet).invokeExact( "foo");
 
   363             String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact( "foo");
 
   364             assertEquals(o, "bar", "getAndSet String");
 
   364             assertEquals(o, "bar", "getAndSet String");
 
   365             String x = (String) hs.get(TestAccessMode.get).invokeExact();
 
   365             String x = (String) hs.get(TestAccessMode.GET).invokeExact();
 
   366             assertEquals(x, "foo", "getAndSet String value");
 
   366             assertEquals(x, "foo", "getAndSet String value");
 
   367         }
 
   367         }
 
   368 
   368 
   369     }
 
   369     }
 
   370 
   370 
   371     static void testStaticFieldUnsupported(Handles hs) throws Throwable {
 
   371     static void testStaticFieldUnsupported(Handles hs) throws Throwable {
 
   372 
   372 
   373         for (TestAccessMode am : testAccessModesOfType(TestAccessType.getAndAdd)) {
 
   373         for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
 
   374             checkUOE(am, () -> {
 
   374             checkUOE(am, () -> {
 
   375                 String r = (String) hs.get(am).invokeExact("foo");
 
   375                 String r = (String) hs.get(am).invokeExact("foo");
 
   376             });
 
   376             });
 
   377         }
 
   377         }
 
   378     }
 
   378     }
 
   382         String[] array = new String[10];
 
   382         String[] array = new String[10];
 
   383 
   383 
   384         for (int i = 0; i < array.length; i++) {
 
   384         for (int i = 0; i < array.length; i++) {
 
   385             // Plain
 
   385             // Plain
 
   386             {
 
   386             {
 
   387                 hs.get(TestAccessMode.set).invokeExact(array, i, "foo");
 
   387                 hs.get(TestAccessMode.SET).invokeExact(array, i, "foo");
 
   388                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   388                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   389                 assertEquals(x, "foo", "get String value");
 
   389                 assertEquals(x, "foo", "get String value");
 
   390             }
 
   390             }
 
   391 
   391 
   392 
   392 
   393             // Volatile
 
   393             // Volatile
 
   394             {
 
   394             {
 
   395                 hs.get(TestAccessMode.setVolatile).invokeExact(array, i, "bar");
 
   395                 hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, "bar");
 
   396                 String x = (String) hs.get(TestAccessMode.getVolatile).invokeExact(array, i);
 
   396                 String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i);
 
   397                 assertEquals(x, "bar", "setVolatile String value");
 
   397                 assertEquals(x, "bar", "setVolatile String value");
 
   398             }
 
   398             }
 
   399 
   399 
   400             // Lazy
 
   400             // Lazy
 
   401             {
 
   401             {
 
   402                 hs.get(TestAccessMode.setRelease).invokeExact(array, i, "foo");
 
   402                 hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, "foo");
 
   403                 String x = (String) hs.get(TestAccessMode.getAcquire).invokeExact(array, i);
 
   403                 String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i);
 
   404                 assertEquals(x, "foo", "setRelease String value");
 
   404                 assertEquals(x, "foo", "setRelease String value");
 
   405             }
 
   405             }
 
   406 
   406 
   407             // Opaque
 
   407             // Opaque
 
   408             {
 
   408             {
 
   409                 hs.get(TestAccessMode.setOpaque).invokeExact(array, i, "bar");
 
   409                 hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, "bar");
 
   410                 String x = (String) hs.get(TestAccessMode.getOpaque).invokeExact(array, i);
 
   410                 String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i);
 
   411                 assertEquals(x, "bar", "setOpaque String value");
 
   411                 assertEquals(x, "bar", "setOpaque String value");
 
   412             }
 
   412             }
 
   413 
   413 
   414             hs.get(TestAccessMode.set).invokeExact(array, i, "foo");
 
   414             hs.get(TestAccessMode.SET).invokeExact(array, i, "foo");
 
   415 
   415 
   416             // Compare
 
   416             // Compare
 
   417             {
 
   417             {
 
   418                 boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact(array, i, "foo", "bar");
 
   418                 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, "foo", "bar");
 
   419                 assertEquals(r, true, "success compareAndSet String");
 
   419                 assertEquals(r, true, "success compareAndSet String");
 
   420                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   420                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   421                 assertEquals(x, "bar", "success compareAndSet String value");
 
   421                 assertEquals(x, "bar", "success compareAndSet String value");
 
   422             }
 
   422             }
 
   423 
   423 
   424             {
 
   424             {
 
   425                 boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact(array, i, "foo", "baz");
 
   425                 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, "foo", "baz");
 
   426                 assertEquals(r, false, "failing compareAndSet String");
 
   426                 assertEquals(r, false, "failing compareAndSet String");
 
   427                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   427                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   428                 assertEquals(x, "bar", "failing compareAndSet String value");
 
   428                 assertEquals(x, "bar", "failing compareAndSet String value");
 
   429             }
 
   429             }
 
   430 
   430 
   431             {
 
   431             {
 
   432                 String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact(array, i, "bar", "foo");
 
   432                 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(array, i, "bar", "foo");
 
   433                 assertEquals(r, "bar", "success compareAndExchangeVolatile String");
 
   433                 assertEquals(r, "bar", "success compareAndExchangeVolatile String");
 
   434                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   434                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   435                 assertEquals(x, "foo", "success compareAndExchangeVolatile String value");
 
   435                 assertEquals(x, "foo", "success compareAndExchangeVolatile String value");
 
   436             }
 
   436             }
 
   437 
   437 
   438             {
 
   438             {
 
   439                 String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact(array, i, "bar", "baz");
 
   439                 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_VOLATILE).invokeExact(array, i, "bar", "baz");
 
   440                 assertEquals(r, "foo", "failing compareAndExchangeVolatile String");
 
   440                 assertEquals(r, "foo", "failing compareAndExchangeVolatile String");
 
   441                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   441                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   442                 assertEquals(x, "foo", "failing compareAndExchangeVolatile String value");
 
   442                 assertEquals(x, "foo", "failing compareAndExchangeVolatile String value");
 
   443             }
 
   443             }
 
   444 
   444 
   445             {
 
   445             {
 
   446                 String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact(array, i, "foo", "bar");
 
   446                 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, "foo", "bar");
 
   447                 assertEquals(r, "foo", "success compareAndExchangeAcquire String");
 
   447                 assertEquals(r, "foo", "success compareAndExchangeAcquire String");
 
   448                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   448                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   449                 assertEquals(x, "bar", "success compareAndExchangeAcquire String value");
 
   449                 assertEquals(x, "bar", "success compareAndExchangeAcquire String value");
 
   450             }
 
   450             }
 
   451 
   451 
   452             {
 
   452             {
 
   453                 String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact(array, i, "foo", "baz");
 
   453                 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, "foo", "baz");
 
   454                 assertEquals(r, "bar", "failing compareAndExchangeAcquire String");
 
   454                 assertEquals(r, "bar", "failing compareAndExchangeAcquire String");
 
   455                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   455                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   456                 assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");
 
   456                 assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");
 
   457             }
 
   457             }
 
   458 
   458 
   459             {
 
   459             {
 
   460                 String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact(array, i, "bar", "foo");
 
   460                 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, "bar", "foo");
 
   461                 assertEquals(r, "bar", "success compareAndExchangeRelease String");
 
   461                 assertEquals(r, "bar", "success compareAndExchangeRelease String");
 
   462                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   462                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   463                 assertEquals(x, "foo", "success compareAndExchangeRelease String value");
 
   463                 assertEquals(x, "foo", "success compareAndExchangeRelease String value");
 
   464             }
 
   464             }
 
   465 
   465 
   466             {
 
   466             {
 
   467                 String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact(array, i, "bar", "baz");
 
   467                 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, "bar", "baz");
 
   468                 assertEquals(r, "foo", "failing compareAndExchangeRelease String");
 
   468                 assertEquals(r, "foo", "failing compareAndExchangeRelease String");
 
   469                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   469                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   470                 assertEquals(x, "foo", "failing compareAndExchangeRelease String value");
 
   470                 assertEquals(x, "foo", "failing compareAndExchangeRelease String value");
 
   471             }
 
   471             }
 
   472 
   472 
   473             {
 
   473             {
 
   474                 boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSet).invokeExact(array, i, "foo", "bar");
 
   474                 boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, "foo", "bar");
 
   475                 assertEquals(r, true, "weakCompareAndSet String");
 
   475                 assertEquals(r, true, "weakCompareAndSet String");
 
   476                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   476                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   477                 assertEquals(x, "bar", "weakCompareAndSet String value");
 
   477                 assertEquals(x, "bar", "weakCompareAndSet String value");
 
   478             }
 
   478             }
 
   479 
   479 
   480             {
 
   480             {
 
   481                 boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetAcquire).invokeExact(array, i, "bar", "foo");
 
   481                 boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, "bar", "foo");
 
   482                 assertEquals(r, true, "weakCompareAndSetAcquire String");
 
   482                 assertEquals(r, true, "weakCompareAndSetAcquire String");
 
   483                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   483                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   484                 assertEquals(x, "foo", "weakCompareAndSetAcquire String");
 
   484                 assertEquals(x, "foo", "weakCompareAndSetAcquire String");
 
   485             }
 
   485             }
 
   486 
   486 
   487             {
 
   487             {
 
   488                 boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetRelease).invokeExact(array, i, "foo", "bar");
 
   488                 boolean r = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, "foo", "bar");
 
   489                 assertEquals(r, true, "weakCompareAndSetRelease String");
 
   489                 assertEquals(r, true, "weakCompareAndSetRelease String");
 
   490                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   490                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   491                 assertEquals(x, "bar", "weakCompareAndSetRelease String");
 
   491                 assertEquals(x, "bar", "weakCompareAndSetRelease String");
 
   492             }
 
   492             }
 
   493 
   493 
   494             // Compare set and get
 
   494             // Compare set and get
 
   495             {
 
   495             {
 
   496                 String o = (String) hs.get(TestAccessMode.getAndSet).invokeExact(array, i, "foo");
 
   496                 String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, "foo");
 
   497                 assertEquals(o, "bar", "getAndSet String");
 
   497                 assertEquals(o, "bar", "getAndSet String");
 
   498                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);
 
   498                 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
 
   499                 assertEquals(x, "foo", "getAndSet String value");
 
   499                 assertEquals(x, "foo", "getAndSet String value");
 
   500             }
 
   500             }
 
   501 
   501 
   502         }
 
   502         }
 
   503     }
 
   503     }
 
   505     static void testArrayUnsupported(Handles hs) throws Throwable {
 
   505     static void testArrayUnsupported(Handles hs) throws Throwable {
 
   506         String[] array = new String[10];
 
   506         String[] array = new String[10];
 
   507 
   507 
   508         final int i = 0;
 
   508         final int i = 0;
 
   509 
   509 
   510         for (TestAccessMode am : testAccessModesOfType(TestAccessType.getAndAdd)) {
 
   510         for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
 
   511             checkUOE(am, () -> {
 
   511             checkUOE(am, () -> {
 
   512                 String o = (String) hs.get(am).invokeExact(array, i, "foo");
 
   512                 String o = (String) hs.get(am).invokeExact(array, i, "foo");
 
   513             });
 
   513             });
 
   514         }
 
   514         }
 
   515     }
 
   515     }
 
   518         String[] array = new String[10];
 
   518         String[] array = new String[10];
 
   519 
   519 
   520         for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {
 
   520         for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {
 
   521             final int ci = i;
 
   521             final int ci = i;
 
   522 
   522 
   523             for (TestAccessMode am : testAccessModesOfType(TestAccessType.get)) {
 
   523             for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
 
   524                 checkIOOBE(am, () -> {
 
   524                 checkIOOBE(am, () -> {
 
   525                     String x = (String) hs.get(am).invokeExact(array, ci);
 
   525                     String x = (String) hs.get(am).invokeExact(array, ci);
 
   526                 });
 
   526                 });
 
   527             }
 
   527             }
 
   528 
   528 
   529             for (TestAccessMode am : testAccessModesOfType(TestAccessType.set)) {
 
   529             for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
 
   530                 checkIOOBE(am, () -> {
 
   530                 checkIOOBE(am, () -> {
 
   531                     hs.get(am).invokeExact(array, ci, "foo");
 
   531                     hs.get(am).invokeExact(array, ci, "foo");
 
   532                 });
 
   532                 });
 
   533             }
 
   533             }
 
   534 
   534 
   535             for (TestAccessMode am : testAccessModesOfType(TestAccessType.compareAndSet)) {
 
   535             for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
 
   536                 checkIOOBE(am, () -> {
 
   536                 checkIOOBE(am, () -> {
 
   537                     boolean r = (boolean) hs.get(am).invokeExact(array, ci, "foo", "bar");
 
   537                     boolean r = (boolean) hs.get(am).invokeExact(array, ci, "foo", "bar");
 
   538                 });
 
   538                 });
 
   539             }
 
   539             }
 
   540 
   540 
   541             for (TestAccessMode am : testAccessModesOfType(TestAccessType.compareAndExchange)) {
 
   541             for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
 
   542                 checkIOOBE(am, () -> {
 
   542                 checkIOOBE(am, () -> {
 
   543                     String r = (String) hs.get(am).invokeExact(array, ci, "bar", "foo");
 
   543                     String r = (String) hs.get(am).invokeExact(array, ci, "bar", "foo");
 
   544                 });
 
   544                 });
 
   545             }
 
   545             }
 
   546 
   546 
   547             for (TestAccessMode am : testAccessModesOfType(TestAccessType.getAndSet)) {
 
   547             for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
 
   548                 checkIOOBE(am, () -> {
 
   548                 checkIOOBE(am, () -> {
 
   549                     String o = (String) hs.get(am).invokeExact(array, ci, "foo");
 
   549                     String o = (String) hs.get(am).invokeExact(array, ci, "foo");
 
   550                 });
 
   550                 });
 
   551             }
 
   551             }
 
   552 
   552
jdk-sandbox