176 

   176         UNSAFE.putFloat(base, offset, 1.0f);

   177 

   178         // Compare

   179         {

   180             boolean r = UNSAFE.compareAndSwapFloat(base, offset, 1.0f, 2.0f);

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

   182             float x = UNSAFE.getFloat(base, offset);

   183             assertEquals(x, 2.0f, "success compareAndSwap float value");

   184         }

   185 

   186         {

   187             boolean r = UNSAFE.compareAndSwapFloat(base, offset, 1.0f, 3.0f);

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

   189             float x = UNSAFE.getFloat(base, offset);

   190             assertEquals(x, 2.0f, "failing compareAndSwap float value");

   191         }

   192 

   193         // Advanced compare

   194         {

   195             float r = UNSAFE.compareAndExchangeFloatVolatile(base, offset, 2.0f, 1.0f);

   196             assertEquals(r, 2.0f, "success compareAndExchangeVolatile float");

   197             float x = UNSAFE.getFloat(base, offset);

   198             assertEquals(x, 1.0f, "success compareAndExchangeVolatile float value");

   199         }

   200 

   201         {

   202             float r = UNSAFE.compareAndExchangeFloatVolatile(base, offset, 2.0f, 3.0f);

   203             assertEquals(r, 1.0f, "failing compareAndExchangeVolatile float");

   204             float x = UNSAFE.getFloat(base, offset);

   205             assertEquals(x, 1.0f, "failing compareAndExchangeVolatile float value");

   206         }

   207 

   208         {

   209             float r = UNSAFE.compareAndExchangeFloatAcquire(base, offset, 1.0f, 2.0f);

   210             assertEquals(r, 1.0f, "success compareAndExchangeAcquire float");

   211             float x = UNSAFE.getFloat(base, offset);

   212             assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value");

   213         }

   214 

   215         {

   216             float r = UNSAFE.compareAndExchangeFloatAcquire(base, offset, 1.0f, 3.0f);

   217             assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float");

   218             float x = UNSAFE.getFloat(base, offset);

   219             assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value");

   220         }

   221 

   222         {

   223             float r = UNSAFE.compareAndExchangeFloatRelease(base, offset, 2.0f, 1.0f);

   224             assertEquals(r, 2.0f, "success compareAndExchangeRelease float");

   225             float x = UNSAFE.getFloat(base, offset);

   226             assertEquals(x, 1.0f, "success compareAndExchangeRelease float value");

   227         }

   228 

   229         {

   230             float r = UNSAFE.compareAndExchangeFloatRelease(base, offset, 2.0f, 3.0f);

   231             assertEquals(r, 1.0f, "failing compareAndExchangeRelease float");

   232             float x = UNSAFE.getFloat(base, offset);

   233             assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value");

   234         }

   235 

   236         {

   237             boolean success = false;

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

   239                 success = UNSAFE.weakCompareAndSwapFloat(base, offset, 1.0f, 2.0f);

   240             }

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

   242             float x = UNSAFE.getFloat(base, offset);

   243             assertEquals(x, 2.0f, "weakCompareAndSwap float value");

   244         }

   245 

   246         {

   247             boolean success = false;

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

   249                 success = UNSAFE.weakCompareAndSwapFloatAcquire(base, offset, 2.0f, 1.0f);

   250             }

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

   252             float x = UNSAFE.getFloat(base, offset);

   253             assertEquals(x, 1.0f, "weakCompareAndSwapAcquire float");

   254         }

   255 

   256         {

   257             boolean success = false;

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

   259                 success = UNSAFE.weakCompareAndSwapFloatRelease(base, offset, 1.0f, 2.0f);

   260             }

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

   262             float x = UNSAFE.getFloat(base, offset);

   263             assertEquals(x, 2.0f, "weakCompareAndSwapRelease float");

   264         }

   265 

   266         {

   267             boolean success = false;

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

   269                 success = UNSAFE.weakCompareAndSwapFloatVolatile(base, offset, 2.0f, 1.0f);

   270             }

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

   272             float x = UNSAFE.getFloat(base, offset);

   273             assertEquals(x, 1.0f, "weakCompareAndSwapVolatile float");

   274         }

   275 

   276         UNSAFE.putFloat(base, offset, 2.0f);

   277 

   278         // Compare set and get

   279         {

   280             float o = UNSAFE.getAndSetFloat(base, offset, 1.0f);

   281             assertEquals(o, 2.0f, "getAndSet float");

   282             float x = UNSAFE.getFloat(base, offset);

   283             assertEquals(x, 1.0f, "getAndSet float value");

   284         }

   285 

   286         UNSAFE.putFloat(base, offset, 1.0f);

   287 

   288         // get and add, add and get

   289         {

   290             float o = UNSAFE.getAndAddFloat(base, offset, 2.0f);

   291             assertEquals(o, 1.0f, "getAndAdd float");

   292             float x = UNSAFE.getFloat(base, offset);

   293             assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float");

   294         }