Merge remote-tracking branch 'origin/master' into 7.4

9 files changed, 243 insertions, 358 deletions

diff --git a/WebContent/VAADIN/themes/valo/components/_combobox.scss b/WebContent/VAADIN/themes/valo/components/_combobox.scss
index f84faef603..ace3dbb4bb 100644
--- a/WebContent/VAADIN/themes/valo/components/_combobox.scss
+++ b/WebContent/VAADIN/themes/valo/components/_combobox.scss
@@ -266,17 +266,21 @@
  * @group combobox
  */
 @mixin valo-combobox-button-style ($unit-size: $v-unit-size, $bevel: $v-bevel, $background-color: $v-textfield-background-color, $border-radius: $v-border-radius, $border: $v-textfield-border) {
-  $border-width: first-number($v-textfield-border) or 0;
+  $border-width: first-number($border) or 0;
   @include valo-tappable;
   position: absolute;
-  top: $border-width;
-  right: $border-width;
-  bottom: $border-width;
   width: $unit-size;
-  cursor: pointer;
+
+  @if $border and $border != none {
+    top: $border-width;
+    right: $border-width;
+    bottom: $border-width;
+  }
 
   @if type-of($background-color) == color {
-    border-left: valo-border($color: $background-color, $border: $v-textfield-border, $strength: 0.5);
+    @if $border {
+      border-left: valo-border($color: $background-color, $border: $v-textfield-border, $strength: 0.5);
+    }
     color: mix($background-color, valo-font-color($background-color));
 
     .v-ie8 & {
diff --git a/WebContent/VAADIN/themes/valo/components/_datefield.scss b/WebContent/VAADIN/themes/valo/components/_datefield.scss
index 6d36ade43a..52a4acf821 100644
--- a/WebContent/VAADIN/themes/valo/components/_datefield.scss
+++ b/WebContent/VAADIN/themes/valo/components/_datefield.scss
@@ -202,26 +202,30 @@
   @include valo-tappable;
   -webkit-appearance: none;
   background: transparent;
-  @if $border {
-    // Only override border if we are actually setting some border
-    border: none;
-  }
   padding: 0;
   position: absolute;
   z-index: 10;
-  top: $border-width;
-  bottom: $border-width;
-  left: $border-width;
   width: $unit-size;
   line-height: $unit-size - ($border-width*2);
   text-align: center;
-  cursor: pointer;
   font: inherit;
   outline: none;
   margin: 0;
 
+  @if $border and $border != none {
+    top: $border-width;
+    bottom: $border-width;
+    left: $border-width;
+  }
+
+  @if $border {
+    border: none;
+  }
+
   @if type-of($background-color) == color {
-    border-right: valo-border($color: $background-color, $border: $v-textfield-border, $strength: 0.5);
+    @if $border {
+      border-right: valo-border($color: $background-color, $border: $v-textfield-border, $strength: 0.5);
+    }
     color: mix($background-color, valo-font-color($background-color));
 
     &:hover {
diff --git a/WebContent/release-notes.html b/WebContent/release-notes.html
index d02e0eeb37..a060372580 100644
--- a/WebContent/release-notes.html
+++ b/WebContent/release-notes.html
@@ -133,6 +133,7 @@
                 <p>JavascriptFunction.call parameter type has been changed to elemental.json.JsonArray, affecting JavaScript.addFunction, AbstractJavaScriptComponent.addFunction and AbstractJavaScriptExtension.addFunction</p>
                 <p>Raw JSON values passed to AbstractJavaScriptComponent.callFunction and AbstractJavaScriptExtension.callFunction should be changed to use elemental.json types.</p>
             </li>
+            <li>The semantics of empty and required for Field classes has been made more consistent. This mainly affects Checkbox which is now considered to be empty when it is not checked.</li>
             <li>Support for Opera 12 has been dropped. Newer versions based on the Blink rendering engine are still supported.</li>
         </ul>
         <h3 id="knownissues">Known issues</h3>
diff --git a/client/src/com/vaadin/client/debug/internal/ErrorNotificationHandler.java b/client/src/com/vaadin/client/debug/internal/ErrorNotificationHandler.java
index f4fbe12c0d..5d128cbdcc 100644
--- a/client/src/com/vaadin/client/debug/internal/ErrorNotificationHandler.java
+++ b/client/src/com/vaadin/client/debug/internal/ErrorNotificationHandler.java
@@ -20,6 +20,7 @@ import java.util.logging.Handler;
 import java.util.logging.Level;
 import java.util.logging.LogRecord;
 
+import com.google.gwt.dom.client.Style.TextAlign;
 import com.google.gwt.logging.client.TextLogFormatter;
 import com.google.gwt.user.client.ui.Widget;
 import com.vaadin.client.ApplicationConfiguration;
@@ -65,10 +66,12 @@ public class ErrorNotificationHandler extends Handler {
                         .getRunningApplications().get(0);
                 owner = connection.getUIConnector().getWidget();
             }
-            VNotification
-                    .createNotification(VNotification.DELAY_FOREVER, owner)
-                    .show("<h1>Uncaught client side exception</h1><br />"
-                            + exceptionText, VNotification.CENTERED, "error");
+            VNotification n = VNotification.createNotification(
+                    VNotification.DELAY_FOREVER, owner);
+            n.getElement().getStyle().setTextAlign(TextAlign.LEFT);
+            n.show("<h1>Uncaught client side exception</h1><br />"
+                    + exceptionText.replace("\n", "<br/>\n"),
+                    VNotification.CENTERED, "error");
         } catch (Exception e2) {
             // Just swallow this exception
         }
diff --git a/server/src/com/vaadin/navigator/Navigator.java b/server/src/com/vaadin/navigator/Navigator.java
index 591f73dc75..ef5c61a294 100644
--- a/server/src/com/vaadin/navigator/Navigator.java
+++ b/server/src/com/vaadin/navigator/Navigator.java
@@ -58,9 +58,8 @@ import com.vaadin.ui.UI;
  * Views can be explicitly registered or dynamically generated and listening to
  * view changes is possible.
  * <p>
- * Note that {@link Navigator} is not a component itself but comes with
- * {@link SimpleViewDisplay} which is a component that displays the selected
- * view as its contents.
+ * Note that {@link Navigator} is not a component itself but uses a
+ * {@link ViewDisplay} to update contents based on the state.
  * 
  * @author Vaadin Ltd
  * @since 7.0
@@ -627,11 +626,9 @@ public class Navigator implements Serializable {
     }
 
     /**
-     * Return the ViewDisplay used by the navigator. Unless another display is
-     * specified, a {@link SimpleViewDisplay} (which is a {@link Component}) is
-     * used by default.
+     * Return the {@link ViewDisplay} used by the navigator.
      * 
-     * @return current ViewDisplay
+     * @return the ViewDisplay used for displaying views
      */
     public ViewDisplay getDisplay() {
         return display;
diff --git a/server/src/com/vaadin/server/communication/PushRequestHandler.java b/server/src/com/vaadin/server/communication/PushRequestHandler.java
index 40eb1b688e..d0367d0bed 100644
--- a/server/src/com/vaadin/server/communication/PushRequestHandler.java
+++ b/server/src/com/vaadin/server/communication/PushRequestHandler.java
@@ -29,6 +29,7 @@ import org.atmosphere.cpr.AtmosphereInterceptor;
 import org.atmosphere.cpr.AtmosphereRequest;
 import org.atmosphere.cpr.AtmosphereResponse;
 import org.atmosphere.interceptor.HeartbeatInterceptor;
+import org.atmosphere.util.VoidAnnotationProcessor;
 
 import com.vaadin.server.RequestHandler;
 import com.vaadin.server.ServiceDestroyEvent;
@@ -91,6 +92,8 @@ public class PushRequestHandler implements RequestHandler,
         atmosphere.addAtmosphereHandler("/*", pushHandler.handler);
         atmosphere.addInitParameter(ApplicationConfig.BROADCASTER_CACHE,
                 UUIDBroadcasterCache.class.getName());
+        atmosphere.addInitParameter(ApplicationConfig.ANNOTATION_PROCESSOR,
+                VoidAnnotationProcessor.class.getName());
         atmosphere.addInitParameter(ApplicationConfig.PROPERTY_SESSION_SUPPORT,
                 "true");
         atmosphere.addInitParameter(ApplicationConfig.MESSAGE_DELIMITER,
diff --git a/server/tests/src/com/vaadin/data/util/sqlcontainer/SQLContainerTableQueryTest.java b/server/tests/src/com/vaadin/data/util/sqlcontainer/SQLContainerTableQueryTest.java
index f82ba49c3e..2d66b728a7 100644
--- a/server/tests/src/com/vaadin/data/util/sqlcontainer/SQLContainerTableQueryTest.java
+++ b/server/tests/src/com/vaadin/data/util/sqlcontainer/SQLContainerTableQueryTest.java
@@ -29,10 +29,9 @@ import static org.junit.Assert.assertTrue;
 public class SQLContainerTableQueryTest {
 
     private static final int offset = SQLTestsConstants.offset;
-    private static final String createGarbage = SQLTestsConstants.createGarbage;
     private JDBCConnectionPool connectionPool;
     private TableQuery peopleQuery;
-    private SQLContainer peopleContainer;
+    private SQLContainer container;
 
     @Before
     public void setUp() throws SQLException {
@@ -48,9 +47,19 @@ public class SQLContainerTableQueryTest {
 
         DataGenerator.addPeopleToDatabase(connectionPool);
 
-        peopleQuery = new TableQuery("people", connectionPool,
+        peopleQuery = getTableQuery("people");
+        container = new SQLContainer(peopleQuery);
+    }
+
+    private TableQuery getTableQuery(String tableName) {
+        return new TableQuery(tableName, connectionPool,
                 SQLTestsConstants.sqlGen);
-        peopleContainer = new SQLContainer(peopleQuery);
+    }
+
+    private SQLContainer getGarbageContainer() throws SQLException {
+        DataGenerator.createGarbage(connectionPool);
+
+        return new SQLContainer(getTableQuery("garbage"));
     }
 
     @After
@@ -63,19 +72,19 @@ public class SQLContainerTableQueryTest {
     @Test
     public void itemWithExistingVersionColumnIsRemoved()
             throws SQLException {
-        peopleContainer.setAutoCommit(true);
+        container.setAutoCommit(true);
         peopleQuery.setVersionColumn("ID");
 
-        assertTrue(peopleContainer.removeItem(peopleContainer.lastItemId()));
+        assertTrue(container.removeItem(container.lastItemId()));
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void itemWithNonExistingVersionColumnCannotBeRemoved() throws SQLException {
         peopleQuery.setVersionColumn("version");
 
-        peopleContainer.removeItem(peopleContainer.lastItemId());
+        container.removeItem(container.lastItemId());
 
-        peopleContainer.commit();
+        container.commit();
     }
 
     @Test
@@ -89,74 +98,87 @@ public class SQLContainerTableQueryTest {
             throws SQLException {
         SQLContainer container = new SQLContainer(new TableQuery("people",
                 connectionPool, SQLTestsConstants.sqlGen));
+
         assertTrue(container.containsId(new RowId(
                 new Object[]{1 + offset})));
+        Assert.assertTrue(container.containsId(new RowId(
+                new Object[] { 1 + offset })));
+        assertTrue(this.container.containsId(new RowId(
+                new Object[]{1 + offset})));
     }
 
     @Test
     public void containsId_withTableQueryAndNonexistingId_returnsFalse()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Assert.assertFalse(container.containsId(new RowId(
-                new Object[] { 1337 + offset })));
+                new Object[]{1337 + offset})));
+    }
+
+    @Test
+    public void getContainerProperty_tableExistingItemIdAndNonexistingPropertyId_returnsNull()
+            throws SQLException {
+        Assert.assertNull(container.getContainerProperty(new RowId(
+                new Object[]{1 + offset}), "asdf"));
+    }
+
+    @Test
+    public void getContainerProperty_tableNonexistingItemId_returnsNull()
+            throws SQLException {
+        Assert.assertNull(container.getContainerProperty(new RowId(
+                new Object[]{1337 + offset}), "NAME"));
+    }
+
+    @Test
+    public void getType_tableIDPropertyId_returnsInteger() throws SQLException {
+        if (SQLTestsConstants.db == DB.ORACLE) {
+            Assert.assertEquals(BigDecimal.class, container.getType("ID"));
+        } else {
+            Assert.assertEquals(Integer.class, container.getType("ID"));
+        }
+    }
+
+    @Test
+    public void getType_tableNonexistingPropertyId_returnsNull()
+            throws SQLException {
+        Assert.assertNull(container.getType("asdf"));
+    }
+
+    @Test
+    public void size_table_returnsFour() throws SQLException {
+        Assert.assertEquals(4, container.size());
     }
 
     @Test
     public void getContainerProperty_tableExistingItemIdAndPropertyId_returnsProperty()
             throws SQLException {
-        TableQuery t = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(t);
         if (SQLTestsConstants.db == DB.ORACLE) {
             Assert.assertEquals(
                     "Ville",
                     container
                             .getContainerProperty(
-                                    new RowId(new Object[] { new BigDecimal(
-                                            0 + offset) }), "NAME").getValue());
+                                    new RowId(new Object[]{new BigDecimal(
+                                            0 + offset)}), "NAME").getValue());
         } else {
             Assert.assertEquals(
                     "Ville",
                     container.getContainerProperty(
-                            new RowId(new Object[] { 0 + offset }), "NAME")
+                            new RowId(new Object[]{0 + offset}), "NAME")
                             .getValue());
         }
     }
 
-    @Test
-    public void getContainerProperty_tableExistingItemIdAndNonexistingPropertyId_returnsNull()
-            throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
-        Assert.assertNull(container.getContainerProperty(new RowId(
-                new Object[] { 1 + offset }), "asdf"));
-    }
-
-    @Test
-    public void getContainerProperty_tableNonexistingItemId_returnsNull()
-            throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
-        Assert.assertNull(container.getContainerProperty(new RowId(
-                new Object[] { 1337 + offset }), "NAME"));
-    }
 
     @Test
     public void getContainerPropertyIds_table_returnsIDAndNAME()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Collection<?> propertyIds = container.getContainerPropertyIds();
         Assert.assertEquals(3, propertyIds.size());
-        Assert.assertArrayEquals(new String[] { "ID", "NAME", "AGE" },
+        Assert.assertArrayEquals(new String[]{"ID", "NAME", "AGE"},
                 propertyIds.toArray());
     }
 
     @Test
     public void getItem_tableExistingItemId_returnsItem() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Item item;
         if (SQLTestsConstants.db == DB.ORACLE) {
             item = container.getItem(new RowId(new Object[] { new BigDecimal(
@@ -173,8 +195,6 @@ public class SQLContainerTableQueryTest {
         String OLD_VALUE = "SomeValue"; //$NON-NLS-1$
         String NEW_VALUE = "OtherValue"; //$NON-NLS-1$
 
-        SQLContainer container = new SQLContainer(new TableQuery("people", //$NON-NLS-1$
-                connectionPool, SQLTestsConstants.sqlGen));
         Object itemID = container.addItem();
         Item item = container.getItem(itemID);
         item.getItemProperty("NAME").setValue(OLD_VALUE); //$NON-NLS-1$
@@ -201,9 +221,6 @@ public class SQLContainerTableQueryTest {
     public void getItem_table5000RowsWithParameter1337_returnsItemWithId1337()
             throws SQLException {
         DataGenerator.addFiveThousandPeople(connectionPool);
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
 
         Item item;
         if (SQLTestsConstants.db == DB.ORACLE) {
@@ -225,8 +242,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void getItemIds_table_returnsItemIdsWithKeys0through3()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Collection<?> itemIds = container.getItemIds();
         Assert.assertEquals(4, itemIds.size());
         RowId zero = new RowId(new Object[] { 0 + offset });
@@ -248,38 +263,10 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void getType_tableNAMEPropertyId_returnsString() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Assert.assertEquals(String.class, container.getType("NAME"));
     }
 
     @Test
-    public void getType_tableIDPropertyId_returnsInteger() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
-        if (SQLTestsConstants.db == DB.ORACLE) {
-            Assert.assertEquals(BigDecimal.class, container.getType("ID"));
-        } else {
-            Assert.assertEquals(Integer.class, container.getType("ID"));
-        }
-    }
-
-    @Test
-    public void getType_tableNonexistingPropertyId_returnsNull()
-            throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
-        Assert.assertNull(container.getType("asdf"));
-    }
-
-    @Test
-    public void size_table_returnsFour() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
-        Assert.assertEquals(4, container.size());
-    }
-
-    @Test
     public void size_tableOneAddedItem_returnsFive() throws SQLException {
         Connection conn = connectionPool.reserveConnection();
         Statement statement = conn.createStatement();
@@ -293,22 +280,18 @@ public class SQLContainerTableQueryTest {
         conn.commit();
         connectionPool.releaseConnection(conn);
 
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Assert.assertEquals(5, container.size());
     }
 
     @Test
     public void indexOfId_tableWithParameterThree_returnsThree()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         if (SQLTestsConstants.db == DB.ORACLE) {
             Assert.assertEquals(3, container.indexOfId(new RowId(
-                    new Object[] { new BigDecimal(3 + offset) })));
+                    new Object[]{new BigDecimal(3 + offset)})));
         } else {
             Assert.assertEquals(3,
-                    container.indexOfId(new RowId(new Object[] { 3 + offset })));
+                    container.indexOfId(new RowId(new Object[]{3 + offset})));
         }
     }
 
@@ -316,18 +299,16 @@ public class SQLContainerTableQueryTest {
     public void indexOfId_table5000RowsWithParameter1337_returns1337()
             throws SQLException {
         DataGenerator.addFiveThousandPeople(connectionPool);
-        TableQuery q = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(q);
+
         if (SQLTestsConstants.db == DB.ORACLE) {
-            container.getItem(new RowId(new Object[] { new BigDecimal(
-                    1337 + offset) }));
+            container.getItem(new RowId(new Object[]{new BigDecimal(
+                    1337 + offset)}));
             Assert.assertEquals(1337, container.indexOfId(new RowId(
-                    new Object[] { new BigDecimal(1337 + offset) })));
+                    new Object[]{new BigDecimal(1337 + offset)})));
         } else {
-            container.getItem(new RowId(new Object[] { 1337 + offset }));
+            container.getItem(new RowId(new Object[]{1337 + offset}));
             Assert.assertEquals(1337, container.indexOfId(new RowId(
-                    new Object[] { 1337 + offset })));
+                    new Object[]{1337 + offset})));
         }
     }
 
