Merge branch 'testbench4' into master

Change-Id: Ia036030703538e2110d656b4b35d210147edb961

3 files changed, 268 insertions, 361 deletions

diff --git a/uitest/src/com/vaadin/tests/application/calculator/Calc.java b/uitest/src/com/vaadin/tests/application/calculator/Calc.java
new file mode 100644
index 0000000000..7911556f4e
--- /dev/null
+++ b/uitest/src/com/vaadin/tests/application/calculator/Calc.java
@@ -0,0 +1,268 @@
+/*
+ * Copyright 2000-2013 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.tests.application.calculator;
+
+import com.vaadin.server.VaadinRequest;
+import com.vaadin.tests.components.AbstractTestUI;
+import com.vaadin.ui.Alignment;
+import com.vaadin.ui.Button;
+import com.vaadin.ui.Button.ClickEvent;
+import com.vaadin.ui.Button.ClickListener;
+import com.vaadin.ui.GridLayout;
+import com.vaadin.ui.HorizontalLayout;
+import com.vaadin.ui.Label;
+import com.vaadin.ui.Table;
+import com.vaadin.ui.Table.ColumnHeaderMode;
+import com.vaadin.ui.TextField;
+import com.vaadin.ui.VerticalLayout;
+import com.vaadin.ui.Window;
+
+@SuppressWarnings("serial")
+public class Calc extends AbstractTestUI {
+
+    private class Log extends VerticalLayout {
+
+        private Table table;
+        private Button addCommentButton;
+        private int line = 0;
+
+        public Log() {
+            super();
+
+            table = new Table();
+            table.setSizeFull();
+
+            setWidth("200px");
+            setHeight("100%");
+
+            table.setColumnHeaderMode(ColumnHeaderMode.HIDDEN);
+            table.addContainerProperty("Operation", String.class, "");
+
+            addComponent(table);
+
+            addCommentButton = new Button("Add Comment");
+            addCommentButton.setWidth("100%");
+
+            addCommentButton.addClickListener(new ClickListener() {
+                @Override
+                public void buttonClick(ClickEvent event) {
+
+                    final Window w = new Window("Add comment");
+                    VerticalLayout vl = new VerticalLayout();
+                    vl.setMargin(true);
+
+                    final TextField tf = new TextField();
+                    tf.setSizeFull();
+                    vl.addComponent(tf);
+
+                    HorizontalLayout hl = new HorizontalLayout();
+
+                    Button okButton = new Button("OK");
+                    okButton.setWidth("100%");
+                    okButton.addClickListener(new ClickListener() {
+                        @Override
+                        public void buttonClick(ClickEvent event) {
+                            addRow("[ " + tf.getValue() + " ]");
+                            tf.setValue("");
+                            w.close();
+                            removeWindow(w);
+                        }
+                    });
+
+                    Button cancelButton = new Button("Cancel");
+                    cancelButton.setWidth("100%");
+                    cancelButton.addClickListener(new ClickListener() {
+                        @Override
+                        public void buttonClick(ClickEvent event) {
+                            tf.setValue("");
+                            w.close();
+                            removeWindow(w);
+                        }
+                    });
+
+                    hl.addComponent(cancelButton);
+                    hl.addComponent(okButton);
+                    hl.setSpacing(true);
+                    hl.setWidth("100%");
+
+                    vl.addComponent(hl);
+                    vl.setSpacing(true);
+
+                    w.setContent(vl);
+                    addWindow(w);
+                }
+            });
+
+            addComponent(addCommentButton);
+
+            setExpandRatio(table, 1);
+            setSpacing(true);
+        }
+
+        public void addRow(String row) {
+            Integer id = ++line;
+            table.addItem(new Object[] { row }, id);
+            table.setCurrentPageFirstItemIndex(line + 1);
+        }
+
+    }
+
+    // All variables are automatically stored in the session.
+    private Double current = 0.0;
+    private double stored = 0.0;
+    private char lastOperationRequested = 'C';
+    private VerticalLayout topLayout = new VerticalLayout();
+
+    // User interface components
+    private final TextField display = new TextField();
+
+    private final Log log = new Log();
+
+    // Calculator "business logic" implemented here to keep the example
+    // minimal
+    private double calculate(char requestedOperation) {
+        if ('0' <= requestedOperation && requestedOperation <= '9') {
+            if (current == null) {
+                current = 0.0;
+            }
+            current = current * 10
+                    + Double.parseDouble("" + requestedOperation);
+            return current;
+        }
+
+        if (current == null) {
+            current = stored;
+        }
+        switch (lastOperationRequested) {
+        case '+':
+            stored += current;
+            break;
+        case '-':
+            stored -= current;
+            break;
+        case '/':
+            stored /= current;
+            break;
+        case '*':
+            stored *= current;
+            break;
+        default:
+            stored = current;
+            break;
+        }
+
+        switch (requestedOperation) {
+        case '+':
+            log.addRow(current + " +");
+            break;
+        case '-':
+            log.addRow(current + " -");
+            break;
+        case '/':
+            log.addRow(current + " /");
+            break;
+        case '*':
+            log.addRow(current + " x");
+            break;
+        case '=':
+            log.addRow(current + " =");
+            log.addRow("------------");
+            log.addRow("" + stored);
+            break;
+        }
+
+        lastOperationRequested = requestedOperation;
+        current = null;
+        if (requestedOperation == 'C') {
+            log.addRow("0.0");
+            stored = 0.0;
+        }
+        return stored;
+    }
+
+    @Override
+    protected void setup(VaadinRequest request) {
+        setContent(topLayout);
+
+        // Create the main layout for our application (4 columns, 5 rows)
+        final GridLayout layout = new GridLayout(4, 5);
+
+        topLayout.setMargin(true);
+        topLayout.setSpacing(true);
+        Label title = new Label("Calculator");
+        topLayout.addComponent(title);
+        topLayout.addComponent(log);
+
+        HorizontalLayout horizontalLayout = new HorizontalLayout();
+        horizontalLayout.setSpacing(true);
+        horizontalLayout.addComponent(layout);
+        horizontalLayout.addComponent(log);
+        topLayout.addComponent(horizontalLayout);
+
+        // Create a result label that over all 4 columns in the first row
+        layout.setSpacing(true);
+        layout.addComponent(display, 0, 0, 3, 0);
+        layout.setComponentAlignment(display, Alignment.MIDDLE_RIGHT);
+        display.setSizeFull();
+        display.setId("display");
+        display.setValue("0.0");
+
+        // The operations for the calculator in the order they appear on the
+        // screen (left to right, top to bottom)
+        String[] operations = new String[] { "7", "8", "9", "/", "4", "5", "6",
+                "*", "1", "2", "3", "-", "0", "=", "C", "+" };
+
+        for (String caption : operations) {
+
+            // Create a button and use this application for event handling
+            Button button = new Button(caption);
+            button.setWidth("40px");
+            button.addClickListener(new ClickListener() {
+                @Override
+                public void buttonClick(ClickEvent event) {
+                    // Get the button that was clicked
+                    Button button = event.getButton();
+
+                    // Get the requested operation from the button caption
+                    char requestedOperation = button.getCaption().charAt(0);
+
+                    // Calculate the new value
+                    double newValue = calculate(requestedOperation);
+
+                    // Update the result label with the new value
+                    display.setValue("" + newValue);
+                }
+            });
+            button.setId("button_" + caption);
+
+            // Add the button to our main layout
+            layout.addComponent(button);
+        }
+
+    }
+
+    @Override
+    protected String getTestDescription() {
+        return "Provide test application for generic testing purposes";
+    }
+
+    @Override
+    protected Integer getTicketNumber() {
+        return 12444;
+    }
+
+}
diff --git a/uitest/src/com/vaadin/tests/gwtadapter/componentlocator/TestDetachedNotPresent.html b/uitest/src/com/vaadin/tests/componentlocator/TestDetachedNotPresent.html
index 24e5e992ca..24e5e992ca 100644
--- a/uitest/src/com/vaadin/tests/gwtadapter/componentlocator/TestDetachedNotPresent.html
+++ b/uitest/src/com/vaadin/tests/componentlocator/TestDetachedNotPresent.html
diff --git a/uitest/src/com/vaadin/tests/components/ui/UIAccess.java b/uitest/src/com/vaadin/tests/components/ui/UIAccess.java
deleted file mode 100644
index d036827159..0000000000
--- a/uitest/src/com/vaadin/tests/components/ui/UIAccess.java
+++ /dev/null
@@ -1,361 +0,0 @@
-/*
- * Copyright 2000-2013 Vaadin Ltd.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-
-package com.vaadin.tests.components.ui;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.locks.ReentrantLock;
-
-import com.vaadin.server.VaadinRequest;
-import com.vaadin.server.VaadinService;
-import com.vaadin.server.VaadinSession;
-import com.vaadin.shared.communication.PushMode;
-import com.vaadin.tests.components.AbstractTestUIWithLog;
-import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.UI;
-import com.vaadin.util.CurrentInstance;
-
-public class UIAccess extends AbstractTestUIWithLog {
-
-    private volatile boolean checkCurrentInstancesBeforeResponse = false;
-
-    private Future<Void> checkFromBeforeClientResponse;
-
-    private class CurrentInstanceTestType {
-        private String value;
-
-        public CurrentInstanceTestType(String value) {
-            this.value = value;
-        }
-
-        @Override
-        public String toString() {
-            return value;
-        }
-    }
-
-    @Override
-    protected void setup(VaadinRequest request) {
-        addComponent(new Button("Access from UI thread",
-                new Button.ClickListener() {
-
-                    @Override
-                    public void buttonClick(ClickEvent event) {
-                        log.clear();
-                        // Ensure beforeClientResponse is invoked
-                        markAsDirty();
-                        checkFromBeforeClientResponse = access(new Runnable() {
-                            @Override
-                            public void run() {
-                                log("Access from UI thread is run");
-                            }
-                        });
-                        log("Access from UI thread future is done? "
-                                + checkFromBeforeClientResponse.isDone());
-                    }
-                }));
-        addComponent(new Button("Access from background thread",
-                new Button.ClickListener() {
-                    @Override
-                    public void buttonClick(ClickEvent event) {
-                        log.clear();
-                        final CountDownLatch latch = new CountDownLatch(1);
-
-                        new Thread() {
-                            @Override
-                            public void run() {
-                                final boolean threadHasCurrentResponse = VaadinService
-                                        .getCurrentResponse() != null;
-                                // session is locked by request thread at this
-                                // point
-                                final Future<Void> initialFuture = access(new Runnable() {
-                                    @Override
-                                    public void run() {
-                                        log("Initial background message");
-                                        log("Thread has current response? "
-                                                + threadHasCurrentResponse);
-                                    }
-                                });
-
-                                // Let request thread continue
-                                latch.countDown();
-
-                                // Wait until thread can be locked
-                                while (!getSession().getLockInstance()
-                                        .tryLock()) {
-                                    try {
-                                        Thread.sleep(100);
-                                    } catch (InterruptedException e) {
-                                        throw new RuntimeException(e);
-                                    }
-                                }
-                                try {
-                                    log("Thread got lock, inital future done? "
-                                            + initialFuture.isDone());
-                                    setPollInterval(-1);
-                                } finally {
-                                    getSession().unlock();
-                                }
-                            }
-                        }.start();
-
-                        // Wait for thread to do initialize before continuing
-                        try {
-                            latch.await();
-                        } catch (InterruptedException e) {
-                            throw new RuntimeException(e);
-                        }
-
-                        setPollInterval(3000);
-                    }
-                }));
-        addComponent(new Button("Access throwing exception",
-                new Button.ClickListener() {
-                    @Override
-                    public void buttonClick(ClickEvent event) {
-                        log.clear();
-                        final Future<Void> firstFuture = access(new Runnable() {
-                            @Override
-                            public void run() {
-                                log("Throwing exception in access");
-                                throw new RuntimeException(
-                                        "Catch me if you can");
-                            }
-                        });
-                        access(new Runnable() {
-                            @Override
-                            public void run() {
-                                log("firstFuture is done? "
-                                        + firstFuture.isDone());
-                                try {
-                                    firstFuture.get();
-                                    log("Should not get here");
-                                } catch (InterruptedException e) {
-                                    throw new RuntimeException(e);
-                                } catch (ExecutionException e) {
-                                    log("Got exception from firstFuture: "
-                                            + e.getMessage());
-                                }
-                            }
-                        });
-                    }
-                }));
-        addComponent(new Button("Cancel future before started",
-                new Button.ClickListener() {
-                    @Override
-                    public void buttonClick(ClickEvent event) {
-                        log.clear();
-                        Future<Void> future = access(new Runnable() {
-                            @Override
-                            public void run() {
-                                log("Should not get here");
-                            }
-                        });
-                        future.cancel(false);
-                        log("future was cancled, should not start");
-                    }
-                }));
-        addComponent(new Button("Cancel running future",
-                new Button.ClickListener() {
-                    @Override
-                    public void buttonClick(ClickEvent event) {
-                        log.clear();
-                        final ReentrantLock interruptLock = new ReentrantLock();
-
-                        final Future<Void> future = access(new Runnable() {
-                            @Override
-                            public void run() {
-                                log("Waiting for thread to start");
-                                while (!interruptLock.isLocked()) {
-                                    try {
-                                        Thread.sleep(100);
-                                    } catch (InterruptedException e) {
-                                        log("Premature interruption");
-                                        throw new RuntimeException(e);
-                                    }
-                                }
-
-                                log("Thread started, waiting for interruption");
-                                try {
-                                    interruptLock.lockInterruptibly();
-                                } catch (InterruptedException e) {
-                                    log("I was interrupted");
-                                }
-                            }
-                        });
-
-                        new Thread() {
-                            @Override
-                            public void run() {
-                                interruptLock.lock();
-                                // Wait until UI thread has started waiting for
-                                // the lock
-                                while (!interruptLock.hasQueuedThreads()) {
-                                    try {
-                                        Thread.sleep(100);
-                                    } catch (InterruptedException e) {
-                                        throw new RuntimeException(e);
-                                    }
-                                }
-
-                                future.cancel(true);
-                            }
-                        }.start();
-                    }
-                }));
-        addComponent(new Button("CurrentInstance accessSynchronously values",
-                new Button.ClickListener() {
-                    @Override
-                    public void buttonClick(ClickEvent event) {
-                        log.clear();
-                        // accessSynchronously should maintain values
-                        CurrentInstance.set(CurrentInstanceTestType.class,
-                                new CurrentInstanceTestType(
-                                        "Set before accessSynchronosly"));
-                        accessSynchronously(new Runnable() {
-                            @Override
-                            public void run() {
-                                log.log("accessSynchronously has request? "
-                                        + (VaadinService.getCurrentRequest() != null));
-                                log.log("Test value in accessSynchronously: "
-                                        + CurrentInstance
-                                                .get(CurrentInstanceTestType.class));
-                                CurrentInstance.set(
-                                        CurrentInstanceTestType.class,
-                                        new CurrentInstanceTestType(
-                                                "Set in accessSynchronosly"));
-                            }
-                        });
-                        log.log("has request after accessSynchronously? "
-                                + (VaadinService.getCurrentRequest() != null));
-                        log("Test value after accessSynchornously: "
-                                + CurrentInstance
-                                        .get(CurrentInstanceTestType.class));
-                    }
-                }));
-        addComponent(new Button("CurrentInstance access values",
-                new Button.ClickListener() {
-                    @Override
-                    public void buttonClick(ClickEvent event) {
-                        log.clear();
-                        // accessSynchronously should maintain values
-                        CurrentInstance
-                                .setInheritable(CurrentInstanceTestType.class,
-                                        new CurrentInstanceTestType(
-                                                "Set before access"));
-                        access(new Runnable() {
-                            @Override
-                            public void run() {
-                                log.log("access has request? "
-                                        + (VaadinService.getCurrentRequest() != null));
-                                log.log("Test value in access: "
-                                        + CurrentInstance
-                                                .get(CurrentInstanceTestType.class));
-                                CurrentInstance.setInheritable(
-                                        CurrentInstanceTestType.class,
-                                        new CurrentInstanceTestType(
-                                                "Set in access"));
-                            }
-                        });
-                        CurrentInstance.setInheritable(
-                                CurrentInstanceTestType.class,
-                                new CurrentInstanceTestType(
-                                        "Set before run pending"));
-
-                        getSession().getService().runPendingAccessTasks(
-                                getSession());
-
-                        log.log("has request after access? "
-                                + (VaadinService.getCurrentRequest() != null));
-                        log("Test value after access: "
-                                + CurrentInstance
-                                        .get(CurrentInstanceTestType.class));
-                    }
-                }));
-
-        addComponent(new Button("CurrentInstance when pushing",
-                new Button.ClickListener() {
-                    @Override
-                    public void buttonClick(ClickEvent event) {
-                        log.clear();
-                        if (getPushConfiguration().getPushMode() != PushMode.AUTOMATIC) {
-                            log("Can only test with automatic push enabled");
-                            return;
-                        }
-
-                        final VaadinSession session = getSession();
-                        new Thread() {
-                            @Override
-                            public void run() {
-                                // Pretend this isn't a Vaadin thread
-                                CurrentInstance.clearAll();
-
-                                /*
-                                 * Get explicit lock to ensure the (implicit)
-                                 * push does not happen during normal request
-                                 * handling.
-                                 */
-                                session.lock();
-                                try {
-                                    access(new Runnable() {
-                                        @Override
-                                        public void run() {
-                                            checkCurrentInstancesBeforeResponse = true;
-                                            // Trigger beforeClientResponse
-                                            markAsDirty();
-                                        }
-                                    });
-                                } finally {
-                                    session.unlock();
-                                }
-                            }
-                        }.start();
-                    }
-                }));
-    }
-
-    @Override
-    public void beforeClientResponse(boolean initial) {
-        if (checkFromBeforeClientResponse != null) {
-            log("beforeClientResponse future is done? "
-                    + checkFromBeforeClientResponse.isDone());
-            checkFromBeforeClientResponse = null;
-        }
-        if (checkCurrentInstancesBeforeResponse) {
-            UI currentUI = UI.getCurrent();
-            VaadinSession currentSession = VaadinSession.getCurrent();
-
-            log("Current UI matches in beforeResponse? " + (currentUI == this));
-            log("Current session matches in beforeResponse? "
-                    + (currentSession == getSession()));
-            checkCurrentInstancesBeforeResponse = false;
-        }
-    }
-
-    @Override
-    protected String getTestDescription() {
-        return "Test for various ways of using UI.access";
-    }
-
-    @Override
-    protected Integer getTicketNumber() {
-        return Integer.valueOf(11897);
-    }
-
-}