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/X-VarHandleTestAccess.java.template
changeset 38358 cb99c6d2af1b
parent 37719 add11bc0e6e2
parent 38355 674cfd9b90cf
child 38368 c8eb5d6812c5
equal deleted inserted replaced
38350:da6c6f544dfb 38358:cb99c6d2af1b 
   103         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
 
   103         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
 
   104         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_VOLATILE));
 
   104         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_VOLATILE));
 
   105         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
 
   105         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
 
   106         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
 
   106         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
 
   107         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
 
   107         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
 
   108         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_VOLATILE));
 
       
   109         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
 
   108         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
 
   110         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
 
   109         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
 
   111         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
 
   110         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
 
   112 #else[CAS]
 
   111 #else[CAS]
 
   113         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
 
   112         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
 
   114         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_VOLATILE));
 
   113         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_VOLATILE));
 
   115         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
 
   114         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
 
   116         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
 
   115         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
 
   117         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
 
   116         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
 
   118         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_VOLATILE));
 
       
   119         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
 
   117         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
 
   120         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
 
   118         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
 
   121         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
 
   119         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
 
   122 #end[CAS]
 
   120 #end[CAS]
 
   123 
   121 
   297         checkUOE(() -> {
 
   295         checkUOE(() -> {
 
   298             boolean r = vh.weakCompareAndSet(recv, $value1$, $value2$);
 
   296             boolean r = vh.weakCompareAndSet(recv, $value1$, $value2$);
 
   299         });
 
   297         });
 
   300 
   298 
   301         checkUOE(() -> {
 
   299         checkUOE(() -> {
 
   302             boolean r = vh.weakCompareAndSetVolatile(recv, $value1$, $value2$);
 
       
   303         });
 
       
   304 
       
   305         checkUOE(() -> {
 
       
   306             boolean r = vh.weakCompareAndSetAcquire(recv, $value1$, $value2$);
 
   300             boolean r = vh.weakCompareAndSetAcquire(recv, $value1$, $value2$);
 
   307         });
 
   301         });
 
   308 
   302 
   309         checkUOE(() -> {
 
   303         checkUOE(() -> {
 
   310             boolean r = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
 
   304             boolean r = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
 
   384             $type$ r = ($type$) vh.compareAndExchangeRelease($value1$, $value2$);
 
   378             $type$ r = ($type$) vh.compareAndExchangeRelease($value1$, $value2$);
 
   385         });
 
   379         });
 
   386 
   380 
   387         checkUOE(() -> {
 
   381         checkUOE(() -> {
 
   388             boolean r = vh.weakCompareAndSet($value1$, $value2$);
 
   382             boolean r = vh.weakCompareAndSet($value1$, $value2$);
 
   389         });
 
       
   390 
       
   391         checkUOE(() -> {
 
       
   392             boolean r = vh.weakCompareAndSetVolatile($value1$, $value2$);
 
       
   393         });
 
   383         });
 
   394 
   384 
   395         checkUOE(() -> {
 
   385         checkUOE(() -> {
 
   396             boolean r = vh.weakCompareAndSetAcquire($value1$, $value2$);
 
   386             boolean r = vh.weakCompareAndSetAcquire($value1$, $value2$);
 
   397         });
 
   387         });
 
   502             $type$ x = ($type$) vh.get(recv);
 
   492             $type$ x = ($type$) vh.get(recv);
 
   503             assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value");
 
   493             assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value");
 
   504         }
 
   494         }
 
   505 
   495 
   506         {
 
   496         {
 
   507             boolean r = vh.weakCompareAndSet(recv, $value1$, $value2$);
 
   497             boolean success = false;
 
   508             assertEquals(r, true, "weakCompareAndSet $type$");
 
   498             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
       
   499                 success = vh.weakCompareAndSet(recv, $value1$, $value2$);
 
       
   500             }
 
       
   501             assertEquals(success, true, "weakCompareAndSet $type$");
 
   509             $type$ x = ($type$) vh.get(recv);
 
   502             $type$ x = ($type$) vh.get(recv);
 
   510             assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
 
   503             assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
 
   511         }
 
   504         }
 
   512 
   505 
   513         {
 
   506         {
 
   514             boolean r = vh.weakCompareAndSetAcquire(recv, $value2$, $value1$);
 
   507             boolean success = false;
 
   515             assertEquals(r, true, "weakCompareAndSetAcquire $type$");
 
   508             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
       
   509                 success = vh.weakCompareAndSetAcquire(recv, $value2$, $value1$);
 
       
   510             }
 
       
   511             assertEquals(success, true, "weakCompareAndSetAcquire $type$");
 
   516             $type$ x = ($type$) vh.get(recv);
 
   512             $type$ x = ($type$) vh.get(recv);
 
   517             assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
 
   513             assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
 
   518         }
 
   514         }
 
   519 
   515 
   520         {
 
   516         {
 
   521             boolean r = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
 
   517             boolean success = false;
 
   522             assertEquals(r, true, "weakCompareAndSetRelease $type$");
 
   518             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
       
   519                 success = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
 
       
   520             }
 
       
   521             assertEquals(success, true, "weakCompareAndSetRelease $type$");
 
   523             $type$ x = ($type$) vh.get(recv);
 
   522             $type$ x = ($type$) vh.get(recv);
 
   524             assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
 
   523             assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
 
   525         }
 
   524         }
 
   526 
   525 
   527         {
 
       
   528             boolean r = vh.weakCompareAndSetVolatile(recv, $value2$, $value1$);
 
       
   529             assertEquals(r, true, "weakCompareAndSetVolatile $type$");
 
       
   530             $type$ x = ($type$) vh.get(recv);
 
       
   531             assertEquals(x, $value1$, "weakCompareAndSetVolatile $type$ value");
 
       
   532         }
 
       
   533 
       
   534         // Compare set and get
 
   526         // Compare set and get
 
   535         {
 
   527         {
 
   536             $type$ o = ($type$) vh.getAndSet(recv, $value2$);
 
   528             $type$ o = ($type$) vh.getAndSet(recv, $value1$);
 
   537             assertEquals(o, $value1$, "getAndSet $type$");
 
   529             assertEquals(o, $value2$, "getAndSet $type$");
 
   538             $type$ x = ($type$) vh.get(recv);
 
   530             $type$ x = ($type$) vh.get(recv);
 
   539             assertEquals(x, $value2$, "getAndSet $type$ value");
 
   531             assertEquals(x, $value1$, "getAndSet $type$ value");
 
   540         }
 
   532         }
 
   541 #end[CAS]
 
   533 #end[CAS]
 
   542 
   534 
   543 #if[AtomicAdd]
 
   535 #if[AtomicAdd]
 
   544         vh.set(recv, $value1$);
 
   536         vh.set(recv, $value1$);
 
   574         checkUOE(() -> {
 
   566         checkUOE(() -> {
 
   575             boolean r = vh.weakCompareAndSet(recv, $value1$, $value2$);
 
   567             boolean r = vh.weakCompareAndSet(recv, $value1$, $value2$);
 
   576         });
 
   568         });
 
   577 
   569 
   578         checkUOE(() -> {
 
   570         checkUOE(() -> {
 
   579             boolean r = vh.weakCompareAndSetVolatile(recv, $value1$, $value2$);
 
       
   580         });
 
       
   581 
       
   582         checkUOE(() -> {
 
       
   583             boolean r = vh.weakCompareAndSetAcquire(recv, $value1$, $value2$);
 
   571             boolean r = vh.weakCompareAndSetAcquire(recv, $value1$, $value2$);
 
   584         });
 
   572         });
 
   585 
   573 
   586         checkUOE(() -> {
 
   574         checkUOE(() -> {
 
   587             boolean r = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
 
   575             boolean r = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
 
   689             $type$ x = ($type$) vh.get();
 
   677             $type$ x = ($type$) vh.get();
 
   690             assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value");
 
   678             assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value");
 
   691         }
 
   679         }
 
   692 
   680 
   693         {
 
   681         {
 
   694             boolean r = (boolean) vh.weakCompareAndSet($value1$, $value2$);
 
   682             boolean success = false;
 
   695             assertEquals(r, true, "weakCompareAndSet $type$");
 
   683             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
       
   684                 success = vh.weakCompareAndSet($value1$, $value2$);
 
       
   685             }
 
       
   686             assertEquals(success, true, "weakCompareAndSet $type$");
 
   696             $type$ x = ($type$) vh.get();
 
   687             $type$ x = ($type$) vh.get();
 
   697             assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
 
   688             assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
 
   698         }
 
   689         }
 
   699 
   690 
   700         {
 
   691         {
 
   701             boolean r = (boolean) vh.weakCompareAndSetAcquire($value2$, $value1$);
 
   692             boolean success = false;
 
   702             assertEquals(r, true, "weakCompareAndSetAcquire $type$");
 
   693             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
       
   694                 success = vh.weakCompareAndSetAcquire($value2$, $value1$);
 
       
   695             }
 
       
   696             assertEquals(success, true, "weakCompareAndSetAcquire $type$");
 
   703             $type$ x = ($type$) vh.get();
 
   697             $type$ x = ($type$) vh.get();
 
   704             assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
 
   698             assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
 
   705         }
 
   699         }
 
   706 
   700 
   707         {
 
   701         {
 
   708             boolean r = (boolean) vh.weakCompareAndSetRelease($value1$, $value2$);
 
   702             boolean success = false;
 
   709             assertEquals(r, true, "weakCompareAndSetRelease $type$");
 
   703             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
       
   704                 success = vh.weakCompareAndSetRelease($value1$, $value2$);
 
       
   705             }
 
       
   706             assertEquals(success, true, "weakCompareAndSetRelease $type$");
 
   710             $type$ x = ($type$) vh.get();
 
   707             $type$ x = ($type$) vh.get();
 
   711             assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
 
   708             assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
 
   712         }
 
   709         }
 
   713 
   710 
   714         {
 
       
   715             boolean r = (boolean) vh.weakCompareAndSetVolatile($value2$, $value1$);
 
       
   716             assertEquals(r, true, "weakCompareAndSetVolatile $type$");
 
       
   717             $type$ x = ($type$) vh.get();
 
       
   718             assertEquals(x, $value1$, "weakCompareAndSetVolatile $type$ value");
 
       
   719         }
 
       
   720 
       
   721         // Compare set and get
 
   711         // Compare set and get
 
   722         {
 
   712         {
 
   723             $type$ o = ($type$) vh.getAndSet( $value2$);
 
   713             $type$ o = ($type$) vh.getAndSet( $value1$);
 
   724             assertEquals(o, $value1$, "getAndSet $type$");
 
   714             assertEquals(o, $value2$, "getAndSet $type$");
 
   725             $type$ x = ($type$) vh.get();
 
   715             $type$ x = ($type$) vh.get();
 
   726             assertEquals(x, $value2$, "getAndSet $type$ value");
 
   716             assertEquals(x, $value1$, "getAndSet $type$ value");
 
   727         }
 
   717         }
 
   728 #end[CAS]
 
   718 #end[CAS]
 
   729 
   719 
   730 #if[AtomicAdd]
 
   720 #if[AtomicAdd]
 
   731         vh.set($value1$);
 
   721         vh.set($value1$);
 
   761         checkUOE(() -> {
 
   751         checkUOE(() -> {
 
   762             boolean r = vh.weakCompareAndSet($value1$, $value2$);
 
   752             boolean r = vh.weakCompareAndSet($value1$, $value2$);
 
   763         });
 
   753         });
 
   764 
   754 
   765         checkUOE(() -> {
 
   755         checkUOE(() -> {
 
   766             boolean r = vh.weakCompareAndSetVolatile($value1$, $value2$);
 
       
   767         });
 
       
   768 
       
   769         checkUOE(() -> {
 
       
   770             boolean r = vh.weakCompareAndSetAcquire($value1$, $value2$);
 
   756             boolean r = vh.weakCompareAndSetAcquire($value1$, $value2$);
 
   771         });
 
   757         });
 
   772 
   758 
   773         checkUOE(() -> {
 
   759         checkUOE(() -> {
 
   774             boolean r = vh.weakCompareAndSetRelease($value1$, $value2$);
 
   760             boolean r = vh.weakCompareAndSetRelease($value1$, $value2$);
 
   879                 $type$ x = ($type$) vh.get(array, i);
 
   865                 $type$ x = ($type$) vh.get(array, i);
 
   880                 assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value");
 
   866                 assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value");
 
   881             }
 
   867             }
 
   882 
   868 
   883             {
 
   869             {
 
   884                 boolean r = vh.weakCompareAndSet(array, i, $value1$, $value2$);
 
   870                 boolean success = false;
 
   885                 assertEquals(r, true, "weakCompareAndSet $type$");
 
   871                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
       
   872                     success = vh.weakCompareAndSet(array, i, $value1$, $value2$);
 
       
   873                 }
 
       
   874                 assertEquals(success, true, "weakCompareAndSet $type$");
 
   886                 $type$ x = ($type$) vh.get(array, i);
 
   875                 $type$ x = ($type$) vh.get(array, i);
 
   887                 assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
 
   876                 assertEquals(x, $value2$, "weakCompareAndSet $type$ value");
 
   888             }
 
   877             }
 
   889 
   878 
   890             {
 
   879             {
 
   891                 boolean r = vh.weakCompareAndSetAcquire(array, i, $value2$, $value1$);
 
   880                 boolean success = false;
 
   892                 assertEquals(r, true, "weakCompareAndSetAcquire $type$");
 
   881                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
       
   882                     success = vh.weakCompareAndSetAcquire(array, i, $value2$, $value1$);
 
       
   883                 }
 
       
   884                 assertEquals(success, true, "weakCompareAndSetAcquire $type$");
 
   893                 $type$ x = ($type$) vh.get(array, i);
 
   885                 $type$ x = ($type$) vh.get(array, i);
 
   894                 assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
 
   886                 assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
 
   895             }
 
   887             }
 
   896 
   888 
   897             {
 
   889             {
 
   898                 boolean r = vh.weakCompareAndSetRelease(array, i, $value1$, $value2$);
 
   890                 boolean success = false;
 
   899                 assertEquals(r, true, "weakCompareAndSetRelease $type$");
 
   891                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 
       
   892                     success = vh.weakCompareAndSetRelease(array, i, $value1$, $value2$);
 
       
   893                 }
 
       
   894                 assertEquals(success, true, "weakCompareAndSetRelease $type$");
 
   900                 $type$ x = ($type$) vh.get(array, i);
 
   895                 $type$ x = ($type$) vh.get(array, i);
 
   901                 assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
 
   896                 assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
 
   902             }
 
   897             }
 
   903 
   898 
   904             {
 
       
   905                 boolean r = vh.weakCompareAndSetVolatile(array, i, $value2$, $value1$);
 
       
   906                 assertEquals(r, true, "weakCompareAndSetVolatile $type$");
 
       
   907                 $type$ x = ($type$) vh.get(array, i);
 
       
   908                 assertEquals(x, $value1$, "weakCompareAndSetVolatile $type$ value");
 
       
   909             }
 
       
   910 
       
   911             // Compare set and get
 
   899             // Compare set and get
 
   912             {
 
   900             {
 
   913                 $type$ o = ($type$) vh.getAndSet(array, i, $value2$);
 
   901                 $type$ o = ($type$) vh.getAndSet(array, i, $value1$);
 
   914                 assertEquals(o, $value1$, "getAndSet $type$");
 
   902                 assertEquals(o, $value2$, "getAndSet $type$");
 
   915                 $type$ x = ($type$) vh.get(array, i);
 
   903                 $type$ x = ($type$) vh.get(array, i);
 
   916                 assertEquals(x, $value2$, "getAndSet $type$ value");
 
   904                 assertEquals(x, $value1$, "getAndSet $type$ value");
 
   917             }
 
   905             }
 
   918 #end[CAS]
 
   906 #end[CAS]
 
   919 
   907 
   920 #if[AtomicAdd]
 
   908 #if[AtomicAdd]
 
   921             vh.set(array, i, $value1$);
 
   909             vh.set(array, i, $value1$);
 
   955         checkUOE(() -> {
 
   943         checkUOE(() -> {
 
   956             boolean r = vh.weakCompareAndSet(array, i, $value1$, $value2$);
 
   944             boolean r = vh.weakCompareAndSet(array, i, $value1$, $value2$);
 
   957         });
 
   945         });
 
   958 
   946 
   959         checkUOE(() -> {
 
   947         checkUOE(() -> {
 
   960             boolean r = vh.weakCompareAndSetVolatile(array, i, $value1$, $value2$);
 
       
   961         });
 
       
   962 
       
   963         checkUOE(() -> {
 
       
   964             boolean r = vh.weakCompareAndSetAcquire(array, i, $value1$, $value2$);
 
   948             boolean r = vh.weakCompareAndSetAcquire(array, i, $value1$, $value2$);
 
   965         });
 
   949         });
 
   966 
   950 
   967         checkUOE(() -> {
 
   951         checkUOE(() -> {
 
   968             boolean r = vh.weakCompareAndSetRelease(array, i, $value1$, $value2$);
 
   952             boolean r = vh.weakCompareAndSetRelease(array, i, $value1$, $value2$);
 
  1038             checkIOOBE(() -> {
 
  1022             checkIOOBE(() -> {
 
  1039                 boolean r = vh.weakCompareAndSet(array, ci, $value1$, $value2$);
 
  1023                 boolean r = vh.weakCompareAndSet(array, ci, $value1$, $value2$);
 
  1040             });
 
  1024             });
 
  1041 
  1025 
  1042             checkIOOBE(() -> {
 
  1026             checkIOOBE(() -> {
 
  1043                 boolean r = vh.weakCompareAndSetVolatile(array, ci, $value1$, $value2$);
 
       
  1044             });
 
       
  1045 
       
  1046             checkIOOBE(() -> {
 
       
  1047                 boolean r = vh.weakCompareAndSetAcquire(array, ci, $value1$, $value2$);
 
  1027                 boolean r = vh.weakCompareAndSetAcquire(array, ci, $value1$, $value2$);
 
  1048             });
 
  1028             });
 
  1049 
  1029 
  1050             checkIOOBE(() -> {
 
  1030             checkIOOBE(() -> {
 
  1051                 boolean r = vh.weakCompareAndSetRelease(array, ci, $value1$, $value2$);
 
  1031                 boolean r = vh.weakCompareAndSetRelease(array, ci, $value1$, $value2$);
jdk-sandbox