1 /*

     2  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /*

    25  * @test

    26  * @run testng/othervm -Diters=20000 VarHandleTestMethodHandleAccessString

    27  */

    28 

    29 import org.testng.annotations.BeforeClass;

    30 import org.testng.annotations.DataProvider;

    31 import org.testng.annotations.Test;

    32 

    33 import java.lang.invoke.MethodHandles;

    34 import java.lang.invoke.VarHandle;

    35 import java.util.ArrayList;

    36 import java.util.Arrays;

    37 import java.util.List;

    38 

    39 import static org.testng.Assert.*;

    40 

    41 public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest {

    42     static final String static_final_v = "foo";

    43 

    44     static String static_v;

    45 

    46     final String final_v = "foo";

    47 

    48     String v;

    49 

    50     VarHandle vhFinalField;

    51 

    52     VarHandle vhField;

    53 

    54     VarHandle vhStaticField;

    55 

    56     VarHandle vhStaticFinalField;

    57 

    58     VarHandle vhArray;

    59 

    60     @BeforeClass

    61     public void setup() throws Exception {

    62         vhFinalField = MethodHandles.lookup().findVarHandle(

    63                 VarHandleTestMethodHandleAccessString.class, "final_v", String.class);

    64 

    65         vhField = MethodHandles.lookup().findVarHandle(

    66                 VarHandleTestMethodHandleAccessString.class, "v", String.class);

    67 

    68         vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(

    69             VarHandleTestMethodHandleAccessString.class, "static_final_v", String.class);

    70 

    71         vhStaticField = MethodHandles.lookup().findStaticVarHandle(

    72             VarHandleTestMethodHandleAccessString.class, "static_v", String.class);

    73 

    74         vhArray = MethodHandles.arrayElementVarHandle(String[].class);

    75     }

    76 

    77 

    78     @DataProvider

    79     public Object[][] accessTestCaseProvider() throws Exception {

    80         List<AccessTestCase<?>> cases = new ArrayList<>();

    81 

    82         for (VarHandleToMethodHandle f : VarHandleToMethodHandle.values()) {

    83             cases.add(new MethodHandleAccessTestCase("Instance field",

    84                                                      vhField, f, hs -> testInstanceField(this, hs)));

    85             cases.add(new MethodHandleAccessTestCase("Instance field unsupported",

    86                                                      vhField, f, hs -> testInstanceFieldUnsupported(this, hs),

    87                                                      false));

    88 

    89             cases.add(new MethodHandleAccessTestCase("Static field",

    90                                                      vhStaticField, f, VarHandleTestMethodHandleAccessString::testStaticField));

    91             cases.add(new MethodHandleAccessTestCase("Static field unsupported",

    92                                                      vhStaticField, f, VarHandleTestMethodHandleAccessString::testStaticFieldUnsupported,

    93                                                      false));

    94 

    95             cases.add(new MethodHandleAccessTestCase("Array",

    96                                                      vhArray, f, VarHandleTestMethodHandleAccessString::testArray));

    97             cases.add(new MethodHandleAccessTestCase("Array unsupported",

    98                                                      vhArray, f, VarHandleTestMethodHandleAccessString::testArrayUnsupported,

    99                                                      false));

   100             cases.add(new MethodHandleAccessTestCase("Array index out of bounds",

   101                                                      vhArray, f, VarHandleTestMethodHandleAccessString::testArrayIndexOutOfBounds,

   102                                                      false));

   103         }

   104 

   105         // Work around issue with jtreg summary reporting which truncates

   106         // the String result of Object.toString to 30 characters, hence

   107         // the first dummy argument

   108         return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);

   109     }

   110 

   111     @Test(dataProvider = "accessTestCaseProvider")

   112     public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {

   113         T t = atc.get();

   114         int iters = atc.requiresLoop() ? ITERS : 1;

   115         for (int c = 0; c < iters; c++) {

   116             atc.testAccess(t);

   117         }

   118     }

   119 

   120 

   121     static void testInstanceField(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable {

   122         // Plain

   123         {

   124             hs.get(TestAccessMode.set).invokeExact(recv, "foo");

   125             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   126             assertEquals(x, "foo", "set String value");

   127         }

   128 

   129 

   130         // Volatile

   131         {

   132             hs.get(TestAccessMode.setVolatile).invokeExact(recv, "bar");

   133             String x = (String) hs.get(TestAccessMode.getVolatile).invokeExact(recv);

   134             assertEquals(x, "bar", "setVolatile String value");

   135         }

   136 

   137         // Lazy

   138         {

   139             hs.get(TestAccessMode.setRelease).invokeExact(recv, "foo");

   140             String x = (String) hs.get(TestAccessMode.getAcquire).invokeExact(recv);

   141             assertEquals(x, "foo", "setRelease String value");

   142         }

   143 

   144         // Opaque

   145         {

   146             hs.get(TestAccessMode.setOpaque).invokeExact(recv, "bar");

   147             String x = (String) hs.get(TestAccessMode.getOpaque).invokeExact(recv);

   148             assertEquals(x, "bar", "setOpaque String value");

   149         }

   150 

   151         hs.get(TestAccessMode.set).invokeExact(recv, "foo");

   152 

   153         // Compare

   154         {

   155             boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact(recv, "foo", "bar");

   156             assertEquals(r, true, "success compareAndSet String");

   157             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   158             assertEquals(x, "bar", "success compareAndSet String value");

   159         }

   160 

   161         {

   162             boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact(recv, "foo", "baz");

   163             assertEquals(r, false, "failing compareAndSet String");

   164             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   165             assertEquals(x, "bar", "failing compareAndSet String value");

   166         }

   167 

   168         {

   169             String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact(recv, "bar", "foo");

   170             assertEquals(r, "bar", "success compareAndExchangeVolatile String");

   171             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   172             assertEquals(x, "foo", "success compareAndExchangeVolatile String value");

   173         }

   174 

   175         {

   176             String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact(recv, "bar", "baz");

   177             assertEquals(r, "foo", "failing compareAndExchangeVolatile String");

   178             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   179             assertEquals(x, "foo", "failing compareAndExchangeVolatile String value");

   180         }

   181 

   182         {

   183             String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact(recv, "foo", "bar");

   184             assertEquals(r, "foo", "success compareAndExchangeAcquire String");

   185             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   186             assertEquals(x, "bar", "success compareAndExchangeAcquire String value");

   187         }

   188 

   189         {

   190             String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact(recv, "foo", "baz");

   191             assertEquals(r, "bar", "failing compareAndExchangeAcquire String");

   192             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   193             assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");

   194         }

   195 

   196         {

   197             String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact(recv, "bar", "foo");

   198             assertEquals(r, "bar", "success compareAndExchangeRelease String");

   199             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   200             assertEquals(x, "foo", "success compareAndExchangeRelease String value");

   201         }

   202 

   203         {

   204             String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact(recv, "bar", "baz");

   205             assertEquals(r, "foo", "failing compareAndExchangeRelease String");

   206             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   207             assertEquals(x, "foo", "failing compareAndExchangeRelease String value");

   208         }

   209 

   210         {

   211             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSet).invokeExact(recv, "foo", "bar");

   212             assertEquals(r, true, "weakCompareAndSet String");

   213             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   214             assertEquals(x, "bar", "weakCompareAndSet String value");

   215         }

   216 

   217         {

   218             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetAcquire).invokeExact(recv, "bar", "foo");

   219             assertEquals(r, true, "weakCompareAndSetAcquire String");

   220             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   221             assertEquals(x, "foo", "weakCompareAndSetAcquire String");

   222         }

   223 

   224         {

   225             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetRelease).invokeExact(recv, "foo", "bar");

   226             assertEquals(r, true, "weakCompareAndSetRelease String");

   227             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   228             assertEquals(x, "bar", "weakCompareAndSetRelease String");

   229         }

   230 

   231         // Compare set and get

   232         {

   233             String o = (String) hs.get(TestAccessMode.getAndSet).invokeExact(recv, "foo");

   234             assertEquals(o, "bar", "getAndSet String");

   235             String x = (String) hs.get(TestAccessMode.get).invokeExact(recv);

   236             assertEquals(x, "foo", "getAndSet String value");

   237         }

   238 

   239     }

   240 

   241     static void testInstanceFieldUnsupported(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable {

   242 

   243         for (TestAccessMode am : testAccessModesOfType(TestAccessType.getAndAdd)) {

   244             checkUOE(am, () -> {

   245                 String r = (String) hs.get(am).invokeExact(recv, "foo");

   246             });

   247         }

   248     }

   249 

   250 

   251     static void testStaticField(Handles hs) throws Throwable {

   252         // Plain

   253         {

   254             hs.get(TestAccessMode.set).invokeExact("foo");

   255             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   256             assertEquals(x, "foo", "set String value");

   257         }

   258 

   259 

   260         // Volatile

   261         {

   262             hs.get(TestAccessMode.setVolatile).invokeExact("bar");

   263             String x = (String) hs.get(TestAccessMode.getVolatile).invokeExact();

   264             assertEquals(x, "bar", "setVolatile String value");

   265         }

   266 

   267         // Lazy

   268         {

   269             hs.get(TestAccessMode.setRelease).invokeExact("foo");

   270             String x = (String) hs.get(TestAccessMode.getAcquire).invokeExact();

   271             assertEquals(x, "foo", "setRelease String value");

   272         }

   273 

   274         // Opaque

   275         {

   276             hs.get(TestAccessMode.setOpaque).invokeExact("bar");

   277             String x = (String) hs.get(TestAccessMode.getOpaque).invokeExact();

   278             assertEquals(x, "bar", "setOpaque String value");

   279         }

   280 

   281         hs.get(TestAccessMode.set).invokeExact("foo");

   282 

   283         // Compare

   284         {

   285             boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact("foo", "bar");

   286             assertEquals(r, true, "success compareAndSet String");

   287             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   288             assertEquals(x, "bar", "success compareAndSet String value");

   289         }

   290 

   291         {

   292             boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact("foo", "baz");

   293             assertEquals(r, false, "failing compareAndSet String");

   294             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   295             assertEquals(x, "bar", "failing compareAndSet String value");

   296         }

   297 

   298         {

   299             String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact("bar", "foo");

   300             assertEquals(r, "bar", "success compareAndExchangeVolatile String");

   301             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   302             assertEquals(x, "foo", "success compareAndExchangeVolatile String value");

   303         }

   304 

   305         {

   306             String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact("bar", "baz");

   307             assertEquals(r, "foo", "failing compareAndExchangeVolatile String");

   308             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   309             assertEquals(x, "foo", "failing compareAndExchangeVolatile String value");

   310         }

   311 

   312         {

   313             String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact("foo", "bar");

   314             assertEquals(r, "foo", "success compareAndExchangeAcquire String");

   315             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   316             assertEquals(x, "bar", "success compareAndExchangeAcquire String value");

   317         }

   318 

   319         {

   320             String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact("foo", "baz");

   321             assertEquals(r, "bar", "failing compareAndExchangeAcquire String");

   322             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   323             assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");

   324         }

   325 

   326         {

   327             String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact("bar", "foo");

   328             assertEquals(r, "bar", "success compareAndExchangeRelease String");

   329             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   330             assertEquals(x, "foo", "success compareAndExchangeRelease String value");

   331         }

   332 

   333         {

   334             String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact("bar", "baz");

   335             assertEquals(r, "foo", "failing compareAndExchangeRelease String");

   336             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   337             assertEquals(x, "foo", "failing compareAndExchangeRelease String value");

   338         }

   339 

   340         {

   341             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSet).invokeExact("foo", "bar");

   342             assertEquals(r, true, "weakCompareAndSet String");

   343             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   344             assertEquals(x, "bar", "weakCompareAndSet String value");

   345         }

   346 

   347         {

   348             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetAcquire).invokeExact("bar", "foo");

   349             assertEquals(r, true, "weakCompareAndSetAcquire String");

   350             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   351             assertEquals(x, "foo", "weakCompareAndSetAcquire String");

   352         }

   353 

   354         {

   355             boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetRelease).invokeExact( "foo", "bar");

   356             assertEquals(r, true, "weakCompareAndSetRelease String");

   357             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   358             assertEquals(x, "bar", "weakCompareAndSetRelease String");

   359         }

   360 

   361         // Compare set and get

   362         {

   363             String o = (String) hs.get(TestAccessMode.getAndSet).invokeExact( "foo");

   364             assertEquals(o, "bar", "getAndSet String");

   365             String x = (String) hs.get(TestAccessMode.get).invokeExact();

   366             assertEquals(x, "foo", "getAndSet String value");

   367         }

   368 

   369     }

   370 

   371     static void testStaticFieldUnsupported(Handles hs) throws Throwable {

   372 

   373         for (TestAccessMode am : testAccessModesOfType(TestAccessType.getAndAdd)) {

   374             checkUOE(am, () -> {

   375                 String r = (String) hs.get(am).invokeExact("foo");

   376             });

   377         }

   378     }

   379 

   380 

   381     static void testArray(Handles hs) throws Throwable {

   382         String[] array = new String[10];

   383 

   384         for (int i = 0; i < array.length; i++) {

   385             // Plain

   386             {

   387                 hs.get(TestAccessMode.set).invokeExact(array, i, "foo");

   388                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   389                 assertEquals(x, "foo", "get String value");

   390             }

   391 

   392 

   393             // Volatile

   394             {

   395                 hs.get(TestAccessMode.setVolatile).invokeExact(array, i, "bar");

   396                 String x = (String) hs.get(TestAccessMode.getVolatile).invokeExact(array, i);

   397                 assertEquals(x, "bar", "setVolatile String value");

   398             }

   399 

   400             // Lazy

   401             {

   402                 hs.get(TestAccessMode.setRelease).invokeExact(array, i, "foo");

   403                 String x = (String) hs.get(TestAccessMode.getAcquire).invokeExact(array, i);

   404                 assertEquals(x, "foo", "setRelease String value");

   405             }

   406 

   407             // Opaque

   408             {

   409                 hs.get(TestAccessMode.setOpaque).invokeExact(array, i, "bar");

   410                 String x = (String) hs.get(TestAccessMode.getOpaque).invokeExact(array, i);

   411                 assertEquals(x, "bar", "setOpaque String value");

   412             }

   413 

   414             hs.get(TestAccessMode.set).invokeExact(array, i, "foo");

   415 

   416             // Compare

   417             {

   418                 boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact(array, i, "foo", "bar");

   419                 assertEquals(r, true, "success compareAndSet String");

   420                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   421                 assertEquals(x, "bar", "success compareAndSet String value");

   422             }

   423 

   424             {

   425                 boolean r = (boolean) hs.get(TestAccessMode.compareAndSet).invokeExact(array, i, "foo", "baz");

   426                 assertEquals(r, false, "failing compareAndSet String");

   427                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   428                 assertEquals(x, "bar", "failing compareAndSet String value");

   429             }

   430 

   431             {

   432                 String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact(array, i, "bar", "foo");

   433                 assertEquals(r, "bar", "success compareAndExchangeVolatile String");

   434                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   435                 assertEquals(x, "foo", "success compareAndExchangeVolatile String value");

   436             }

   437 

   438             {

   439                 String r = (String) hs.get(TestAccessMode.compareAndExchangeVolatile).invokeExact(array, i, "bar", "baz");

   440                 assertEquals(r, "foo", "failing compareAndExchangeVolatile String");

   441                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   442                 assertEquals(x, "foo", "failing compareAndExchangeVolatile String value");

   443             }

   444 

   445             {

   446                 String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact(array, i, "foo", "bar");

   447                 assertEquals(r, "foo", "success compareAndExchangeAcquire String");

   448                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   449                 assertEquals(x, "bar", "success compareAndExchangeAcquire String value");

   450             }

   451 

   452             {

   453                 String r = (String) hs.get(TestAccessMode.compareAndExchangeAcquire).invokeExact(array, i, "foo", "baz");

   454                 assertEquals(r, "bar", "failing compareAndExchangeAcquire String");

   455                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   456                 assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");

   457             }

   458 

   459             {

   460                 String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact(array, i, "bar", "foo");

   461                 assertEquals(r, "bar", "success compareAndExchangeRelease String");

   462                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   463                 assertEquals(x, "foo", "success compareAndExchangeRelease String value");

   464             }

   465 

   466             {

   467                 String r = (String) hs.get(TestAccessMode.compareAndExchangeRelease).invokeExact(array, i, "bar", "baz");

   468                 assertEquals(r, "foo", "failing compareAndExchangeRelease String");

   469                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   470                 assertEquals(x, "foo", "failing compareAndExchangeRelease String value");

   471             }

   472 

   473             {

   474                 boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSet).invokeExact(array, i, "foo", "bar");

   475                 assertEquals(r, true, "weakCompareAndSet String");

   476                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   477                 assertEquals(x, "bar", "weakCompareAndSet String value");

   478             }

   479 

   480             {

   481                 boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetAcquire).invokeExact(array, i, "bar", "foo");

   482                 assertEquals(r, true, "weakCompareAndSetAcquire String");

   483                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   484                 assertEquals(x, "foo", "weakCompareAndSetAcquire String");

   485             }

   486 

   487             {

   488                 boolean r = (boolean) hs.get(TestAccessMode.weakCompareAndSetRelease).invokeExact(array, i, "foo", "bar");

   489                 assertEquals(r, true, "weakCompareAndSetRelease String");

   490                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   491                 assertEquals(x, "bar", "weakCompareAndSetRelease String");

   492             }

   493 

   494             // Compare set and get

   495             {

   496                 String o = (String) hs.get(TestAccessMode.getAndSet).invokeExact(array, i, "foo");

   497                 assertEquals(o, "bar", "getAndSet String");

   498                 String x = (String) hs.get(TestAccessMode.get).invokeExact(array, i);

   499                 assertEquals(x, "foo", "getAndSet String value");

   500             }

   501 

   502         }

   503     }

   504 

   505     static void testArrayUnsupported(Handles hs) throws Throwable {

   506         String[] array = new String[10];

   507 

   508         final int i = 0;

   509 

   510         for (TestAccessMode am : testAccessModesOfType(TestAccessType.getAndAdd)) {

   511             checkUOE(am, () -> {

   512                 String o = (String) hs.get(am).invokeExact(array, i, "foo");

   513             });

   514         }

   515     }

   516 

   517     static void testArrayIndexOutOfBounds(Handles hs) throws Throwable {

   518         String[] array = new String[10];

   519 

   520         for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {

   521             final int ci = i;

   522 

   523             for (TestAccessMode am : testAccessModesOfType(TestAccessType.get)) {

   524                 checkIOOBE(am, () -> {

   525                     String x = (String) hs.get(am).invokeExact(array, ci);

   526                 });

   527             }

   528 

   529             for (TestAccessMode am : testAccessModesOfType(TestAccessType.set)) {

   530                 checkIOOBE(am, () -> {

   531                     hs.get(am).invokeExact(array, ci, "foo");

   532                 });

   533             }

   534 

   535             for (TestAccessMode am : testAccessModesOfType(TestAccessType.compareAndSet)) {

   536                 checkIOOBE(am, () -> {

   537                     boolean r = (boolean) hs.get(am).invokeExact(array, ci, "foo", "bar");

   538                 });

   539             }

   540 

   541             for (TestAccessMode am : testAccessModesOfType(TestAccessType.compareAndExchange)) {

   542                 checkIOOBE(am, () -> {

   543                     String r = (String) hs.get(am).invokeExact(array, ci, "bar", "foo");

   544                 });

   545             }

   546 

   547             for (TestAccessMode am : testAccessModesOfType(TestAccessType.getAndSet)) {

   548                 checkIOOBE(am, () -> {

   549                     String o = (String) hs.get(am).invokeExact(array, ci, "foo");

   550                 });

   551             }

   552 

   553         }

   554     }

   555 }

   556