Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 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 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 124 | hs.get(TestAccessMode.SET).invokeExact(recv, "foo"); |
| 125 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 126 | assertEquals(x, "foo", "set String value"); |
| 127 | } |
| 128 | |
| 129 | |
| 130 | // Volatile |
| 131 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 132 | hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, "bar"); |
| 133 | String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 134 | assertEquals(x, "bar", "setVolatile String value"); |
| 135 | } |
| 136 | |
| 137 | // Lazy |
| 138 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 139 | hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, "foo"); |
| 140 | String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 141 | assertEquals(x, "foo", "setRelease String value"); |
| 142 | } |
| 143 | |
| 144 | // Opaque |
| 145 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 146 | hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, "bar"); |
| 147 | String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 148 | assertEquals(x, "bar", "setOpaque String value"); |
| 149 | } |
| 150 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 151 | hs.get(TestAccessMode.SET).invokeExact(recv, "foo"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 152 | |
| 153 | // Compare |
| 154 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 155 | boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, "foo", "bar"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 156 | assertEquals(r, true, "success compareAndSet String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 157 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 158 | assertEquals(x, "bar", "success compareAndSet String value"); |
| 159 | } |
| 160 | |
| 161 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 162 | boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, "foo", "baz"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 163 | assertEquals(r, false, "failing compareAndSet String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 164 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 165 | assertEquals(x, "bar", "failing compareAndSet String value"); |
| 166 | } |
| 167 | |
| 168 | { |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 169 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, "bar", "foo"); |
| 170 | assertEquals(r, "bar", "success compareAndExchange String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 171 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 172 | assertEquals(x, "foo", "success compareAndExchange String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 173 | } |
| 174 | |
| 175 | { |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 176 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, "bar", "baz"); |
| 177 | assertEquals(r, "foo", "failing compareAndExchange String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 178 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 179 | assertEquals(x, "foo", "failing compareAndExchange String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 183 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, "foo", "bar"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 184 | assertEquals(r, "foo", "success compareAndExchangeAcquire String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 185 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 186 | assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); |
| 187 | } |
| 188 | |
| 189 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 190 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, "foo", "baz"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 191 | assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 192 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 193 | assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); |
| 194 | } |
| 195 | |
| 196 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 197 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, "bar", "foo"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 198 | assertEquals(r, "bar", "success compareAndExchangeRelease String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 199 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 200 | assertEquals(x, "foo", "success compareAndExchangeRelease String value"); |
| 201 | } |
| 202 | |
| 203 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 204 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, "bar", "baz"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 205 | assertEquals(r, "foo", "failing compareAndExchangeRelease String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 206 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 207 | assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); |
| 208 | } |
| 209 | |
| 210 | { |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 211 | boolean success = false; |
| 212 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 213 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, "foo", "bar"); |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 214 | } |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 215 | assertEquals(success, true, "weakCompareAndSetPlain String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 216 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 217 | assertEquals(x, "bar", "weakCompareAndSetPlain String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 218 | } |
| 219 | |
| 220 | { |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 221 | boolean success = false; |
| 222 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
| 223 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, "bar", "foo"); |
| 224 | } |
| 225 | assertEquals(success, true, "weakCompareAndSetAcquire String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 226 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 227 | assertEquals(x, "foo", "weakCompareAndSetAcquire String"); |
| 228 | } |
| 229 | |
| 230 | { |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 231 | boolean success = false; |
| 232 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
| 233 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, "foo", "bar"); |
| 234 | } |
| 235 | assertEquals(success, true, "weakCompareAndSetRelease String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 236 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 237 | assertEquals(x, "bar", "weakCompareAndSetRelease String"); |
| 238 | } |
| 239 | |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 240 | { |
| 241 | boolean success = false; |
| 242 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 243 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, "bar", "foo"); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 244 | } |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 245 | assertEquals(success, true, "weakCompareAndSet String"); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 246 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 247 | assertEquals(x, "foo", "weakCompareAndSet String"); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 248 | } |
| 249 | |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 250 | // Compare set and get |
| 251 | { |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 252 | String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, "bar"); |
| 253 | assertEquals(o, "foo", "getAndSet String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 254 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 255 | assertEquals(x, "bar", "getAndSet String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 256 | } |
| 257 | |
Paul Sandoz | 82d4891 | 2016-09-01 10:16:57 -0700 | [diff] [blame] | 258 | |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | static void testInstanceFieldUnsupported(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable { |
| 262 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 263 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) { |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 264 | checkUOE(am, () -> { |
| 265 | String r = (String) hs.get(am).invokeExact(recv, "foo"); |
| 266 | }); |
| 267 | } |
Paul Sandoz | 82d4891 | 2016-09-01 10:16:57 -0700 | [diff] [blame] | 268 | |
| 269 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) { |
| 270 | checkUOE(am, () -> { |
| 271 | String r = (String) hs.get(am).invokeExact(recv, "foo"); |
| 272 | }); |
| 273 | } |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 274 | } |
| 275 | |
| 276 | |
| 277 | static void testStaticField(Handles hs) throws Throwable { |
| 278 | // Plain |
| 279 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 280 | hs.get(TestAccessMode.SET).invokeExact("foo"); |
| 281 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 282 | assertEquals(x, "foo", "set String value"); |
| 283 | } |
| 284 | |
| 285 | |
| 286 | // Volatile |
| 287 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 288 | hs.get(TestAccessMode.SET_VOLATILE).invokeExact("bar"); |
| 289 | String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 290 | assertEquals(x, "bar", "setVolatile String value"); |
| 291 | } |
| 292 | |
| 293 | // Lazy |
| 294 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 295 | hs.get(TestAccessMode.SET_RELEASE).invokeExact("foo"); |
| 296 | String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 297 | assertEquals(x, "foo", "setRelease String value"); |
| 298 | } |
| 299 | |
| 300 | // Opaque |
| 301 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 302 | hs.get(TestAccessMode.SET_OPAQUE).invokeExact("bar"); |
| 303 | String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 304 | assertEquals(x, "bar", "setOpaque String value"); |
| 305 | } |
| 306 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 307 | hs.get(TestAccessMode.SET).invokeExact("foo"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 308 | |
| 309 | // Compare |
| 310 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 311 | boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact("foo", "bar"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 312 | assertEquals(r, true, "success compareAndSet String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 313 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 314 | assertEquals(x, "bar", "success compareAndSet String value"); |
| 315 | } |
| 316 | |
| 317 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 318 | boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact("foo", "baz"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 319 | assertEquals(r, false, "failing compareAndSet String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 320 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 321 | assertEquals(x, "bar", "failing compareAndSet String value"); |
| 322 | } |
| 323 | |
| 324 | { |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 325 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact("bar", "foo"); |
| 326 | assertEquals(r, "bar", "success compareAndExchange String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 327 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 328 | assertEquals(x, "foo", "success compareAndExchange String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 329 | } |
| 330 | |
| 331 | { |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 332 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact("bar", "baz"); |
| 333 | assertEquals(r, "foo", "failing compareAndExchange String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 334 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 335 | assertEquals(x, "foo", "failing compareAndExchange String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 336 | } |
| 337 | |
| 338 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 339 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact("foo", "bar"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 340 | assertEquals(r, "foo", "success compareAndExchangeAcquire String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 341 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 342 | assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); |
| 343 | } |
| 344 | |
| 345 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 346 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact("foo", "baz"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 347 | assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 348 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 349 | assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); |
| 350 | } |
| 351 | |
| 352 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 353 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact("bar", "foo"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 354 | assertEquals(r, "bar", "success compareAndExchangeRelease String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 355 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 356 | assertEquals(x, "foo", "success compareAndExchangeRelease String value"); |
| 357 | } |
| 358 | |
| 359 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 360 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact("bar", "baz"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 361 | assertEquals(r, "foo", "failing compareAndExchangeRelease String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 362 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 363 | assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); |
| 364 | } |
| 365 | |
| 366 | { |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 367 | boolean success = false; |
| 368 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 369 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact("foo", "bar"); |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 370 | } |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 371 | assertEquals(success, true, "weakCompareAndSetPlain String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 372 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 373 | assertEquals(x, "bar", "weakCompareAndSetPlain String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 374 | } |
| 375 | |
| 376 | { |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 377 | boolean success = false; |
| 378 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
| 379 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact("bar", "foo"); |
| 380 | } |
| 381 | assertEquals(success, true, "weakCompareAndSetAcquire String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 382 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 383 | assertEquals(x, "foo", "weakCompareAndSetAcquire String"); |
| 384 | } |
| 385 | |
| 386 | { |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 387 | boolean success = false; |
| 388 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
| 389 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact("foo", "bar"); |
| 390 | } |
| 391 | assertEquals(success, true, "weakCompareAndSetRelease String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 392 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 393 | assertEquals(x, "bar", "weakCompareAndSetRelease String"); |
| 394 | } |
| 395 | |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 396 | { |
| 397 | boolean success = false; |
| 398 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 399 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact("bar", "foo"); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 400 | } |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 401 | assertEquals(success, true, "weakCompareAndSet String"); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 402 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 403 | assertEquals(x, "foo", "weakCompareAndSet String"); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 404 | } |
| 405 | |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 406 | // Compare set and get |
| 407 | { |
Paul Sandoz | 82d4891 | 2016-09-01 10:16:57 -0700 | [diff] [blame] | 408 | hs.get(TestAccessMode.SET).invokeExact("foo"); |
| 409 | |
| 410 | String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact("bar"); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 411 | assertEquals(o, "foo", "getAndSet String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 412 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 413 | assertEquals(x, "bar", "getAndSet String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 414 | } |
| 415 | |
Paul Sandoz | 82d4891 | 2016-09-01 10:16:57 -0700 | [diff] [blame] | 416 | // Compare set and get |
| 417 | { |
| 418 | hs.get(TestAccessMode.SET).invokeExact("foo"); |
| 419 | |
| 420 | String o = (String) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact("bar"); |
| 421 | assertEquals(o, "foo", "getAndSetAcquire String"); |
| 422 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
| 423 | assertEquals(x, "bar", "getAndSetAcquire String value"); |
| 424 | } |
| 425 | |
| 426 | // Compare set and get |
| 427 | { |
| 428 | hs.get(TestAccessMode.SET).invokeExact("foo"); |
| 429 | |
| 430 | String o = (String) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact("bar"); |
| 431 | assertEquals(o, "foo", "getAndSetRelease String"); |
| 432 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(); |
| 433 | assertEquals(x, "bar", "getAndSetRelease String value"); |
| 434 | } |
| 435 | |
| 436 | |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 437 | } |
| 438 | |
| 439 | static void testStaticFieldUnsupported(Handles hs) throws Throwable { |
| 440 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 441 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) { |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 442 | checkUOE(am, () -> { |
| 443 | String r = (String) hs.get(am).invokeExact("foo"); |
| 444 | }); |
| 445 | } |
Paul Sandoz | 82d4891 | 2016-09-01 10:16:57 -0700 | [diff] [blame] | 446 | |
| 447 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) { |
| 448 | checkUOE(am, () -> { |
| 449 | String r = (String) hs.get(am).invokeExact("foo"); |
| 450 | }); |
| 451 | } |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 452 | } |
| 453 | |
| 454 | |
| 455 | static void testArray(Handles hs) throws Throwable { |
| 456 | String[] array = new String[10]; |
| 457 | |
| 458 | for (int i = 0; i < array.length; i++) { |
| 459 | // Plain |
| 460 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 461 | hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); |
| 462 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 463 | assertEquals(x, "foo", "get String value"); |
| 464 | } |
| 465 | |
| 466 | |
| 467 | // Volatile |
| 468 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 469 | hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, "bar"); |
| 470 | String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 471 | assertEquals(x, "bar", "setVolatile String value"); |
| 472 | } |
| 473 | |
| 474 | // Lazy |
| 475 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 476 | hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, "foo"); |
| 477 | String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 478 | assertEquals(x, "foo", "setRelease String value"); |
| 479 | } |
| 480 | |
| 481 | // Opaque |
| 482 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 483 | hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, "bar"); |
| 484 | String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 485 | assertEquals(x, "bar", "setOpaque String value"); |
| 486 | } |
| 487 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 488 | hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 489 | |
| 490 | // Compare |
| 491 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 492 | boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, "foo", "bar"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 493 | assertEquals(r, true, "success compareAndSet String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 494 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 495 | assertEquals(x, "bar", "success compareAndSet String value"); |
| 496 | } |
| 497 | |
| 498 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 499 | boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, "foo", "baz"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 500 | assertEquals(r, false, "failing compareAndSet String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 501 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 502 | assertEquals(x, "bar", "failing compareAndSet String value"); |
| 503 | } |
| 504 | |
| 505 | { |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 506 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, "bar", "foo"); |
| 507 | assertEquals(r, "bar", "success compareAndExchange String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 508 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 509 | assertEquals(x, "foo", "success compareAndExchange String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 510 | } |
| 511 | |
| 512 | { |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 513 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, "bar", "baz"); |
| 514 | assertEquals(r, "foo", "failing compareAndExchange String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 515 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 3f0273a | 2016-06-23 13:46:48 +0200 | [diff] [blame] | 516 | assertEquals(x, "foo", "failing compareAndExchange String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 517 | } |
| 518 | |
| 519 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 520 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, "foo", "bar"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 521 | assertEquals(r, "foo", "success compareAndExchangeAcquire String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 522 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 523 | assertEquals(x, "bar", "success compareAndExchangeAcquire String value"); |
| 524 | } |
| 525 | |
| 526 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 527 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, "foo", "baz"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 528 | assertEquals(r, "bar", "failing compareAndExchangeAcquire String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 529 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 530 | assertEquals(x, "bar", "failing compareAndExchangeAcquire String value"); |
| 531 | } |
| 532 | |
| 533 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 534 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, "bar", "foo"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 535 | assertEquals(r, "bar", "success compareAndExchangeRelease String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 536 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 537 | assertEquals(x, "foo", "success compareAndExchangeRelease String value"); |
| 538 | } |
| 539 | |
| 540 | { |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 541 | String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, "bar", "baz"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 542 | assertEquals(r, "foo", "failing compareAndExchangeRelease String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 543 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 544 | assertEquals(x, "foo", "failing compareAndExchangeRelease String value"); |
| 545 | } |
| 546 | |
| 547 | { |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 548 | boolean success = false; |
| 549 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 550 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, "foo", "bar"); |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 551 | } |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 552 | assertEquals(success, true, "weakCompareAndSetPlain String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 553 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 554 | assertEquals(x, "bar", "weakCompareAndSetPlain String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 555 | } |
| 556 | |
| 557 | { |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 558 | boolean success = false; |
| 559 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
| 560 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, "bar", "foo"); |
| 561 | } |
| 562 | assertEquals(success, true, "weakCompareAndSetAcquire String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 563 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 564 | assertEquals(x, "foo", "weakCompareAndSetAcquire String"); |
| 565 | } |
| 566 | |
| 567 | { |
Aleksey Shipilev | 4f53885 | 2016-05-04 17:17:28 +0300 | [diff] [blame] | 568 | boolean success = false; |
| 569 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
| 570 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, "foo", "bar"); |
| 571 | } |
| 572 | assertEquals(success, true, "weakCompareAndSetRelease String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 573 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 574 | assertEquals(x, "bar", "weakCompareAndSetRelease String"); |
| 575 | } |
| 576 | |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 577 | { |
| 578 | boolean success = false; |
| 579 | for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 580 | success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, "bar", "foo"); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 581 | } |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 582 | assertEquals(success, true, "weakCompareAndSet String"); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 583 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Paul Sandoz | 3bd5ebe | 2016-09-01 13:56:13 -0700 | [diff] [blame] | 584 | assertEquals(x, "foo", "weakCompareAndSet String"); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 585 | } |
| 586 | |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 587 | // Compare set and get |
| 588 | { |
Paul Sandoz | 82d4891 | 2016-09-01 10:16:57 -0700 | [diff] [blame] | 589 | hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); |
| 590 | |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 591 | String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, "bar"); |
| 592 | assertEquals(o, "foo", "getAndSet String"); |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 593 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
Aleksey Shipilev | 33bb922 | 2016-05-17 22:28:00 +0300 | [diff] [blame] | 594 | assertEquals(x, "bar", "getAndSet String value"); |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 595 | } |
| 596 | |
Paul Sandoz | 82d4891 | 2016-09-01 10:16:57 -0700 | [diff] [blame] | 597 | { |
| 598 | hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); |
| 599 | |
| 600 | String o = (String) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, "bar"); |
| 601 | assertEquals(o, "foo", "getAndSetAcquire String"); |
| 602 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
| 603 | assertEquals(x, "bar", "getAndSetAcquire String value"); |
| 604 | } |
| 605 | |
| 606 | { |
| 607 | hs.get(TestAccessMode.SET).invokeExact(array, i, "foo"); |
| 608 | |
| 609 | String o = (String) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, "bar"); |
| 610 | assertEquals(o, "foo", "getAndSetRelease String"); |
| 611 | String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i); |
| 612 | assertEquals(x, "bar", "getAndSetRelease String value"); |
| 613 | } |
| 614 | |
| 615 | |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 616 | } |
| 617 | } |
| 618 | |
| 619 | static void testArrayUnsupported(Handles hs) throws Throwable { |
| 620 | String[] array = new String[10]; |
| 621 | |
| 622 | final int i = 0; |
| 623 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 624 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) { |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 625 | checkUOE(am, () -> { |
| 626 | String o = (String) hs.get(am).invokeExact(array, i, "foo"); |
| 627 | }); |
| 628 | } |
Paul Sandoz | 82d4891 | 2016-09-01 10:16:57 -0700 | [diff] [blame] | 629 | |
| 630 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) { |
| 631 | checkUOE(am, () -> { |
| 632 | String o = (String) hs.get(am).invokeExact(array, i, "foo"); |
| 633 | }); |
| 634 | } |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 635 | } |
| 636 | |
| 637 | static void testArrayIndexOutOfBounds(Handles hs) throws Throwable { |
| 638 | String[] array = new String[10]; |
| 639 | |
| 640 | for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) { |
| 641 | final int ci = i; |
| 642 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 643 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) { |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 644 | checkIOOBE(am, () -> { |
| 645 | String x = (String) hs.get(am).invokeExact(array, ci); |
| 646 | }); |
| 647 | } |
| 648 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 649 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) { |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 650 | checkIOOBE(am, () -> { |
| 651 | hs.get(am).invokeExact(array, ci, "foo"); |
| 652 | }); |
| 653 | } |
| 654 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 655 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) { |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 656 | checkIOOBE(am, () -> { |
| 657 | boolean r = (boolean) hs.get(am).invokeExact(array, ci, "foo", "bar"); |
| 658 | }); |
| 659 | } |
| 660 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 661 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) { |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 662 | checkIOOBE(am, () -> { |
| 663 | String r = (String) hs.get(am).invokeExact(array, ci, "bar", "foo"); |
| 664 | }); |
| 665 | } |
| 666 | |
Paul Sandoz | a7aff44 | 2016-04-13 15:05:48 +0200 | [diff] [blame] | 667 | for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) { |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 668 | checkIOOBE(am, () -> { |
| 669 | String o = (String) hs.get(am).invokeExact(array, ci, "foo"); |
| 670 | }); |
| 671 | } |
| 672 | |
Paul Sandoz | 82d4891 | 2016-09-01 10:16:57 -0700 | [diff] [blame] | 673 | |
Paul Sandoz | 9fb30a3 | 2016-03-24 11:21:21 +0100 | [diff] [blame] | 674 | } |
| 675 | } |
| 676 | } |
| 677 | |