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 { |
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 |