176 

   176         UNSAFE.putDouble(base, offset, 1.0d);

   177 

   178         // Compare

   179         {

   180             boolean r = UNSAFE.compareAndSwapDouble(base, offset, 1.0d, 2.0d);

   181             assertEquals(r, true, "success compareAndSwap double");

   182             double x = UNSAFE.getDouble(base, offset);

   183             assertEquals(x, 2.0d, "success compareAndSwap double value");

   184         }

   185 

   186         {

   187             boolean r = UNSAFE.compareAndSwapDouble(base, offset, 1.0d, 3.0d);

   188             assertEquals(r, false, "failing compareAndSwap double");

   189             double x = UNSAFE.getDouble(base, offset);

   190             assertEquals(x, 2.0d, "failing compareAndSwap double value");

   191         }

   192 

   193         // Advanced compare

   194         {

   195             double r = UNSAFE.compareAndExchangeDoubleVolatile(base, offset, 2.0d, 1.0d);

   196             assertEquals(r, 2.0d, "success compareAndExchangeVolatile double");

   197             double x = UNSAFE.getDouble(base, offset);

   198             assertEquals(x, 1.0d, "success compareAndExchangeVolatile double value");

   199         }

   200 

   201         {

   202             double r = UNSAFE.compareAndExchangeDoubleVolatile(base, offset, 2.0d, 3.0d);

   203             assertEquals(r, 1.0d, "failing compareAndExchangeVolatile double");

   204             double x = UNSAFE.getDouble(base, offset);

   205             assertEquals(x, 1.0d, "failing compareAndExchangeVolatile double value");

   206         }

   207 

   208         {

   209             double r = UNSAFE.compareAndExchangeDoubleAcquire(base, offset, 1.0d, 2.0d);

   210             assertEquals(r, 1.0d, "success compareAndExchangeAcquire double");

   211             double x = UNSAFE.getDouble(base, offset);

   212             assertEquals(x, 2.0d, "success compareAndExchangeAcquire double value");

   213         }

   214 

   215         {

   216             double r = UNSAFE.compareAndExchangeDoubleAcquire(base, offset, 1.0d, 3.0d);

   217             assertEquals(r, 2.0d, "failing compareAndExchangeAcquire double");

   218             double x = UNSAFE.getDouble(base, offset);

   219             assertEquals(x, 2.0d, "failing compareAndExchangeAcquire double value");

   220         }

   221 

   222         {

   223             double r = UNSAFE.compareAndExchangeDoubleRelease(base, offset, 2.0d, 1.0d);

   224             assertEquals(r, 2.0d, "success compareAndExchangeRelease double");

   225             double x = UNSAFE.getDouble(base, offset);

   226             assertEquals(x, 1.0d, "success compareAndExchangeRelease double value");

   227         }

   228 

   229         {

   230             double r = UNSAFE.compareAndExchangeDoubleRelease(base, offset, 2.0d, 3.0d);

   231             assertEquals(r, 1.0d, "failing compareAndExchangeRelease double");

   232             double x = UNSAFE.getDouble(base, offset);

   233             assertEquals(x, 1.0d, "failing compareAndExchangeRelease double value");

   234         }

   235 

   236         {

   237             boolean success = false;

   238             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {

   239                 success = UNSAFE.weakCompareAndSwapDouble(base, offset, 1.0d, 2.0d);

   240             }

   241             assertEquals(success, true, "weakCompareAndSwap double");

   242             double x = UNSAFE.getDouble(base, offset);

   243             assertEquals(x, 2.0d, "weakCompareAndSwap double value");

   244         }

   245 

   246         {

   247             boolean success = false;

   248             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {

   249                 success = UNSAFE.weakCompareAndSwapDoubleAcquire(base, offset, 2.0d, 1.0d);

   250             }

   251             assertEquals(success, true, "weakCompareAndSwapAcquire double");

   252             double x = UNSAFE.getDouble(base, offset);

   253             assertEquals(x, 1.0d, "weakCompareAndSwapAcquire double");

   254         }

   255 

   256         {

   257             boolean success = false;

   258             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {

   259                 success = UNSAFE.weakCompareAndSwapDoubleRelease(base, offset, 1.0d, 2.0d);

   260             }

   261             assertEquals(success, true, "weakCompareAndSwapRelease double");

   262             double x = UNSAFE.getDouble(base, offset);

   263             assertEquals(x, 2.0d, "weakCompareAndSwapRelease double");

   264         }

   265 

   266         {

   267             boolean success = false;

   268             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {

   269                 success = UNSAFE.weakCompareAndSwapDoubleVolatile(base, offset, 2.0d, 1.0d);

   270             }

   271             assertEquals(success, true, "weakCompareAndSwapVolatile double");

   272             double x = UNSAFE.getDouble(base, offset);

   273             assertEquals(x, 1.0d, "weakCompareAndSwapVolatile double");

   274         }

   275 

   276         UNSAFE.putDouble(base, offset, 2.0d);

   277 

   278         // Compare set and get

   279         {

   280             double o = UNSAFE.getAndSetDouble(base, offset, 1.0d);

   281             assertEquals(o, 2.0d, "getAndSet double");

   282             double x = UNSAFE.getDouble(base, offset);

   283             assertEquals(x, 1.0d, "getAndSet double value");

   284         }

   285 

   286         UNSAFE.putDouble(base, offset, 1.0d);

   287 

   288         // get and add, add and get

   289         {

   290             double o = UNSAFE.getAndAddDouble(base, offset, 2.0d);

   291             assertEquals(o, 1.0d, "getAndAdd double");

   292             double x = UNSAFE.getDouble(base, offset);

   293             assertEquals(x, (double)(1.0d + 2.0d), "getAndAdd double");

   294         }