Home | History | Annotate | Download | only in concurrent
      1 /*
      2  * Written by Doug Lea and Martin Buchholz with assistance from
      3  * members of JCP JSR-166 Expert Group and released to the public
      4  * domain, as explained at
      5  * http://creativecommons.org/publicdomain/zero/1.0/
      6  */
      7 
      8 /*
      9  * Source:
     10  * http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/test/tck-jsr166e/AtomicDoubleTest.java?revision=1.8
     11  * (Modified to adapt to guava coding conventions)
     12  */
     13 
     14 package com.google.common.util.concurrent;
     15 
     16 import junit.framework.*;
     17 
     18 /**
     19  * Unit test for {@link AtomicDouble}.
     20  */
     21 public class AtomicDoubleTest extends JSR166TestCase {
     22 
     23   private static final double[] VALUES = {
     24     Double.NEGATIVE_INFINITY,
     25     -Double.MAX_VALUE,
     26     (double) Long.MIN_VALUE,
     27     (double) Integer.MIN_VALUE,
     28     -Math.PI,
     29     -1.0,
     30     -Double.MIN_VALUE,
     31     -0.0,
     32     +0.0,
     33     Double.MIN_VALUE,
     34     1.0,
     35     Math.PI,
     36     (double) Integer.MAX_VALUE,
     37     (double) Long.MAX_VALUE,
     38     Double.MAX_VALUE,
     39     Double.POSITIVE_INFINITY,
     40     Double.NaN,
     41     Float.MAX_VALUE,
     42   };
     43 
     44   /** The notion of equality used by AtomicDouble */
     45   static boolean bitEquals(double x, double y) {
     46     return Double.doubleToRawLongBits(x) == Double.doubleToRawLongBits(y);
     47   }
     48 
     49   static void assertBitEquals(double x, double y) {
     50     assertEquals(Double.doubleToRawLongBits(x),
     51                  Double.doubleToRawLongBits(y));
     52   }
     53 
     54   /**
     55    * constructor initializes to given value
     56    */
     57   public void testConstructor() {
     58     for (double x : VALUES) {
     59       AtomicDouble a = new AtomicDouble(x);
     60       assertBitEquals(x, a.get());
     61     }
     62   }
     63 
     64   /**
     65    * default constructed initializes to zero
     66    */
     67   public void testConstructor2() {
     68     AtomicDouble a = new AtomicDouble();
     69     assertBitEquals(0.0, a.get());
     70   }
     71 
     72   /**
     73    * get returns the last value set
     74    */
     75   public void testGetSet() {
     76     AtomicDouble at = new AtomicDouble(1.0);
     77     assertBitEquals(1.0, at.get());
     78     for (double x : VALUES) {
     79       at.set(x);
     80       assertBitEquals(x, at.get());
     81     }
     82   }
     83 
     84   /**
     85    * get returns the last value lazySet in same thread
     86    */
     87   public void testGetLazySet() {
     88     AtomicDouble at = new AtomicDouble(1.0);
     89     assertBitEquals(1.0, at.get());
     90     for (double x : VALUES) {
     91       at.lazySet(x);
     92       assertBitEquals(x, at.get());
     93     }
     94   }
     95 
     96   /**
     97    * compareAndSet succeeds in changing value if equal to expected else fails
     98    */
     99   public void testCompareAndSet() {
    100     double prev = Math.E;
    101     double unused = Math.E + Math.PI;
    102     AtomicDouble at = new AtomicDouble(prev);
    103     for (double x : VALUES) {
    104       assertBitEquals(prev, at.get());
    105       assertFalse(at.compareAndSet(unused, x));
    106       assertBitEquals(prev, at.get());
    107       assertTrue(at.compareAndSet(prev, x));
    108       assertBitEquals(x, at.get());
    109       prev = x;
    110     }
    111   }
    112 
    113   /**
    114    * compareAndSet in one thread enables another waiting for value
    115    * to succeed
    116    */
    117 
    118       public void testCompareAndSetInMultipleThreads() throws Exception {
    119     final AtomicDouble at = new AtomicDouble(1.0);
    120     Thread t = newStartedThread(new CheckedRunnable() {
    121         public void realRun() {
    122           while (!at.compareAndSet(2.0, 3.0)) {
    123             Thread.yield();
    124           }
    125         }});
    126 
    127     assertTrue(at.compareAndSet(1.0, 2.0));
    128     awaitTermination(t);
    129     assertBitEquals(3.0, at.get());
    130   }
    131 
    132   /**
    133    * repeated weakCompareAndSet succeeds in changing value when equal
    134    * to expected
    135    */
    136   public void testWeakCompareAndSet() {
    137     double prev = Math.E;
    138     double unused = Math.E + Math.PI;
    139     AtomicDouble at = new AtomicDouble(prev);
    140     for (double x : VALUES) {
    141       assertBitEquals(prev, at.get());
    142       assertFalse(at.weakCompareAndSet(unused, x));
    143       assertBitEquals(prev, at.get());
    144       while (!at.weakCompareAndSet(prev, x)) {
    145         ;
    146       }
    147       assertBitEquals(x, at.get());
    148       prev = x;
    149     }
    150   }
    151 
    152   /**
    153    * getAndSet returns previous value and sets to given value
    154    */
    155   public void testGetAndSet() {
    156     double prev = Math.E;
    157     AtomicDouble at = new AtomicDouble(prev);
    158     for (double x : VALUES) {
    159       assertBitEquals(prev, at.getAndSet(x));
    160       prev = x;
    161     }
    162   }
    163 
    164   /**
    165    * getAndAdd returns previous value and adds given value
    166    */
    167   public void testGetAndAdd() {
    168     for (double x : VALUES) {
    169       for (double y : VALUES) {
    170         AtomicDouble a = new AtomicDouble(x);
    171         double z = a.getAndAdd(y);
    172         assertBitEquals(x, z);
    173         assertBitEquals(x + y, a.get());
    174       }
    175     }
    176   }
    177 
    178   /**
    179    * addAndGet adds given value to current, and returns current value
    180    */
    181   public void testAddAndGet() {
    182     for (double x : VALUES) {
    183       for (double y : VALUES) {
    184         AtomicDouble a = new AtomicDouble(x);
    185         double z = a.addAndGet(y);
    186         assertBitEquals(x + y, z);
    187         assertBitEquals(x + y, a.get());
    188       }
    189     }
    190   }
    191 
    192   /**
    193    * a deserialized serialized atomic holds same value
    194    */
    195   public void testSerialization() throws Exception {
    196     AtomicDouble a = new AtomicDouble();
    197     AtomicDouble b = serialClone(a);
    198     assertTrue(a != b);
    199     a.set(-22.0);
    200     AtomicDouble c = serialClone(a);
    201     assertBitEquals(-22.0, a.get());
    202     assertBitEquals(0.0, b.get());
    203     assertBitEquals(-22.0, c.get());
    204     for (double x : VALUES) {
    205       AtomicDouble d = new AtomicDouble(x);
    206       assertBitEquals(serialClone(d).get(), d.get());
    207     }
    208   }
    209 
    210   /**
    211    * toString returns current value
    212    */
    213   public void testToString() {
    214     AtomicDouble at = new AtomicDouble();
    215     assertEquals("0.0", at.toString());
    216     for (double x : VALUES) {
    217       at.set(x);
    218       assertEquals(Double.toString(x), at.toString());
    219     }
    220   }
    221 
    222   /**
    223    * intValue returns current value.
    224    */
    225   public void testIntValue() {
    226     AtomicDouble at = new AtomicDouble();
    227     assertEquals(0, at.intValue());
    228     for (double x : VALUES) {
    229       at.set(x);
    230       assertEquals((int) x, at.intValue());
    231     }
    232   }
    233 
    234   /**
    235    * longValue returns current value.
    236    */
    237   public void testLongValue() {
    238     AtomicDouble at = new AtomicDouble();
    239     assertEquals(0L, at.longValue());
    240     for (double x : VALUES) {
    241       at.set(x);
    242       assertEquals((long) x, at.longValue());
    243     }
    244   }
    245 
    246   /**
    247    * floatValue returns current value.
    248    */
    249   public void testFloatValue() {
    250     AtomicDouble at = new AtomicDouble();
    251     assertEquals(0.0f, at.floatValue());
    252     for (double x : VALUES) {
    253       at.set(x);
    254       assertEquals((float) x, at.floatValue());
    255     }
    256   }
    257 
    258   /**
    259    * doubleValue returns current value.
    260    */
    261   public void testDoubleValue() {
    262     AtomicDouble at = new AtomicDouble();
    263     assertEquals(0.0d, at.doubleValue());
    264     for (double x : VALUES) {
    265       at.set(x);
    266       assertBitEquals(x, at.doubleValue());
    267     }
    268   }
    269 
    270   /**
    271    * compareAndSet treats +0.0 and -0.0 as distinct values
    272    */
    273   public void testDistinctZeros() {
    274     AtomicDouble at = new AtomicDouble(+0.0);
    275     assertFalse(at.compareAndSet(-0.0, 7.0));
    276     assertFalse(at.weakCompareAndSet(-0.0, 7.0));
    277     assertBitEquals(+0.0, at.get());
    278     assertTrue(at.compareAndSet(+0.0, -0.0));
    279     assertBitEquals(-0.0, at.get());
    280     assertFalse(at.compareAndSet(+0.0, 7.0));
    281     assertFalse(at.weakCompareAndSet(+0.0, 7.0));
    282     assertBitEquals(-0.0, at.get());
    283   }
    284 }
    285