@@ -335,8 +316,6 @@ public class SQLContainerTableQueryTest {
     public void getIdByIndex_table5000rowsIndex1337_returnsRowId1337()
             throws SQLException {
         DataGenerator.addFiveThousandPeople(connectionPool);
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object itemId = container.getIdByIndex(1337);
         if (SQLTestsConstants.db == DB.ORACLE) {
             Assert.assertEquals(
@@ -352,10 +331,8 @@ public class SQLContainerTableQueryTest {
     public void getIdByIndex_tableWithPaging5000rowsIndex1337_returnsRowId1337()
             throws SQLException {
         DataGenerator.addFiveThousandPeople(connectionPool);
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
-        Object itemId = container.getIdByIndex(1337);
+
+         Object itemId = container.getIdByIndex(1337);
         if (SQLTestsConstants.db == DB.ORACLE) {
             Assert.assertEquals(
                     new RowId(new Object[] { 1337 + offset }).toString(),
@@ -387,29 +364,25 @@ public class SQLContainerTableQueryTest {
     public void prevItemId_tableCurrentItem1337_returns1336()
             throws SQLException {
         DataGenerator.addFiveThousandPeople(connectionPool);
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object itemId = container.getIdByIndex(1337);
         if (SQLTestsConstants.db == DB.ORACLE) {
             Assert.assertEquals(
-                    new RowId(new Object[] { 1336 + offset }).toString(),
+                    new RowId(new Object[]{1336 + offset}).toString(),
                     container.prevItemId(itemId).toString());
         } else {
-            Assert.assertEquals(new RowId(new Object[] { 1336 + offset }),
+            Assert.assertEquals(new RowId(new Object[]{1336 + offset}),
                     container.prevItemId(itemId));
         }
     }
 
     @Test
     public void firstItemId_table_returnsItemId0() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         if (SQLTestsConstants.db == DB.ORACLE) {
             Assert.assertEquals(
-                    new RowId(new Object[] { 0 + offset }).toString(),
+                    new RowId(new Object[]{0 + offset}).toString(),
                     container.firstItemId().toString());
         } else {
-            Assert.assertEquals(new RowId(new Object[] { 0 + offset }),
+            Assert.assertEquals(new RowId(new Object[]{0 + offset}),
                     container.firstItemId());
         }
     }
@@ -419,22 +392,18 @@ public class SQLContainerTableQueryTest {
             throws SQLException {
         DataGenerator.addFiveThousandPeople(connectionPool);
 
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         if (SQLTestsConstants.db == DB.ORACLE) {
             Assert.assertEquals(
-                    new RowId(new Object[] { 4999 + offset }).toString(),
+                    new RowId(new Object[]{4999 + offset}).toString(),
                     container.lastItemId().toString());
         } else {
-            Assert.assertEquals(new RowId(new Object[] { 4999 + offset }),
+            Assert.assertEquals(new RowId(new Object[]{4999 + offset}),
                     container.lastItemId());
         }
     }
 
     @Test
     public void isFirstId_tableActualFirstId_returnsTrue() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         if (SQLTestsConstants.db == DB.ORACLE) {
             assertTrue(container.isFirstId(new RowId(
                     new Object[]{new BigDecimal(0 + offset)})));
@@ -446,34 +415,28 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void isFirstId_tableSecondId_returnsFalse() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         if (SQLTestsConstants.db == DB.ORACLE) {
             Assert.assertFalse(container.isFirstId(new RowId(
-                    new Object[] { new BigDecimal(1 + offset) })));
+                    new Object[]{new BigDecimal(1 + offset)})));
         } else {
             Assert.assertFalse(container.isFirstId(new RowId(
-                    new Object[] { 1 + offset })));
+                    new Object[]{1 + offset})));
         }
     }
 
     @Test
     public void isLastId_tableSecondId_returnsFalse() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         if (SQLTestsConstants.db == DB.ORACLE) {
             Assert.assertFalse(container.isLastId(new RowId(
-                    new Object[] { new BigDecimal(1 + offset) })));
+                    new Object[]{new BigDecimal(1 + offset)})));
         } else {
             Assert.assertFalse(container.isLastId(new RowId(
-                    new Object[] { 1 + offset })));
+                    new Object[]{1 + offset})));
         }
     }
 
     @Test
     public void isLastId_tableLastId_returnsTrue() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         if (SQLTestsConstants.db == DB.ORACLE) {
             assertTrue(container.isLastId(new RowId(
                     new Object[]{new BigDecimal(3 + offset)})));
@@ -486,8 +449,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void isLastId_table5000RowsLastId_returnsTrue() throws SQLException {
         DataGenerator.addFiveThousandPeople(connectionPool);
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         if (SQLTestsConstants.db == DB.ORACLE) {
             assertTrue(container.isLastId(new RowId(
                     new Object[]{new BigDecimal(4999 + offset)})));
@@ -501,8 +462,7 @@ public class SQLContainerTableQueryTest {
     public void allIdsFound_table5000RowsLastId_shouldSucceed()
             throws SQLException {
         DataGenerator.addFiveThousandPeople(connectionPool);
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
+
         for (int i = 0; i < 5000; i++) {
             assertTrue(container.containsId(container.getIdByIndex(i)));
         }
@@ -512,8 +472,7 @@ public class SQLContainerTableQueryTest {
     public void allIdsFound_table5000RowsLastId_autoCommit_shouldSucceed()
             throws SQLException {
         DataGenerator.addFiveThousandPeople(connectionPool);
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
+
         container.setAutoCommit(true);
         for (int i = 0; i < 5000; i++) {
             assertTrue(container.containsId(container.getIdByIndex(i)));
@@ -522,8 +481,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void refresh_table_sizeShouldUpdate() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Assert.assertEquals(4, container.size());
         DataGenerator.addFiveThousandPeople(connectionPool);
         container.refresh();
@@ -537,8 +494,6 @@ public class SQLContainerTableQueryTest {
         // after adding lots of items unless we call refresh inbetween. This to
         // make sure that the refresh method actually refreshes stuff and isn't
         // a NOP.
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Assert.assertEquals(4, container.size());
         DataGenerator.addFiveThousandPeople(connectionPool);
         Assert.assertEquals(4, container.size());
@@ -546,8 +501,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void setAutoCommit_table_shouldSucceed() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.setAutoCommit(true);
         assertTrue(container.isAutoCommit());
         container.setAutoCommit(false);
@@ -556,15 +509,11 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void getPageLength_table_returnsDefault100() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Assert.assertEquals(100, container.getPageLength());
     }
 
     @Test
     public void setPageLength_table_shouldSucceed() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.setPageLength(20);
         Assert.assertEquals(20, container.getPageLength());
         container.setPageLength(200);
@@ -573,59 +522,43 @@ public class SQLContainerTableQueryTest {
 
     @Test(expected = UnsupportedOperationException.class)
     public void addContainerProperty_normal_isUnsupported() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.addContainerProperty("asdf", String.class, "");
     }
 
     @Test(expected = UnsupportedOperationException.class)
     public void removeContainerProperty_normal_isUnsupported()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.removeContainerProperty("asdf");
     }
 
     @Test(expected = UnsupportedOperationException.class)
     public void addItemObject_normal_isUnsupported() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.addItem("asdf");
     }
 
     @Test(expected = UnsupportedOperationException.class)
     public void addItemAfterObjectObject_normal_isUnsupported()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.addItemAfter("asdf", "foo");
     }
 
     @Test(expected = UnsupportedOperationException.class)
     public void addItemAtIntObject_normal_isUnsupported() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.addItemAt(2, "asdf");
     }
 
     @Test(expected = UnsupportedOperationException.class)
     public void addItemAtInt_normal_isUnsupported() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.addItemAt(2);
     }
 
     @Test(expected = UnsupportedOperationException.class)
     public void addItemAfterObject_normal_isUnsupported() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.addItemAfter("asdf");
     }
 
     @Test
     public void addItem_tableAddOneNewItem_returnsItemId() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object itemId = container.addItem();
         Assert.assertNotNull(itemId);
     }
@@ -633,9 +566,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void addItem_tableAddOneNewItem_autoCommit_returnsFinalItemId()
             throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         container.setAutoCommit(true);
         Object itemId = container.addItem();
         Assert.assertNotNull(itemId);
@@ -646,9 +576,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void addItem_tableAddOneNewItem_autoCommit_sizeIsIncreased()
             throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         container.setAutoCommit(true);
         int originalSize = container.size();
         container.addItem();
@@ -658,8 +585,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void addItem_tableAddOneNewItem_shouldChangeSize()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         int size = container.size();
         container.addItem();
         Assert.assertEquals(size + 1, container.size());
@@ -668,8 +593,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void addItem_tableAddTwoNewItems_shouldChangeSize()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         int size = container.size();
         Object id1 = container.addItem();
         Object id2 = container.addItem();
@@ -681,8 +604,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void nextItemId_tableNewlyAddedItem_returnsNewlyAdded()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object lastId = container.lastItemId();
         Object id = container.addItem();
         Assert.assertEquals(id, container.nextItemId(lastId));
@@ -691,8 +612,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void lastItemId_tableNewlyAddedItem_returnsNewlyAdded()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object lastId = container.lastItemId();
         Object id = container.addItem();
         Assert.assertEquals(id, container.lastItemId());
@@ -701,8 +620,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void indexOfId_tableNewlyAddedItem_returnsFour() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
         Assert.assertEquals(4, container.indexOfId(id));
     }
