jdk/test/java/lang/invoke/VarHandles/VarHandleTestAccessChar.java
changeset 40732 2fd9cf42bb3c
parent 39472 6df82f4c63ac
child 40733 8d1263354d62
equal deleted inserted replaced
40731:70a4f131d226 40732:2fd9cf42bb3c
   106         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
   106         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
   107         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_VOLATILE));
   107         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_VOLATILE));
   108         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
   108         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
   109         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
   109         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
   110         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
   110         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
       
   111         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_ACQUIRE));
       
   112         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_RELEASE));
   111 
   113 
   112         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
   114         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
       
   115         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE));
       
   116         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_RELEASE));
   113         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.ADD_AND_GET));
   117         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.ADD_AND_GET));
       
   118 
       
   119         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR));
       
   120         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE));
       
   121         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE));
       
   122         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND));
       
   123         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE));
       
   124         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE));
       
   125         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR));
       
   126         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE));
       
   127         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE));
   114     }
   128     }
   115 
   129 
   116 
   130 
   117     @DataProvider
   131     @DataProvider
   118     public Object[][] typesProvider() throws Exception {
   132     public Object[][] typesProvider() throws Exception {
   259         checkUOE(() -> {
   273         checkUOE(() -> {
   260             vh.setOpaque(recv, '\u4567');
   274             vh.setOpaque(recv, '\u4567');
   261         });
   275         });
   262 
   276 
   263 
   277 
       
   278 
   264     }
   279     }
   265 
   280 
   266 
   281 
   267     static void testStaticFinalField(VarHandle vh) {
   282     static void testStaticFinalField(VarHandle vh) {
   268         // Plain
   283         // Plain
   307         checkUOE(() -> {
   322         checkUOE(() -> {
   308             vh.setOpaque('\u4567');
   323             vh.setOpaque('\u4567');
   309         });
   324         });
   310 
   325 
   311 
   326 
       
   327 
   312     }
   328     }
   313 
   329 
   314 
   330 
   315     static void testInstanceField(VarHandleTestAccessChar recv, VarHandle vh) {
   331     static void testInstanceField(VarHandleTestAccessChar recv, VarHandle vh) {
   316         // Plain
   332         // Plain
   441             assertEquals(x, '\u0123', "weakCompareAndSetVolatile char value");
   457             assertEquals(x, '\u0123', "weakCompareAndSetVolatile char value");
   442         }
   458         }
   443 
   459 
   444         // Compare set and get
   460         // Compare set and get
   445         {
   461         {
       
   462             vh.set(recv, '\u0123');
       
   463 
   446             char o = (char) vh.getAndSet(recv, '\u4567');
   464             char o = (char) vh.getAndSet(recv, '\u4567');
   447             assertEquals(o, '\u0123', "getAndSet char");
   465             assertEquals(o, '\u0123', "getAndSet char");
   448             char x = (char) vh.get(recv);
   466             char x = (char) vh.get(recv);
   449             assertEquals(x, '\u4567', "getAndSet char value");
   467             assertEquals(x, '\u4567', "getAndSet char value");
   450         }
   468         }
   451 
   469 
   452         vh.set(recv, '\u0123');
   470         {
       
   471             vh.set(recv, '\u0123');
       
   472 
       
   473             char o = (char) vh.getAndSetAcquire(recv, '\u4567');
       
   474             assertEquals(o, '\u0123', "getAndSetAcquire char");
       
   475             char x = (char) vh.get(recv);
       
   476             assertEquals(x, '\u4567', "getAndSetAcquire char value");
       
   477         }
       
   478 
       
   479         {
       
   480             vh.set(recv, '\u0123');
       
   481 
       
   482             char o = (char) vh.getAndSetRelease(recv, '\u4567');
       
   483             assertEquals(o, '\u0123', "getAndSetRelease char");
       
   484             char x = (char) vh.get(recv);
       
   485             assertEquals(x, '\u4567', "getAndSetRelease char value");
       
   486         }
   453 
   487 
   454         // get and add, add and get
   488         // get and add, add and get
   455         {
   489         {
       
   490             vh.set(recv, '\u0123');
       
   491 
   456             char o = (char) vh.getAndAdd(recv, '\u89AB');
   492             char o = (char) vh.getAndAdd(recv, '\u89AB');
   457             assertEquals(o, '\u0123', "getAndAdd char");
   493             assertEquals(o, '\u0123', "getAndAdd char");
   458             char c = (char) vh.addAndGet(recv, '\u89AB');
   494             char c = (char) vh.addAndGet(recv, '\u89AB');
   459             assertEquals(c, (char)('\u0123' + '\u89AB' + '\u89AB'), "getAndAdd char value");
   495             assertEquals(c, (char)('\u0123' + '\u89AB' + '\u89AB'), "getAndAdd char value");
   460         }
   496         }
       
   497 
       
   498         {
       
   499             vh.set(recv, '\u0123');
       
   500 
       
   501             char o = (char) vh.getAndAddAcquire(recv, '\u4567');
       
   502             assertEquals(o, '\u0123', "getAndAddAcquire char");
       
   503             char x = (char) vh.get(recv);
       
   504             assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value");
       
   505         }
       
   506 
       
   507         {
       
   508             vh.set(recv, '\u0123');
       
   509 
       
   510             char o = (char) vh.getAndAddRelease(recv, '\u4567');
       
   511             assertEquals(o, '\u0123', "getAndAddReleasechar");
       
   512             char x = (char) vh.get(recv);
       
   513             assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value");
       
   514         }
       
   515 
       
   516         // get and bitwise or
       
   517         {
       
   518             vh.set(recv, '\u0123');
       
   519 
       
   520             char o = (char) vh.getAndBitwiseOr(recv, '\u4567');
       
   521             assertEquals(o, '\u0123', "getAndBitwiseOr char");
       
   522             char x = (char) vh.get(recv);
       
   523             assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value");
       
   524         }
       
   525 
       
   526         {
       
   527             vh.set(recv, '\u0123');
       
   528 
       
   529             char o = (char) vh.getAndBitwiseOrAcquire(recv, '\u4567');
       
   530             assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char");
       
   531             char x = (char) vh.get(recv);
       
   532             assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value");
       
   533         }
       
   534 
       
   535         {
       
   536             vh.set(recv, '\u0123');
       
   537 
       
   538             char o = (char) vh.getAndBitwiseOrRelease(recv, '\u4567');
       
   539             assertEquals(o, '\u0123', "getAndBitwiseOrRelease char");
       
   540             char x = (char) vh.get(recv);
       
   541             assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value");
       
   542         }
       
   543 
       
   544         // get and bitwise and
       
   545         {
       
   546             vh.set(recv, '\u0123');
       
   547 
       
   548             char o = (char) vh.getAndBitwiseAnd(recv, '\u4567');
       
   549             assertEquals(o, '\u0123', "getAndBitwiseAnd char");
       
   550             char x = (char) vh.get(recv);
       
   551             assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value");
       
   552         }
       
   553 
       
   554         {
       
   555             vh.set(recv, '\u0123');
       
   556 
       
   557             char o = (char) vh.getAndBitwiseAndAcquire(recv, '\u4567');
       
   558             assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char");
       
   559             char x = (char) vh.get(recv);
       
   560             assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value");
       
   561         }
       
   562 
       
   563         {
       
   564             vh.set(recv, '\u0123');
       
   565 
       
   566             char o = (char) vh.getAndBitwiseAndRelease(recv, '\u4567');
       
   567             assertEquals(o, '\u0123', "getAndBitwiseAndRelease char");
       
   568             char x = (char) vh.get(recv);
       
   569             assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value");
       
   570         }
       
   571 
       
   572         // get and bitwise xor
       
   573         {
       
   574             vh.set(recv, '\u0123');
       
   575 
       
   576             char o = (char) vh.getAndBitwiseXor(recv, '\u4567');
       
   577             assertEquals(o, '\u0123', "getAndBitwiseXor char");
       
   578             char x = (char) vh.get(recv);
       
   579             assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value");
       
   580         }
       
   581 
       
   582         {
       
   583             vh.set(recv, '\u0123');
       
   584 
       
   585             char o = (char) vh.getAndBitwiseXorAcquire(recv, '\u4567');
       
   586             assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char");
       
   587             char x = (char) vh.get(recv);
       
   588             assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value");
       
   589         }
       
   590 
       
   591         {
       
   592             vh.set(recv, '\u0123');
       
   593 
       
   594             char o = (char) vh.getAndBitwiseXorRelease(recv, '\u4567');
       
   595             assertEquals(o, '\u0123', "getAndBitwiseXorRelease char");
       
   596             char x = (char) vh.get(recv);
       
   597             assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value");
       
   598         }
   461     }
   599     }
   462 
   600 
   463     static void testInstanceFieldUnsupported(VarHandleTestAccessChar recv, VarHandle vh) {
   601     static void testInstanceFieldUnsupported(VarHandleTestAccessChar recv, VarHandle vh) {
       
   602 
   464 
   603 
   465     }
   604     }
   466 
   605 
   467 
   606 
   468     static void testStaticField(VarHandle vh) {
   607     static void testStaticField(VarHandle vh) {
   594             assertEquals(x, '\u0123', "weakCompareAndSetVolatile char");
   733             assertEquals(x, '\u0123', "weakCompareAndSetVolatile char");
   595         }
   734         }
   596 
   735 
   597         // Compare set and get
   736         // Compare set and get
   598         {
   737         {
       
   738             vh.set('\u0123');
       
   739 
   599             char o = (char) vh.getAndSet('\u4567');
   740             char o = (char) vh.getAndSet('\u4567');
   600             assertEquals(o, '\u0123', "getAndSet char");
   741             assertEquals(o, '\u0123', "getAndSet char");
   601             char x = (char) vh.get();
   742             char x = (char) vh.get();
   602             assertEquals(x, '\u4567', "getAndSet char value");
   743             assertEquals(x, '\u4567', "getAndSet char value");
   603         }
   744         }
   604 
   745 
   605         vh.set('\u0123');
   746         {
       
   747             vh.set('\u0123');
       
   748 
       
   749             char o = (char) vh.getAndSetAcquire('\u4567');
       
   750             assertEquals(o, '\u0123', "getAndSetAcquire char");
       
   751             char x = (char) vh.get();
       
   752             assertEquals(x, '\u4567', "getAndSetAcquire char value");
       
   753         }
       
   754 
       
   755         {
       
   756             vh.set('\u0123');
       
   757 
       
   758             char o = (char) vh.getAndSetRelease('\u4567');
       
   759             assertEquals(o, '\u0123', "getAndSetRelease char");
       
   760             char x = (char) vh.get();
       
   761             assertEquals(x, '\u4567', "getAndSetRelease char value");
       
   762         }
   606 
   763 
   607         // get and add, add and get
   764         // get and add, add and get
   608         {
   765         {
       
   766             vh.set('\u0123');
       
   767 
   609             char o = (char) vh.getAndAdd( '\u89AB');
   768             char o = (char) vh.getAndAdd( '\u89AB');
   610             assertEquals(o, '\u0123', "getAndAdd char");
   769             assertEquals(o, '\u0123', "getAndAdd char");
   611             char c = (char) vh.addAndGet('\u89AB');
   770             char c = (char) vh.addAndGet('\u89AB');
   612             assertEquals(c, (char)('\u0123' + '\u89AB' + '\u89AB'), "getAndAdd char value");
   771             assertEquals(c, (char)('\u0123' + '\u89AB' + '\u89AB'), "getAndAdd char value");
   613         }
   772         }
       
   773 
       
   774         {
       
   775             vh.set('\u0123');
       
   776 
       
   777             char o = (char) vh.getAndAddAcquire('\u4567');
       
   778             assertEquals(o, '\u0123', "getAndAddAcquire char");
       
   779             char x = (char) vh.get();
       
   780             assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value");
       
   781         }
       
   782 
       
   783         {
       
   784             vh.set('\u0123');
       
   785 
       
   786             char o = (char) vh.getAndAddRelease('\u4567');
       
   787             assertEquals(o, '\u0123', "getAndAddReleasechar");
       
   788             char x = (char) vh.get();
       
   789             assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value");
       
   790         }
       
   791 
       
   792         // get and bitwise or
       
   793         {
       
   794             vh.set('\u0123');
       
   795 
       
   796             char o = (char) vh.getAndBitwiseOr('\u4567');
       
   797             assertEquals(o, '\u0123', "getAndBitwiseOr char");
       
   798             char x = (char) vh.get();
       
   799             assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value");
       
   800         }
       
   801 
       
   802         {
       
   803             vh.set('\u0123');
       
   804 
       
   805             char o = (char) vh.getAndBitwiseOrAcquire('\u4567');
       
   806             assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char");
       
   807             char x = (char) vh.get();
       
   808             assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value");
       
   809         }
       
   810 
       
   811         {
       
   812             vh.set('\u0123');
       
   813 
       
   814             char o = (char) vh.getAndBitwiseOrRelease('\u4567');
       
   815             assertEquals(o, '\u0123', "getAndBitwiseOrRelease char");
       
   816             char x = (char) vh.get();
       
   817             assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value");
       
   818         }
       
   819 
       
   820         // get and bitwise and
       
   821         {
       
   822             vh.set('\u0123');
       
   823 
       
   824             char o = (char) vh.getAndBitwiseAnd('\u4567');
       
   825             assertEquals(o, '\u0123', "getAndBitwiseAnd char");
       
   826             char x = (char) vh.get();
       
   827             assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value");
       
   828         }
       
   829 
       
   830         {
       
   831             vh.set('\u0123');
       
   832 
       
   833             char o = (char) vh.getAndBitwiseAndAcquire('\u4567');
       
   834             assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char");
       
   835             char x = (char) vh.get();
       
   836             assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value");
       
   837         }
       
   838 
       
   839         {
       
   840             vh.set('\u0123');
       
   841 
       
   842             char o = (char) vh.getAndBitwiseAndRelease('\u4567');
       
   843             assertEquals(o, '\u0123', "getAndBitwiseAndRelease char");
       
   844             char x = (char) vh.get();
       
   845             assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value");
       
   846         }
       
   847 
       
   848         // get and bitwise xor
       
   849         {
       
   850             vh.set('\u0123');
       
   851 
       
   852             char o = (char) vh.getAndBitwiseXor('\u4567');
       
   853             assertEquals(o, '\u0123', "getAndBitwiseXor char");
       
   854             char x = (char) vh.get();
       
   855             assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value");
       
   856         }
       
   857 
       
   858         {
       
   859             vh.set('\u0123');
       
   860 
       
   861             char o = (char) vh.getAndBitwiseXorAcquire('\u4567');
       
   862             assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char");
       
   863             char x = (char) vh.get();
       
   864             assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value");
       
   865         }
       
   866 
       
   867         {
       
   868             vh.set('\u0123');
       
   869 
       
   870             char o = (char) vh.getAndBitwiseXorRelease('\u4567');
       
   871             assertEquals(o, '\u0123', "getAndBitwiseXorRelease char");
       
   872             char x = (char) vh.get();
       
   873             assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value");
       
   874         }
   614     }
   875     }
   615 
   876 
   616     static void testStaticFieldUnsupported(VarHandle vh) {
   877     static void testStaticFieldUnsupported(VarHandle vh) {
       
   878 
   617 
   879 
   618     }
   880     }
   619 
   881 
   620 
   882 
   621     static void testArray(VarHandle vh) {
   883     static void testArray(VarHandle vh) {
   750                 assertEquals(x, '\u0123', "weakCompareAndSetVolatile char");
  1012                 assertEquals(x, '\u0123', "weakCompareAndSetVolatile char");
   751             }
  1013             }
   752 
  1014 
   753             // Compare set and get
  1015             // Compare set and get
   754             {
  1016             {
       
  1017                 vh.set(array, i, '\u0123');
       
  1018 
   755                 char o = (char) vh.getAndSet(array, i, '\u4567');
  1019                 char o = (char) vh.getAndSet(array, i, '\u4567');
   756                 assertEquals(o, '\u0123', "getAndSet char");
  1020                 assertEquals(o, '\u0123', "getAndSet char");
   757                 char x = (char) vh.get(array, i);
  1021                 char x = (char) vh.get(array, i);
   758                 assertEquals(x, '\u4567', "getAndSet char value");
  1022                 assertEquals(x, '\u4567', "getAndSet char value");
   759             }
  1023             }
   760 
  1024 
   761             vh.set(array, i, '\u0123');
  1025             {
       
  1026                 vh.set(array, i, '\u0123');
       
  1027 
       
  1028                 char o = (char) vh.getAndSetAcquire(array, i, '\u4567');
       
  1029                 assertEquals(o, '\u0123', "getAndSetAcquire char");
       
  1030                 char x = (char) vh.get(array, i);
       
  1031                 assertEquals(x, '\u4567', "getAndSetAcquire char value");
       
  1032             }
       
  1033 
       
  1034             {
       
  1035                 vh.set(array, i, '\u0123');
       
  1036 
       
  1037                 char o = (char) vh.getAndSetRelease(array, i, '\u4567');
       
  1038                 assertEquals(o, '\u0123', "getAndSetRelease char");
       
  1039                 char x = (char) vh.get(array, i);
       
  1040                 assertEquals(x, '\u4567', "getAndSetRelease char value");
       
  1041             }
   762 
  1042 
   763             // get and add, add and get
  1043             // get and add, add and get
   764             {
  1044             {
       
  1045                 vh.set(array, i, '\u0123');
       
  1046 
   765                 char o = (char) vh.getAndAdd(array, i, '\u89AB');
  1047                 char o = (char) vh.getAndAdd(array, i, '\u89AB');
   766                 assertEquals(o, '\u0123', "getAndAdd char");
  1048                 assertEquals(o, '\u0123', "getAndAdd char");
   767                 char c = (char) vh.addAndGet(array, i, '\u89AB');
  1049                 char c = (char) vh.addAndGet(array, i, '\u89AB');
   768                 assertEquals(c, (char)('\u0123' + '\u89AB' + '\u89AB'), "getAndAdd char value");
  1050                 assertEquals(c, (char)('\u0123' + '\u89AB' + '\u89AB'), "getAndAdd char value");
   769             }
  1051             }
       
  1052 
       
  1053             {
       
  1054                 vh.set(array, i, '\u0123');
       
  1055 
       
  1056                 char o = (char) vh.getAndAddAcquire(array, i, '\u4567');
       
  1057                 assertEquals(o, '\u0123', "getAndAddAcquire char");
       
  1058                 char x = (char) vh.get(array, i);
       
  1059                 assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddAcquire char value");
       
  1060             }
       
  1061 
       
  1062             {
       
  1063                 vh.set(array, i, '\u0123');
       
  1064 
       
  1065                 char o = (char) vh.getAndAddRelease(array, i, '\u4567');
       
  1066                 assertEquals(o, '\u0123', "getAndAddReleasechar");
       
  1067                 char x = (char) vh.get(array, i);
       
  1068                 assertEquals(x, (char)('\u0123' + '\u4567'), "getAndAddRelease char value");
       
  1069             }
       
  1070 
       
  1071             // get and bitwise or
       
  1072             {
       
  1073                 vh.set(array, i, '\u0123');
       
  1074 
       
  1075                 char o = (char) vh.getAndBitwiseOr(array, i, '\u4567');
       
  1076                 assertEquals(o, '\u0123', "getAndBitwiseOr char");
       
  1077                 char x = (char) vh.get(array, i);
       
  1078                 assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOr char value");
       
  1079             }
       
  1080 
       
  1081             {
       
  1082                 vh.set(array, i, '\u0123');
       
  1083 
       
  1084                 char o = (char) vh.getAndBitwiseOrAcquire(array, i, '\u4567');
       
  1085                 assertEquals(o, '\u0123', "getAndBitwiseOrAcquire char");
       
  1086                 char x = (char) vh.get(array, i);
       
  1087                 assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrAcquire char value");
       
  1088             }
       
  1089 
       
  1090             {
       
  1091                 vh.set(array, i, '\u0123');
       
  1092 
       
  1093                 char o = (char) vh.getAndBitwiseOrRelease(array, i, '\u4567');
       
  1094                 assertEquals(o, '\u0123', "getAndBitwiseOrRelease char");
       
  1095                 char x = (char) vh.get(array, i);
       
  1096                 assertEquals(x, (char)('\u0123' | '\u4567'), "getAndBitwiseOrRelease char value");
       
  1097             }
       
  1098 
       
  1099             // get and bitwise and
       
  1100             {
       
  1101                 vh.set(array, i, '\u0123');
       
  1102 
       
  1103                 char o = (char) vh.getAndBitwiseAnd(array, i, '\u4567');
       
  1104                 assertEquals(o, '\u0123', "getAndBitwiseAnd char");
       
  1105                 char x = (char) vh.get(array, i);
       
  1106                 assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAnd char value");
       
  1107             }
       
  1108 
       
  1109             {
       
  1110                 vh.set(array, i, '\u0123');
       
  1111 
       
  1112                 char o = (char) vh.getAndBitwiseAndAcquire(array, i, '\u4567');
       
  1113                 assertEquals(o, '\u0123', "getAndBitwiseAndAcquire char");
       
  1114                 char x = (char) vh.get(array, i);
       
  1115                 assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndAcquire char value");
       
  1116             }
       
  1117 
       
  1118             {
       
  1119                 vh.set(array, i, '\u0123');
       
  1120 
       
  1121                 char o = (char) vh.getAndBitwiseAndRelease(array, i, '\u4567');
       
  1122                 assertEquals(o, '\u0123', "getAndBitwiseAndRelease char");
       
  1123                 char x = (char) vh.get(array, i);
       
  1124                 assertEquals(x, (char)('\u0123' & '\u4567'), "getAndBitwiseAndRelease char value");
       
  1125             }
       
  1126 
       
  1127             // get and bitwise xor
       
  1128             {
       
  1129                 vh.set(array, i, '\u0123');
       
  1130 
       
  1131                 char o = (char) vh.getAndBitwiseXor(array, i, '\u4567');
       
  1132                 assertEquals(o, '\u0123', "getAndBitwiseXor char");
       
  1133                 char x = (char) vh.get(array, i);
       
  1134                 assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXor char value");
       
  1135             }
       
  1136 
       
  1137             {
       
  1138                 vh.set(array, i, '\u0123');
       
  1139 
       
  1140                 char o = (char) vh.getAndBitwiseXorAcquire(array, i, '\u4567');
       
  1141                 assertEquals(o, '\u0123', "getAndBitwiseXorAcquire char");
       
  1142                 char x = (char) vh.get(array, i);
       
  1143                 assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorAcquire char value");
       
  1144             }
       
  1145 
       
  1146             {
       
  1147                 vh.set(array, i, '\u0123');
       
  1148 
       
  1149                 char o = (char) vh.getAndBitwiseXorRelease(array, i, '\u4567');
       
  1150                 assertEquals(o, '\u0123', "getAndBitwiseXorRelease char");
       
  1151                 char x = (char) vh.get(array, i);
       
  1152                 assertEquals(x, (char)('\u0123' ^ '\u4567'), "getAndBitwiseXorRelease char value");
       
  1153             }
   770         }
  1154         }
   771     }
  1155     }
   772 
  1156 
   773     static void testArrayUnsupported(VarHandle vh) {
  1157     static void testArrayUnsupported(VarHandle vh) {
   774         char[] array = new char[10];
  1158         char[] array = new char[10];
   775 
  1159 
   776         int i = 0;
  1160         int i = 0;
   777 
  1161 
       
  1162 
   778     }
  1163     }
   779 
  1164 
   780     static void testArrayIndexOutOfBounds(VarHandle vh) throws Throwable {
  1165     static void testArrayIndexOutOfBounds(VarHandle vh) throws Throwable {
   781         char[] array = new char[10];
  1166         char[] array = new char[10];
   782 
  1167 
   850             checkIOOBE(() -> {
  1235             checkIOOBE(() -> {
   851                 char o = (char) vh.getAndSet(array, ci, '\u0123');
  1236                 char o = (char) vh.getAndSet(array, ci, '\u0123');
   852             });
  1237             });
   853 
  1238 
   854             checkIOOBE(() -> {
  1239             checkIOOBE(() -> {
   855                 char o = (char) vh.getAndAdd(array, ci, '\u89AB');
  1240                 char o = (char) vh.getAndSetAcquire(array, ci, '\u0123');
   856             });
  1241             });
   857 
  1242 
   858             checkIOOBE(() -> {
  1243             checkIOOBE(() -> {
   859                 char o = (char) vh.addAndGet(array, ci, '\u89AB');
  1244                 char o = (char) vh.getAndSetRelease(array, ci, '\u0123');
       
  1245             });
       
  1246 
       
  1247             checkIOOBE(() -> {
       
  1248                 char o = (char) vh.getAndAdd(array, ci, '\u0123');
       
  1249             });
       
  1250 
       
  1251             checkIOOBE(() -> {
       
  1252                 char o = (char) vh.getAndAddAcquire(array, ci, '\u0123');
       
  1253             });
       
  1254 
       
  1255             checkIOOBE(() -> {
       
  1256                 char o = (char) vh.getAndAddRelease(array, ci, '\u0123');
       
  1257             });
       
  1258 
       
  1259             checkIOOBE(() -> {
       
  1260                 char o = (char) vh.addAndGet(array, ci, '\u0123');
       
  1261             });
       
  1262 
       
  1263             checkIOOBE(() -> {
       
  1264                 char o = (char) vh.getAndBitwiseOr(array, ci, '\u0123');
       
  1265             });
       
  1266 
       
  1267             checkIOOBE(() -> {
       
  1268                 char o = (char) vh.getAndBitwiseOrAcquire(array, ci, '\u0123');
       
  1269             });
       
  1270 
       
  1271             checkIOOBE(() -> {
       
  1272                 char o = (char) vh.getAndBitwiseOrRelease(array, ci, '\u0123');
       
  1273             });
       
  1274 
       
  1275             checkIOOBE(() -> {
       
  1276                 char o = (char) vh.getAndBitwiseAnd(array, ci, '\u0123');
       
  1277             });
       
  1278 
       
  1279             checkIOOBE(() -> {
       
  1280                 char o = (char) vh.getAndBitwiseAndAcquire(array, ci, '\u0123');
       
  1281             });
       
  1282 
       
  1283             checkIOOBE(() -> {
       
  1284                 char o = (char) vh.getAndBitwiseAndRelease(array, ci, '\u0123');
       
  1285             });
       
  1286 
       
  1287             checkIOOBE(() -> {
       
  1288                 char o = (char) vh.getAndBitwiseXor(array, ci, '\u0123');
       
  1289             });
       
  1290 
       
  1291             checkIOOBE(() -> {
       
  1292                 char o = (char) vh.getAndBitwiseXorAcquire(array, ci, '\u0123');
       
  1293             });
       
  1294 
       
  1295             checkIOOBE(() -> {
       
  1296                 char o = (char) vh.getAndBitwiseXorRelease(array, ci, '\u0123');
   860             });
  1297             });
   861         }
  1298         }
   862     }
  1299     }
   863 }
  1300 }
   864 
  1301