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

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

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

revision 1.33, Sun May 24 01:42:14 2015 UTC revision 1.34, Thu Jun 16 23:35:25 2016 UTC
# Line 86  Line 86 
86                  aa.addAndGet(index, 1);                  aa.addAndGet(index, 1);
87                  shouldThrow();                  shouldThrow();
88              } catch (IndexOutOfBoundsException success) {}              } catch (IndexOutOfBoundsException success) {}
89                try {
90                    aa.getPlain(index);
91                    shouldThrow();
92                } catch (IndexOutOfBoundsException success) {}
93                try {
94                    aa.getOpaque(index);
95                    shouldThrow();
96                } catch (IndexOutOfBoundsException success) {}
97                try {
98                    aa.getAcquire(index);
99                    shouldThrow();
100                } catch (IndexOutOfBoundsException success) {}
101                try {
102                    aa.setPlain(index, 1);
103                    shouldThrow();
104                } catch (IndexOutOfBoundsException success) {}
105                try {
106                    aa.setOpaque(index, 1);
107                    shouldThrow();
108                } catch (IndexOutOfBoundsException success) {}
109                try {
110                    aa.setRelease(index, 1);
111                    shouldThrow();
112                } catch (IndexOutOfBoundsException success) {}
113                try {
114                    aa.compareAndExchange(index, 1, 2);
115                    shouldThrow();
116                } catch (IndexOutOfBoundsException success) {}
117                try {
118                    aa.compareAndExchangeAcquire(index, 1, 2);
119                    shouldThrow();
120                } catch (IndexOutOfBoundsException success) {}
121                try {
122                    aa.compareAndExchangeRelease(index, 1, 2);
123                    shouldThrow();
124                } catch (IndexOutOfBoundsException success) {}
125                try {
126                    aa.weakCompareAndSetVolatile(index, 1, 2);
127                    shouldThrow();
128                } catch (IndexOutOfBoundsException success) {}
129                try {
130                    aa.weakCompareAndSetAcquire(index, 1, 2);
131                    shouldThrow();
132                } catch (IndexOutOfBoundsException success) {}
133                try {
134                    aa.weakCompareAndSetRelease(index, 1, 2);
135                    shouldThrow();
136                } catch (IndexOutOfBoundsException success) {}
137          }          }
138      }      }
139    
# Line 340  Line 388 
388          assertEquals(Arrays.toString(a), aa.toString());          assertEquals(Arrays.toString(a), aa.toString());
389      }      }
390    
391        // jdk9
392    
393        /**
394         * getPlain returns the last value set
395         */
396        public void testGetPlainSet() {
397            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
398            for (int i = 0; i < SIZE; i++) {
399                aa.set(i, 1);
400                assertEquals(1, aa.getPlain(i));
401                aa.set(i, 2);
402                assertEquals(2, aa.getPlain(i));
403                aa.set(i, -3);
404                assertEquals(-3, aa.getPlain(i));
405            }
406        }
407    
408        /**
409         * getOpaque returns the last value set
410         */
411        public void testGetOpaqueSet() {
412            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
413            for (int i = 0; i < SIZE; i++) {
414                aa.set(i, 1);
415                assertEquals(1, aa.getOpaque(i));
416                aa.set(i, 2);
417                assertEquals(2, aa.getOpaque(i));
418                aa.set(i, -3);
419                assertEquals(-3, aa.getOpaque(i));
420            }
421        }
422    
423        /**
424         * getAcquire returns the last value set
425         */
426        public void testGetAcquireSet() {
427            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
428            for (int i = 0; i < SIZE; i++) {
429                aa.set(i, 1);
430                assertEquals(1, aa.getAcquire(i));
431                aa.set(i, 2);
432                assertEquals(2, aa.getAcquire(i));
433                aa.set(i, -3);
434                assertEquals(-3, aa.getAcquire(i));
435            }
436        }
437    
438        /**
439         * get returns the last value setPlain
440         */
441        public void testGetSetPlain() {
442            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
443            for (int i = 0; i < SIZE; i++) {
444                aa.setPlain(i, 1);
445                assertEquals(1, aa.get(i));
446                aa.setPlain(i, 2);
447                assertEquals(2, aa.get(i));
448                aa.setPlain(i, -3);
449                assertEquals(-3, aa.get(i));
450            }
451        }
452    
453        /**
454         * get returns the last value setOpaque
455         */
456        public void testGetSetOpaque() {
457            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
458            for (int i = 0; i < SIZE; i++) {
459                aa.setOpaque(i, 1);
460                assertEquals(1, aa.get(i));
461                aa.setOpaque(i, 2);
462                assertEquals(2, aa.get(i));
463                aa.setOpaque(i, -3);
464                assertEquals(-3, aa.get(i));
465            }
466        }
467    
468        /**
469         * get returns the last value setRelease
470         */
471        public void testGetSetRelease() {
472            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
473            for (int i = 0; i < SIZE; i++) {
474                aa.setRelease(i, 1);
475                assertEquals(1, aa.get(i));
476                aa.setRelease(i, 2);
477                assertEquals(2, aa.get(i));
478                aa.setRelease(i, -3);
479                assertEquals(-3, aa.get(i));
480            }
481        }
482    
483        /**
484         * compareAndExchange succeeds in changing value if equal to
485         * expected else fails
486         */
487        public void testCompareAndExchange() {
488            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
489            for (int i = 0; i < SIZE; i++) {
490                aa.set(i, 1);
491                assertEquals(1, aa.compareAndExchange(i, 1, 2));
492                assertEquals(2, aa.compareAndExchange(i, 2, -4));
493                assertEquals(-4, aa.get(i));
494                assertEquals(-4, aa.compareAndExchange(i,-5, 7));
495                assertEquals(-4, aa.get(i));
496                assertEquals(-4, aa.compareAndExchange(i, -4, 7));
497                assertEquals(7, aa.get(i));
498            }
499        }
500    
501        /**
502         * compareAndExchangeAcquire succeeds in changing value if equal to
503         * expected else fails
504         */
505        public void testCompareAndExchangeAcquire() {
506            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
507            for (int i = 0; i < SIZE; i++) {
508                aa.set(i, 1);
509                assertEquals(1, aa.compareAndExchangeAcquire(i, 1, 2));
510                assertEquals(2, aa.compareAndExchangeAcquire(i, 2, -4));
511                assertEquals(-4, aa.get(i));
512                assertEquals(-4, aa.compareAndExchangeAcquire(i,-5, 7));
513                assertEquals(-4, aa.get(i));
514                assertEquals(-4, aa.compareAndExchangeAcquire(i, -4, 7));
515                assertEquals(7, aa.get(i));
516            }
517        }
518    
519        /**
520         * compareAndExchangeRelease succeeds in changing value if equal to
521         * expected else fails
522         */
523        public void testCompareAndExchangeRelease() {
524            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
525            for (int i = 0; i < SIZE; i++) {
526                aa.set(i, 1);
527                assertEquals(1, aa.compareAndExchangeRelease(i, 1, 2));
528                assertEquals(2, aa.compareAndExchangeRelease(i, 2, -4));
529                assertEquals(-4, aa.get(i));
530                assertEquals(-4, aa.compareAndExchangeRelease(i,-5, 7));
531                assertEquals(-4, aa.get(i));
532                assertEquals(-4, aa.compareAndExchangeRelease(i, -4, 7));
533                assertEquals(7, aa.get(i));
534            }
535        }
536    
537        /**
538         * repeated weakCompareAndSetVolatile succeeds in changing value when equal
539         * to expected
540         */
541        public void testWeakCompareAndSetVolatile() {
542            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
543            for (int i = 0; i < SIZE; i++) {
544                aa.set(i, 1);
545                do {} while (!aa.weakCompareAndSetVolatile(i, 1, 2));
546                do {} while (!aa.weakCompareAndSetVolatile(i, 2, -4));
547                assertEquals(-4, aa.get(i));
548                do {} while (!aa.weakCompareAndSetVolatile(i, -4, 7));
549                assertEquals(7, aa.get(i));
550            }
551        }
552    
553        /**
554         * repeated weakCompareAndSetAcquire succeeds in changing value when equal
555         * to expected
556         */
557        public void testWeakCompareAndSetAcquire() {
558            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
559            for (int i = 0; i < SIZE; i++) {
560                aa.set(i, 1);
561                do {} while (!aa.weakCompareAndSetAcquire(i, 1, 2));
562                do {} while (!aa.weakCompareAndSetAcquire(i, 2, -4));
563                assertEquals(-4, aa.get(i));
564                do {} while (!aa.weakCompareAndSetAcquire(i, -4, 7));
565                assertEquals(7, aa.get(i));
566            }
567        }
568    
569        /**
570         * repeated weakCompareAndSetRelease succeeds in changing value when equal
571         * to expected
572         */
573        public void testWeakCompareAndSetRelease() {
574            AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
575            for (int i = 0; i < SIZE; i++) {
576                aa.set(i, 1);
577                do {} while (!aa.weakCompareAndSetRelease(i, 1, 2));
578                do {} while (!aa.weakCompareAndSetRelease(i, 2, -4));
579                assertEquals(-4, aa.get(i));
580                do {} while (!aa.weakCompareAndSetRelease(i, -4, 7));
581                assertEquals(7, aa.get(i));
582            }
583        }
584    
585  }  }

Legend:
Removed from v.1.33  
changed lines
  Added in v.1.34

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8