@@ -710,8 +627,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void getItem_tableNewlyAddedItem_returnsNewlyAdded()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
         Assert.assertNotNull(container.getItem(id));
     }
@@ -719,8 +634,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void getItemIds_tableNewlyAddedItem_containsNewlyAdded()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
         assertTrue(container.getItemIds().contains(id));
     }
@@ -728,8 +641,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void getContainerProperty_tableNewlyAddedItem_returnsPropertyOfNewlyAddedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
         Item item = container.getItem(id);
         item.getItemProperty("NAME").setValue("asdf");
@@ -740,86 +651,80 @@ public class SQLContainerTableQueryTest {
     @Test
     public void containsId_tableNewlyAddedItem_returnsTrue()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
+
         assertTrue(container.containsId(id));
     }
 
     @Test
     public void prevItemId_tableTwoNewlyAddedItems_returnsFirstAddedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id1 = container.addItem();
         Object id2 = container.addItem();
+
         Assert.assertEquals(id1, container.prevItemId(id2));
     }
 
     @Test
     public void firstItemId_tableEmptyResultSet_returnsFirstAddedItem()
             throws SQLException {
-        DataGenerator.createGarbage(connectionPool);
-        SQLContainer container = new SQLContainer(new TableQuery("garbage",
-                connectionPool, SQLTestsConstants.sqlGen));
-        Object id = container.addItem();
-        Assert.assertSame(id, container.firstItemId());
+        SQLContainer garbageContainer = getGarbageContainer();
+
+        Object id = garbageContainer.addItem();
+
+        Assert.assertSame(id, garbageContainer.firstItemId());
     }
 
     @Test
     public void isFirstId_tableEmptyResultSet_returnsFirstAddedItem()
             throws SQLException {
-        DataGenerator.createGarbage(connectionPool);
-        SQLContainer container = new SQLContainer(new TableQuery("garbage",
-                connectionPool, SQLTestsConstants.sqlGen));
-        Object id = container.addItem();
-        assertTrue(container.isFirstId(id));
+        SQLContainer garbageContainer = getGarbageContainer();
+
+        Object id = garbageContainer.addItem();
+
+        assertTrue(garbageContainer.isFirstId(id));
     }
 
     @Test
     public void isLastId_tableOneItemAdded_returnsTrueForAddedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
