diff --git a/aws/s3/core/src/test/java/org/jclouds/aws/s3/BaseS3MapIntegrationTest.java b/aws/s3/core/src/test/java/org/jclouds/aws/s3/BaseS3MapIntegrationTest.java
index a51d4c57ac..d6068ff9b1 100644
--- a/aws/s3/core/src/test/java/org/jclouds/aws/s3/BaseS3MapIntegrationTest.java
+++ b/aws/s3/core/src/test/java/org/jclouds/aws/s3/BaseS3MapIntegrationTest.java
@@ -47,11 +47,11 @@ import com.google.common.collect.ImmutableSet;
 @Test
 public abstract class BaseS3MapIntegrationTest<T> extends S3IntegrationTest {
 
-   public abstract void testPutAll();
+   public abstract void testPutAll() throws InterruptedException;
 
-   public abstract void testEntrySet() throws IOException;
+   public abstract void testEntrySet() throws IOException, InterruptedException;
 
-   public abstract void testValues() throws IOException;
+   public abstract void testValues() throws IOException, InterruptedException;
 
    protected BaseS3Map<T> map;
    protected Map<String, String> fiveStrings = ImmutableMap.of("one", "apple", "two", "bear",
@@ -94,54 +94,119 @@ public abstract class BaseS3MapIntegrationTest<T> extends S3IntegrationTest {
    protected abstract BaseS3Map<T> createMap(S3Context context, String bucket);
 
    @Test(groups = { "integration", "live" })
-   public void testClear() {
+   public void testClear() throws InterruptedException {
       map.clear();
-      assertEquals(map.size(), 0);
+      assertEventuallyMapSize(0);
       putString("one", "apple");
-      assertEquals(map.size(), 1);
+      assertEventuallyMapSize(1);
       map.clear();
-      assertEquals(map.size(), 0);
+      assertEventuallyMapSize(0);
    }
 
    @Test(groups = { "integration", "live" })
-   public abstract void testRemove() throws IOException;
+   public abstract void testRemove() throws IOException, InterruptedException;
 
    @Test(groups = { "integration", "live" })
-   public void testKeySet() {
-      assertEquals(map.keySet().size(), 0);
+   public void testKeySet() throws InterruptedException {
+      assertEventuallyKeySize(0);
       putString("one", "two");
-      assertEquals(map.keySet(), ImmutableSet.of("one"));
+      assertEventuallyKeySize(1);
+      assertEventuallyKeySetEquals(ImmutableSet.of("one"));
+   }
+
+   protected void assertEventuallyKeySetEquals(final Object toEqual) throws InterruptedException {
+      assertEventually(new Runnable() {
+         public void run() {
+            assertEquals(map.keySet(), toEqual);
+         }
+      });
+   }
+
+   protected void assertEventuallyKeySize(final int size) throws InterruptedException {
+      assertEventually(new Runnable() {
+         public void run() {
+            assertEquals(map.keySet().size(), size);
+         }
+      });
    }
 
    @Test(groups = { "integration", "live" })
-   public void testContainsKey() {
-      assert !map.containsKey("one");
+   public void testContainsKey() throws InterruptedException {
+      assertEventuallyDoesntContainKey();
       putString("one", "apple");
-      assert map.containsKey("one");
+      assertEventuallyContainsKey();
+   }
+
+   protected void assertEventuallyContainsKey() throws InterruptedException {
+      assertEventually(new Runnable() {
+         public void run() {
+            assert map.containsKey("one");
+         }
+      });
+   }
+
+   protected void assertEventuallyDoesntContainKey() throws InterruptedException {
+      assertEventually(new Runnable() {
+         public void run() {
+            assert !map.containsKey("one");
+         }
+      });
    }
 
    @Test(groups = { "integration", "live" })
-   public void testIsEmpty() {
-      assert map.isEmpty();
+   public void testIsEmpty() throws InterruptedException {
+      assertEventuallyEmpty();
       putString("one", "apple");
-      assert !map.isEmpty();
+      assertEventuallyNotEmpty();
+   }
+
+   protected void assertEventuallyNotEmpty() throws InterruptedException {
+      assertEventually(new Runnable() {
+         public void run() {
+            assert !map.isEmpty();
+         }
+      });
+   }
+
+   protected void assertEventuallyEmpty() throws InterruptedException {
+      assertEventually(new Runnable() {
+         public void run() {
+            assert map.isEmpty();
+         }
+      });
    }
 
    abstract protected void putString(String key, String value);
 
-   protected void fourLeftRemovingOne() {
+   protected void fourLeftRemovingOne() throws InterruptedException {
       map.remove("one");
-      assertEquals(map.size(), 4);
-      assertEquals(new TreeSet<String>(map.keySet()), new TreeSet<String>(ImmutableSet.of("two",
-               "three", "four", "five")));
+      assertEventuallyMapSize(4);
+      assertEventuallyKeySetEquals(new TreeSet<String>(ImmutableSet.of("two", "three", "four",
+               "five")));
+   }
+
+   protected void assertEventuallyMapSize(final int size) throws InterruptedException {
+      assertEventually(new Runnable() {
+         public void run() {
+            assertEquals(map.size(), size);
+         }
+      });
    }
 
    @Test(groups = { "integration", "live" })
-   public abstract void testPut() throws IOException;
+   public abstract void testPut() throws IOException, InterruptedException;
 
    @Test(groups = { "integration", "live" })
-   public void testGetBucket() {
-      assertEquals(map.getBucket().getName(), bucketName);
+   public void testGetBucket() throws InterruptedException {
+      assertEventuallyBucketNameCorrect();
+   }
+
+   protected void assertEventuallyBucketNameCorrect() throws InterruptedException {
+      assertEventually(new Runnable() {
+         public void run() {
+            assertEquals(map.getBucket().getName(), bucketName);
+         }
+      });
    }
 
 }
\ No newline at end of file
diff --git a/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3InputStreamMapIntegrationTest.java b/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3InputStreamMapIntegrationTest.java
index 4f75a6e988..e7f27c6fea 100644
--- a/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3InputStreamMapIntegrationTest.java
+++ b/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3InputStreamMapIntegrationTest.java
@@ -23,188 +23,184 @@
  */
 package org.jclouds.aws.s3;
 
-import org.apache.commons.io.IOUtils;
-import org.jclouds.aws.s3.internal.BaseS3Map;
-import org.jclouds.util.Utils;
 import static org.testng.Assert.assertEquals;
-import org.testng.annotations.Test;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Collection;
 import java.util.HashSet;
-import java.util.Map.Entry;
 import java.util.Set;
 import java.util.TreeSet;
+import java.util.Map.Entry;
+
+import org.apache.commons.io.IOUtils;
+import org.jclouds.aws.s3.internal.BaseS3Map;
+import org.jclouds.util.Utils;
+import org.testng.annotations.Test;
 
 /**
  * Tests to cover @{link LiveS3ObjectMap}
- *
+ * 
  * @author Adrian Cole
  */
 @Test(testName = "s3.S3InputStreamMapIntegrationTest")
 public class S3InputStreamMapIntegrationTest extends BaseS3MapIntegrationTest<InputStream> {
-    S3InputStreamMap map = null;
+   S3InputStreamMap map = null;
 
-    @SuppressWarnings("unchecked")
-    protected BaseS3Map<InputStream> createMap(S3Context context, String bucket) {
-        map = context.createInputStreamMap(bucket);
-        return (BaseS3Map<InputStream>) map;
-    }
+   @SuppressWarnings("unchecked")
+   protected BaseS3Map<InputStream> createMap(S3Context context, String bucket) {
+      map = context.createInputStreamMap(bucket);
+      return (BaseS3Map<InputStream>) map;
+   }
 
-    @Override
-    @Test(groups = {"integration", "live"})
-    public void testValues() throws IOException {
-        map.putAll(this.fiveInputs);
-        Collection<InputStream> values = map.values();
-        assertEquals(values.size(), 5);
-        Set<String> valuesAsString = new HashSet<String>();
-        for (InputStream stream : values) {
-            valuesAsString.add(Utils.toStringAndClose(stream));
-        }
-        valuesAsString.removeAll(fiveStrings.values());
-        assert valuesAsString.size() == 0;
-    }
+   @Override
+   @Test(groups = { "integration", "live" })
+   public void testValues() throws IOException {
+      map.putAll(this.fiveInputs);
+      Collection<InputStream> values = map.values();
+      assertEquals(values.size(), 5);
+      Set<String> valuesAsString = new HashSet<String>();
+      for (InputStream stream : values) {
+         valuesAsString.add(Utils.toStringAndClose(stream));
+      }
+      valuesAsString.removeAll(fiveStrings.values());
+      assert valuesAsString.size() == 0;
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testRemove() throws IOException {
-        putString("one", "two");
-        InputStream old = map.remove("one");
-        assertEquals(Utils.toStringAndClose(old), "two");
-        old = map.remove("one");
-        assert old == null;
-        old = map.get("one");
-        assert old == null;
-        assertEquals(map.keySet().size(), 0);
-    }
+   @Test(groups = { "integration", "live" })
+   public void testRemove() throws IOException, InterruptedException {
+      putString("one", "two");
+      InputStream old = map.remove("one");
+      assertEquals(Utils.toStringAndClose(old), "two");
+      old = map.remove("one");
+      assert old == null;
+      old = map.get("one");
+      assert old == null;
+      assertEventuallyKeySize(0);
+   }
 
-    @Override
-    @Test(groups = {"integration", "live"})
-    public void testEntrySet() throws IOException {
-        map.putAllStrings(this.fiveStrings);
-        Set<Entry<String, InputStream>> entries = map.entrySet();
-        assertEquals(entries.size(), 5);
-        for (Entry<String, InputStream> entry : entries) {
-            assertEquals(IOUtils.toString(entry.getValue()), fiveStrings
-                    .get(entry.getKey()));
-            entry.setValue(IOUtils.toInputStream(""));
-        }
-        assertEquals(map.size(), 5);
-        for (InputStream value : map.values()) {
-            assertEquals(IOUtils.toString(value), "");
-        }
-    }
+   @Override
+   @Test(groups = { "integration", "live" })
+   public void testEntrySet() throws IOException, InterruptedException {
+      map.putAllStrings(this.fiveStrings);
+      Set<Entry<String, InputStream>> entries = map.entrySet();
+      assertEquals(entries.size(), 5);
+      for (Entry<String, InputStream> entry : entries) {
+         assertEquals(IOUtils.toString(entry.getValue()), fiveStrings.get(entry.getKey()));
+         entry.setValue(IOUtils.toInputStream(""));
+      }
+      assertEventuallyMapSize(5);
+      for (InputStream value : map.values()) {
+         assertEquals(IOUtils.toString(value), "");
+      }
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testContainsStringValue() {
-        map.putString("one", "apple");
-        assert map.containsValue(fiveStrings.get("one"));
-    }
+   @Test(groups = { "integration", "live" })
+   public void testContainsStringValue() {
+      map.putString("one", "apple");
+      assert map.containsValue(fiveStrings.get("one"));
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testContainsFileValue() {
-        map.putString("one", "apple");
-        assert map.containsValue(fiveFiles.get("one"));
-    }
+   @Test(groups = { "integration", "live" })
+   public void testContainsFileValue() {
+      map.putString("one", "apple");
+      assert map.containsValue(fiveFiles.get("one"));
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testContainsInputStreamValue() {
-        map.putString("one", "apple");
-        assert map.containsValue(this.fiveInputs.get("one"));
-    }
+   @Test(groups = { "integration", "live" })
+   public void testContainsInputStreamValue() {
+      map.putString("one", "apple");
+      assert map.containsValue(this.fiveInputs.get("one"));
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testContainsBytesValue() {
-        map.putString("one", "apple");
-        assert map.containsValue(this.fiveBytes.get("one"));
-    }
+   @Test(groups = { "integration", "live" })
+   public void testContainsBytesValue() {
+      map.putString("one", "apple");
+      assert map.containsValue(this.fiveBytes.get("one"));
+   }
 
-    @Override
-    @Test(groups = {"integration", "live"})
-    public void testPutAll() {
-        map.putAll(this.fiveInputs);
-        assertEquals(map.size(), 5);
-        assertEquals(new TreeSet<String>(map.keySet()), new TreeSet<String>(
-                fiveInputs.keySet()));
-        fourLeftRemovingOne();
-    }
+   @Override
+   @Test(groups = { "integration", "live" })
+   public void testPutAll() throws InterruptedException {
+      map.putAll(this.fiveInputs);
+      assertEventuallyMapSize(5);
+      assertEventuallyKeySetEquals(new TreeSet<String>(fiveInputs.keySet()));
+      fourLeftRemovingOne();
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testPutAllBytes() {
-        map.putAllBytes(this.fiveBytes);
-        assertEquals(map.size(), 5);
-        assertEquals(new TreeSet<String>(map.keySet()), new TreeSet<String>(
-                fiveBytes.keySet()));
-        fourLeftRemovingOne();
-    }
+   @Test(groups = { "integration", "live" })
+   public void testPutAllBytes() throws InterruptedException {
+      map.putAllBytes(this.fiveBytes);
+      assertEventuallyMapSize(5);
+      assertEventuallyKeySetEquals(new TreeSet<String>(fiveBytes.keySet()));
+      fourLeftRemovingOne();
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testPutAllFiles() {
-        map.putAllFiles(this.fiveFiles);
-        assertEquals(map.size(), 5);
-        assertEquals(new TreeSet<String>(map.keySet()), new TreeSet<String>(
-                fiveFiles.keySet()));
-        fourLeftRemovingOne();
-    }
+   @Test(groups = { "integration", "live" })
+   public void testPutAllFiles() throws InterruptedException {
+      map.putAllFiles(this.fiveFiles);
+      assertEventuallyMapSize(5);
+      assertEventuallyKeySetEquals(new TreeSet<String>(fiveFiles.keySet()));
+      fourLeftRemovingOne();
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testPutAllStrings() {
-        map.putAllStrings(this.fiveStrings);
-        assertEquals(map.size(), 5);
-        assertEquals(new TreeSet<String>(map.keySet()), new TreeSet<String>(
-                fiveStrings.keySet()));
-        fourLeftRemovingOne();
-    }
+   @Test(groups = { "integration", "live" })
+   public void testPutAllStrings() throws InterruptedException {
+      map.putAllStrings(this.fiveStrings);
+      assertEventuallyMapSize(5);
+      assertEventuallyKeySetEquals(new TreeSet<String>(fiveStrings.keySet()));
+      fourLeftRemovingOne();
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testPutString() throws IOException {
-        InputStream old = map.putString("one", "apple");
-        getOneReturnsAppleAndOldValueIsNull(old);
-        InputStream apple = map.putString("one", "bear");
-        getOneReturnsBearAndOldValueIsApple(apple);
-    }
+   @Test(groups = { "integration", "live" })
+   public void testPutString() throws IOException, InterruptedException {
+      InputStream old = map.putString("one", "apple");
+      getOneReturnsAppleAndOldValueIsNull(old);
+      InputStream apple = map.putString("one", "bear");
+      getOneReturnsBearAndOldValueIsApple(apple);
+   }
 
-    void getOneReturnsAppleAndOldValueIsNull(InputStream old)
-            throws IOException {
-        assert old == null;
-        assertEquals(Utils.toStringAndClose(map.get("one")), "apple");
-        assertEquals(map.size(), 1);
-    }
+   void getOneReturnsAppleAndOldValueIsNull(InputStream old) throws IOException,
+            InterruptedException {
+      assert old == null;
+      assertEquals(Utils.toStringAndClose(map.get("one")), "apple");
+      assertEventuallyMapSize(1);
+   }
 
-    void getOneReturnsBearAndOldValueIsApple(InputStream oldValue)
-            throws IOException {
-        assertEquals(Utils.toStringAndClose(map.get("one")), "bear");
-        assertEquals(Utils.toStringAndClose(oldValue), "apple");
-        assertEquals(map.size(), 1);
-    }
+   void getOneReturnsBearAndOldValueIsApple(InputStream oldValue) throws IOException,
+            InterruptedException {
+      assertEquals(Utils.toStringAndClose(map.get("one")), "bear");
+      assertEquals(Utils.toStringAndClose(oldValue), "apple");
+      assertEventuallyMapSize(1);
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testPutFile() throws IOException {
-        InputStream old = map.putFile("one", fiveFiles.get("one"));
-        getOneReturnsAppleAndOldValueIsNull(old);
-        InputStream apple = map.putFile("one", fiveFiles.get("two"));
-        getOneReturnsBearAndOldValueIsApple(apple);
-    }
+   @Test(groups = { "integration", "live" })
+   public void testPutFile() throws IOException, InterruptedException {
+      InputStream old = map.putFile("one", fiveFiles.get("one"));
+      getOneReturnsAppleAndOldValueIsNull(old);
+      InputStream apple = map.putFile("one", fiveFiles.get("two"));
+      getOneReturnsBearAndOldValueIsApple(apple);
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testPutBytes() throws IOException {
-        InputStream old = map.putBytes("one", "apple".getBytes());
-        getOneReturnsAppleAndOldValueIsNull(old);
-        InputStream apple = map.putBytes("one", "bear".getBytes());
-        getOneReturnsBearAndOldValueIsApple(apple);
-    }
+   @Test(groups = { "integration", "live" })
+   public void testPutBytes() throws IOException, InterruptedException {
+      InputStream old = map.putBytes("one", "apple".getBytes());
+      getOneReturnsAppleAndOldValueIsNull(old);
+      InputStream apple = map.putBytes("one", "bear".getBytes());
+      getOneReturnsBearAndOldValueIsApple(apple);
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testPut() throws IOException {
-        InputStream old = map.put("one", IOUtils.toInputStream("apple"));
-        getOneReturnsAppleAndOldValueIsNull(old);
-        InputStream apple = map.put("one", IOUtils.toInputStream("bear"));
-        getOneReturnsBearAndOldValueIsApple(apple);
-    }
+   @Test(groups = { "integration", "live" })
+   public void testPut() throws IOException, InterruptedException {
+      InputStream old = map.put("one", IOUtils.toInputStream("apple"));
+      getOneReturnsAppleAndOldValueIsNull(old);
+      InputStream apple = map.put("one", IOUtils.toInputStream("bear"));
+      getOneReturnsBearAndOldValueIsApple(apple);
+   }
 
-    @Override
-    protected void putString(String key, String value) {
-        map.putString(key, value);
-    }
+   @Override
+   protected void putString(String key, String value) {
+      map.putString(key, value);
+   }
 
 }
diff --git a/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3IntegrationTest.java b/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3IntegrationTest.java
index 0f333d799a..6984952732 100644
--- a/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3IntegrationTest.java
+++ b/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3IntegrationTest.java
@@ -49,6 +49,7 @@ import org.jclouds.aws.s3.domain.S3Object;
 import org.jclouds.aws.s3.reference.S3Constants;
 import org.jclouds.aws.s3.util.S3Utils;
 import org.jclouds.http.config.JavaUrlHttpFutureCommandClientModule;
+import org.jclouds.util.Utils;
 import org.testng.ITestContext;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.AfterMethod;
@@ -61,6 +62,28 @@ import com.google.inject.Module;
 
 public class S3IntegrationTest {
    protected static final String TEST_STRING = "<apples><apple name=\"fuji\"></apple> </apples>";
+   public static long INCONSISTENCY_WINDOW = 1000;
+
+   /**
+    * 
+    * Due to eventual consistency, the size of the bucket and hence the size of the map may not
+    * return correctly immediately. Hence, we will try up to the inconsistency window to see if the
+    * assertion completes.
+    */
+   protected void assertEventually(Runnable assertion) throws InterruptedException {
+      AssertionError error = null;
+      for (int i = 0; i < 5; i++) {
+         try {
+            assertion.run();
+            return;
+         } catch (AssertionError e) {
+            error = e;
+         }
+         Thread.sleep(INCONSISTENCY_WINDOW / 5);
+      }
+      if (error != null)
+         throw error;
+   }
 
    protected byte[] goodMd5;
    protected byte[] badMd5;
@@ -70,8 +93,20 @@ public class S3IntegrationTest {
             ExecutionException, TimeoutException {
       deleteBucket(sourceBucket);
       client.putBucketIfNotExists(sourceBucket).get(10, TimeUnit.SECONDS);
-      assertEquals(client.listBucket(sourceBucket).get(10, TimeUnit.SECONDS).getContents().size(),
-               0, "bucket " + sourceBucket + "wasn't empty");
+      assertEventuallyBucketEmpty(sourceBucket);
+   }
+
+   protected void assertEventuallyBucketEmpty(final String bucketName) throws InterruptedException {
+      assertEventually(new Runnable() {
+         public void run() {
+            try {
+               assertEquals(client.listBucket(bucketName).get(10, TimeUnit.SECONDS).getContents()
+                        .size(), 0, "bucket " + bucketName + "wasn't empty");
+            } catch (Exception e) {
+               Utils.<RuntimeException> rethrowIfRuntimeOrSameType(e);
+            }
+         }
+      });
    }
 
    protected void addObjectToBucket(String sourceBucket, String key) throws InterruptedException,
@@ -89,14 +124,27 @@ public class S3IntegrationTest {
 
    protected S3Object validateContent(String sourceBucket, String key) throws InterruptedException,
             ExecutionException, TimeoutException, IOException {
-      assertEquals(client.listBucket(sourceBucket).get(10, TimeUnit.SECONDS).getContents().size(),
-               1);
+      assertEventuallyBucketSize(sourceBucket, 1);
       S3Object newObject = client.getObject(sourceBucket, key).get(10, TimeUnit.SECONDS);
       assert newObject != S3Object.NOT_FOUND;
       assertEquals(S3Utils.getContentAsStringAndClose(newObject), TEST_STRING);
       return newObject;
    }
 
+   protected void assertEventuallyBucketSize(final String bucketName, final int count)
+            throws InterruptedException {
+      assertEventually(new Runnable() {
+         public void run() {
+            try {
+               assertEquals(client.listBucket(bucketName).get(10, TimeUnit.SECONDS).getContents()
+                        .size(), count);
+            } catch (Exception e) {
+               Utils.<RuntimeException> rethrowIfRuntimeOrSameType(e);
+            }
+         }
+      });
+   }
+
    @BeforeClass(groups = { "integration", "live" })
    protected void enableDebug() {
       if (debugEnabled()) {
diff --git a/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3ObjectMapIntegrationTest.java b/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3ObjectMapIntegrationTest.java
index 571a77fc6d..1200004bab 100644
--- a/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3ObjectMapIntegrationTest.java
+++ b/aws/s3/core/src/test/java/org/jclouds/aws/s3/S3ObjectMapIntegrationTest.java
@@ -23,144 +23,148 @@
  */
 package org.jclouds.aws.s3;
 
+import static org.testng.Assert.assertEquals;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.Map.Entry;
+
 import org.apache.commons.io.IOUtils;
 import org.jclouds.aws.s3.domain.S3Object;
 import org.jclouds.aws.s3.internal.BaseS3Map;
 import org.jclouds.aws.s3.util.S3Utils;
-import static org.testng.Assert.assertEquals;
 import org.testng.annotations.Test;
 
-import java.io.IOException;
-import java.util.*;
-import java.util.Map.Entry;
-
 /**
  * Tests to cover @{link LiveS3ObjectMap}
- *
+ * 
  * @author Adrian Cole
  */
 @Test(testName = "s3.S3ObjectMapIntegrationTest")
 public class S3ObjectMapIntegrationTest extends BaseS3MapIntegrationTest<S3Object> {
-    S3ObjectMap map = null;
+   S3ObjectMap map = null;
 
-    @SuppressWarnings("unchecked")
-    protected BaseS3Map<S3Object> createMap(S3Context context, String bucket) {
-        map = context.createS3ObjectMap(bucket);
-        return (BaseS3Map<S3Object>) map;
-    }
+   @SuppressWarnings("unchecked")
+   protected BaseS3Map<S3Object> createMap(S3Context context, String bucket) {
+      map = context.createS3ObjectMap(bucket);
+      return (BaseS3Map<S3Object>) map;
+   }
 
-    @Override
-    @Test(groups = {"integration", "live"})
-    public void testValues() throws IOException {
-        putFiveStrings();
-        Collection<S3Object> values = map.values();
-        assertEquals(values.size(), 5);
-        Set<String> valuesAsString = new HashSet<String>();
-        for (S3Object object : values) {
-            valuesAsString.add(S3Utils.getContentAsStringAndClose(object));
-        }
-        valuesAsString.removeAll(fiveStrings.values());
-        assert valuesAsString.size() == 0;
-    }
+   @Override
+   @Test(groups = { "integration", "live" })
+   public void testValues() throws IOException, InterruptedException {
+      putFiveStrings();
+      Collection<S3Object> values = map.values();
+      assertEventuallyMapSize(5);
+      Set<String> valuesAsString = new HashSet<String>();
+      for (S3Object object : values) {
+         valuesAsString.add(S3Utils.getContentAsStringAndClose(object));
+      }
+      valuesAsString.removeAll(fiveStrings.values());
+      assert valuesAsString.size() == 0;
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testRemove() throws IOException {
-        putString("one", "two");
-        S3Object old = map.remove("one");
-        assertEquals(S3Utils.getContentAsStringAndClose(old), "two");
-        old = map.remove("one");
-        assert old == S3Object.NOT_FOUND;
-        old = map.get("one");
-        assert old == S3Object.NOT_FOUND;
-        assertEquals(map.keySet().size(), 0);
-    }
+   @Test(groups = { "integration", "live" })
+   public void testRemove() throws IOException, InterruptedException {
+      putString("one", "two");
+      S3Object old = map.remove("one");
+      assertEquals(S3Utils.getContentAsStringAndClose(old), "two");
+      old = map.remove("one");
+      assert old == S3Object.NOT_FOUND;
+      old = map.get("one");
+      assert old == S3Object.NOT_FOUND;
+      assertEventuallyKeySize(0);
+   }
 
-    @Override
-    @Test(groups = {"integration", "live"})
-    public void testEntrySet() throws IOException {
-        putFiveStrings();
-        Set<Entry<String, S3Object>> entries = map.entrySet();
-        assertEquals(entries.size(), 5);
-        for (Entry<String, S3Object> entry : entries) {
-            assertEquals(S3Utils.getContentAsStringAndClose(entry.getValue()),
-                    fiveStrings.get(entry.getKey()));
-            S3Object value = entry.getValue();
-            value.setData("");
-            value.generateMd5();
-            entry.setValue(value);
-        }
-        assertEquals(map.size(), 5);
-        for (S3Object value : map.values()) {
-            assertEquals(S3Utils.getContentAsStringAndClose(value), "");
-        }
-    }
+   @Override
+   @Test(groups = { "integration", "live" })
+   public void testEntrySet() throws IOException, InterruptedException {
+      putFiveStrings();
+      Set<Entry<String, S3Object>> entries = map.entrySet();
+      assertEquals(entries.size(), 5);
+      for (Entry<String, S3Object> entry : entries) {
+         assertEquals(S3Utils.getContentAsStringAndClose(entry.getValue()), fiveStrings.get(entry
+                  .getKey()));
+         S3Object value = entry.getValue();
+         value.setData("");
+         value.generateMd5();
+         entry.setValue(value);
+      }
+      assertEventuallyMapSize(5);
+      for (S3Object value : map.values()) {
+         assertEquals(S3Utils.getContentAsStringAndClose(value), "");
+      }
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testContains() {
-        putString("one", "apple");
-        S3Object object = new S3Object("one");
-        object.setData("apple");
-        assert map.containsValue(object);
-    }
+   @Test(groups = { "integration", "live" })
+   public void testContains() {
+      putString("one", "apple");
+      S3Object object = new S3Object("one");
+      object.setData("apple");
+      assert map.containsValue(object);
+   }
 
-    void getOneReturnsAppleAndOldValueIsNull(S3Object old) throws IOException {
-        assert old == S3Object.NOT_FOUND;
-        assertEquals(S3Utils.getContentAsStringAndClose(map.get("one")),
-                "apple");
-        assert map.size() == 1;
-    }
+   void getOneReturnsAppleAndOldValueIsNull(S3Object old) throws IOException, InterruptedException {
+      assert old == S3Object.NOT_FOUND;
+      assertEquals(S3Utils.getContentAsStringAndClose(map.get("one")), "apple");
+      assertEventuallyMapSize(1);
+   }
 
-    void getOneReturnsBearAndOldValueIsApple(S3Object oldValue)
-            throws IOException {
-        assertEquals(S3Utils.getContentAsStringAndClose(map.get("one")), "bear");
-        assertEquals(S3Utils.getContentAsStringAndClose(oldValue), "apple");
-        assert map.size() == 1;
-    }
+   void getOneReturnsBearAndOldValueIsApple(S3Object oldValue) throws IOException,
+            InterruptedException {
+      assertEquals(S3Utils.getContentAsStringAndClose(map.get("one")), "bear");
+      assertEquals(S3Utils.getContentAsStringAndClose(oldValue), "apple");
+      assertEventuallyMapSize(1);
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testPut() throws IOException {
-        S3Object object = new S3Object("one");
-        object.setData(IOUtils.toInputStream("apple"));
-        object.generateMd5();
-        S3Object old = map.put(object.getKey(), object);
-        getOneReturnsAppleAndOldValueIsNull(old);
-        object.setData(IOUtils.toInputStream("bear"));
-        object.generateMd5();
-        S3Object apple = map.put(object.getKey(), object);
-        getOneReturnsBearAndOldValueIsApple(apple);
-    }
+   @Test(groups = { "integration", "live" })
+   public void testPut() throws IOException, InterruptedException {
+      S3Object object = new S3Object("one");
+      object.setData(IOUtils.toInputStream("apple"));
+      object.generateMd5();
+      S3Object old = map.put(object.getKey(), object);
+      getOneReturnsAppleAndOldValueIsNull(old);
+      object.setData(IOUtils.toInputStream("bear"));
+      object.generateMd5();
+      S3Object apple = map.put(object.getKey(), object);
+      getOneReturnsBearAndOldValueIsApple(apple);
+   }
 
-    @Test(groups = {"integration", "live"})
-    public void testPutAll() {
-        Map<String, S3Object> newMap = new HashMap<String, S3Object>();
-        for (String key : fiveInputs.keySet()) {
-            S3Object object = new S3Object(key);
-            object.setData(fiveInputs.get(key));
-            object.getMetadata().setSize(fiveBytes.get(key).length);
-            newMap.put(key, object);
-        }
-        map.putAll(newMap);
-        assertEquals(map.size(), 5);
-        assertEquals(new TreeSet<String>(map.keySet()), new TreeSet<String>(
-                fiveInputs.keySet()));
-        fourLeftRemovingOne();
-    }
+   @Test(groups = { "integration", "live" })
+   public void testPutAll() throws InterruptedException {
+      Map<String, S3Object> newMap = new HashMap<String, S3Object>();
+      for (String key : fiveInputs.keySet()) {
+         S3Object object = new S3Object(key);
+         object.setData(fiveInputs.get(key));
+         object.getMetadata().setSize(fiveBytes.get(key).length);
+         newMap.put(key, object);
+      }
+      map.putAll(newMap);
+      assertEventuallyMapSize(5);
+      assertEventuallyKeySetEquals(new TreeSet<String>(fiveInputs.keySet()));
+      fourLeftRemovingOne();
+   }
 
-    @Override
-    protected void putString(String key, String value) {
-        S3Object object = new S3Object(key);
-        object.setData(value);
-        map.put(key, object);
-    }
+   @Override
+   protected void putString(String key, String value) {
+      S3Object object = new S3Object(key);
+      object.setData(value);
+      map.put(key, object);
+   }
 
-    protected void putFiveStrings() {
-        Map<String, S3Object> newMap = new HashMap<String, S3Object>();
-        for (Map.Entry<String, String> entry : fiveStrings.entrySet()) {
-            S3Object object = new S3Object(entry.getKey());
-            object.setData(entry.getValue());
-            newMap.put(entry.getKey(), object);
-        }
-        map.putAll(newMap);
-    }
+   protected void putFiveStrings() {
+      Map<String, S3Object> newMap = new HashMap<String, S3Object>();
+      for (Map.Entry<String, String> entry : fiveStrings.entrySet()) {
+         S3Object object = new S3Object(entry.getKey());
+         object.setData(entry.getValue());
+         newMap.put(entry.getKey(), object);
+      }
+      map.putAll(newMap);
+   }
 
 }