Merge lp:~elopio/ubuntu-calculator-app/emulators into lp:~ubuntu-calculator-dev/ubuntu-calculator-app/old_trunk

[Leo Arias]

Updated the autopilot tests to use emulators.

[lp:~elopio/ubuntu-calculator-app/emulators]

138. By Leo Arias on 2013-08-08

Made the tests with multiple screens more readable now that we are sure there will not be more than 2.

139. By Leo Arias on 2013-08-08

Removed the unused code.

140. By Leo Arias on 2013-08-08

Added the missing emulators file.

[Nicholas Skaggs (nskaggs)]

Per IRC, commenting on trying to do more to remove the sleep. The rest of the code looks good -- glad to see another suite converted :-)

[lp:~elopio/ubuntu-calculator-app/emulators]

141. By Leo Arias on 2013-08-08

Fixed pyflakes errors.

142. By Leo Arias on 2013-08-08

Replaced the sleep with a wait_for on the visible property of the delete button.

[Nicholas Skaggs (nskaggs)]

adding the wait_for covers my concerns.

review: Approve

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

review: Approve (continuous-integration)

=== modified file 'Simple/Screen.qml'
--- Simple/Screen.qml	2013-08-08 13:43:12 +0000
+++ Simple/Screen.qml	2013-08-08 15:40:41 +0000
@@ -237,6 +237,7 @@
                         width: formulaLabel.operationsWidth
                     }
                     CalcLabel {
+                        objectName: _operation == "=" ? "result" : "operand" + index
                         id: formulaLabel
                         labelText: _text
                         numbers: _number

=== modified file 'debian/control'
--- debian/control	2013-05-18 09:52:21 +0000
+++ debian/control	2013-08-08 15:40:41 +0000
@@ -24,6 +24,7 @@
 Depends: ${shlibs:Depends},
          ${misc:Depends},
          ubuntu-calculator-app (= ${binary:Version}),
+         ubuntu-ui-toolkit-autopilot,
          libautopilot-qt,
          python-support (>= 0.90)
 Description: Autopilot tests for the calculator app for Ubuntu

=== removed directory 'tests/autopilot/ubuntu_calculator_app/emulators'
=== added file 'tests/autopilot/ubuntu_calculator_app/emulators.py'
--- tests/autopilot/ubuntu_calculator_app/emulators.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/ubuntu_calculator_app/emulators.py	2013-08-08 15:40:41 +0000
@@ -0,0 +1,239 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Copyright (C) 2013 Canonical Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+"""Calculator app autopilot emulators."""
+
+from ubuntuuitoolkit import emulators as toolkit_emulators
+
+
+class MainView(toolkit_emulators.MainView):
+    """Calculator MainView Autopilot emulator."""
+
+    # TODO when we start the tests for the scientific calculator, many of this
+    # methods will have to be moved to the SimplePage emulator, and the main
+    # view can call them depending on the current page displayed.
+    # --elopio - 2013-08-08
+
+    def __init__(self, *args):
+        super(MainView, self).__init__(*args)
+        self.pointing_device = toolkit_emulators.get_pointing_device()
+
+    def clear_with_button(self):
+        """Clear the calculation using the clear button."""
+        self.get_calc_keyboard().click_clear()
+
+    def get_calc_keyboard(self):
+        """Return the CalcKeyboard autopilot emulator."""
+        return self.select_single(CalcKeyboard)
+
+    def calculate_operation(self, operation):
+        """Calculate an operation.
+
+        :parameter operation: A string with the operation to calculate.
+
+        """
+        self.enter_operation(operation)
+        self.get_calc_keyboard().click_equals()
+
+    def enter_operation(self, operation):
+        """Enter an operation.
+
+        :parameter operation: A string with the operation to enter.
+
+        """
+        self.get_calc_keyboard().enter_operation(operation)
+
+    def change_sign(self):
+        """Change the sign of the last operand."""
+        self.get_calc_keyboard().click_sign()
+
+    def get_result(self):
+        """Return the result of a calculation."""
+        return self.get_current_screen().get_result()
+
+    def get_current_screen(self):
+        """Return the screen for the current calculation."""
+        count = self.get_number_of_screens()
+        return self.select_many(Screen)[count - 1]
+
+    def get_operand_by_index(self, index):
+        """Return an operand of a calculation entered."""
+        return self.get_current_screen().get_operand_by_index(index)
+
+    def clear_with_swipe(self):
+        """Clear the calculation making a swipe on the screen."""
+        self.get_current_screen().swipe_up()
+        self._wait_for_screen_to_finish_animation()
+
+    def _wait_for_screen_to_finish_animation(self):
+        qquicklistview = self.select_single('QQuickListView')
+        qquicklistview.moving.wait_for(False)
+
+    def is_cleared(self):
+        """Return True if the screen has no calculation. False otherwise."""
+        return self.get_current_screen().is_cleared()
+
+    def get_screen_by_index(self, index):
+        """Return a screen."""
+        return self._get_screens()[index]
+
+    def _get_screens(self):
+        return self.select_many(Screen)
+
+    def get_number_of_screens(self):
+        """Return the number of screens."""
+        return len(self._get_screens())
+
+    def swipe_previous_calculation_into_view(self, screen_index):
+        previous_screen = self.get_screen_by_index(screen_index)
+        _, prev_screen_y, _, prev_screen_h = previous_screen.globalRect
+        x, y, w, h = self.globalRect
+        start_x = stop_x = x + w / 2
+        start_y = y + h / 2
+        stop_y = start_y + y - prev_screen_y
+        self.pointing_device.drag(start_x, start_y, stop_x, stop_y)
+        self._wait_for_screen_to_finish_animation()
+
+    def delete_previous_calculation(self, screen_index, confirm):
+        """Delete an old calculation.
+
+        :parameter screen_index: If index of the screen with the calculation
+            to delete.
+        :parameter confirm: If True, the deletion will be confimed. If False,
+            it will be canceled.
+
+        """
+        self.swipe_previous_calculation_into_view(screen_index)
+        screen = self.get_screen_by_index(screen_index)
+        screen.swipe_to_left()
+        self._wait_for_screen_to_finish_animation()
+        if confirm:
+            screen.confirm_delete()
+        else:
+            raise NotImplementedError('Not yet implemented.')
+
+
+class CalcKeyboard(toolkit_emulators.UbuntuUIToolkitEmulatorBase):
+    """CalcKeyboard Autopilot emulator."""
+
+    _BUTTONS_DICT = {
+        "0": "zeroButton",
+        "1": "oneButton",
+        "2": "twoButton",
+        "3": "threeButton",
+        "4": "fourButton",
+        "5": "fiveButton",
+        "6": "sixButton",
+        "7": "sevenButton",
+        "8": "eightButton",
+        "9": "nineButton",
+        "+": "plusButton",
+        "-": "minusButton",
+        "/": "divideButton",
+        "*": "multiplyButton",
+    }
+
+    def __init__(self, *args):
+        super(CalcKeyboard, self).__init__(*args)
+        self.pointing_device = toolkit_emulators.get_pointing_device()
+
+    def click_clear(self):
+        """Click the clear button."""
+        clear_button = self._get_keyboard_button('clearButton')
+        self.pointing_device.click_object(clear_button)
+
+    def _get_keyboard_button(self, objectName):
+        return self.select_single('KeyboardButton', objectName=objectName)
+
+    def enter_operation(self, operation):
+        """Enter an operation on the calculator.
+
+        :parameter operation: A string with the operation to enter.
+
+        """
+        for char in operation:
+            button = self._get_keyboard_button(self._BUTTONS_DICT[char])
+            self.pointing_device.click_object(button)
+
+    def click_equals(self):
+        """Click the equals button."""
+        equals_button = self._get_keyboard_button('equalsButton')
+        self.pointing_device.click_object(equals_button)
+
+    def click_sign(self):
+        """Click the sign button."""
+        sign_button = self._get_keyboard_button('signButton')
+        self.pointing_device.click_object(sign_button)
+
+
+class Screen(toolkit_emulators.UbuntuUIToolkitEmulatorBase):
+    """Screen Autopilot emulator."""
+
+    def __init__(self, *args):
+        super(Screen, self).__init__(*args)
+        self.pointing_device = toolkit_emulators.get_pointing_device()
+
+    def get_result(self):
+        """Return the result of a calculation."""
+        result_label = self.get_result_label()
+        assert result_label is not None, 'No result displayed.'
+        return result_label.numbers
+
+    def get_result_label(self):
+        return self.select_single('CalcLabel', objectName='result')
+
+    def get_operand_by_index(self, index):
+        """Return an operand of a calculation entered."""
+        operand_label = self.select_single(
+            'CalcLabel', objectName='operand{0}'.format(index))
+        assert operand_label is not None, 'No operand with index {0}.'.format(
+            index)
+        return operand_label.numbers
+
+    def swipe_up(self):
+        """Swipe up on the screen to clear the calculation."""
+        x, y, w, h = self.globalRect
+        tx = x + (w / 2)
+        ty = y + (h / 2)
+
+        self.pointing_device.drag(tx, ty + h, tx, ty - h)
+
+    def is_cleared(self):
+        """Return True if the screen has no calculation. False otherwise."""
+        return (self.get_result_label() is None and
+                self._get_number_of_labels() == 1 and
+                self.get_operand_by_index(0) == "")
+
+    def _get_number_of_labels(self):
+        return len(self.select_many('CalcLabel'))
+
+    def swipe_to_left(self):
+        """Swipe the screen to the left.
+
+        If it's an old calculation, a delete dialog will appear.
+
+        """
+        x, y, w, h = self.globalRect
+        tx = x + (w - w / 8)
+        ty = y + (h / 2)
+        self.pointing_device.drag(tx, ty, tx / 8, ty)
+
+    def confirm_delete(self):
+        """Confirm the deletion of the calculation."""
+        delete_button = self.select_single(
+            'Button', objectName='calculationDelete')
+        delete_button.visible.wait_for(True)
+        self.pointing_device.click_object(delete_button)

=== removed file 'tests/autopilot/ubuntu_calculator_app/emulators/__init__.py'
--- tests/autopilot/ubuntu_calculator_app/emulators/__init__.py	2013-03-22 12:15:46 +0000
+++ tests/autopilot/ubuntu_calculator_app/emulators/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2013 Canonical
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.

=== removed file 'tests/autopilot/ubuntu_calculator_app/emulators/simple_page.py'
--- tests/autopilot/ubuntu_calculator_app/emulators/simple_page.py	2013-08-02 03:01:14 +0000
+++ tests/autopilot/ubuntu_calculator_app/emulators/simple_page.py	1970-01-01 00:00:00 +0000
@@ -1,32 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2013 Canonical
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-
-
-class SimplePage(object):
-    """An emulator class that makes it easy to interact with the call panel."""
-    def __init__(self, app):
-        self.app = app
-
-    def get_button(self, text):
-        return self.app.select_single('KeyboardButton', text=text)
-
-    def get_formula_label(self):
-        return self.app.select_single('CalcLabel', isLast=True)
-
-    def get_calc_label(self, numbers):
-        return self.app.select_single('CalcLabel', numbers=numbers)
-
-    def get_screen(self):
-        return self.app.select_many("Screen")[0]
-
-    def get_confirm_delete_button(self):
-        return self.app.select_single(
-            "Button", objectName="calculationDelete", visible=True)
-
-    def get_main_screen_qqlv(self):
-        page = self.app.select_single("SimplePage")
-        return page.select_single("QQuickListView")

=== modified file 'tests/autopilot/ubuntu_calculator_app/tests/__init__.py'
--- tests/autopilot/ubuntu_calculator_app/tests/__init__.py	2013-07-14 22:05:48 +0000
+++ tests/autopilot/ubuntu_calculator_app/tests/__init__.py	2013-08-08 15:40:41 +0000
@@ -12,9 +12,9 @@
 from autopilot.input import Mouse, Touch, Pointer
 from autopilot.platform import model
 from autopilot.testcase import AutopilotTestCase
-
-
-from ubuntu_calculator_app.emulators.simple_page import SimplePage
+from ubuntuuitoolkit import emulators as toolkit_emulators
+
+from ubuntu_calculator_app import emulators
 
 
 class CalculatorTestCase(AutopilotTestCase):
@@ -43,7 +43,8 @@
         self.app = self.launch_test_application(
             "qmlscene",
             self.local_location,
-            app_type='qt')
+            app_type='qt',
+            emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
 
     def launch_test_installed(self):
         self.app = self.launch_test_application(
@@ -51,20 +52,9 @@
             "/usr/share/ubuntu-calculator-app/ubuntu-calculator-app.qml",
             "--desktop_file_hint="
             "/usr/share/applications/ubuntu-calculator-app.desktop",
-            app_type='qt')
-
-    def click_button(self, object_name):
-        button = self.app.select_single(
-            'KeyboardButton', objectName=object_name + "Button")
-
-        x, y, h, w = button.globalRect
-
-        tx = x + (h / 2)
-        ty = y + (w / 2)
-
-        self.pointing_device.move(tx, ty)
-        self.pointing_device.click()
+            app_type='qt',
+            emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
 
     @property
-    def simple_page(self):
-        return SimplePage(self.app)
+    def main_view(self):
+        return self.app.select_single(emulators.MainView)

=== modified file 'tests/autopilot/ubuntu_calculator_app/tests/test_simple_page.py'
--- tests/autopilot/ubuntu_calculator_app/tests/test_simple_page.py	2013-08-02 13:40:05 +0000
+++ tests/autopilot/ubuntu_calculator_app/tests/test_simple_page.py	2013-08-08 15:40:41 +0000
@@ -1,295 +1,184 @@
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2013 Canonical
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-
+#
+# Copyright (C) 2013 Canonical Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 """Tests for the Calculator App"""
 
 from __future__ import absolute_import
 
-from testtools.matchers import Equals, NotEquals
+from testtools.matchers import Equals
 from autopilot.matchers import Eventually
 
 from ubuntu_calculator_app.tests import CalculatorTestCase
-from ubuntu_calculator_app.emulators.simple_page import SimplePage
-
-import os.path
-import unittest
-from types import IntType
 
 
 class TestSimplePage(CalculatorTestCase):
 
-    _BUTTONS_DICT = {
-        "0": "zero",
-        "1": "one",
-        "2": "two",
-        "3": "three",
-        "4": "four",
-        "5": "five",
-        "6": "six",
-        "7": "seven",
-        "8": "eight",
-        "9": "nine",
-        "+": "plus",
-        "-": "minus",
-        "/": "divide",
-        "*": "multiply",
-        "=": "equals",
-    }
+    def setUp(self):
+        super(TestSimplePage, self).setUp()
+        self.addCleanup(self._delete_old_calculations)
 
-    @property
-    def simple_page(self):
-        return SimplePage(self.app)
+    def _delete_old_calculations(self):
+        while self.main_view.get_number_of_screens() > 1:
+            self.main_view.delete_previous_calculation(0, confirm=True)
 
     def test_operation_after_clear(self):
         """ Test that after clearing one calculation, the next is still correct
         (bug #1164973).
 
         """
-        self._calculate("1+1")
-
-        # make sure the result is already there
-        self._assert_result("2")
-
-        # now clear the input by pressing "AC"
-        self.click_button("clear")
-
-        self._calculate("1+1")
-
-        # make sure the result is correct
-        self._assert_result("2")
-
-    def _calculate(self, operation):
-        self._click_buttons(operation + "=")
-
-    def _tear_off(self, operation):
-        self._calculate(operation)
-        screen = self.simple_page.get_screen()
-        x, y, w, h = screen.globalRect
-        tx = x + (w / 2)
-        ty = y + (h / 2)
-
-        self.pointing_device.drag(tx, ty + h, tx, ty - h)
-
-        self._assert_result("")
-
-    def _delete_last_calculation(self):
-        screen = self.simple_page.get_screen()
-        quick_list_view = self.simple_page.get_main_screen_qqlv()
-
-        x, y, w, h = screen.globalRect
-        tx = x + (w - w / 8)
-        ty = y + (h / 2)
-        self.pointing_device.drag(tx, ty, tx / 8, ty)
-        self.pointing_device.drag(tx, ty, tx, ty + h)
-
-        self.assertThat(quick_list_view.moving, Eventually(Equals(False)))
-
-        delete_button = self.simple_page.get_confirm_delete_button()
-        self.pointing_device.click_object(delete_button)
-
-    def _click_buttons(self, input_):
-        for char in input_:
-            self.click_button(self._BUTTONS_DICT[char])
+        self.main_view.calculate_operation("1+1")
+        self._assert_result("2")
+        self.main_view.clear_with_button()
+        self.main_view.calculate_operation("1+1")
+        self._assert_result("2")
 
     def _assert_result(self, expected_result):
-        get_result = lambda: self.simple_page.get_formula_label().numbers
-        self.assertThat(
-            get_result, Eventually(Equals(expected_result)))
-
-    def _close_and_reopen(self):
-        # See #1188292, there is a bug in SDK that prevents to use terminate
-        #self.simple_page.app.process.terminate()
-        #self.simple_page.app.process.wait()
-
-        screen = self.simple_page.get_screen()
-        x, y, w, h = screen.globalRect
-
-        self.pointing_device.move(x + (w / 25), y + h / 2.7)
-        self.pointing_device.click()
-
-        self.simple_page.app.process.wait()
-
-        local_location = "../../ubuntu-calculator-app.qml"
-
-        # Yes, I know, it's a duplication of CalculatorTestCase().setUp(),
-        # but I didn't find a better way to implement it
-        if os.path.exists(local_location):
-            self.app = self.launch_test_application(
-                "qmlscene",
-                local_location,
-                app_type='qt')
-        else:
-            self.app = self.launch_test_application(
-                "qmlscene",
-                "/usr/share/ubuntu-calculator-app/ubuntu-calculator-app.qml",
-                "--desktop_file_hint="
-                "/usr/share/applications/ubuntu-calculator-app.desktop",
-                app_type='qt')
-
-        # Check if windows has been launch
-        self.assertThat(
-            self.simple_page.app.select_single("QQuickView").visible,
-            Eventually(Equals(True)))
+        self.assertThat(
+            self.main_view.get_result, Eventually(Equals(expected_result)))
+
+    def test_enter_operand(self):
+        self.main_view.enter_operation("123")
+        self.assertEqual(self.main_view.get_operand_by_index(0), "123")
 
     def test_equals_dont_change_numbers(self):
         """ Test that typing a number and pressing "=" won't change the number
         (bug #1165894).
 
         """
-        self._click_buttons("123")
-
-        # check that the label is displaying correctly
-        self._assert_result("123")
-
-        # click the "=" button
-        self._click_buttons("=")
+        self.main_view.enter_operation("123")
+        self.main_view.get_calc_keyboard().click_equals()
 
         # check that the label is still displaying correctly
-        self._assert_result("123")
+        self.assertEqual(self.main_view.get_operand_by_index(0), "123")
 
     def test_multiply_priority(self):
         """Multiply is done before addition or substraction."""
-        self._calculate("2+2*2")
+        self.main_view.calculate_operation("2+2*2")
         self._assert_result("6")
 
     def test_divide_priority(self):
         """Divide is done before addition or substraction."""
-        self._calculate("5+6/2")
+        self.main_view.calculate_operation("5+6/2")
         self._assert_result("8")
 
     def test_swipe_up_clears(self):
-        """Make sure swiping up clears the formulae label."""
-        screen = self.simple_page.get_screen()
-        self._click_buttons("9")
-
-        x, y, w, h = screen.globalRect
-        tx = x + (w / 2)
-        ty = y + (h / 2)
-
-        self.pointing_device.drag(tx, ty + h, tx, ty - h)
-
-        self._assert_result("")
+        """Make sure swiping up clears the formula label."""
+        self.main_view.enter_operation("9")
+        self.main_view.clear_with_swipe()
+        self.assertThat(self.main_view.is_cleared, Eventually(Equals(True)))
 
     def test_sign_button(self):
         """Ensure the sign button is working."""
-        self._click_buttons("5+")
-        self.click_button("sign")
-        self._click_buttons("1=")
+        calc_keyboard = self.main_view.get_calc_keyboard()
+        calc_keyboard.enter_operation("5+")
+        calc_keyboard.click_sign()
+        calc_keyboard.enter_operation("1")
+        calc_keyboard.click_equals()
 
         self._assert_result("4")
 
     def test_addition(self):
-        self._calculate("4+2")
+        self.main_view.calculate_operation("4+2")
         self._assert_result("6")
 
     def test_substraction(self):
-        self._calculate("5-4")
+        self.main_view.calculate_operation("5-4")
         self._assert_result("1")
 
     def test_positive_numbers_multiplication(self):
-        self._calculate("2*3")
+        self.main_view.calculate_operation("2*3")
         self._assert_result("6")
 
     def test_multiplication_by_zero(self):
-        self._calculate("4*0")
+        self.main_view.calculate_operation("4*0")
         self._assert_result("0")
 
     def test_one_negative_number_multiplication(self):
-        self._calculate("-3*4")
+        self.main_view.calculate_operation("-3*4")
         self._assert_result("-12")
 
     def test_two_negative_numbers_multiplication(self):
-        self._calculate("-2*-3")
+        self.main_view.calculate_operation("-2*-3")
         self._assert_result("6")
 
     def test_three_positive_numbers_multiplication(self):
-        self._calculate("2*3*10")
+        self.main_view.calculate_operation("2*3*10")
         self._assert_result("60")
 
     def test_two_negatives_in_three_numbers_multiplication(self):
-        self._calculate("-2*-3*5")
+        self.main_view.calculate_operation("-2*-3*5")
         self._assert_result("30")
 
     def test_three_negative_numbers_multiplication(self):
-        self._calculate("-4*-5*-7")
+        self.main_view.calculate_operation("-4*-5*-7")
         self._assert_result("-140")
 
     def test_divide_positive(self):
-        self._calculate("4/2")
+        self.main_view.calculate_operation("4/2")
         self._assert_result("2")
 
     def test_divide_negative(self):
-        self._calculate("4/-2")
+        self.main_view.calculate_operation("4/-2")
         self._assert_result("-2")
 
     def test_divide_two_negatives(self):
-        self._calculate("-4/-2")
+        self.main_view.calculate_operation("-4/-2")
         self._assert_result("2")
 
     def test_divide_with_zero(self):
-        self._calculate("0/4")
+        self.main_view.calculate_operation("0/4")
         self._assert_result("0")
 
     def test_divide_by_zero(self):
-        self._calculate("4/0")
-        result_box = self.simple_page.get_formula_label().numbers
-
-        self.assertThat(
-            lambda: type(result_box) is not IntType, Eventually(Equals(True)))
-
-    def test_tear_off(self):
-        """Test tear off adds calculation to history"""
-        quick_list_view = self.simple_page.get_main_screen_qqlv()
-        num_calc_sections_old = int(quick_list_view.count)
-        # Do the calc
-        self._tear_off("9+5")
-
-        # Check if has been saved
-        self.assertThat(
-            lambda: num_calc_sections_old,
-            Eventually(NotEquals(quick_list_view.count)))
+        self.main_view.calculate_operation("4/0")
+        self._assert_result("Infinity")
+
+    def test_swipe_up_with_result(self):
+        """Test swipe up adds calculation to history"""
+        self.main_view.calculate_operation("9+8")
+        self.main_view.clear_with_swipe()
+
+        self.assertThat(
+            self.main_view.get_number_of_screens, Eventually(Equals(2)))
+        self.assertTrue(
+            self.main_view.get_screen_by_index(1).is_cleared())
+        self.assertEquals(
+            self.main_view.get_screen_by_index(0).get_result(), "17")
 
     def test_swipe_delete_calculation_right_left(self):
-        """Try to delete a calculation swiping it from right to left"""
-        quick_list_view = self.simple_page.get_main_screen_qqlv()
-        num_calc_sections_old = int(quick_list_view.count)
-        # Do the calc
-        self._tear_off("9+5")
-
-        # Delete the calculation
-        self._delete_last_calculation()
-        # Check if has been deleted
+        """Delete a calculation swiping it from right to left"""
+        self.main_view.calculate_operation("9+5")
+        self.main_view.clear_with_swipe()
+
+        self.main_view.swipe_previous_calculation_into_view(0)
+        self.main_view.delete_previous_calculation(0, confirm=True)
+
         self.assertThat(
-            lambda: num_calc_sections_old,
-            Eventually(Equals(quick_list_view.count)))
+            self.main_view.get_number_of_screens, Eventually(Equals(1)))
 
     def test_click_history(self):
-        """Try to do a calculation using history items"""
-        # Do the calc
-        self._tear_off("19+1")
-
-        # Clic on calc
-        calc = self.simple_page.get_calc_label("20")
-        self.pointing_device.click_object(calc)
-
-        self._calculate("+5")
+        """Do a calculation using history items."""
+        self.main_view.calculate_operation("19+1")
+        self.main_view.clear_with_swipe()
+
+        result_label = self.main_view.get_screen_by_index(0).get_result_label()
+        self.pointing_device.click_object(result_label)
+
+        calc_keyboard = self.main_view.get_calc_keyboard()
+        calc_keyboard.enter_operation("+5")
+        calc_keyboard.click_equals()
+
         self._assert_result("25")
-
-    @unittest.skip("We are doing things wrong on so many levels, we are \
-        trying to click the close button with magic numbers which we \
-        cannot rely on, also on touch devices there is no such thing as \
-        close button, skipping this test for now till we find a better \
-        solution. bug 1207593")
-    def test_save_calculation_between_reload(self):
-        # Do the calc
-        self._tear_off("44-2")
-
-        self._close_and_reopen()
-
-        label = lambda: self.simple_page.get_calc_label("42")
-        self.assertThat(label, Eventually(NotEquals(None)))