+
         assertTrue(container.isLastId(id));
     }
 
     @Test
     public void isLastId_tableTwoItemsAdded_returnsTrueForLastAddedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.addItem();
+
         Object id2 = container.addItem();
+
         assertTrue(container.isLastId(id2));
     }
 
     @Test
     public void getIdByIndex_tableOneItemAddedLastIndexInContainer_returnsAddedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
+
         Assert.assertEquals(id, container.getIdByIndex(container.size() - 1));
     }
 
     @Test
     public void removeItem_tableNoAddedItems_removesItemFromContainer()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
-        int size = container.size();
+        int originalSize = container.size();
         Object id = container.firstItemId();
+
         assertTrue(container.removeItem(id));
+
         Assert.assertNotSame(id, container.firstItemId());
-        Assert.assertEquals(size - 1, container.size());
+        Assert.assertEquals(originalSize - 1, container.size());
     }
 
     @Test
     public void containsId_tableRemovedItem_returnsFalse() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.firstItemId();
         assertTrue(container.removeItem(id));
         Assert.assertFalse(container.containsId(id));
@@ -828,10 +733,9 @@ public class SQLContainerTableQueryTest {
     @Test
     public void removeItem_tableOneAddedItem_removesTheAddedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
         int size = container.size();
+
         assertTrue(container.removeItem(id));
         Assert.assertFalse(container.containsId(id));
         Assert.assertEquals(size - 1, container.size());
@@ -839,18 +743,16 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void getItem_tableItemRemoved_returnsNull() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.firstItemId();
+
         assertTrue(container.removeItem(id));
         Assert.assertNull(container.getItem(id));
     }
 
     @Test
     public void getItem_tableAddedItemRemoved_returnsNull() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
