[cvs] / jsr166 / src / test / tck / Atomic8Test.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/Atomic8Test.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1, Sun Sep 8 23:00:36 2013 UTC revision 1.2, Mon Sep 9 06:23:16 2013 UTC
# Line 37  Line 37 
37      volatile int anIntField;      volatile int anIntField;
38      volatile Integer anIntegerField;      volatile Integer anIntegerField;
39    
40        AtomicLongFieldUpdater aLongFieldUpdater() {
41            return AtomicLongFieldUpdater.newUpdater
42                (Atomic8Test.class, "aLongField");
43        }
44    
45        AtomicIntegerFieldUpdater anIntFieldUpdater() {
46            return AtomicIntegerFieldUpdater.newUpdater
47                (Atomic8Test.class, "anIntField");
48        }
49    
50        AtomicReferenceFieldUpdater<Atomic8Test,Integer> anIntegerFieldUpdater() {
51            return AtomicReferenceFieldUpdater.newUpdater
52                (Atomic8Test.class, Integer.class, "anIntegerField");
53        }
54    
55      /**      /**
56       * AtomicLong getAndUpdate returns previous value and updates       * AtomicLong getAndUpdate returns previous value and updates
57       * result of supplied function       * result of supplied function
# Line 77  Line 92 
92          AtomicLong a = new AtomicLong(1L);          AtomicLong a = new AtomicLong(1L);
93          assertEquals(7L, a.accumulateAndGet(6L, Long::sum));          assertEquals(7L, a.accumulateAndGet(6L, Long::sum));
94          assertEquals(10L, a.accumulateAndGet(3L, Long::sum));          assertEquals(10L, a.accumulateAndGet(3L, Long::sum));
95            assertEquals(10L, a.get());
96      }      }
97    
98      /**      /**
# Line 98  Line 114 
114          AtomicInteger a = new AtomicInteger(1);          AtomicInteger a = new AtomicInteger(1);
115          assertEquals(18, a.updateAndGet(Atomic8Test::addInt17));          assertEquals(18, a.updateAndGet(Atomic8Test::addInt17));
116          assertEquals(35, a.updateAndGet(Atomic8Test::addInt17));          assertEquals(35, a.updateAndGet(Atomic8Test::addInt17));
117            assertEquals(35, a.get());
118      }      }
119    
120      /**      /**
# Line 119  Line 136 
136          AtomicInteger a = new AtomicInteger(1);          AtomicInteger a = new AtomicInteger(1);
137          assertEquals(7, a.accumulateAndGet(6, Integer::sum));          assertEquals(7, a.accumulateAndGet(6, Integer::sum));
138          assertEquals(10, a.accumulateAndGet(3, Integer::sum));          assertEquals(10, a.accumulateAndGet(3, Integer::sum));
139            assertEquals(10, a.get());
140      }      }
141    
142      /**      /**
# Line 140  Line 158 
158          AtomicReference<Integer> a = new AtomicReference<Integer>(one);          AtomicReference<Integer> a = new AtomicReference<Integer>(one);
159          assertEquals(new Integer(18), a.updateAndGet(Atomic8Test::addInteger17));          assertEquals(new Integer(18), a.updateAndGet(Atomic8Test::addInteger17));
160          assertEquals(new Integer(35), a.updateAndGet(Atomic8Test::addInteger17));          assertEquals(new Integer(35), a.updateAndGet(Atomic8Test::addInteger17));
161            assertEquals(new Integer(35), a.get());
162      }      }
163    
164      /**      /**
# Line 161  Line 180 
180          AtomicReference<Integer> a = new AtomicReference<Integer>(one);          AtomicReference<Integer> a = new AtomicReference<Integer>(one);
181          assertEquals(new Integer(7), a.accumulateAndGet(6, Atomic8Test::sumInteger));          assertEquals(new Integer(7), a.accumulateAndGet(6, Atomic8Test::sumInteger));
182          assertEquals(new Integer(10), a.accumulateAndGet(3, Atomic8Test::sumInteger));          assertEquals(new Integer(10), a.accumulateAndGet(3, Atomic8Test::sumInteger));
183            assertEquals(new Integer(10), a.get());
184      }      }
185    
186    
# Line 185  Line 205 
205          a.set(0, 1);          a.set(0, 1);
206          assertEquals(18L, a.updateAndGet(0, Atomic8Test::addLong17));          assertEquals(18L, a.updateAndGet(0, Atomic8Test::addLong17));
207          assertEquals(35L, a.updateAndGet(0, Atomic8Test::addLong17));          assertEquals(35L, a.updateAndGet(0, Atomic8Test::addLong17));
208            assertEquals(35L, a.get(0));
209      }      }
210    
211      /**      /**
# Line 208  Line 229 
229          a.set(0, 1);          a.set(0, 1);
230          assertEquals(7L, a.accumulateAndGet(0, 6L, Long::sum));          assertEquals(7L, a.accumulateAndGet(0, 6L, Long::sum));
231          assertEquals(10L, a.accumulateAndGet(0, 3L, Long::sum));          assertEquals(10L, a.accumulateAndGet(0, 3L, Long::sum));
232            assertEquals(10L, a.get(0));
233      }      }
234    
235      /**      /**
# Line 231  Line 253 
253          a.set(0, 1);          a.set(0, 1);
254          assertEquals(18, a.updateAndGet(0, Atomic8Test::addInt17));          assertEquals(18, a.updateAndGet(0, Atomic8Test::addInt17));
255          assertEquals(35, a.updateAndGet(0, Atomic8Test::addInt17));          assertEquals(35, a.updateAndGet(0, Atomic8Test::addInt17));
256            assertEquals(35, a.get(0));
257      }      }
258    
259      /**      /**
# Line 307  Line 330 
330       * result of supplied function       * result of supplied function
331       */       */
332      public void testLongFieldUpdaterGetAndUpdate() {      public void testLongFieldUpdaterGetAndUpdate() {
333          AtomicLongFieldUpdater a = AtomicLongFieldUpdater.          AtomicLongFieldUpdater a = aLongFieldUpdater();
             newUpdater(Atomic8Test.class, "aLongField");  
334          a.set(this, 1);          a.set(this, 1);
335          assertEquals(1L, a.getAndUpdate(this, Atomic8Test::addLong17));          assertEquals(1L, a.getAndUpdate(this, Atomic8Test::addLong17));
336          assertEquals(18L, a.getAndUpdate(this, Atomic8Test::addLong17));          assertEquals(18L, a.getAndUpdate(this, Atomic8Test::addLong17));
337          assertEquals(35L, a.get(this));          assertEquals(35L, a.get(this));
338            assertEquals(35L, aLongField);
339      }      }
340    
341      /**      /**
# Line 320  Line 343 
343       * returns result.       * returns result.
344       */       */
345      public void testLongFieldUpdaterUpdateAndGet() {      public void testLongFieldUpdaterUpdateAndGet() {
346          AtomicLongFieldUpdater a = AtomicLongFieldUpdater.          AtomicLongFieldUpdater a = aLongFieldUpdater();
             newUpdater(Atomic8Test.class, "aLongField");  
347          a.set(this, 1);          a.set(this, 1);
348          assertEquals(18L, a.updateAndGet(this, Atomic8Test::addLong17));          assertEquals(18L, a.updateAndGet(this, Atomic8Test::addLong17));
349          assertEquals(35L, a.updateAndGet(this, Atomic8Test::addLong17));          assertEquals(35L, a.updateAndGet(this, Atomic8Test::addLong17));
350            assertEquals(35L, a.get(this));
351            assertEquals(35L, aLongField);
352      }      }
353    
354      /**      /**
# Line 332  Line 356 
356       * and updates with supplied function.       * and updates with supplied function.
357       */       */
358      public void testLongFieldUpdaterGetAndAccumulate() {      public void testLongFieldUpdaterGetAndAccumulate() {
359          AtomicLongFieldUpdater a = AtomicLongFieldUpdater.          AtomicLongFieldUpdater a = aLongFieldUpdater();
             newUpdater(Atomic8Test.class, "aLongField");  
360          a.set(this, 1);          a.set(this, 1);
361          assertEquals(1L, a.getAndAccumulate(this, 2L, Long::sum));          assertEquals(1L, a.getAndAccumulate(this, 2L, Long::sum));
362          assertEquals(3L, a.getAndAccumulate(this, 3L, Long::sum));          assertEquals(3L, a.getAndAccumulate(this, 3L, Long::sum));
363          assertEquals(6L, a.get(this));          assertEquals(6L, a.get(this));
364            assertEquals(6L, aLongField);
365      }      }
366    
367      /**      /**
# Line 345  Line 369 
369       * function and returns result.       * function and returns result.
370       */       */
371      public void testLongFieldUpdaterAccumulateAndGet() {      public void testLongFieldUpdaterAccumulateAndGet() {
372          AtomicLongFieldUpdater a = AtomicLongFieldUpdater.          AtomicLongFieldUpdater a = aLongFieldUpdater();
             newUpdater(Atomic8Test.class, "aLongField");  
373          a.set(this, 1);          a.set(this, 1);
374          assertEquals(7L, a.accumulateAndGet(this, 6L, Long::sum));          assertEquals(7L, a.accumulateAndGet(this, 6L, Long::sum));
375          assertEquals(10L, a.accumulateAndGet(this, 3L, Long::sum));          assertEquals(10L, a.accumulateAndGet(this, 3L, Long::sum));
376            assertEquals(10L, a.get(this));
377            assertEquals(10L, aLongField);
378      }      }
379    
380      /**      /**
# Line 357  Line 382 
382       * result of supplied function       * result of supplied function
383       */       */
384      public void testIntegerFieldUpdaterGetAndUpdate() {      public void testIntegerFieldUpdaterGetAndUpdate() {
385          AtomicIntegerFieldUpdater a = AtomicIntegerFieldUpdater.          AtomicIntegerFieldUpdater a = anIntFieldUpdater();
             newUpdater(Atomic8Test.class, "anIntField");  
386          a.set(this, 1);          a.set(this, 1);
387          assertEquals(1, a.getAndUpdate(this, Atomic8Test::addInt17));          assertEquals(1, a.getAndUpdate(this, Atomic8Test::addInt17));
388          assertEquals(18, a.getAndUpdate(this, Atomic8Test::addInt17));          assertEquals(18, a.getAndUpdate(this, Atomic8Test::addInt17));
389          assertEquals(35, a.get(this));          assertEquals(35, a.get(this));
390            assertEquals(35, anIntField);
391      }      }
392    
393      /**      /**
# Line 370  Line 395 
395       * returns result.       * returns result.
396       */       */
397      public void testIntegerFieldUpdaterUpdateAndGet() {      public void testIntegerFieldUpdaterUpdateAndGet() {
398          AtomicIntegerFieldUpdater a = AtomicIntegerFieldUpdater.          AtomicIntegerFieldUpdater a = anIntFieldUpdater();
             newUpdater(Atomic8Test.class, "anIntField");  
399          a.set(this, 1);          a.set(this, 1);
400          assertEquals(18, a.updateAndGet(this, Atomic8Test::addInt17));          assertEquals(18, a.updateAndGet(this, Atomic8Test::addInt17));
401          assertEquals(35, a.updateAndGet(this, Atomic8Test::addInt17));          assertEquals(35, a.updateAndGet(this, Atomic8Test::addInt17));
402            assertEquals(35, a.get(this));
403            assertEquals(35, anIntField);
404      }      }
405    
406      /**      /**
# Line 382  Line 408 
408       * and updates with supplied function.       * and updates with supplied function.
409       */       */
410      public void testIntegerFieldUpdaterGetAndAccumulate() {      public void testIntegerFieldUpdaterGetAndAccumulate() {
411          AtomicIntegerFieldUpdater a = AtomicIntegerFieldUpdater.          AtomicIntegerFieldUpdater a = anIntFieldUpdater();
             newUpdater(Atomic8Test.class, "anIntField");  
412          a.set(this, 1);          a.set(this, 1);
413          assertEquals(1, a.getAndAccumulate(this, 2, Integer::sum));          assertEquals(1, a.getAndAccumulate(this, 2, Integer::sum));
414          assertEquals(3, a.getAndAccumulate(this, 3, Integer::sum));          assertEquals(3, a.getAndAccumulate(this, 3, Integer::sum));
415          assertEquals(6, a.get(this));          assertEquals(6, a.get(this));
416            assertEquals(6, anIntField);
417      }      }
418    
419      /**      /**
# Line 395  Line 421 
421       * function and returns result.       * function and returns result.
422       */       */
423      public void testIntegerFieldUpdaterAccumulateAndGet() {      public void testIntegerFieldUpdaterAccumulateAndGet() {
424          AtomicIntegerFieldUpdater a = AtomicIntegerFieldUpdater.          AtomicIntegerFieldUpdater a = anIntFieldUpdater();
             newUpdater(Atomic8Test.class, "anIntField");  
425          a.set(this, 1);          a.set(this, 1);
426          assertEquals(7, a.accumulateAndGet(this, 6, Integer::sum));          assertEquals(7, a.accumulateAndGet(this, 6, Integer::sum));
427          assertEquals(10, a.accumulateAndGet(this, 3, Integer::sum));          assertEquals(10, a.accumulateAndGet(this, 3, Integer::sum));
428            assertEquals(10, a.get(this));
429            assertEquals(10, anIntField);
430      }      }
431    
432    
# Line 408  Line 435 
435       * and updates result of supplied function       * and updates result of supplied function
436       */       */
437      public void testReferenceFieldUpdaterGetAndUpdate() {      public void testReferenceFieldUpdaterGetAndUpdate() {
438          AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = AtomicReferenceFieldUpdater.          AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
             newUpdater(Atomic8Test.class, Integer.class, "anIntegerField");  
439          a.set(this, one);          a.set(this, one);
440          assertEquals(new Integer(1), a.getAndUpdate(this, Atomic8Test::addInteger17));          assertEquals(new Integer(1), a.getAndUpdate(this, Atomic8Test::addInteger17));
441          assertEquals(new Integer(18), a.getAndUpdate(this, Atomic8Test::addInteger17));          assertEquals(new Integer(18), a.getAndUpdate(this, Atomic8Test::addInteger17));
442          assertEquals(new Integer(35), a.get(this));          assertEquals(new Integer(35), a.get(this));
443            assertEquals(new Integer(35), anIntegerField);
444      }      }
445    
446      /**      /**
# Line 421  Line 448 
448       * function and returns result.       * function and returns result.
449       */       */
450      public void testReferenceFieldUpdaterUpdateAndGet() {      public void testReferenceFieldUpdaterUpdateAndGet() {
451          AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = AtomicReferenceFieldUpdater.          AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
             newUpdater(Atomic8Test.class, Integer.class, "anIntegerField");  
452          a.set(this, one);          a.set(this, one);
453          assertEquals(new Integer(18), a.updateAndGet(this, Atomic8Test::addInteger17));          assertEquals(new Integer(18), a.updateAndGet(this, Atomic8Test::addInteger17));
454          assertEquals(new Integer(35), a.updateAndGet(this, Atomic8Test::addInteger17));          assertEquals(new Integer(35), a.updateAndGet(this, Atomic8Test::addInteger17));
455            assertEquals(new Integer(35), a.get(this));
456            assertEquals(new Integer(35), anIntegerField);
457      }      }
458    
459      /**      /**
# Line 433  Line 461 
461       * with supplied function.       * with supplied function.
462       */       */
463      public void testReferenceFieldUpdaterGetAndAccumulate() {      public void testReferenceFieldUpdaterGetAndAccumulate() {
464          AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = AtomicReferenceFieldUpdater.          AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
             newUpdater(Atomic8Test.class, Integer.class, "anIntegerField");  
465          a.set(this, one);          a.set(this, one);
466          assertEquals(new Integer(1), a.getAndAccumulate(this, 2, Atomic8Test::sumInteger));          assertEquals(new Integer(1), a.getAndAccumulate(this, 2, Atomic8Test::sumInteger));
467          assertEquals(new Integer(3), a.getAndAccumulate(this, 3, Atomic8Test::sumInteger));          assertEquals(new Integer(3), a.getAndAccumulate(this, 3, Atomic8Test::sumInteger));
468          assertEquals(new Integer(6), a.get(this));          assertEquals(new Integer(6), a.get(this));
469            assertEquals(new Integer(6), anIntegerField);
470      }      }
471    
472      /**      /**
# Line 446  Line 474 
474       * supplied function and returns result.       * supplied function and returns result.
475       */       */
476      public void testReferenceFieldUpdaterAccumulateAndGet() {      public void testReferenceFieldUpdaterAccumulateAndGet() {
477          AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = AtomicReferenceFieldUpdater.          AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
             newUpdater(Atomic8Test.class, Integer.class, "anIntegerField");  
478          a.set(this, one);          a.set(this, one);
479          assertEquals(new Integer(7), a.accumulateAndGet(this, 6, Atomic8Test::sumInteger));          assertEquals(new Integer(7), a.accumulateAndGet(this, 6, Atomic8Test::sumInteger));
480          assertEquals(new Integer(10), a.accumulateAndGet(this, 3, Atomic8Test::sumInteger));          assertEquals(new Integer(10), a.accumulateAndGet(this, 3, Atomic8Test::sumInteger));
481            assertEquals(new Integer(10), a.get(this));
482            assertEquals(new Integer(10), anIntegerField);
483      }      }
484    
485      /**      /**
486       * All Atomic getAndUpdate methods throw npe on null function argument       * All Atomic getAndUpdate methods throw NullPointerException on
487         * null function argument
488       */       */
489      public void testGetAndUpdateNPE() {      public void testGetAndUpdateNPE() {
490          try { new AtomicLong().getAndUpdate(null); shouldThrow();          Runnable[] throwingActions = {
491          } catch(NullPointerException ok) {}              () -> new AtomicLong().getAndUpdate(null),
492          try { new AtomicInteger().getAndUpdate(null); shouldThrow();              () -> new AtomicInteger().getAndUpdate(null),
493          } catch(NullPointerException ok) {}              () -> new AtomicReference().getAndUpdate(null),
494          try { new AtomicReference().getAndUpdate(null); shouldThrow();              () -> new AtomicLongArray(1).getAndUpdate(0, null),
495          } catch(NullPointerException ok) {}              () -> new AtomicIntegerArray(1).getAndUpdate(0, null),
496          try { new AtomicLongArray(1).getAndUpdate(0, null); shouldThrow();              () -> new AtomicReferenceArray(1).getAndUpdate(0, null),
497          } catch(NullPointerException ok) {}              () -> aLongFieldUpdater().getAndUpdate(this, null),
498          try { new AtomicIntegerArray(1).getAndUpdate(0, null); shouldThrow();              () -> anIntFieldUpdater().getAndUpdate(this, null),
499          } catch(NullPointerException ok) {}              () -> anIntegerFieldUpdater().getAndUpdate(this, null),
500          try { new AtomicReferenceArray(1).getAndUpdate(0, null); shouldThrow();              ////() -> aLongFieldUpdater().getAndUpdate(null, Atomic8Test::addLong17),
501          } catch(NullPointerException ok) {}              ////() -> anIntFieldUpdater().getAndUpdate(null, Atomic8Test::addInt17),
502          try { AtomicLongFieldUpdater.              ////() -> anIntegerFieldUpdater().getAndUpdate(null, Atomic8Test::addInteger17),
503                  newUpdater(Atomic8Test.class, "aLongField").          };
504                  getAndUpdate(this, null);          assertThrows(NullPointerException.class, throwingActions);
             shouldThrow();  
         } catch(NullPointerException ok) {}  
         try { AtomicIntegerFieldUpdater.  
                 newUpdater(Atomic8Test.class, "anIntField").  
                 getAndUpdate(this, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
         try {  AtomicReferenceFieldUpdater.  
                 newUpdater(Atomic8Test.class, Integer.class, "anIntegerField").  
                 getAndUpdate(this, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
     }  
   
     /**  
      * All Atomic updateAndGet methods throw npe on null function argument  
      */  
     public void testUpdateGetAndNPE() {  
         try { new AtomicLong().updateAndGet(null); shouldThrow();  
         } catch(NullPointerException ok) {}  
         try { new AtomicInteger().updateAndGet(null); shouldThrow();  
         } catch(NullPointerException ok) {}  
         try { new AtomicReference().updateAndGet(null); shouldThrow();  
         } catch(NullPointerException ok) {}  
         try { new AtomicLongArray(1).updateAndGet(0, null); shouldThrow();  
         } catch(NullPointerException ok) {}  
         try { new AtomicIntegerArray(1).updateAndGet(0, null); shouldThrow();  
         } catch(NullPointerException ok) {}  
         try { new AtomicReferenceArray(1).updateAndGet(0, null); shouldThrow();  
         } catch(NullPointerException ok) {}  
         try { AtomicLongFieldUpdater.  
                 newUpdater(Atomic8Test.class, "aLongField").  
                 updateAndGet(this, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
         try { AtomicIntegerFieldUpdater.  
                 newUpdater(Atomic8Test.class, "anIntField").  
                 updateAndGet(this, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
         try {  AtomicReferenceFieldUpdater.  
                 newUpdater(Atomic8Test.class, Integer.class, "anIntegerField").  
                 updateAndGet(this, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
505      }      }
506    
507      /**      /**
508       * All Atomic getAndAccumulate methods throw npe on null function argument       * All Atomic updateAndGet methods throw NullPointerException on null function argument
509         */
510        public void testUpdateAndGetNPE() {
511            Runnable[] throwingActions = {
512                () -> new AtomicLong().updateAndGet(null),
513                () -> new AtomicInteger().updateAndGet(null),
514                () -> new AtomicReference().updateAndGet(null),
515                () -> new AtomicLongArray(1).updateAndGet(0, null),
516                () -> new AtomicIntegerArray(1).updateAndGet(0, null),
517                () -> new AtomicReferenceArray(1).updateAndGet(0, null),
518                () -> aLongFieldUpdater().updateAndGet(this, null),
519                () -> anIntFieldUpdater().updateAndGet(this, null),
520                () -> anIntegerFieldUpdater().updateAndGet(this, null),
521            };
522            assertThrows(NullPointerException.class, throwingActions);
523        }
524    
525        /**
526         * All Atomic getAndAccumulate methods throw NullPointerException
527         * on null function argument
528       */       */
529      public void testGetAndAccumulateNPE() {      public void testGetAndAccumulateNPE() {
530          try { new AtomicLong().getAndAccumulate(1L, null); shouldThrow();          Runnable[] throwingActions = {
531          } catch(NullPointerException ok) {}              () -> new AtomicLong().getAndAccumulate(1L, null),
532          try { new AtomicInteger().getAndAccumulate(1, null); shouldThrow();              () -> new AtomicInteger().getAndAccumulate(1, null),
533          } catch(NullPointerException ok) {}              () -> new AtomicReference().getAndAccumulate(one, null),
534          try { new AtomicReference().getAndAccumulate(one, null); shouldThrow();              () -> new AtomicLongArray(1).getAndAccumulate(0, 1L, null),
535          } catch(NullPointerException ok) {}              () -> new AtomicIntegerArray(1).getAndAccumulate(0, 1, null),
536          try { new AtomicLongArray(1).getAndAccumulate(0, 1L, null); shouldThrow();              () -> new AtomicReferenceArray(1).getAndAccumulate(0, one, null),
537          } catch(NullPointerException ok) {}              () -> aLongFieldUpdater().getAndAccumulate(this, 1L, null),
538          try { new AtomicIntegerArray(1).getAndAccumulate(0, 1, null); shouldThrow();              () -> anIntFieldUpdater().getAndAccumulate(this, 1, null),
539          } catch(NullPointerException ok) {}              () -> anIntegerFieldUpdater().getAndAccumulate(this, one, null),
540          try { new AtomicReferenceArray(1).getAndAccumulate(0, one, null); shouldThrow();          };
541          } catch(NullPointerException ok) {}          assertThrows(NullPointerException.class, throwingActions);
         try { AtomicLongFieldUpdater.  
                 newUpdater(Atomic8Test.class, "aLongField").  
                 getAndAccumulate(this, 1L, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
         try { AtomicIntegerFieldUpdater.  
                 newUpdater(Atomic8Test.class, "anIntField").  
                 getAndAccumulate(this, 1, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
         try {  AtomicReferenceFieldUpdater.  
                 newUpdater(Atomic8Test.class, Integer.class, "anIntegerField").  
                 getAndAccumulate(this, one, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
542      }      }
543    
544      /**      /**
545       * All Atomic accumulateAndGet methods throw npe on null function argument       * All Atomic accumulateAndGet methods throw NullPointerException
546         * on null function argument
547       */       */
548      public void testAccumulateAndGetNPE() {      public void testAccumulateAndGetNPE() {
549          try { new AtomicLong().accumulateAndGet(1L, null); shouldThrow();          Runnable[] throwingActions = {
550          } catch(NullPointerException ok) {}              () -> new AtomicLong().accumulateAndGet(1L, null),
551          try { new AtomicInteger().accumulateAndGet(1, null); shouldThrow();              () -> new AtomicInteger().accumulateAndGet(1, null),
552          } catch(NullPointerException ok) {}              () -> new AtomicReference().accumulateAndGet(one, null),
553          try { new AtomicReference().accumulateAndGet(one, null); shouldThrow();              () -> new AtomicLongArray(1).accumulateAndGet(0, 1L, null),
554          } catch(NullPointerException ok) {}              () -> new AtomicIntegerArray(1).accumulateAndGet(0, 1, null),
555          try { new AtomicLongArray(1).accumulateAndGet(0, 1L, null); shouldThrow();              () -> new AtomicReferenceArray(1).accumulateAndGet(0, one, null),
556          } catch(NullPointerException ok) {}              () -> aLongFieldUpdater().accumulateAndGet(this, 1L, null),
557          try { new AtomicIntegerArray(1).accumulateAndGet(0, 1, null); shouldThrow();              () -> anIntFieldUpdater().accumulateAndGet(this, 1, null),
558          } catch(NullPointerException ok) {}              () -> anIntegerFieldUpdater().accumulateAndGet(this, one, null),
559          try { new AtomicReferenceArray(1).accumulateAndGet(0, one, null); shouldThrow();          };
560          } catch(NullPointerException ok) {}          assertThrows(NullPointerException.class, throwingActions);
         try { AtomicLongFieldUpdater.  
                 newUpdater(Atomic8Test.class, "aLongField").  
                 accumulateAndGet(this, 1L, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
         try { AtomicIntegerFieldUpdater.  
                 newUpdater(Atomic8Test.class, "anIntField").  
                 accumulateAndGet(this, 1, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
         try {  AtomicReferenceFieldUpdater.  
                 newUpdater(Atomic8Test.class, Integer.class, "anIntegerField").  
                 accumulateAndGet(this, one, null);  
             shouldThrow();  
         } catch(NullPointerException ok) {}  
561      }      }
562    
563  }  }
   

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8