HCOLL-155 uncompleted, checked in order that Peter can review the changes so far of - chm.acquireUsingReadLocked and chm.acquireUsingWriteLocked

src/test/java/net/openhft/chronicle/map/ReplicationCheckingMap.java

@@ -251,6 +251,16 @@ public class ReplicationCheckingMap<K, V> implements ChronicleMap<K, V> {
         return map1.acquireUsing(key, usingValue);
     }
 
+    @Override
+    public SegmentLock acquireUsingReadLocked(K key, V usingValue) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public SegmentLock acquireUsingWriteLocked(K key, V usingValue) {
+        throw new UnsupportedOperationException();
+    }
+
     @Override
     public File file() {
         throw new UnsupportedOperationException();

src/test/java/net/openhft/chronicle/map/StatelessClientTest.java

@@ -270,6 +270,133 @@ public class StatelessClientTest {
     }
 
 
+    @Test
+    public void testBufferOverFlowPutAllWherePutReturnsNull() throws IOException,
+            InterruptedException {
+
+        final ChronicleMap<Integer, CharSequence> serverMap;
+        final ChronicleMap<Integer, CharSequence> statelessMap;
+
+
+        // stateless client
+        {
+            statelessMap = ChronicleMapBuilder.of(Integer
+                    .class, CharSequence.class)
+                    .putReturnsNull(true)
+                    .stateless(remoteAddress(new InetSocketAddress("localhost", 8086))).create();
+        }
+
+        // server
+        {
+            serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+                    .replicators((byte) 2, TcpReplicationConfig.of(8086))
+                    .putReturnsNull(true)
+                    .create();
+        }
+
+
+        Map<Integer, CharSequence> payload = new HashMap<Integer, CharSequence>();
+
+        for (int i = 0; i < SIZE; i++) {
+            payload.put(i, "some value=" + i);
+        }
+
+
+        statelessMap.putAll(payload);
+
+        int value = SIZE - 10;
+
+        Assert.assertEquals("some value=" + value, statelessMap.get(value));
+        Assert.assertEquals(SIZE, statelessMap.size());
+
+        serverMap.close();
+        statelessMap.close();
+
+    }
+
+
+    @Test
+    public void testPutWherePutReturnsNull() throws IOException,
+            InterruptedException {
+
+        final ChronicleMap<Integer, CharSequence> serverMap;
+        final ChronicleMap<Integer, CharSequence> statelessMap;
+
+
+        // stateless client
+        {
+            statelessMap = ChronicleMapBuilder.of(Integer
+                    .class, CharSequence.class)
+                    .putReturnsNull(true)
+                    .removeReturnsNull(true)
+                    .stateless(remoteAddress(new InetSocketAddress("localhost", 8086))).create();
+        }
+
+        // server
+        {
+            serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+                    .replicators((byte) 2, TcpReplicationConfig.of(8086))
+                    .putReturnsNull(true)
+                    .removeReturnsNull(true)
+                    .create();
+        }
+
+
+        statelessMap.put(1, "some value");
+
+        Assert.assertEquals("some value", statelessMap.get(1));
+        Assert.assertEquals(1, statelessMap.size());
+
+
+        serverMap.close();
+        statelessMap.close();
+
+    }
+
+
+
+    @Test
+    public void testRemoveWhereRemoveReturnsNull() throws IOException,
+            InterruptedException {
+
+        final ChronicleMap<Integer, CharSequence> serverMap;
+        final ChronicleMap<Integer, CharSequence> statelessMap;
+
+
+        // stateless client
+        {
+            statelessMap = ChronicleMapBuilder.of(Integer
+                    .class, CharSequence.class)
+                    .putReturnsNull(true)
+                    .removeReturnsNull(true)
+                    .stateless(remoteAddress(new InetSocketAddress("localhost", 8086))).create();
+        }
+
+        // server
+        {
+            serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+                    .replicators((byte) 2, TcpReplicationConfig.of(8086))
+                    .putReturnsNull(true)
+                    .removeReturnsNull(true)
+                    .create();
+        }
+
+
+        statelessMap.put(1, "some value");
+
+        Assert.assertEquals("some value", statelessMap.get(1));
+        Assert.assertEquals(1, statelessMap.size());
+
+        statelessMap.remove(1);
+
+        Assert.assertEquals(null, statelessMap.get(1));
+        Assert.assertEquals(0, statelessMap.size());
+
+        serverMap.close();
+        statelessMap.close();
+
+    }
+
     @Test
     public void testEquals() throws IOException, InterruptedException {
 

src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java

@@ -21,6 +21,7 @@ package net.openhft.chronicle.map.jrs166.map;
 import net.openhft.chronicle.map.ChronicleMap;
 import net.openhft.chronicle.map.ChronicleMapBuilder;
 import net.openhft.chronicle.hash.TcpReplicationConfig;
+import net.openhft.chronicle.map.SegmentLock;
 import net.openhft.chronicle.map.jrs166.JSR166TestCase;
 import org.jetbrains.annotations.NotNull;
 import org.junit.Test;
@@ -149,6 +150,16 @@ public class StatelessChronicleMapTest extends JSR166TestCase {
             return d.acquireUsing(key, usingValue);
         }
 
+        @Override
+        public SegmentLock acquireUsingReadLocked(K key, V usingValue) {
+           throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public SegmentLock acquireUsingWriteLocked(K key, V usingValue) {
+            throw new UnsupportedOperationException();
+        }
+
         @Override
         public V putIfAbsent(K key, V value) {
             return d.putIfAbsent(key, value);