805 lines
33 KiB
Python
805 lines
33 KiB
Python
# -*- coding: utf-8 -*-
|
|
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
import re
|
|
import sys
|
|
import os
|
|
import unittest
|
|
|
|
# Add this directory to the import path.
|
|
sys.path.append(os.path.dirname(__file__))
|
|
|
|
from selection import (
|
|
CaretActions,
|
|
SelectionManager,
|
|
)
|
|
from marionette_driver.by import By
|
|
from marionette_driver.keys import Keys
|
|
from marionette_harness.marionette_test import (
|
|
MarionetteTestCase,
|
|
SkipTest,
|
|
parameterized,
|
|
)
|
|
|
|
|
|
class AccessibleCaretSelectionModeTestCase(MarionetteTestCase):
|
|
"""Test cases for AccessibleCaret under selection mode."""
|
|
|
|
# Element IDs.
|
|
_input_id = "input"
|
|
_input_padding_id = "input-padding"
|
|
_input_size_id = "input-size"
|
|
_textarea_id = "textarea"
|
|
_textarea2_id = "textarea2"
|
|
_textarea_disabled_id = "textarea-disabled"
|
|
_textarea_one_line_id = "textarea-one-line"
|
|
_textarea_rtl_id = "textarea-rtl"
|
|
_contenteditable_id = "contenteditable"
|
|
_contenteditable2_id = "contenteditable2"
|
|
_content_id = "content"
|
|
_content2_id = "content2"
|
|
_non_selectable_id = "non-selectable"
|
|
|
|
# Test html files.
|
|
_selection_html = "layout/test_carets_selection.html"
|
|
_multipleline_html = "layout/test_carets_multipleline.html"
|
|
_multiplerange_html = "layout/test_carets_multiplerange.html"
|
|
_longtext_html = "layout/test_carets_longtext.html"
|
|
_iframe_html = "layout/test_carets_iframe.html"
|
|
_iframe_scroll_html = "layout/test_carets_iframe_scroll.html"
|
|
_display_none_html = "layout/test_carets_display_none.html"
|
|
_svg_shapes_html = "layout/test_carets_svg_shapes.html"
|
|
_key_scroll_html = "layout/test_carets_key_scroll.html"
|
|
|
|
def setUp(self):
|
|
# Code to execute before every test is running.
|
|
super(AccessibleCaretSelectionModeTestCase, self).setUp()
|
|
self.carets_tested_pref = "layout.accessiblecaret.enabled"
|
|
self.prefs = {
|
|
"layout.word_select.eat_space_to_next_word": False,
|
|
self.carets_tested_pref: True,
|
|
# To disable transition, or the caret may not be the desired
|
|
# location yet, we cannot press a caret successfully.
|
|
"layout.accessiblecaret.transition-duration": "0.0",
|
|
# Enabled hapticfeedback on all platforms. The tests shouldn't crash
|
|
# on platforms without hapticfeedback support.
|
|
"layout.accessiblecaret.hapticfeedback": True,
|
|
}
|
|
self.marionette.set_prefs(self.prefs)
|
|
self.actions = CaretActions(self.marionette)
|
|
|
|
def tearDown(self):
|
|
self.marionette.actions.release()
|
|
super(AccessibleCaretSelectionModeTestCase, self).tearDown()
|
|
|
|
def open_test_html(self, test_html):
|
|
self.marionette.navigate(self.marionette.absolute_url(test_html))
|
|
|
|
def word_offset(self, text, ordinal):
|
|
"Get the character offset of the ordinal-th word in text."
|
|
tokens = re.split(r"(\S+)", text) # both words and spaces
|
|
spaces = tokens[0::2] # collect spaces at odd indices
|
|
words = tokens[1::2] # collect word at even indices
|
|
|
|
if ordinal >= len(words):
|
|
raise IndexError(
|
|
"Only %d words in text, but got ordinal %d" % (len(words), ordinal)
|
|
)
|
|
|
|
# Cursor position of the targeting word is behind the the first
|
|
# character in the word. For example, offset to 'def' in 'abc def' is
|
|
# between 'd' and 'e'.
|
|
offset = len(spaces[0]) + 1
|
|
offset += sum(len(words[i]) + len(spaces[i + 1]) for i in range(ordinal))
|
|
return offset
|
|
|
|
def test_word_offset(self):
|
|
text = " " * 3 + "abc" + " " * 3 + "def"
|
|
|
|
self.assertTrue(self.word_offset(text, 0), 4)
|
|
self.assertTrue(self.word_offset(text, 1), 10)
|
|
with self.assertRaises(IndexError):
|
|
self.word_offset(text, 2)
|
|
|
|
def word_location(self, el, ordinal):
|
|
"""Get the location (x, y) of the ordinal-th word in el.
|
|
|
|
The ordinal starts from 0.
|
|
|
|
Note: this function has a side effect which changes focus to the
|
|
target element el.
|
|
|
|
"""
|
|
sel = SelectionManager(el)
|
|
offset = self.word_offset(sel.content, ordinal)
|
|
|
|
# Move the blinking cursor to the word.
|
|
self.actions.click(element=el).perform()
|
|
sel.move_cursor_to_front()
|
|
sel.move_cursor_by_offset(offset)
|
|
x, y = sel.cursor_location()
|
|
|
|
return x, y
|
|
|
|
def rect_relative_to_window(self, el):
|
|
"""Get element's bounding rectangle.
|
|
|
|
This function is similar to el.rect, but the coordinate is relative to
|
|
the top left corner of the window instead of the document.
|
|
|
|
"""
|
|
return self.marionette.execute_script(
|
|
"""
|
|
let rect = arguments[0].getBoundingClientRect();
|
|
return {x: rect.x, y:rect.y, width: rect.width, height: rect.height};
|
|
""",
|
|
script_args=[el],
|
|
)
|
|
|
|
def long_press_on_location(self, el, x=None, y=None):
|
|
"""Long press the location (x, y) to select a word.
|
|
|
|
If no (x, y) are given, it will be targeted at the center of the
|
|
element. On Windows, those spaces after the word will also be selected.
|
|
This function sends synthesized eMouseLongTap to gecko.
|
|
|
|
"""
|
|
rect = self.rect_relative_to_window(el)
|
|
target_x = rect["x"] + (x if x is not None else rect["width"] // 2)
|
|
target_y = rect["y"] + (y if y is not None else rect["height"] // 2)
|
|
|
|
self.marionette.execute_script(
|
|
"""
|
|
let utils = window.windowUtils;
|
|
utils.sendTouchEventToWindow('touchstart', [0],
|
|
[arguments[0]], [arguments[1]],
|
|
[1], [1], [0], [1], [0], [0], [0], 0);
|
|
utils.sendMouseEventToWindow('mouselongtap', arguments[0], arguments[1],
|
|
0, 1, 0);
|
|
utils.sendTouchEventToWindow('touchend', [0],
|
|
[arguments[0]], [arguments[1]],
|
|
[1], [1], [0], [1], [0], [0], [0], 0);
|
|
""",
|
|
script_args=[target_x, target_y],
|
|
sandbox="system",
|
|
)
|
|
|
|
def long_press_on_word(self, el, wordOrdinal):
|
|
x, y = self.word_location(el, wordOrdinal)
|
|
self.long_press_on_location(el, x, y)
|
|
|
|
def to_unix_line_ending(self, s):
|
|
"""Changes all Windows/Mac line endings in s to UNIX line endings."""
|
|
|
|
return s.replace("\r\n", "\n").replace("\r", "\n")
|
|
|
|
@parameterized(_input_id, el_id=_input_id)
|
|
@parameterized(_textarea_id, el_id=_textarea_id)
|
|
@parameterized(_textarea_disabled_id, el_id=_textarea_disabled_id)
|
|
@parameterized(_textarea_rtl_id, el_id=_textarea_rtl_id)
|
|
@parameterized(_contenteditable_id, el_id=_contenteditable_id)
|
|
@parameterized(_content_id, el_id=_content_id)
|
|
def test_long_press_to_select_a_word(self, el_id):
|
|
self.open_test_html(self._selection_html)
|
|
el = self.marionette.find_element(By.ID, el_id)
|
|
self._test_long_press_to_select_a_word(el)
|
|
|
|
def _test_long_press_to_select_a_word(self, el):
|
|
sel = SelectionManager(el)
|
|
original_content = sel.content
|
|
words = original_content.split()
|
|
self.assertTrue(len(words) >= 2, "Expect at least two words in the content.")
|
|
target_content = words[0]
|
|
|
|
# Goal: Select the first word.
|
|
self.long_press_on_word(el, 0)
|
|
|
|
# Ignore extra spaces selected after the word.
|
|
self.assertEqual(target_content, sel.selected_content)
|
|
|
|
@parameterized(_input_id, el_id=_input_id)
|
|
@parameterized(_textarea_id, el_id=_textarea_id)
|
|
@parameterized(_textarea_disabled_id, el_id=_textarea_disabled_id)
|
|
@parameterized(_textarea_rtl_id, el_id=_textarea_rtl_id)
|
|
@parameterized(_contenteditable_id, el_id=_contenteditable_id)
|
|
@parameterized(_content_id, el_id=_content_id)
|
|
def test_drag_carets(self, el_id):
|
|
self.open_test_html(self._selection_html)
|
|
el = self.marionette.find_element(By.ID, el_id)
|
|
sel = SelectionManager(el)
|
|
original_content = sel.content
|
|
words = original_content.split()
|
|
self.assertTrue(len(words) >= 1, "Expect at least one word in the content.")
|
|
|
|
# Goal: Select all text after the first word.
|
|
target_content = original_content[len(words[0]) :]
|
|
|
|
# Get the location of the carets at the end of the content for later
|
|
# use.
|
|
self.actions.click(element=el).perform()
|
|
sel.select_all()
|
|
end_caret_x, end_caret_y = sel.second_caret_location()
|
|
|
|
self.long_press_on_word(el, 0)
|
|
|
|
# Drag the second caret to the end of the content.
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
self.actions.flick(el, caret2_x, caret2_y, end_caret_x, end_caret_y).perform()
|
|
|
|
# Drag the first caret to the previous position of the second caret.
|
|
self.actions.flick(el, caret1_x, caret1_y, caret2_x, caret2_y).perform()
|
|
|
|
self.assertEqual(target_content, sel.selected_content)
|
|
|
|
@parameterized(_input_id, el_id=_input_id)
|
|
@parameterized(_textarea_id, el_id=_textarea_id)
|
|
@parameterized(_textarea_disabled_id, el_id=_textarea_disabled_id)
|
|
@parameterized(_textarea_rtl_id, el_id=_textarea_rtl_id)
|
|
@parameterized(_contenteditable_id, el_id=_contenteditable_id)
|
|
@parameterized(_content_id, el_id=_content_id)
|
|
def test_drag_swappable_carets(self, el_id):
|
|
self.open_test_html(self._selection_html)
|
|
el = self.marionette.find_element(By.ID, el_id)
|
|
sel = SelectionManager(el)
|
|
original_content = sel.content
|
|
words = original_content.split()
|
|
self.assertTrue(len(words) >= 1, "Expect at least one word in the content.")
|
|
|
|
target_content1 = words[0]
|
|
target_content2 = original_content[len(words[0]) :]
|
|
|
|
# Get the location of the carets at the end of the content for later
|
|
# use.
|
|
self.actions.click(element=el).perform()
|
|
sel.select_all()
|
|
end_caret_x, end_caret_y = sel.second_caret_location()
|
|
|
|
self.long_press_on_word(el, 0)
|
|
|
|
# Drag the first caret to the end and back to where it was
|
|
# immediately. The selection range should not be collapsed.
|
|
caret1_x, caret1_y = sel.first_caret_location()
|
|
self.actions.flick(el, caret1_x, caret1_y, end_caret_x, end_caret_y).flick(
|
|
el, end_caret_x, end_caret_y, caret1_x, caret1_y
|
|
).perform()
|
|
self.assertEqual(target_content1, sel.selected_content)
|
|
|
|
# Drag the first caret to the end.
|
|
caret1_x, caret1_y = sel.first_caret_location()
|
|
self.actions.flick(el, caret1_x, caret1_y, end_caret_x, end_caret_y).perform()
|
|
self.assertEqual(target_content2, sel.selected_content)
|
|
|
|
@parameterized(_input_id, el_id=_input_id)
|
|
# Bug 1855083: Skip textarea tests due to high frequent intermittent.
|
|
# @parameterized(_textarea_id, el_id=_textarea_id)
|
|
# @parameterized(_textarea_disabled_id, el_id=_textarea_disabled_id)
|
|
@parameterized(_textarea_rtl_id, el_id=_textarea_rtl_id)
|
|
@parameterized(_contenteditable_id, el_id=_contenteditable_id)
|
|
@parameterized(_content_id, el_id=_content_id)
|
|
def test_minimum_select_one_character(self, el_id):
|
|
self.open_test_html(self._selection_html)
|
|
el = self.marionette.find_element(By.ID, el_id)
|
|
self._test_minimum_select_one_character(el)
|
|
|
|
@parameterized(_textarea2_id, el_id=_textarea2_id)
|
|
@parameterized(_contenteditable2_id, el_id=_contenteditable2_id)
|
|
@parameterized(_content2_id, el_id=_content2_id)
|
|
def test_minimum_select_one_character2(self, el_id):
|
|
self.open_test_html(self._multipleline_html)
|
|
el = self.marionette.find_element(By.ID, el_id)
|
|
self._test_minimum_select_one_character(el)
|
|
|
|
def _test_minimum_select_one_character(self, el):
|
|
sel = SelectionManager(el)
|
|
original_content = sel.content
|
|
words = original_content.split()
|
|
self.assertTrue(len(words) >= 1, "Expect at least one word in the content.")
|
|
|
|
# Get the location of the carets at the end of the content for later
|
|
# use.
|
|
sel.select_all()
|
|
end_caret_x, end_caret_y = sel.second_caret_location()
|
|
self.actions.click(element=el).perform()
|
|
|
|
# Goal: Select the first character.
|
|
target_content = original_content[0]
|
|
|
|
self.long_press_on_word(el, 0)
|
|
|
|
# Drag the second caret to the end of the content.
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
self.actions.flick(el, caret2_x, caret2_y, end_caret_x, end_caret_y).perform()
|
|
|
|
# Drag the second caret to the position of the first caret.
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
self.actions.flick(el, caret2_x, caret2_y, caret1_x, caret1_y).perform()
|
|
|
|
self.assertEqual(target_content, sel.selected_content)
|
|
|
|
@parameterized(
|
|
_input_id + "_to_" + _textarea_id, el1_id=_input_id, el2_id=_textarea_id
|
|
)
|
|
@parameterized(
|
|
_input_id + "_to_" + _contenteditable_id,
|
|
el1_id=_input_id,
|
|
el2_id=_contenteditable_id,
|
|
)
|
|
@parameterized(
|
|
_input_id + "_to_" + _content_id, el1_id=_input_id, el2_id=_content_id
|
|
)
|
|
@parameterized(
|
|
_textarea_id + "_to_" + _input_id, el1_id=_textarea_id, el2_id=_input_id
|
|
)
|
|
@parameterized(
|
|
_textarea_id + "_to_" + _contenteditable_id,
|
|
el1_id=_textarea_id,
|
|
el2_id=_contenteditable_id,
|
|
)
|
|
@parameterized(
|
|
_textarea_id + "_to_" + _content_id, el1_id=_textarea_id, el2_id=_content_id
|
|
)
|
|
@parameterized(
|
|
_contenteditable_id + "_to_" + _input_id,
|
|
el1_id=_contenteditable_id,
|
|
el2_id=_input_id,
|
|
)
|
|
@parameterized(
|
|
_contenteditable_id + "_to_" + _textarea_id,
|
|
el1_id=_contenteditable_id,
|
|
el2_id=_textarea_id,
|
|
)
|
|
@parameterized(
|
|
_contenteditable_id + "_to_" + _content_id,
|
|
el1_id=_contenteditable_id,
|
|
el2_id=_content_id,
|
|
)
|
|
@parameterized(
|
|
_content_id + "_to_" + _input_id, el1_id=_content_id, el2_id=_input_id
|
|
)
|
|
@parameterized(
|
|
_content_id + "_to_" + _textarea_id, el1_id=_content_id, el2_id=_textarea_id
|
|
)
|
|
@parameterized(
|
|
_content_id + "_to_" + _contenteditable_id,
|
|
el1_id=_content_id,
|
|
el2_id=_contenteditable_id,
|
|
)
|
|
def test_long_press_changes_focus_from(self, el1_id, el2_id):
|
|
self.open_test_html(self._selection_html)
|
|
el1 = self.marionette.find_element(By.ID, el1_id)
|
|
el2 = self.marionette.find_element(By.ID, el2_id)
|
|
|
|
# Compute the content of the first word in el2.
|
|
sel = SelectionManager(el2)
|
|
original_content = sel.content
|
|
words = original_content.split()
|
|
target_content = words[0]
|
|
|
|
# Goal: Click to focus el1, and then select the first word on el2.
|
|
|
|
# We want to collect the location of the first word in el2 here
|
|
# since self.word_location() has the side effect which would
|
|
# change the focus.
|
|
x, y = self.word_location(el2, 0)
|
|
|
|
self.actions.click(element=el1).perform()
|
|
self.long_press_on_location(el2, x, y)
|
|
self.assertEqual(target_content, sel.selected_content)
|
|
|
|
@parameterized(_input_id, el_id=_input_id)
|
|
@parameterized(_textarea_id, el_id=_textarea_id)
|
|
@parameterized(_textarea_rtl_id, el_id=_textarea_rtl_id)
|
|
@parameterized(_contenteditable_id, el_id=_contenteditable_id)
|
|
def test_focus_not_changed_by_long_press_on_non_selectable(self, el_id):
|
|
self.open_test_html(self._selection_html)
|
|
el = self.marionette.find_element(By.ID, el_id)
|
|
non_selectable = self.marionette.find_element(By.ID, self._non_selectable_id)
|
|
|
|
# Goal: Focus remains on the editable element el after long pressing on
|
|
# the non-selectable element.
|
|
sel = SelectionManager(el)
|
|
self.long_press_on_word(el, 0)
|
|
self.long_press_on_location(non_selectable)
|
|
active_sel = SelectionManager(self.marionette.get_active_element())
|
|
self.assertEqual(sel.content, active_sel.content)
|
|
|
|
@parameterized(_input_id, el_id=_input_id)
|
|
@parameterized(_textarea_id, el_id=_textarea_id)
|
|
@parameterized(_textarea_disabled_id, el_id=_textarea_disabled_id)
|
|
@parameterized(_textarea_rtl_id, el_id=_textarea_rtl_id)
|
|
@parameterized(_contenteditable_id, el_id=_contenteditable_id)
|
|
@parameterized(_content_id, el_id=_content_id)
|
|
def test_handle_tilt_when_carets_overlap_each_other(self, el_id):
|
|
"""Test tilt handling when carets overlap to each other.
|
|
|
|
Let the two carets overlap each other. If they are set to tilted
|
|
successfully, click on the tilted carets should not cause the selection
|
|
to be collapsed and the carets should be draggable.
|
|
|
|
"""
|
|
self.open_test_html(self._selection_html)
|
|
el = self.marionette.find_element(By.ID, el_id)
|
|
sel = SelectionManager(el)
|
|
original_content = sel.content
|
|
words = original_content.split()
|
|
self.assertTrue(len(words) >= 1, "Expect at least one word in the content.")
|
|
|
|
# Goal: Select the first word.
|
|
self.long_press_on_word(el, 0)
|
|
target_content = sel.selected_content
|
|
|
|
# Drag the first caret to the position of the second caret to trigger
|
|
# carets overlapping.
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
self.actions.flick(el, caret1_x, caret1_y, caret2_x, caret2_y).perform()
|
|
|
|
# We make two hit tests targeting the left edge of the left tilted caret
|
|
# and the right edge of the right tilted caret. If either of the hits is
|
|
# missed, selection would be collapsed and both carets should not be
|
|
# draggable.
|
|
(caret3_x, caret3_y), (caret4_x, caret4_y) = sel.carets_location()
|
|
|
|
# The following values are from ua.css and all.js
|
|
caret_width = float(self.marionette.get_pref("layout.accessiblecaret.width"))
|
|
caret_margin_left = float(
|
|
self.marionette.get_pref("layout.accessiblecaret.margin-left")
|
|
)
|
|
tilt_right_margin_left = 0.41 * caret_width
|
|
tilt_left_margin_left = -0.39 * caret_width
|
|
|
|
left_caret_left_edge_x = caret3_x + caret_margin_left + tilt_left_margin_left
|
|
self.actions.move(el, left_caret_left_edge_x + 2, caret3_y).click().perform()
|
|
|
|
right_caret_right_edge_x = (
|
|
caret4_x + caret_margin_left + tilt_right_margin_left + caret_width
|
|
)
|
|
self.actions.move(el, right_caret_right_edge_x - 2, caret4_y).click().perform()
|
|
|
|
# Drag the first caret back to the initial selection, the first word.
|
|
self.actions.flick(el, caret3_x, caret3_y, caret1_x, caret1_y).perform()
|
|
|
|
self.assertEqual(target_content, sel.selected_content)
|
|
|
|
def test_drag_caret_over_non_selectable_field(self):
|
|
"""Test dragging the caret over a non-selectable field.
|
|
|
|
The selected content should exclude non-selectable elements and the
|
|
second caret should appear in last range's position.
|
|
|
|
"""
|
|
self.open_test_html(self._multiplerange_html)
|
|
body = self.marionette.find_element(By.ID, "bd")
|
|
sel3 = self.marionette.find_element(By.ID, "sel3")
|
|
sel4 = self.marionette.find_element(By.ID, "sel4")
|
|
sel6 = self.marionette.find_element(By.ID, "sel6")
|
|
|
|
# Select target element and get target caret location
|
|
self.long_press_on_word(sel4, 3)
|
|
sel = SelectionManager(body)
|
|
end_caret_x, end_caret_y = sel.second_caret_location()
|
|
|
|
self.long_press_on_word(sel6, 0)
|
|
end_caret2_x, end_caret2_y = sel.second_caret_location()
|
|
|
|
# Select start element
|
|
self.long_press_on_word(sel3, 3)
|
|
|
|
# Drag end caret to target location
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
self.actions.flick(
|
|
body, caret2_x, caret2_y, end_caret_x, end_caret_y, 1
|
|
).perform()
|
|
self.assertEqual(
|
|
self.to_unix_line_ending(sel.selected_content.strip()),
|
|
"this 3\nuser can select this",
|
|
)
|
|
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
self.actions.flick(
|
|
body, caret2_x, caret2_y, end_caret2_x, end_caret2_y, 1
|
|
).perform()
|
|
self.assertEqual(
|
|
self.to_unix_line_ending(sel.selected_content.strip()),
|
|
"this 3\nuser can select this 4\nuser can select this 5\nuser",
|
|
)
|
|
|
|
# Drag first caret to target location
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
self.actions.flick(
|
|
body, caret1_x, caret1_y, end_caret_x, end_caret_y, 1
|
|
).perform()
|
|
self.assertEqual(
|
|
self.to_unix_line_ending(sel.selected_content.strip()),
|
|
"4\nuser can select this 5\nuser",
|
|
)
|
|
|
|
def test_drag_swappable_caret_over_non_selectable_field(self):
|
|
self.open_test_html(self._multiplerange_html)
|
|
body = self.marionette.find_element(By.ID, "bd")
|
|
sel3 = self.marionette.find_element(By.ID, "sel3")
|
|
sel4 = self.marionette.find_element(By.ID, "sel4")
|
|
sel = SelectionManager(body)
|
|
|
|
self.long_press_on_word(sel4, 3)
|
|
(
|
|
(end_caret1_x, end_caret1_y),
|
|
(end_caret2_x, end_caret2_y),
|
|
) = sel.carets_location()
|
|
|
|
self.long_press_on_word(sel3, 3)
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
|
|
# Drag the first caret down, which will across the second caret.
|
|
self.actions.flick(
|
|
body, caret1_x, caret1_y, end_caret1_x, end_caret1_y
|
|
).perform()
|
|
self.assertEqual(
|
|
self.to_unix_line_ending(sel.selected_content.strip()), "3\nuser can select"
|
|
)
|
|
|
|
# The old second caret becomes the first caret. Drag it down again.
|
|
self.actions.flick(
|
|
body, caret2_x, caret2_y, end_caret2_x, end_caret2_y
|
|
).perform()
|
|
self.assertEqual(self.to_unix_line_ending(sel.selected_content.strip()), "this")
|
|
|
|
def test_drag_caret_to_beginning_of_a_line(self):
|
|
"""Bug 1094056
|
|
Test caret visibility when caret is dragged to beginning of a line
|
|
"""
|
|
self.open_test_html(self._multiplerange_html)
|
|
body = self.marionette.find_element(By.ID, "bd")
|
|
sel1 = self.marionette.find_element(By.ID, "sel1")
|
|
sel2 = self.marionette.find_element(By.ID, "sel2")
|
|
|
|
# Select the first word in the second line
|
|
self.long_press_on_word(sel2, 0)
|
|
sel = SelectionManager(body)
|
|
(
|
|
(start_caret_x, start_caret_y),
|
|
(end_caret_x, end_caret_y),
|
|
) = sel.carets_location()
|
|
|
|
# Select target word in the first line
|
|
self.long_press_on_word(sel1, 2)
|
|
|
|
# Drag end caret to the beginning of the second line
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
self.actions.flick(
|
|
body, caret2_x, caret2_y, start_caret_x, start_caret_y
|
|
).perform()
|
|
|
|
# Drag end caret back to the target word
|
|
self.actions.flick(
|
|
body, start_caret_x, start_caret_y, caret2_x, caret2_y
|
|
).perform()
|
|
|
|
self.assertEqual(self.to_unix_line_ending(sel.selected_content), "select")
|
|
|
|
def test_select_word_inside_an_iframe(self):
|
|
"""Bug 1088552
|
|
The scroll offset in iframe should be taken into consideration properly.
|
|
In this test, we scroll content in the iframe to the bottom to cause a
|
|
huge offset. If we use the right coordinate system, selection should
|
|
work. Otherwise, it would be hard to trigger select word.
|
|
"""
|
|
self.open_test_html(self._iframe_html)
|
|
iframe = self.marionette.find_element(By.ID, "frame")
|
|
|
|
# switch to inner iframe and scroll to the bottom
|
|
self.marionette.switch_to_frame(iframe)
|
|
self.marionette.execute_script('document.getElementById("bd").scrollTop += 999')
|
|
|
|
# long press to select bottom text
|
|
body = self.marionette.find_element(By.ID, "bd")
|
|
sel = SelectionManager(body)
|
|
self._bottomtext = self.marionette.find_element(By.ID, "bottomtext")
|
|
self.long_press_on_location(self._bottomtext)
|
|
|
|
self.assertNotEqual(self.to_unix_line_ending(sel.selected_content), "")
|
|
|
|
def test_select_word_inside_an_unfocused_iframe(self):
|
|
"""Bug 1306634: Test we can long press to select a word in an unfocused iframe."""
|
|
self.open_test_html(self._iframe_html)
|
|
|
|
el = self.marionette.find_element(By.ID, self._input_id)
|
|
sel = SelectionManager(el)
|
|
|
|
# First, we select the first word in the input of the parent document.
|
|
el_first_word = sel.content.split()[0] # first world is "ABC"
|
|
self.long_press_on_word(el, 0)
|
|
self.assertEqual(el_first_word, sel.selected_content)
|
|
|
|
# Then, we long press on the center of the iframe. It should select a
|
|
# word inside of the document, not the placehoder in the parent
|
|
# document.
|
|
iframe = self.marionette.find_element(By.ID, "frame")
|
|
self.long_press_on_location(iframe)
|
|
self.marionette.switch_to_frame(iframe)
|
|
body = self.marionette.find_element(By.ID, "bd")
|
|
sel = SelectionManager(body)
|
|
self.assertNotEqual("", sel.selected_content)
|
|
|
|
def test_carets_initialized_in_display_none(self):
|
|
"""Test AccessibleCaretEventHub is properly initialized on a <html> with
|
|
display: none.
|
|
|
|
"""
|
|
self.open_test_html(self._display_none_html)
|
|
html = self.marionette.find_element(By.ID, "html")
|
|
content = self.marionette.find_element(By.ID, "content")
|
|
|
|
# Remove 'display: none' from <html>
|
|
self.marionette.execute_script(
|
|
'arguments[0].style.display = "unset";', script_args=[html]
|
|
)
|
|
|
|
# If AccessibleCaretEventHub is initialized successfully, select a word
|
|
# should work.
|
|
self._test_long_press_to_select_a_word(content)
|
|
|
|
@unittest.skip("Bug 1855083: High frequent intermittent.")
|
|
def test_long_press_to_select_when_partial_visible_word_is_selected(self):
|
|
self.open_test_html(self._selection_html)
|
|
el = self.marionette.find_element(By.ID, self._input_size_id)
|
|
sel = SelectionManager(el)
|
|
|
|
original_content = sel.content
|
|
words = original_content.split()
|
|
|
|
# We cannot use self.long_press_on_word() for the second long press
|
|
# on the first word because it has side effect that changes the
|
|
# cursor position. We need to save the location of the first word to
|
|
# be used later.
|
|
word0_x, word0_y = self.word_location(el, 0)
|
|
|
|
# Long press on the second word.
|
|
self.long_press_on_word(el, 1)
|
|
self.assertEqual(words[1], sel.selected_content)
|
|
|
|
# Long press on the first word.
|
|
self.long_press_on_location(el, word0_x, word0_y)
|
|
self.assertEqual(words[0], sel.selected_content)
|
|
|
|
# If the second caret is visible, it can be dragged to the position
|
|
# of the first caret. After that, selection will contain only the
|
|
# first character.
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
self.actions.flick(el, caret2_x, caret2_y, caret1_x, caret1_y).perform()
|
|
self.assertEqual(words[0][0], sel.selected_content)
|
|
|
|
@parameterized(_input_id, el_id=_input_id)
|
|
@parameterized(_input_padding_id, el_id=_input_padding_id)
|
|
@parameterized(_textarea_one_line_id, el_id=_textarea_one_line_id)
|
|
@parameterized(_contenteditable_id, el_id=_contenteditable_id)
|
|
def test_carets_not_jump_when_dragging_to_editable_content_boundary(self, el_id):
|
|
self.open_test_html(self._selection_html)
|
|
el = self.marionette.find_element(By.ID, el_id)
|
|
sel = SelectionManager(el)
|
|
original_content = sel.content
|
|
words = original_content.split()
|
|
self.assertTrue(len(words) >= 3, "Expect at least three words in the content.")
|
|
|
|
# Goal: the selection is not changed after dragging the caret on the
|
|
# Y-axis.
|
|
target_content = words[1]
|
|
|
|
self.long_press_on_word(el, 1)
|
|
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.carets_location()
|
|
|
|
# Drag the first caret up by 40px.
|
|
self.actions.flick(el, caret1_x, caret1_y, caret1_x, caret1_y - 40).perform()
|
|
self.assertEqual(target_content, sel.selected_content)
|
|
|
|
# Drag the second caret down by 50px.
|
|
self.actions.flick(el, caret2_x, caret2_y, caret2_x, caret2_y + 50).perform()
|
|
self.assertEqual(target_content, sel.selected_content)
|
|
|
|
def test_carets_should_not_appear_when_long_pressing_svg_shapes(self):
|
|
self.open_test_html(self._svg_shapes_html)
|
|
|
|
rect = self.marionette.find_element(By.ID, "rect")
|
|
text = self.marionette.find_element(By.ID, "text")
|
|
|
|
sel = SelectionManager(text)
|
|
num_words_in_text = len(sel.content.split())
|
|
|
|
# Goal: the carets should not appear when long-pressing on the
|
|
# unselectable SVG rect.
|
|
|
|
# Get the position of the end of last word in text, i.e. the
|
|
# position of the second caret when selecting the last word.
|
|
self.long_press_on_word(text, num_words_in_text - 1)
|
|
(_, _), (x2, y2) = sel.carets_location()
|
|
|
|
# Long press to select the unselectable SVG rect.
|
|
self.long_press_on_location(rect)
|
|
(_, _), (x, y) = sel.carets_location()
|
|
|
|
# Drag the second caret to (x2, y2).
|
|
self.actions.flick(text, x, y, x2, y2).perform()
|
|
|
|
# If the carets should appear on the rect, the selection will be
|
|
# extended to cover all the words in text. Assert this should not
|
|
# happen.
|
|
self.assertNotEqual(sel.content, sel.selected_content.strip())
|
|
|
|
def test_select_word_scroll_then_drag_caret(self):
|
|
"""Bug 1657256: Test select word, scroll page up , and then drag the second
|
|
caret down to cover "EEEEEE".
|
|
|
|
Note the selection should be extended to just cover "EEEEEE", not extend
|
|
to other lines below "EEEEEE".
|
|
|
|
"""
|
|
|
|
self.open_test_html(self._iframe_scroll_html)
|
|
iframe = self.marionette.find_element(By.ID, "iframe")
|
|
|
|
# Switch to the inner iframe.
|
|
self.marionette.switch_to_frame(iframe)
|
|
body = self.marionette.find_element(By.ID, "bd")
|
|
sel = SelectionManager(body)
|
|
|
|
# Select "EEEEEE" to get the y position of the second caret. This is the
|
|
# y position we are going to drag the caret to.
|
|
content2 = self.marionette.find_element(By.ID, self._content2_id)
|
|
self.long_press_on_word(content2, 0)
|
|
(_, _), (x, y2) = sel.carets_location()
|
|
|
|
# Step 1: Select "DDDDDD".
|
|
content = self.marionette.find_element(By.ID, self._content_id)
|
|
self.long_press_on_word(content, 0)
|
|
(_, _), (_, y1) = sel.carets_location()
|
|
|
|
# The y-axis offset of the second caret needed to extend the selection.
|
|
y_offset = y2 - y1
|
|
|
|
# Step 2: Scroll the page upwards by 40px.
|
|
scroll_offset = 40
|
|
self.marionette.execute_script(
|
|
"document.documentElement.scrollTop += arguments[0]",
|
|
script_args=[scroll_offset],
|
|
)
|
|
|
|
# Step 3: Drag the second caret down.
|
|
self.actions.flick(
|
|
body, x, y1 - scroll_offset, x, y1 - scroll_offset + y_offset
|
|
).perform()
|
|
|
|
self.assertEqual("DDDDDD EEEEEE", sel.selected_content)
|
|
|
|
@unittest.skip("Bug 1855083: High frequent intermittent.")
|
|
def test_carets_not_show_after_key_scroll_down_and_up(self):
|
|
self.open_test_html(self._key_scroll_html)
|
|
html = self.marionette.find_element(By.ID, "html")
|
|
sel = SelectionManager(html)
|
|
|
|
# Select "BBBBB" to get the position of the second caret. This is the
|
|
# position to which we are going to drag the caret in the step 3.
|
|
content2 = self.marionette.find_element(By.ID, self._content2_id)
|
|
self.long_press_on_word(content2, 0)
|
|
(_, _), (x2, y2) = sel.carets_location()
|
|
|
|
# Step 1: Select "AAAAA".
|
|
content = self.marionette.find_element(By.ID, self._content_id)
|
|
self.long_press_on_word(content, 0)
|
|
(_, _), (x1, y1) = sel.carets_location()
|
|
|
|
# Step 2: Scroll the page down and up.
|
|
#
|
|
# FIXME: The selection highlight on "AAAAA" often disappears after page
|
|
# up, which is the root cause of the intermittent. Longer pause between
|
|
# the page down and page up might help, but it's not a great solution.
|
|
self.actions.key_chain.send_keys(Keys.PAGE_DOWN).pause(1000).send_keys(
|
|
Keys.PAGE_UP
|
|
).perform()
|
|
self.assertEqual("AAAAA", sel.selected_content)
|
|
|
|
# Step 3: The carets shouldn't show up after scrolling the page. We're
|
|
# attempting to drag the second caret down so that if the bug occurs, we
|
|
# can drag the second caret to extend the selection to "BBBBB".
|
|
self.actions.flick(html, x1, y1, x2, y2).perform()
|
|
self.assertNotEqual("AAAAA\nBBBBB", sel.selected_content)
|