def select(self, match_string):
        # This needs to be duplicated from base.py because when we return from the frame
        # we don't return to the Settings app in its initial state,
        # so the wait for in its launch method times out

        # have to go back to top level to get the B2G select box wrapper
        self.marionette.switch_to_frame()

        Wait(self.marionette).until(
            expected.elements_present(
                By.CSS_SELECTOR, '.value-selector-container li'))

        options = self.marionette.find_elements(By.CSS_SELECTOR, '.value-selector-container li')
        close = self.marionette.find_element(By.CSS_SELECTOR, 'button.value-option-confirm')

        # loop options until we find the match
        for li in options:
            if match_string == li.text:
                li.tap()
                break
        else:
            raise Exception("Element '%s' could not be found in select wrapper" % match_string)

        close.tap()
        Wait(self.marionette).until(expected.element_not_displayed(close))

        # TODO we should find something suitable to wait for, but this goes too
        # fast against desktop builds causing intermittent failures
        time.sleep(0.2)

        # now back to app
        self.apps.switch_to_displayed_app()

 def reject_call(self):
     Wait(self.marionette).until(
         expected.element_displayed(*self._lockscreen_handle_locator))
     self._handle_incoming_call('reject')
     self.marionette.switch_to_frame()
     Wait(self.marionette).until(
         expected.element_not_displayed(*self._call_screen_locator))

 def tap_save_event(self):
     event_start_time = self.marionette.find_element(*self._event_start_time_value_locator).text
     event_start_date = self.marionette.find_element(*self._event_start_date_value_locator).text
     el = self.marionette.find_element(*self._modify_event_view_locator)
     self.marionette.find_element(*self._save_event_button_locator).tap()
     Wait(self.marionette).until(expected.element_not_displayed(el))
     return datetime.strptime(event_start_time + event_start_date, '%I:%M %p%m/%d/%Y')

 def a11y_click_next_to_wifi_section(self):
     progress = self.marionette.find_element(*self._progress_activity_locator)
     self.a11y_click_next()
     Wait(self.marionette).until(expected.element_not_displayed(progress))
     Wait(self.marionette).until(expected.element_displayed(
         Wait(self.marionette).until(expected.element_present(
             *self._section_wifi_locator))))

 def tap_done(self):
     time_picker = self.marionette.find_element(*self._time_picker_locator)
     self.marionette.find_element(*self._done_button_locator).tap()
     Wait(self.marionette).until(expected.element_not_displayed(time_picker))
     # TODO: wait for the time picker to fade out Bug 1038186
     time.sleep(2)
     self.apps.switch_to_displayed_app()

 def wait_for_content_ready(self):
     app = Gallery(self.device.marionette)
     Wait(self.device.marionette, timeout=240).until(
         lambda m: len(m.find_elements(
             By.CSS_SELECTOR, '.thumbnail')) == self.picture_count)
     Wait(self.device.marionette, timeout=60).until(
         expected.element_not_displayed(self.device.marionette.find_element(
             *app._progress_bar_locator)))

 def reset_mobile_usage(self):
     self.marionette.find_element(*self._reset_button_locator).tap()
     reset_mobile_usage = Wait(self.marionette).until(
         expected.element_present(*self._reset_mobile_usage_button_locator))
     Wait(self.marionette).until(expected.element_displayed(reset_mobile_usage))
     reset_dialog = self.marionette.find_element(*self._reset_dialog_locator)
     reset_mobile_usage.tap()
     Wait(self.marionette).until(expected.element_not_displayed(reset_dialog))

 def tap_back(self):
     el = self.marionette.find_element(*self._details_header_locator)
     Wait(self.marionette).until(expected.element_displayed(el))
     # TODO: remove tap with coordinates after Bug 1061698 is fixed
     el.tap(25, 25)
     Wait(self.marionette).until(expected.element_not_displayed(el))
     from gaiatest.apps.contacts.app import Contacts
     return Contacts(self.marionette)

 def tap_edit(self):
     edit = Wait(self.marionette).until(expected.element_present(
         *self._edit_contact_button_locator))
     Wait(self.marionette).until(expected.element_displayed(edit))
     edit.tap()
     Wait(self.marionette).until(expected.element_not_displayed(edit))
     from gaiatest.apps.contacts.regions.contact_form import EditContact
     return EditContact(self.marionette)

 def before_scroll(self):
     B2GPerfScrollTest.before_scroll(self)
     # TODO Replace with a suitable wait
     self.logger.debug('Sleep for 5 seconds to allow scan to start')
     time.sleep(5)
     self.logger.debug('Waiting for progress bar to be hidden')
     Wait(self.marionette, timeout=240).until(
         expected.element_not_displayed(
             self.marionette.find_element(By.ID, 'scan-progress')))

 def tap_cancel(self):
     actions_menu = Wait(self.marionette).until(
         expected.element_present(*self._actions_menu_locator))
     Wait(self.marionette).until(
         expected.element_displayed(actions_menu))
     self.marionette.find_element(*self._cancel_button_locator).tap()
     Wait(self.marionette).until(
         expected.element_not_displayed(actions_menu))
     self.apps.switch_to_displayed_app()

    def tap_edit_save_button(self):
        element = Wait(self.marionette).until(expected.element_present(*self._edit_save_locator))
        Wait(self.marionette).until(expected.element_displayed(element))
        element.tap()
        progress = self.marionette.find_element(*self._save_progress_bar_locator)
        Wait(self.marionette).until(expected.element_not_displayed(progress))
        from gaiatest.apps.gallery.app import Gallery

        return Gallery(self.marionette)

 def tap_import_from_sim(self):
     import_from_sim = Wait(self.marionette).until(
         expected.element_present(*self._import_from_sim_button_locator))
     Wait(self.marionette).until(expected.element_displayed(import_from_sim))
     import_from_sim.tap()
     from gaiatest.apps.contacts.app import Contacts
     status_message = Wait(self.marionette).until(
         expected.element_present(*Contacts._status_message_locator))
     Wait(self.marionette).until(expected.element_displayed(status_message))
     Wait(self.marionette).until(expected.element_not_displayed(status_message))

 def share_to_messages(self):
     actions_menu = Wait(self.marionette).until(
         expected.element_present(*self._actions_menu_locator))
     Wait(self.marionette).until(
         expected.element_displayed(actions_menu))
     self.marionette.find_element(*self._messages_button_locator).tap()
     Wait(self.marionette).until(
         expected.element_not_displayed(actions_menu))
     from gaiatest.apps.messages.regions.new_message import NewMessage
     return NewMessage(self.marionette)

 def tap_wallpaper(self):
     Wait(self.marionette).until(
         expected.element_displayed(*self._actions_menu_locator))
     self.marionette.find_element(*self._wallpaper_button_locator).tap()
     Wait(self.marionette).until(
         expected.element_not_displayed(*self._actions_menu_locator))
     from gaiatest.apps.wallpaper.app import Wallpaper
     wallpaper = Wallpaper(self.marionette)
     Wait(self.marionette).until(lambda m: self.apps.displayed_app.name == wallpaper.name)
     self.apps.switch_to_displayed_app()
     return wallpaper

 def tap_update(self, return_details=True):
     self.wait_for_update_button_enabled()
     update = self.marionette.find_element(*self._update_locator)
     update.tap()
     if return_details:
         Wait(self.marionette).until(expected.element_not_displayed(update))
         from gaiatest.apps.contacts.regions.contact_details import ContactDetails
         return ContactDetails(self.marionette)
     else:
         # else we drop back to the underlying app
         Wait(self.marionette).until(lambda m: self.apps.displayed_app.name != self.name)
         self.apps.switch_to_displayed_app()

 def tap_gallery(self):
     actions_menu = Wait(self.marionette).until(
         expected.element_present(*self._actions_menu_locator))
     Wait(self.marionette).until(
         expected.element_displayed(actions_menu))
     self.marionette.find_element(*self._gallery_button_locator).tap()
     Wait(self.marionette).until(
         expected.element_not_displayed(actions_menu))
     from gaiatest.apps.gallery.app import Gallery
     gallery = Gallery(self.marionette)
     Wait(self.marionette).until(lambda m: self.apps.displayed_app.name == gallery.name)
     self.apps.switch_to_displayed_app()
     return gallery

    def wait_for_notification_message(self, message):
        """This will wait for the specified message to appear in the DOM element
           for the notification message, not for that message to be visible.

           This is required as often the message is no longer visible when we check,
           but the expected text still exists in the DOM element.

           This is also the reason that we wait for the element to no longer be
           visible at the end of this method, whereas we do not wait for it to
           first be visible.
        """
        element = self.marionette.find_element(*self._notification_locator)
        Wait(self.marionette).until(self._element_inner_html_contains(element, message))
        Wait(self.marionette).until(expected.element_not_displayed(element))

 def _return_class_from_tap(self, return_class='ContactDetails'):
     if return_class == 'ContactDetails':
         Wait(self.marionette).until(lambda m: expected.element_not_displayed(self.root_element))
         from gaiatest.apps.contacts.regions.contact_details import ContactDetails
         return ContactDetails(self.marionette)
     elif return_class == 'EditContact':
         # This may seem superfluous but we can enter EditContact from Contacts, or from ActivityPicker
         Wait(self.marionette).until(lambda m: self.apps.displayed_app.name == Contacts.name)
         self.apps.switch_to_displayed_app()
         from gaiatest.apps.contacts.regions.contact_form import EditContact
         return EditContact(self.marionette)
     else:
         # We are using contacts picker in activity - after choosing, fall back to open app
         Wait(self.marionette).until(lambda m: self.apps.displayed_app.name != Contacts.name)
         self.apps.switch_to_displayed_app()

 def tap_camera(self):
     actions_menu = Wait(self.marionette).until(
         expected.element_present(*self._actions_menu_locator))
     Wait(self.marionette).until(
         expected.element_displayed(actions_menu))
     self.marionette.find_element(*self._camera_button_locator).tap()
     Wait(self.marionette).until(
         expected.element_not_displayed(actions_menu))
     from gaiatest.apps.camera.app import Camera
     camera = Camera(self.marionette)
     Wait(self.marionette).until(lambda m: self.apps.displayed_app.name == camera.name)
     self.apps.switch_to_displayed_app()
     camera.wait_for_loading_spinner_displayed()
     camera.wait_for_loading_spinner_hidden()
     camera.wait_for_capture_ready()
     return camera