+
         Assert.assertNotNull(container.getItem(id));
         assertTrue(container.removeItem(id));
         Assert.assertNull(container.getItem(id));
@@ -859,9 +761,8 @@ public class SQLContainerTableQueryTest {
     @Test
     public void getItemIds_tableItemRemoved_shouldNotContainRemovedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.firstItemId();
+
         assertTrue(container.getItemIds().contains(id));
         assertTrue(container.removeItem(id));
         Assert.assertFalse(container.getItemIds().contains(id));
@@ -870,9 +771,8 @@ public class SQLContainerTableQueryTest {
     @Test
     public void getItemIds_tableAddedItemRemoved_shouldNotContainRemovedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
+
         assertTrue(container.getItemIds().contains(id));
         assertTrue(container.removeItem(id));
         Assert.assertFalse(container.getItemIds().contains(id));
@@ -880,9 +780,8 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void containsId_tableItemRemoved_returnsFalse() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.firstItemId();
+
         assertTrue(container.containsId(id));
         assertTrue(container.removeItem(id));
         Assert.assertFalse(container.containsId(id));
@@ -891,10 +790,8 @@ public class SQLContainerTableQueryTest {
     @Test
     public void containsId_tableAddedItemRemoved_returnsFalse()
             throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         Object id = container.addItem();
+
         assertTrue(container.containsId(id));
         assertTrue(container.removeItem(id));
         Assert.assertFalse(container.containsId(id));
@@ -903,11 +800,10 @@ public class SQLContainerTableQueryTest {
     @Test
     public void nextItemId_tableItemRemoved_skipsRemovedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object first = container.getIdByIndex(0);
         Object second = container.getIdByIndex(1);
         Object third = container.getIdByIndex(2);
+
         assertTrue(container.removeItem(second));
         Assert.assertEquals(third, container.nextItemId(first));
     }
@@ -915,11 +811,10 @@ public class SQLContainerTableQueryTest {
     @Test
     public void nextItemId_tableAddedItemRemoved_skipsRemovedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object first = container.lastItemId();
         Object second = container.addItem();
         Object third = container.addItem();
+
         assertTrue(container.removeItem(second));
         Assert.assertEquals(third, container.nextItemId(first));
     }
@@ -927,11 +822,10 @@ public class SQLContainerTableQueryTest {
     @Test
     public void prevItemId_tableItemRemoved_skipsRemovedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object first = container.getIdByIndex(0);
         Object second = container.getIdByIndex(1);
         Object third = container.getIdByIndex(2);
+
         assertTrue(container.removeItem(second));
         Assert.assertEquals(first, container.prevItemId(third));
     }
@@ -939,11 +833,10 @@ public class SQLContainerTableQueryTest {
     @Test
     public void prevItemId_tableAddedItemRemoved_skipsRemovedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object first = container.lastItemId();
         Object second = container.addItem();
         Object third = container.addItem();
+
         assertTrue(container.removeItem(second));
         Assert.assertEquals(first, container.prevItemId(third));
     }
@@ -951,9 +844,8 @@ public class SQLContainerTableQueryTest {
     @Test
     public void firstItemId_tableFirstItemRemoved_resultChanges()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object first = container.firstItemId();
+
         assertTrue(container.removeItem(first));
         Assert.assertNotSame(first, container.firstItemId());
     }
@@ -961,22 +853,20 @@ public class SQLContainerTableQueryTest {
     @Test
     public void firstItemId_tableNewlyAddedFirstItemRemoved_resultChanges()
             throws SQLException {
-        DataGenerator.createGarbage(connectionPool);
-        SQLContainer container = new SQLContainer(new TableQuery("garbage",
-                connectionPool, SQLTestsConstants.sqlGen));
-        Object first = container.addItem();
-        Object second = container.addItem();
-        Assert.assertSame(first, container.firstItemId());
-        assertTrue(container.removeItem(first));
-        Assert.assertSame(second, container.firstItemId());
-    }
+        SQLContainer garbageContainer = getGarbageContainer();
+
+        Object first = garbageContainer.addItem();
+        Object second = garbageContainer.addItem();
 
+        Assert.assertSame(first, garbageContainer.firstItemId());
+        assertTrue(garbageContainer.removeItem(first));
+        Assert.assertSame(second, garbageContainer.firstItemId());
+    }
     @Test
     public void lastItemId_tableLastItemRemoved_resultChanges()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object last = container.lastItemId();
+
         assertTrue(container.removeItem(last));
         Assert.assertNotSame(last, container.lastItemId());
     }
@@ -984,9 +874,8 @@ public class SQLContainerTableQueryTest {
     @Test
     public void lastItemId_tableAddedLastItemRemoved_resultChanges()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object last = container.addItem();
+
         Assert.assertSame(last, container.lastItemId());
         assertTrue(container.removeItem(last));
         Assert.assertNotSame(last, container.lastItemId());
@@ -995,9 +884,8 @@ public class SQLContainerTableQueryTest {
     @Test
     public void isFirstId_tableFirstItemRemoved_returnsFalse()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object first = container.firstItemId();
+
         assertTrue(container.removeItem(first));
         Assert.assertFalse(container.isFirstId(first));
     }
@@ -1005,22 +893,21 @@ public class SQLContainerTableQueryTest {
     @Test
     public void isFirstId_tableAddedFirstItemRemoved_returnsFalse()
             throws SQLException {
-        DataGenerator.createGarbage(connectionPool);
-        SQLContainer container = new SQLContainer(new TableQuery("garbage",
-                connectionPool, SQLTestsConstants.sqlGen));
-        Object first = container.addItem();
-        container.addItem();
-        Assert.assertSame(first, container.firstItemId());
-        assertTrue(container.removeItem(first));
-        Assert.assertFalse(container.isFirstId(first));
+        SQLContainer garbageContainer = getGarbageContainer();
+
+        Object first = garbageContainer.addItem();
+        garbageContainer.addItem();
+
+        Assert.assertSame(first, garbageContainer.firstItemId());
+        assertTrue(garbageContainer.removeItem(first));
+        Assert.assertFalse(garbageContainer.isFirstId(first));
     }
 
     @Test
     public void isLastId_tableLastItemRemoved_returnsFalse()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object last = container.lastItemId();
+
         assertTrue(container.removeItem(last));
         Assert.assertFalse(container.isLastId(last));
     }
@@ -1028,9 +915,8 @@ public class SQLContainerTableQueryTest {
     @Test
     public void isLastId_tableAddedLastItemRemoved_returnsFalse()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object last = container.addItem();
+
         Assert.assertSame(last, container.lastItemId());
         assertTrue(container.removeItem(last));
         Assert.assertFalse(container.isLastId(last));
@@ -1038,9 +924,8 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void indexOfId_tableItemRemoved_returnsNegOne() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.getIdByIndex(2);
+
         assertTrue(container.removeItem(id));
         Assert.assertEquals(-1, container.indexOfId(id));
     }
@@ -1048,9 +933,8 @@ public class SQLContainerTableQueryTest {
     @Test
     public void indexOfId_tableAddedItemRemoved_returnsNegOne()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
+
         assertTrue(container.indexOfId(id) != -1);
         assertTrue(container.removeItem(id));
         Assert.assertEquals(-1, container.indexOfId(id));
@@ -1059,9 +943,8 @@ public class SQLContainerTableQueryTest {
     @Test
     public void getIdByIndex_tableItemRemoved_resultChanges()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.getIdByIndex(2);
+
         assertTrue(container.removeItem(id));
         Assert.assertNotSame(id, container.getIdByIndex(2));
     }
@@ -1069,19 +952,16 @@ public class SQLContainerTableQueryTest {
     @Test
     public void getIdByIndex_tableAddedItemRemoved_resultChanges()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object id = container.addItem();
         container.addItem();
         int index = container.indexOfId(id);
+
         assertTrue(container.removeItem(id));
         Assert.assertNotSame(id, container.getIdByIndex(index));
     }
 
     @Test
     public void removeAllItems_table_shouldSucceed() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         assertTrue(container.removeAllItems());
         Assert.assertEquals(0, container.size());
     }
@@ -1089,10 +969,9 @@ public class SQLContainerTableQueryTest {
     @Test
     public void removeAllItems_tableAddedItems_shouldSucceed()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.addItem();
         container.addItem();
+
         assertTrue(container.removeAllItems());
         Assert.assertEquals(0, container.size());
     }
@@ -1101,11 +980,11 @@ public class SQLContainerTableQueryTest {
     @Test(timeout = 1000)
     public void removeAllItems_manyItems_commit_shouldSucceed()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         final int itemNumber = (SQLContainer.CACHE_RATIO + 1)
                 * SQLContainer.DEFAULT_PAGE_LENGTH + 1;
+
         container.removeAllItems();
+
         Assert.assertEquals(container.size(), 0);
         for (int i = 0; i < itemNumber; ++i) {
             container.addItem();
@@ -1119,11 +998,9 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void commit_tableAddedItem_shouldBeWrittenToDB() throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         Object id = container.addItem();
         container.getContainerProperty(id, "NAME").setValue("New Name");
+
         assertTrue(id instanceof TemporaryRowId);
         Assert.assertSame(id, container.lastItemId());
         container.commit();
@@ -1136,9 +1013,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void commit_tableTwoAddedItems_shouldBeWrittenToDB()
             throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         Object id = container.addItem();
         Object id2 = container.addItem();
         container.getContainerProperty(id, "NAME").setValue("Herbert");
@@ -1147,6 +1021,7 @@ public class SQLContainerTableQueryTest {
         Assert.assertSame(id2, container.lastItemId());
         container.commit();
         Object nextToLast = container.getIdByIndex(container.size() - 2);
+
         Assert.assertFalse(nextToLast instanceof TemporaryRowId);
         Assert.assertEquals("Herbert",
                 container.getContainerProperty(nextToLast, "NAME").getValue());
@@ -1159,24 +1034,20 @@ public class SQLContainerTableQueryTest {
     @Test
     public void commit_tableRemovedItem_shouldBeRemovedFromDB()
             throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         Object last = container.lastItemId();
         container.removeItem(last);
         container.commit();
+
         Assert.assertFalse(last.equals(container.lastItemId()));
     }
 
     @Test
     public void commit_tableLastItemUpdated_shouldUpdateRowInDB()
             throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         Object last = container.lastItemId();
         container.getContainerProperty(last, "NAME").setValue("Donald");
         container.commit();
+
         Assert.assertEquals("Donald",
                 container.getContainerProperty(container.lastItemId(), "NAME")
                         .getValue());
@@ -1184,13 +1055,11 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void commit_removeModifiedItem_shouldSucceed() throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         int size = container.size();
         Object key = container.firstItemId();
         Item row = container.getItem(key);
         row.getItemProperty("NAME").setValue("Pekka");
+
         assertTrue(container.removeItem(key));
         container.commit();
         Assert.assertEquals(size - 1, container.size());
@@ -1198,8 +1067,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void rollback_tableItemAdded_discardsAddedItem() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         int size = container.size();
         Object id = container.addItem();
         container.getContainerProperty(id, "NAME").setValue("foo");
@@ -1213,8 +1080,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void rollback_tableItemRemoved_restoresRemovedItem()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         int size = container.size();
         Object last = container.lastItemId();
         container.removeItem(last);
@@ -1226,8 +1091,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void rollback_tableItemChanged_discardsChanges() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Object last = container.lastItemId();
         container.getContainerProperty(last, "NAME").setValue("foo");
         container.rollback();
@@ -1238,8 +1101,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void itemChangeNotification_table_isModifiedReturnsTrue()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Assert.assertFalse(container.isModified());
         RowItem last = (RowItem) container.getItem(container.lastItemId());
         container.itemChangeNotification(last);
@@ -1248,8 +1109,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void itemSetChangeListeners_table_shouldFire() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         ItemSetChangeListener listener = EasyMock
                 .createMock(ItemSetChangeListener.class);
         listener.containerItemSetChange(EasyMock.isA(ItemSetChangeEvent.class));
@@ -1264,8 +1123,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void itemSetChangeListeners_tableItemRemoved_shouldFire()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         ItemSetChangeListener listener = EasyMock
                 .createMock(ItemSetChangeListener.class);
         listener.containerItemSetChange(EasyMock.isA(ItemSetChangeEvent.class));
@@ -1280,8 +1137,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void removeListener_table_shouldNotFire() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         ItemSetChangeListener listener = EasyMock
                 .createMock(ItemSetChangeListener.class);
         EasyMock.replay(listener);
@@ -1295,8 +1150,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void isModified_tableRemovedItem_returnsTrue() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Assert.assertFalse(container.isModified());
         container.removeItem(container.lastItemId());
         assertTrue(container.isModified());
@@ -1304,8 +1157,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void isModified_tableAddedItem_returnsTrue() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Assert.assertFalse(container.isModified());
         container.addItem();
         assertTrue(container.isModified());
@@ -1313,8 +1164,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void isModified_tableChangedItem_returnsTrue() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Assert.assertFalse(container.isModified());
         container.getContainerProperty(container.lastItemId(), "NAME")
                 .setValue("foo");
@@ -1324,8 +1173,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void getSortableContainerPropertyIds_table_returnsAllPropertyIds()
             throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         Collection<?> sortableIds = container.getSortableContainerPropertyIds();
         assertTrue(sortableIds.contains("ID"));
         assertTrue(sortableIds.contains("NAME"));
@@ -1339,9 +1186,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void addOrderBy_table_shouldReorderResults() throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         // Ville, Kalle, Pelle, Börje
         Assert.assertEquals("Ville",
                 container.getContainerProperty(container.firstItemId(), "NAME")
@@ -1362,16 +1206,11 @@ public class SQLContainerTableQueryTest {
 
     @Test(expected = IllegalArgumentException.class)
     public void addOrderBy_tableIllegalColumn_shouldFail() throws SQLException {
-        SQLContainer container = new SQLContainer(new TableQuery("people",
-                connectionPool, SQLTestsConstants.sqlGen));
         container.addOrderBy(new OrderBy("asdf", true));
     }
 
     @Test
     public void sort_table_sortsByName() throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         // Ville, Kalle, Pelle, Börje
         Assert.assertEquals("Ville",
                 container.getContainerProperty(container.firstItemId(), "NAME")
@@ -1393,9 +1232,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void addFilter_table_filtersResults() throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         // Ville, Kalle, Pelle, Börje
         Assert.assertEquals(4, container.size());
         Assert.assertEquals("Börje",
@@ -1412,9 +1248,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void addContainerFilter_filtersResults() throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         // Ville, Kalle, Pelle, Börje
         Assert.assertEquals(4, container.size());
 
@@ -1430,9 +1263,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void addContainerFilter_ignoreCase_filtersResults()
             throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         // Ville, Kalle, Pelle, Börje
         Assert.assertEquals(4, container.size());
 
@@ -1448,9 +1278,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void removeAllContainerFilters_table_noFiltering()
             throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         // Ville, Kalle, Pelle, Börje
         Assert.assertEquals(4, container.size());
 
@@ -1472,9 +1299,6 @@ public class SQLContainerTableQueryTest {
 
     @Test
     public void removeContainerFilters_table_noFiltering() throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         // Ville, Kalle, Pelle, Börje
         Assert.assertEquals(4, container.size());
 
@@ -1497,9 +1321,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void addFilter_tableBufferedItems_alsoFiltersBufferedItems()
             throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         // Ville, Kalle, Pelle, Börje
         Assert.assertEquals(4, container.size());
         Assert.assertEquals("Börje",
@@ -1553,9 +1374,6 @@ public class SQLContainerTableQueryTest {
     @Test
     public void sort_tableBufferedItems_sortsBufferedItemsLastInOrderAdded()
             throws SQLException {
-        TableQuery query = new TableQuery("people", connectionPool,
-                SQLTestsConstants.sqlGen);
-        SQLContainer container = new SQLContainer(query);
         // Ville, Kalle, Pelle, Börje
         Assert.assertEquals("Ville",
                 container.getContainerProperty(container.firstItemId(), "NAME")
diff --git a/server/tests/src/com/vaadin/ui/DateFieldTests.java b/server/tests/src/com/vaadin/ui/DateFieldTests.java
new file mode 100644
index 0000000000..6a75b4630c
--- /dev/null
+++ b/server/tests/src/com/vaadin/ui/DateFieldTests.java
@@ -0,0 +1,56 @@
+package com.vaadin.ui;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Date;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsNull.nullValue;
+
+public class DateFieldTests {
+
+    private DateField dateField;
+    private Date date;
+
+    @Before
+    public void setup() {
+        dateField = new DateField();
+        date = new Date();
+    }
+
+    @Test
+    public void rangeStartIsSetToNull() {
+        dateField.setRangeStart(null);
+
+        assertThat(dateField.getRangeStart(), is(nullValue()));
+    }
+
+    @Test
+    public void rangeStartIsImmutable() {
+        long expectedTime = date.getTime();
+
+        dateField.setRangeStart(date);
+        date.setTime(expectedTime + 1);
+
+        assertThat(dateField.getRangeStart().getTime(), is(expectedTime));
+    }
+
+    @Test
+    public void rangeEndIsSetToNull() {
+        dateField.setRangeEnd(null);
+
+        assertThat(dateField.getRangeEnd(), is(nullValue()));
+    }
+
+    @Test
+    public void rangeEndIsImmutable() {
+        long expectedTime = date.getTime();
+
+        dateField.setRangeEnd(date);
+        date.setTime(expectedTime + 1);
+
+        assertThat(dateField.getRangeEnd().getTime(), is(expectedTime));
+    }
+}
diff --git a/uitest/tb2/com/vaadin/tests/components/tabsheet/TabSheetBasicOperations.html b/uitest/tb2/com/vaadin/tests/components/tabsheet/TabSheetBasicOperations.html
index 357455545e..f0f08efb58 100644
--- a/uitest/tb2/com/vaadin/tests/components/tabsheet/TabSheetBasicOperations.html
+++ b/uitest/tb2/com/vaadin/tests/components/tabsheet/TabSheetBasicOperations.html
@@ -300,7 +300,7 @@
 <tr>
 	<td>assertText</td>
 	<td>vaadin=runcomvaadintestscomponentstabsheetTabSheetTest::PID_SLog/ChildComponentContainer[0]/VLabel[0]</td>
-	<td>11. Tab 0 selected</td>
+	<td>11. Tab 2 selected</td>
 </tr>
 <!--select tab 1-->
 <tr>
@@ -324,7 +324,6 @@
 	<td>vaadin=runcomvaadintestscomponentstabsheetTabSheetTest::PID_SLog/ChildComponentContainer[0]/VLabel[0]</td>
 	<td>13. Tab 2 selected</td>
 </tr>
-
 </tbody></table>
 </body>
 </html>