added end-to-end test for slops

src/java/voldemort/store/memory/InMemoryStorageEngine.java

@@ -24,6 +24,8 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
+import org.apache.log4j.Logger;
+
 import voldemort.VoldemortException;
 import voldemort.annotations.concurrency.NotThreadsafe;
 import voldemort.store.AbstractStorageEngine;
@@ -44,6 +46,7 @@
  */
 public class InMemoryStorageEngine<K, V, T> extends AbstractStorageEngine<K, V, T> {
 
+    private static final Logger logger = Logger.getLogger(InMemoryStorageEngine.class);
     private final ConcurrentMap<K, List<Versioned<V>>> map;
 
     public InMemoryStorageEngine(String name) {
@@ -64,6 +67,10 @@ public boolean delete(K key) {
         return delete(key, null);
     }
 
+    public ConcurrentMap<K, List<Versioned<V>>> getInnerMap() {
+        return map;
+    }
+
     @Override
     public synchronized boolean delete(K key, Version version) {
         StoreUtils.assertValidKey(key);

test/common/voldemort/ServerTestUtils.java

@@ -801,7 +801,7 @@ public static void waitForServerStart(SocketStoreFactory socketStoreFactory, Nod
         boolean success = false;
         int retries = 10;
         Store<ByteArray, ?, ?> store = null;
-        while(retries-- > 0) {
+        while(retries-- > 0 && !success) {
             store = ServerTestUtils.getSocketStore(socketStoreFactory,
                                                    MetadataStore.METADATA_STORE_NAME,
                                                    node.getSocketPort());

test/integration/voldemort/store/memory/InMemoryPutAssertionStorageEngine.java

@@ -0,0 +1,69 @@
+package voldemort.store.memory;
+
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.apache.log4j.Logger;
+
+import voldemort.VoldemortException;
+import voldemort.store.StoreUtils;
+import voldemort.versioning.Versioned;
+
+public class InMemoryPutAssertionStorageEngine<K, V, T> extends InMemoryStorageEngine<K, V, T> {
+
+    private static final Logger logger = Logger.getLogger(InMemoryPutAssertionStorageEngine.class);
+
+    private final ConcurrentMap<K, Boolean> assertionMap;
+
+    public InMemoryPutAssertionStorageEngine(String name) {
+        super(name);
+        this.assertionMap = new ConcurrentHashMap<K, Boolean>();
+    }
+
+    public synchronized void assertPut(K key) throws VoldemortException {
+        StoreUtils.assertValidKey(key);
+
+        // delete if exist
+        List<Versioned<V>> result = super.getInnerMap().remove(key);
+        if(result == null || result.size() == 0) {
+            // if non-exist, record as assertion
+            assertionMap.put(key, true); // use synchronized to avoid race
+                                         // condition here
+            if(logger.isDebugEnabled()) {
+                logger.debug("PUT Assertion added (not yet fulfilled) for key: " + key
+                             + " assertionMap size: " + assertionMap.size());
+            }
+        } else {
+            if(logger.isTraceEnabled()) {
+                logger.trace("PUT Assertion added (immediately fulfilled) for key: " + key
+                             + " assertionMap size: " + assertionMap.size());
+            }
+        }
+    }
+
+    @Override
+    public synchronized void put(K key, Versioned<V> value, T transforms) throws VoldemortException {
+        // try to delete from assertion
+        // do real put if has not been asserted
+        Boolean result = assertionMap.remove(key);
+        if(result == null) {
+            super.put(key, value, transforms);
+            if(logger.isTraceEnabled()) {
+                logger.trace("PUT key: " + key + " (never asserted) assertionMap size: "
+                             + assertionMap.size());
+            }
+        } else {
+            if(logger.isDebugEnabled()) {
+                logger.debug("PUT key: " + key
+                             + " (found and fulfills put assertion) assertionMap size: "
+                             + assertionMap.size());
+            }
+        }
+    }
+
+    public Set<K> getFailedAssertions() {
+        return assertionMap.keySet();
+    }
+}