Added getAndAddPlain to AtomicCounter. (#328)

All the other flavors were already there, plain was missing.

Also added tests for all the weakly ordered methods and made
a few minor test improvements to the existing methods.

agrona/src/main/java/org/agrona/concurrent/status/AtomicCounter.java

@@ -543,6 +543,28 @@ public long getAndAddOpaque(final long increment)
         return currentValue;
     }
 
+    /**
+     * Adds an increment to the counter non-atomically.
+     * <p>
+     * This method is not atomic; it can suffer from lost-updates due to race conditions.
+     * <p>
+     * The load has plain memory semantics and the store has plain memory semantics.
+     * <p>
+     * The typical use-case for this method is when writer and reader are the same thread.
+     *
+     * @param increment to be added
+     * @return the previous value of the counter
+     * @since 2.1.0
+     */
+    public long getAndAddPlain(final long increment)
+    {
+        final byte[] array = byteArray;
+        final long offset = addressOffset;
+        final long currentValue = UnsafeApi.getLong(array, offset);
+        UnsafeApi.putLong(array, offset, currentValue + increment);
+        return currentValue;
+    }
+
     /**
      * Get the current value of a counter and atomically set it to a new value.
      *

agrona/src/test/java/org/agrona/concurrent/status/AtomicCountersTest.java

@@ -32,13 +32,79 @@ public void testPlain()
 
         assertEquals(0, counter.getPlain());
 
-        counter.incrementPlain();
+        assertEquals(0, counter.incrementPlain());
         assertEquals(1, counter.getPlain());
 
         counter.setPlain(42);
         assertEquals(42, counter.getPlain());
 
-        counter.decrementPlain();
+        assertEquals(42, counter.decrementPlain());
         assertEquals(41, counter.getPlain());
+
+        assertEquals(41, counter.getAndAddPlain(10));
+        assertEquals(51, counter.getPlain());
+    }
+
+    @Test
+    public void testVolatile()
+    {
+        final AtomicBuffer buffer = new UnsafeBuffer(new byte[8]);
+        final AtomicCounter counter = new AtomicCounter(buffer, 0);
+
+        assertEquals(0, counter.get());
+
+        assertEquals(0, counter.increment());
+        assertEquals(1, counter.get());
+
+        counter.set(42);
+        assertEquals(42, counter.get());
+
+        assertEquals(42, counter.decrement());
+        assertEquals(41, counter.get());
+
+        assertEquals(41, counter.getAndAdd(10));
+        assertEquals(51, counter.get());
+    }
+
+    @Test
+    public void testOpaque()
+    {
+        final AtomicBuffer buffer = new UnsafeBuffer(new byte[8]);
+        final AtomicCounter counter = new AtomicCounter(buffer, 0);
+
+        assertEquals(0, counter.getOpaque());
+
+        assertEquals(0, counter.incrementOpaque());
+        assertEquals(1, counter.getOpaque());
+
+        counter.setOpaque(42);
+        assertEquals(42, counter.getOpaque());
+
+        assertEquals(42, counter.decrementOpaque());
+        assertEquals(41, counter.getOpaque());
+
+        assertEquals(41, counter.getAndAddOpaque(10));
+        assertEquals(51, counter.getOpaque());
+    }
+
+    @Test
+    public void testReleaseAcquire()
+    {
+        final AtomicBuffer buffer = new UnsafeBuffer(new byte[8]);
+        final AtomicCounter counter = new AtomicCounter(buffer, 0);
+
+        assertEquals(0, counter.getAcquire());
+
+        assertEquals(0, counter.incrementRelease());
+        assertEquals(1, counter.getAcquire());
+
+        counter.setRelease(42);
+        assertEquals(42, counter.getAcquire());
+
+        assertEquals(42, counter.decrementRelease());
+        assertEquals(41, counter.getAcquire());
+
+        assertEquals(41, counter.getAndAddRelease(10));
+        assertEquals(51, counter.getAcquire());
     }
 }