142                                 "null array", bav, vh, h -> testArrayNPE(bas, h),

   143                                 false));

   144                         cases.add(new VarHandleSourceAccessTestCase(

   169                                 "null buffer", bav, vh, h -> testArrayNPE(bbs, h),

   170                                 false));

   171                         cases.add(new VarHandleSourceAccessTestCase(

   201     static void testArrayNPE(ByteArraySource bs, VarHandleSource vhs) {

   202         VarHandle vh = vhs.s;

   203         byte[] array = null;

   204         int ci = 1;

   205 

   206         checkNPE(() -> {

   207             float x = (float) vh.get(array, ci);

   208         });

   209 

   210         checkNPE(() -> {

   211             vh.set(array, ci, VALUE_1);

   212         });

   213 

   214         checkNPE(() -> {

   215             float x = (float) vh.getVolatile(array, ci);

   216         });

   217 

   218         checkNPE(() -> {

   219             float x = (float) vh.getAcquire(array, ci);

   220         });

   221 

   222         checkNPE(() -> {

   223             float x = (float) vh.getOpaque(array, ci);

   224         });

   225 

   226         checkNPE(() -> {

   227             vh.setVolatile(array, ci, VALUE_1);

   228         });

   229 

   230         checkNPE(() -> {

   231             vh.setRelease(array, ci, VALUE_1);

   232         });

   233 

   234         checkNPE(() -> {

   235             vh.setOpaque(array, ci, VALUE_1);

   236         });

   237 

   238         checkNPE(() -> {

   239             boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);

   240         });

   241 

   242         checkNPE(() -> {

   243             float r = (float) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);

   244         });

   245 

   246         checkNPE(() -> {

   247             float r = (float) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);

   248         });

   249 

   250         checkNPE(() -> {

   251             float r = (float) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);

   252         });

   253 

   254         checkNPE(() -> {

   255             boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);

   256         });

   257 

   258         checkNPE(() -> {

   259             boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);

   260         });

   261 

   262         checkNPE(() -> {

   263             boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);

   264         });

   265 

   266         checkNPE(() -> {

   267             boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);

   268         });

   269 

   270         checkNPE(() -> {

   271             float o = (float) vh.getAndSet(array, ci, VALUE_1);

   272         });

   273 

   274         checkNPE(() -> {

   275             float o = (float) vh.getAndSetAcquire(array, ci, VALUE_1);

   276         });

   277 

   278         checkNPE(() -> {

   279             float o = (float) vh.getAndSetRelease(array, ci, VALUE_1);

   280         });

   281 

   282 

   283     }

   284 

   285     static void testArrayNPE(ByteBufferSource bs, VarHandleSource vhs) {

   286         VarHandle vh = vhs.s;

   287         ByteBuffer array = null;

   288         int ci = 1;

   289 

   290         checkNPE(() -> {

   291             float x = (float) vh.get(array, ci);

   292         });

   293 

   294         checkNPE(() -> {

   295             vh.set(array, ci, VALUE_1);

   296         });

   297 

   298         checkNPE(() -> {

   299             float x = (float) vh.getVolatile(array, ci);

   300         });

   301 

   302         checkNPE(() -> {

   303             float x = (float) vh.getAcquire(array, ci);

   304         });

   305 

   306         checkNPE(() -> {

   307             float x = (float) vh.getOpaque(array, ci);

   308         });

   309 

   310         checkNPE(() -> {

   311             vh.setVolatile(array, ci, VALUE_1);

   312         });

   313 

   314         checkNPE(() -> {

   315             vh.setRelease(array, ci, VALUE_1);

   316         });

   317 

   318         checkNPE(() -> {

   319             vh.setOpaque(array, ci, VALUE_1);

   320         });

   321 

   322         checkNPE(() -> {

   323             boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);

   324         });

   325 

   326         checkNPE(() -> {

   327             float r = (float) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);

   328         });

   329 

   330         checkNPE(() -> {

   331             float r = (float) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);

   332         });

   333 

   334         checkNPE(() -> {

   335             float r = (float) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);

   336         });

   337 

   338         checkNPE(() -> {

   339             boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);

   340         });

   341 

   342         checkNPE(() -> {

   343             boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);

   344         });

   345 

   346         checkNPE(() -> {

   347             boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);

   348         });

   349 

   350         checkNPE(() -> {

   351             boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);

   352         });

   353 

   354         checkNPE(() -> {

   355             float o = (float) vh.getAndSet(array, ci, VALUE_1);

   356         });

   357 

   358         checkNPE(() -> {

   359             float o = (float) vh.getAndSetAcquire(array, ci, VALUE_1);

   360         });

   361 

   362         checkNPE(() -> {

   363             float o = (float) vh.getAndSetRelease(array, ci, VALUE_1);

   364         });

   365 

   366 

   367     }

   368