def test_drag_caret_from_front_to_end_across_columns(self):
self.open_test_html('test_carets_columns.html')
el = self.marionette.find_element(By.ID, 'columns-inner')
sel = SelectionManager(el)
content_to_add = '!'
target_content = sel.content + content_to_add
# Goal: the cursor position can be changed by dragging the caret from
# the front to the end of the content.
# Tap to make the cursor appear.
before_image_1 = self.marionette.find_element(By.ID, 'before-image-1')
before_image_1.tap()
# Tap the front of the content to make first caret appear.
sel.move_cursor_to_front()
el.tap(*sel.cursor_location())
src_x, src_y = sel.first_caret_location()
dest_x, dest_y = el.size['width'], el.size['height']
# Drag the first caret to the bottom-right corner of the element.
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
self.assertEqual(target_content, sel.content)
def test_carets_do_not_jump_when_dragging_to_editable_content_boundary(
self):
self.open_test_html()
el = self._input
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 does not being changed after dragging the caret
# on the Y-axis only.
target_content = words[1]
self.long_press_on_word(el, 1)
(caret1_x, caret1_y), (caret2_x,
caret2_y) = sel.selection_carets_location()
# Drag the first caret up by 50px.
self.actions.flick(el, caret1_x, caret1_y, caret1_x,
caret1_y - 50).perform()
self.assertEqual(target_content, sel.selected_content)
# Drag the first 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_caret_position_after_changing_orientation_of_device(self):
'''Bug 1094072
If positions of carets are updated correctly, they should be draggable.
'''
# Skip running test on non-rotatable device ex.desktop browser
if not self.marionette.session_capabilities['rotatable']:
return
self.openTestHtmlLongText(enabled=True)
# Select word in portrait mode, then change to landscape mode
self.marionette.set_orientation('portrait')
self._long_press_to_select_word(self._longtext, 12)
sel = SelectionManager(self._body)
(p_start_caret_x,
p_start_caret_y), (p_end_caret_x,
p_end_caret_y) = sel.selection_carets_location()
self.marionette.set_orientation('landscape')
(l_start_caret_x,
l_start_caret_y), (l_end_caret_x,
l_end_caret_y) = sel.selection_carets_location()
# Drag end caret to the start caret to change the selected content
self.actions.flick(self._body, l_end_caret_x, l_end_caret_y,
l_start_caret_x, l_start_caret_y).perform()
# Change orientation back to portrait mode to prevent affecting
# other tests
self.marionette.set_orientation('portrait')
self.assertEqual(
self._to_unix_line_ending(sel.selected_content.strip()), 'o')
def test_move_cursor_to_front_by_dragging_caret_to_front_br_element(self):
self.open_test_html(self._cursor_html)
el = self.marionette.find_element(By.ID, self._contenteditable_id)
sel = SelectionManager(el)
content_to_add_1 = '!'
content_to_add_2 = '\n\n'
target_content = content_to_add_1 + content_to_add_2 + sel.content
# Goal: the cursor position can be changed by dragging the caret from
# the end of the content to the front br element. Because we cannot get
# caret location if it's on a br element, we need to get the first caret
# location then adding the new lines.
# Get first caret location at the front.
el.tap()
sel.move_cursor_to_front()
dest_x, dest_y = sel.first_caret_location()
# Append new line to the front of the content.
el.send_keys(content_to_add_2);
# Tap to make first caret appear.
el.tap()
sel.move_cursor_to_end()
sel.move_cursor_by_offset(1, backward=True)
el.tap(*sel.cursor_location())
src_x, src_y = sel.first_caret_location()
# Move first caret to the front of the input box.
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
self.actions.key_down(content_to_add_1).key_up(content_to_add_1).perform()
self.assertEqual(target_content, sel.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_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_multirange()
# Select the first word in the second line
self.long_press_on_word(self._sel2, 0)
sel = SelectionManager(self._body)
(start_caret_x,
start_caret_y), (end_caret_x,
end_caret_y) = sel.selection_carets_location()
# Select target word in the first line
self.long_press_on_word(self._sel1, 2)
# Drag end caret to the beginning of the second line
(caret1_x, caret1_y), (caret2_x,
caret2_y) = sel.selection_carets_location()
self.actions.flick(self._body, caret2_x, caret2_y, start_caret_x,
start_caret_y).perform()
# Drag end caret back to the target word
self.actions.flick(self._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_caret_position_after_changing_orientation_of_device(self):
'''Bug 1094072
If positions of carets are updated correctly, they should be draggable.
'''
self.open_test_html_long_text()
# Select word in portrait mode, then change to landscape mode
self.marionette.set_orientation('portrait')
self.long_press_on_word(self._longtext, 12)
sel = SelectionManager(self._body)
(p_start_caret_x,
p_start_caret_y), (p_end_caret_x,
p_end_caret_y) = sel.selection_carets_location()
self.marionette.set_orientation('landscape')
(l_start_caret_x,
l_start_caret_y), (l_end_caret_x,
l_end_caret_y) = sel.selection_carets_location()
# Drag end caret to the start caret to change the selected content
self.actions.flick(self._body, l_end_caret_x, l_end_caret_y,
l_start_caret_x, l_start_caret_y).perform()
# Change orientation back to portrait mode to prevent affecting
# other tests
self.marionette.set_orientation('portrait')
self.assertEqual(self.to_unix_line_ending(sel.selected_content), 'o')
def test_caret_not_appear_when_typing_in_scrollable_content(self):
self.open_test_html(self._cursor_html)
el = self.marionette.find_element(By.ID, self._input_id)
sel = SelectionManager(el)
content_to_add = '!'
non_target_content = content_to_add + sel.content + string.ascii_letters
el.tap()
sel.move_cursor_to_end()
# Insert a long string to the end of the <input>, which triggers
# ScrollPositionChanged event.
el.send_keys(string.ascii_letters)
# The caret should not be visible. If it does appear wrongly due to the
# ScrollPositionChanged event, we can drag it to the front of the
# <input> to change the cursor position.
src_x, src_y = sel.first_caret_location()
dest_x, dest_y = 0, 0
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
# The content should not be inserted at the front of the <input>.
el.send_keys(content_to_add)
self.assertNotEqual(non_target_content, sel.content)
def test_caret_position_after_changing_orientation_of_device(self):
'''Bug 1094072
If positions of carets are updated correctly, they should be draggable.
'''
# Skip running test on non-rotatable device ex.desktop browser
if not self.marionette.session_capabilities['rotatable']:
return
self.openTestHtmlLongText(enabled=True)
# Select word in portrait mode, then change to landscape mode
self.marionette.set_orientation('portrait')
self._long_press_to_select_word(self._longtext, 12)
sel = SelectionManager(self._body)
(p_start_caret_x, p_start_caret_y), (p_end_caret_x, p_end_caret_y) = sel.selection_carets_location()
self.marionette.set_orientation('landscape')
(l_start_caret_x, l_start_caret_y), (l_end_caret_x, l_end_caret_y) = sel.selection_carets_location()
# Drag end caret to the start caret to change the selected content
self.actions.flick(self._body, l_end_caret_x, l_end_caret_y, l_start_caret_x, l_start_caret_y).perform()
# Change orientation back to portrait mode to prevent affecting
# other tests
self.marionette.set_orientation('portrait')
self.assertEqual(self._to_unix_line_ending(sel.selected_content.strip()), 'o')
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)
def test_long_press_to_select_when_partial_visible_word_is_selected(self):
self.open_test_html()
el = self._input
sel = SelectionManager(el)
# To successfully select the second word while the first word is being
# selected, use sufficient spaces between 'a' and 'b' to avoid the
# second caret covers on the second word.
original_content = 'aaaaaaaa bbbbbbbb'
el.clear()
el.send_keys(original_content)
words = original_content.split()
# We cannot use self.long_press_on_word() directly since it has will
# change the cursor position which affects this test. We have to store
# the position of word 0 and word 1 before long-pressing to select the
# word.
word0_x, word0_y = self.word_location(el, 0)
word1_x, word1_y = self.word_location(el, 1)
self.long_press_on_location(el, word0_x, word0_y)
self.assertEqual(words[0], sel.selected_content)
self.long_press_on_location(el, word1_x, word1_y)
self.assertEqual(words[1], sel.selected_content)
self.long_press_on_location(el, word0_x, word0_y)
self.assertEqual(words[0], sel.selected_content)
# If the second carets 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.selection_carets_location()
self.actions.flick(el, caret2_x, caret2_y, caret1_x, caret1_y).perform()
self.assertEqual(words[0][0], sel.selected_content)
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_caret_position_after_changing_orientation_of_device(self):
'''Bug 1094072
If positions of carets are updated correctly, they should be draggable.
'''
self.open_test_html(self._longtext_html)
body = self.marionette.find_element(By.ID, 'bd')
longtext = self.marionette.find_element(By.ID, 'longtext')
# Select word in portrait mode, then change to landscape mode
self.marionette.set_orientation('portrait')
self.long_press_on_word(longtext, 12)
sel = SelectionManager(body)
(p_start_caret_x, p_start_caret_y), (p_end_caret_x, p_end_caret_y) = sel.carets_location()
self.marionette.set_orientation('landscape')
(l_start_caret_x, l_start_caret_y), (l_end_caret_x, l_end_caret_y) = sel.carets_location()
# Drag end caret to the start caret to change the selected content
self.actions.flick(body, l_end_caret_x, l_end_caret_y,
l_start_caret_x, l_start_caret_y).perform()
# Change orientation back to portrait mode to prevent affecting
# other tests
self.marionette.set_orientation('portrait')
self.assertEqual(self.to_unix_line_ending(sel.selected_content), 'o')
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.
el.tap()
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)
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)
def test_long_press_to_select_when_partial_visible_word_is_selected(self):
self.open_test_html()
el = self._input
sel = SelectionManager(el)
# To successfully select the second word while the first word is being
# selected, use sufficient spaces between 'a' and 'b' to avoid the
# second caret covers on the second word.
original_content = 'aaaaaaaa bbbbbbbb'
el.clear()
el.send_keys(original_content)
words = original_content.split()
# We cannot use self.long_press_on_word() directly since it has will
# change the cursor position which affects this test. We have to store
# the position of word 0 and word 1 before long-pressing to select the
# word.
word0_x, word0_y = self.word_location(el, 0)
word1_x, word1_y = self.word_location(el, 1)
self.long_press_on_location(el, word0_x, word0_y)
self.assertEqual(words[0], sel.selected_content)
self.long_press_on_location(el, word1_x, word1_y)
self.assertEqual(words[1], sel.selected_content)
self.long_press_on_location(el, word0_x, word0_y)
self.assertEqual(words[0], sel.selected_content)
# If the second carets 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.selection_carets_location()
self.actions.flick(el, caret2_x, caret2_y, caret1_x, caret1_y).perform()
self.assertEqual(words[0][0], sel.selected_content)
def _test_caret_not_appear_when_typing_in_scrollable_content(
self, el, assertFunc):
sel = SelectionManager(el)
content_to_add = '!'
target_content = sel.content + string.ascii_letters + content_to_add
el.tap()
sel.move_caret_to_end()
# Insert a long string to the end of the <input>, which triggers
# ScrollPositionChanged event.
el.send_keys(string.ascii_letters)
# The caret should not be visible. If it does appear wrongly due to the
# ScrollPositionChanged event, we can drag it to the front of the
# <input> to change the cursor position.
src_x, src_y = sel.touch_caret_location()
dest_x, dest_y = 0, 0
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
# The content should be inserted at the end of the <input>.
el.send_keys(content_to_add)
assertFunc(target_content, sel.content)
def test_move_cursor_to_front_by_dragging_caret_to_front(self, el_id):
self.open_test_html(self._cursor_html)
el = self.marionette.find_element(By.ID, el_id)
sel = SelectionManager(el)
content_to_add = '!'
target_content = content_to_add + sel.content
# Get first caret location at the front.
el.tap()
sel.move_cursor_to_front()
dest_x, dest_y = sel.first_caret_location()
# Tap to make first caret appear. Note: it's strange that when the caret
# is at the end, the rect of the caret in <textarea> cannot be obtained.
# A bug perhaps.
el.tap()
sel.move_cursor_to_end()
sel.move_cursor_by_offset(1, backward=True)
el.tap(*sel.cursor_location())
src_x, src_y = sel.first_caret_location()
# Move first caret to the front of the input box.
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
self.assertEqual(target_content, sel.content)
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_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 50px.
self.actions.flick(el, caret1_x, caret1_y, caret1_x,
caret1_y - 50).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_move_selection_carets(self, el, assertFunc):
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 selection carets at the end of the content for
# later use.
el.tap()
sel.select_all()
(_, _), (end_caret_x, end_caret_y) = sel.selection_carets_location()
self.long_press_on_word(el, 0)
# Move the right caret to the end of the content.
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_carets_location()
self.actions.flick(el, caret2_x, caret2_y, end_caret_x, end_caret_y).perform()
# Move the left caret to the previous position of the right caret.
self.actions.flick(el, caret1_x, caret1_y, caret2_x, caret2_y).perform()
assertFunc(target_content, sel.selected_content)
def _test_move_selection_carets(self, el, assertFunc):
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 selection carets at the end of the content for
# later use.
el.tap()
sel.select_all()
(_, _), (end_caret_x, end_caret_y) = sel.selection_carets_location()
x, y = self._first_word_location(el)
self._long_press_to_select(el, x, y)
# Move the right caret to the end of the content.
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_carets_location()
self.actions.flick(el, caret2_x, caret2_y, end_caret_x, end_caret_y).perform()
# Move the left caret to the previous position of the right caret.
self.actions.flick(el, caret1_x, caret1_y, caret2_x, caret2_y).perform()
# Ignore extra spaces at the beginning of the content in comparison.
assertFunc(target_content.lstrip(), sel.selected_content.lstrip())
def test_drag_caret_over_non_selectable_field(self):
'''Testing drag caret over non selectable field.
So that the selected content should exclude non selectable field and
end selection caret should appear in last range's position.'''
self.openTestHtml(enabled=True)
# Select target element and get target caret location
self._long_press_to_select_word(self._sel4, 3)
sel = SelectionManager(self._body)
(_, _), (end_caret_x, end_caret_y) = sel.selection_carets_location()
self._long_press_to_select_word(self._sel6, 0)
(_, _), (end_caret2_x, end_caret2_y) = sel.selection_carets_location()
# Select start element
self._long_press_to_select_word(self._sel3, 3)
# Drag end caret to target location
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_carets_location()
self.actions.flick(self._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.selection_carets_location()
self.actions.flick(self._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')
def test_caret_not_appear_when_typing_in_scrollable_content(self):
self.open_test_html(self._cursor_html)
el = self.marionette.find_element(By.ID, self._input_id)
sel = SelectionManager(el)
content_to_add = '!'
target_content = sel.content + string.ascii_letters + content_to_add
el.tap()
sel.move_cursor_to_end()
# Insert a long string to the end of the <input>, which triggers
# ScrollPositionChanged event.
el.send_keys(string.ascii_letters)
# The caret should not be visible. If it does appear wrongly due to the
# ScrollPositionChanged event, we can drag it to the front of the
# <input> to change the cursor position.
src_x, src_y = sel.first_caret_location()
dest_x, dest_y = 0, 0
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
# The content should be inserted at the end of the <input>.
el.send_keys(content_to_add)
self.assertEqual(target_content, sel.content)
def _test_handle_tilt_when_carets_overlap_to_each_other(
self, el, assertFunc):
'''Test tilt handling when carets overlap to each other.
Let SelectionCarets overlap to each other. If SelectionCarets are set
to tilted successfully, tapping the tilted carets should not cause the
selection to be collapsed and the carets should be draggable.
'''
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
# Move the left caret to the position of the right caret to trigger
# carets overlapping.
(caret1_x, caret1_y), (caret2_x,
caret2_y) = sel.selection_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.selection_carets_location()
# The following values are from ua.css and all.js
if self.carets_tested_pref == 'selectioncaret.enabled':
caret_width = 44
caret_margin_left = -23
tilt_right_margin_left = 18
tilt_left_margin_left = -17
elif self.carets_tested_pref == 'layout.accessiblecaret.enabled':
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
el.tap(left_caret_left_edge_x + 2, caret3_y)
right_caret_right_edge_x = (caret4_x + caret_margin_left +
tilt_right_margin_left + caret_width)
el.tap(right_caret_right_edge_x - 2, caret4_y)
# Drag the left caret back to the initial selection, the first word.
self.actions.flick(el, caret3_x, caret3_y, caret1_x,
caret1_y).perform()
assertFunc(target_content, sel.selected_content)
def _test_focus_not_being_changed_by_long_press_on_non_selectable(self, el):
# 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(self._non_selectable)
active_sel = SelectionManager(self.marionette.get_active_element())
self.assertEqual(sel.content, active_sel.content)
def test_long_press_to_select_non_selectable_word(self):
'''Testing long press on non selectable field.
We should not select anything when long press on non selectable fields.'''
self.openTestHtml(enabled=True)
halfY = self._nonsel1.size['height'] / 2
long_press_without_contextmenu(self.marionette, self._nonsel1, self._long_press_time, 0, halfY)
sel = SelectionManager(self._nonsel1)
range_count = sel.range_count()
self.assertEqual(range_count, 0)
def test_long_press_to_select_non_selectable_word(self):
'''Testing long press on non selectable field.
We should not select anything when long press on non selectable fields.'''
self.openTestHtml(enabled=True)
halfY = self._nonsel1.size['height'] / 2
long_press_without_contextmenu(self.marionette, self._nonsel1, self._long_press_time, 0, halfY)
sel = SelectionManager(self._nonsel1)
range_count = sel.range_count()
self.assertEqual(range_count, 0)
def test_long_press_to_select_non_selectable_word(self):
'''Testing long press on non selectable field.
We should not select anything when long press on non selectable fields.'''
self.open_test_html_multirange()
halfY = self._nonsel1.size['height'] / 2
self.long_press_on_location(self._nonsel1, 0, halfY)
sel = SelectionManager(self._nonsel1)
range_count = sel.range_count()
self.assertEqual(range_count, 0)
def test_long_press_to_select_non_selectable_word(self):
'''Testing long press on non selectable field.
We should not select anything when long press on non selectable fields.'''
self.open_test_html_multirange()
halfY = self._nonsel1.size['height'] / 2
self.long_press_on_location(self._nonsel1, 0, halfY)
sel = SelectionManager(self._nonsel1)
range_count = sel.range_count()
self.assertEqual(range_count, 0)
def test_move_cursor_to_the_right_by_one_character(self, el_id):
self.open_test_html(self._cursor_html)
el = self.marionette.find_element(By.ID, el_id)
sel = SelectionManager(el)
content_to_add = '!'
target_content = sel.content
target_content = target_content[:1] + content_to_add + target_content[
1:]
# Get first caret (x, y) at position 1 and 2.
el.tap()
sel.move_cursor_to_front()
cursor0_x, cursor0_y = sel.cursor_location()
first_caret0_x, first_caret0_y = sel.first_caret_location()
sel.move_cursor_by_offset(1)
first_caret1_x, first_caret1_y = sel.first_caret_location()
# Tap the front of the input to make first caret appear.
el.tap(cursor0_x, cursor0_y)
# Move first caret.
self.actions.flick(el, first_caret0_x, first_caret0_y, first_caret1_x,
first_caret1_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
self.assertEqual(target_content, sel.content)
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)
def _test_handle_tilt_when_carets_overlap_to_each_other(
self, el, assertFunc):
'''Test tilt handling when carets overlap to each other.
Let SelectionCarets overlap to each other. If SelectionCarets are set
to tilted successfully, tapping the tilted carets should not cause the
selection to be collapsed and the carets should be draggable.
'''
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.
x, y = self._first_word_location(el)
self._long_press_to_select(el, x, y)
target_content = sel.selected_content
# Move the left caret to the position of the right caret to trigger
# carets overlapping.
(caret1_x, caret1_y), (caret2_x,
caret2_y) = sel.selection_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.selection_carets_location()
# The following values are from ua.css.
caret_width = 44
caret_margin_left = -23
tilt_right_margin_left = 18
tilt_left_margin_left = -17
left_caret_left_edge_x = caret3_x + caret_margin_left + tilt_left_margin_left
el.tap(ceil(left_caret_left_edge_x), caret3_y)
right_caret_right_edge_x = (caret4_x + caret_margin_left +
tilt_right_margin_left + caret_width)
el.tap(floor(right_caret_right_edge_x), caret4_y)
# Drag the left caret back to the initial selection, the first word.
self.actions.flick(el, caret3_x, caret3_y, caret1_x,
caret1_y).perform()
assertFunc(target_content, sel.selected_content)
def _test_handle_tilt_when_carets_overlap_to_each_other(self, el, assertFunc):
'''Test tilt handling when carets overlap to each other.
Let SelectionCarets overlap to each other. If SelectionCarets are set
to tilted successfully, tapping the tilted carets should not cause the
selection to be collapsed and the carets should be draggable.
'''
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
# Move the left caret to the position of the right caret to trigger
# carets overlapping.
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_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.selection_carets_location()
# The following values are from ua.css and all.js
if self.carets_tested_pref == 'selectioncaret.enabled':
caret_width = 44
caret_margin_left = -23
tilt_right_margin_left = 18
tilt_left_margin_left = -17
elif self.carets_tested_pref == 'layout.accessiblecaret.enabled':
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
el.tap(left_caret_left_edge_x + 2, caret3_y)
right_caret_right_edge_x = (caret4_x + caret_margin_left +
tilt_right_margin_left + caret_width)
el.tap(right_caret_right_edge_x - 2, caret4_y)
# Drag the left caret back to the initial selection, the first word.
self.actions.flick(el, caret3_x, caret3_y, caret1_x, caret1_y).perform()
assertFunc(target_content, sel.selected_content)
def test_move_cursor_to_the_right_by_one_character(self, el_id):
self.open_test_html(self._cursor_html)
el = self.marionette.find_element(By.ID, el_id)
sel = SelectionManager(el)
content_to_add = '!'
target_content = sel.content
target_content = target_content[:1] + content_to_add + target_content[1:]
# Get first caret (x, y) at position 1 and 2.
el.tap()
sel.move_cursor_to_front()
cursor0_x, cursor0_y = sel.cursor_location()
first_caret0_x, first_caret0_y = sel.first_caret_location()
sel.move_cursor_by_offset(1)
first_caret1_x, first_caret1_y = sel.first_caret_location()
# Tap the front of the input to make first caret appear.
el.tap(cursor0_x, cursor0_y)
# Move first caret.
self.actions.flick(el, first_caret0_x, first_caret0_y,
first_caret1_x, first_caret1_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
self.assertEqual(target_content, sel.content)
def test_dragging_caret_to_top_left_corner_after_timeout(self, el_id):
self.open_test_html(self._cursor_html)
el = self.marionette.find_element(By.ID, el_id)
sel = SelectionManager(el)
content_to_add = '!'
non_target_content = content_to_add + sel.content
# Set caret timeout to be 1 second.
timeout = 1
self.marionette.set_pref(self.caret_timeout_ms_pref, timeout * 1000)
# Set a 3x timeout margin to prevent intermittent test failures.
timeout *= 3
# Tap to make first caret appear. Note: it's strange that when the caret
# is at the end, the rect of the caret in <textarea> cannot be obtained.
# A bug perhaps.
el.tap()
sel.move_cursor_to_end()
sel.move_cursor_by_offset(1, backward=True)
el.tap(*sel.cursor_location())
# Wait until first caret disappears, then pretend to move it to the
# top-left corner of the input box.
src_x, src_y = sel.first_caret_location()
dest_x, dest_y = 0, 0
self.actions.wait(timeout).flick(el, src_x, src_y, dest_x, dest_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
self.assertNotEqual(non_target_content, sel.content)
def _test_touch_caret_timeout_by_dragging_it_to_top_left_corner_after_timout(
self, el, assertFunc):
sel = SelectionManager(el)
content_to_add = '!'
non_target_content = content_to_add + sel.content
# Get touch caret expiration time in millisecond, and convert it to second.
timeout = self.timeout_ms() / 1000.0
# Set a 3x timeout margin to prevent intermittent test failures.
timeout *= 3
# Tap to make touch caret appear. Note: it's strange that when the caret
# is at the end, the rect of the caret in <textarea> cannot be obtained.
# A bug perhaps.
el.tap()
sel.move_caret_to_end()
sel.move_caret_by_offset(1, backward=True)
el.tap(*sel.caret_location())
# Wait until touch caret disappears, then pretend to move it to the
# top-left corner of the input box.
src_x, src_y = sel.touch_caret_location()
dest_x, dest_y = 0, 0
self.actions.wait(timeout).flick(el, src_x, src_y, dest_x,
dest_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
assertFunc(non_target_content, sel.content)
def _test_touch_caret_hides_after_receiving_wheel_event(
self, el, assertFunc):
sel = SelectionManager(el)
content_to_add = '!'
non_target_content = content_to_add + sel.content
# Tap to make touch caret appear. Note: it's strange that when the caret
# is at the end, the rect of the caret in <textarea> cannot be obtained.
# A bug perhaps.
el.tap()
sel.move_caret_to_end()
sel.move_caret_by_offset(1, backward=True)
el.tap(*sel.caret_location())
# Send an arbitrary scroll-down-10px wheel event to the center of the
# input box to hide touch caret. Then pretend to move it to the top-left
# corner of the input box.
src_x, src_y = sel.touch_caret_location()
dest_x, dest_y = 0, 0
el_center_x, el_center_y = el.rect['x'], el.rect['y']
self.marionette.execute_script('''
var utils = window.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
.getInterface(Components.interfaces.nsIDOMWindowUtils);
utils.sendWheelEvent(arguments[0], arguments[1],
0, 10, 0, WheelEvent.DOM_DELTA_PIXEL,
0, 0, 0, 0);
''',
script_args=[el_center_x, el_center_y],
sandbox='system')
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
assertFunc(non_target_content, sel.content)
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, tapping 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
el.tap(left_caret_left_edge_x + 2, caret3_y)
right_caret_right_edge_x = caret4_x + caret_margin_left + tilt_right_margin_left + caret_width
el.tap(right_caret_right_edge_x - 2, caret4_y)
# 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_handle_tilt_when_carets_overlap_to_each_other(self, el, assertFunc):
'''Test tilt handling when carets overlap to each other.
Let SelectionCarets overlap to each other. If SelectionCarets are set
to tilted successfully, tapping the tilted carets should not cause the
selection to be collapsed and the carets should be draggable.
'''
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.
x, y = self._first_word_location(el)
self._long_press_to_select(el, x, y)
target_content = sel.selected_content
# Move the left caret to the position of the right caret to trigger
# carets overlapping.
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_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.selection_carets_location()
# The following values are from ua.css.
caret_width = 44
caret_margin_left = -23
tilt_right_margin_left = 18
tilt_left_margin_left = -17
left_caret_left_edge_x = caret3_x + caret_margin_left + tilt_left_margin_left
el.tap(ceil(left_caret_left_edge_x), caret3_y)
right_caret_right_edge_x = (caret4_x + caret_margin_left +
tilt_right_margin_left + caret_width)
el.tap(floor(right_caret_right_edge_x), caret4_y)
# Drag the left caret back to the initial selection, the first word.
self.actions.flick(el, caret3_x, caret3_y, caret1_x, caret1_y).perform()
assertFunc(target_content, sel.selected_content)
def _test_move_caret_to_end_by_dragging_touch_caret_to_bottom_right_corner(self, el, assertFunc):
sel = SelectionManager(el)
content_to_add = '!'
target_content = sel.content + content_to_add
# Tap the front of the input to make touch caret appear.
el.tap()
sel.move_caret_to_front()
el.tap(*sel.caret_location())
# Move touch caret to the bottom-right corner of the element.
src_x, src_y = sel.touch_caret_location()
dest_x, dest_y = el.size['width'], el.size['height']
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
el.send_keys(content_to_add)
assertFunc(target_content, sel.content)
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.
el.tap()
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)
def test_drag_caret_over_non_selectable_field(self):
'''Testing drag caret over non selectable field.
So that the selected content should exclude non selectable field and
end selection caret should appear in last range's position.'''
self.open_test_html_multirange()
# Select target element and get target caret location
self.long_press_on_word(self._sel4, 3)
sel = SelectionManager(self._body)
(_, _), (end_caret_x, end_caret_y) = sel.selection_carets_location()
self.long_press_on_word(self._sel6, 0)
(_, _), (end_caret2_x, end_caret2_y) = sel.selection_carets_location()
# Select start element
self.long_press_on_word(self._sel3, 3)
# Drag end caret to target location
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_carets_location()
self.actions.flick(self._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.selection_carets_location()
self.actions.flick(self._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.selection_carets_location()
self.actions.flick(self._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_minimum_select_one_character(self, el, assertFunc,
x=None, y=None):
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 selection carets at the end of the content for
# later use.
sel.select_all()
(_, _), (end_caret_x, end_caret_y) = sel.selection_carets_location()
el.tap()
# Goal: Select the first character.
target_content = original_content[0]
if x and y:
# If we got x and y from the arguments, use it as a hint of the
# location of the first word
pass
else:
x, y = self.word_location(el, 0)
self.long_press_on_location(el, x, y)
# Move the right caret to the end of the content.
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_carets_location()
self.actions.flick(el, caret2_x, caret2_y, end_caret_x, end_caret_y).perform()
# Move the right caret to the position of the left caret.
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_carets_location()
self.actions.flick(el, caret2_x, caret2_y, caret1_x, caret1_y).perform()
assertFunc(target_content, sel.selected_content)
def _test_touch_caret_hides_after_receiving_wheel_event(self, el, assertFunc):
sel = SelectionManager(el)
content_to_add = '!'
non_target_content = content_to_add + sel.content
# Tap to make touch caret appear. Note: it's strange that when the caret
# is at the end, the rect of the caret in <textarea> cannot be obtained.
# A bug perhaps.
el.tap()
sel.move_caret_to_end()
sel.move_caret_by_offset(1, backward=True)
el.tap(*sel.caret_location())
# Send an arbitrary scroll-down-10px wheel event to the center of the
# input box to hide touch caret. Then pretend to move it to the top-left
# corner of the input box.
src_x, src_y = sel.touch_caret_location()
dest_x, dest_y = 0, 0
el_center_x, el_center_y = el.rect['x'], el.rect['y']
self.marionette.execute_script(
'''var utils = SpecialPowers.getDOMWindowUtils(window);
utils.sendWheelEvent(arguments[0], arguments[1],
0, 10, 0, WheelEvent.DOM_DELTA_PIXEL,
0, 0, 0, 0);''',
script_args=[el_center_x, el_center_y]
)
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
el.send_keys(content_to_add)
assertFunc(non_target_content, sel.content)
def _test_touch_caret_hides_after_receiving_wheel_event(self, el, assertFunc):
sel = SelectionManager(el)
content_to_add = "!"
non_target_content = content_to_add + sel.content
# Tap to make touch caret appear. Note: it's strange that when the caret
# is at the end, the rect of the caret in <textarea> cannot be obtained.
# A bug perhaps.
el.tap()
sel.move_caret_to_end()
sel.move_caret_by_offset(1, backward=True)
el.tap(*sel.caret_location())
# Send an arbitrary scroll-down-10px wheel event to the center of the
# input box to hide touch caret. Then pretend to move it to the top-left
# corner of the input box.
src_x, src_y = sel.touch_caret_location()
dest_x, dest_y = 0, 0
el_center_x, el_center_y = el.rect["x"], el.rect["y"]
self.marionette.execute_script(
"""
var utils = window.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
.getInterface(Components.interfaces.nsIDOMWindowUtils);
utils.sendWheelEvent(arguments[0], arguments[1],
0, 10, 0, WheelEvent.DOM_DELTA_PIXEL,
0, 0, 0, 0);
""",
script_args=[el_center_x, el_center_y],
sandbox="system",
)
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
assertFunc(non_target_content, sel.content)
def _test_touch_caret_timeout_by_dragging_it_to_top_left_corner_after_timout(self, el, assertFunc):
sel = SelectionManager(el)
content_to_add = "!"
non_target_content = content_to_add + sel.content
# Get touch caret expiration time in millisecond, and convert it to second.
timeout = self.timeout_ms() / 1000.0
# Set a 3x timeout margin to prevent intermittent test failures.
timeout *= 3
# Tap to make touch caret appear. Note: it's strange that when the caret
# is at the end, the rect of the caret in <textarea> cannot be obtained.
# A bug perhaps.
el.tap()
sel.move_caret_to_end()
sel.move_caret_by_offset(1, backward=True)
el.tap(*sel.caret_location())
# Wait until touch caret disappears, then pretend to move it to the
# top-left corner of the input box.
src_x, src_y = sel.touch_caret_location()
dest_x, dest_y = 0, 0
self.actions.wait(timeout).flick(el, src_x, src_y, dest_x, dest_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
assertFunc(non_target_content, sel.content)
def test_dragging_caret_to_top_left_corner_after_timeout(self, el_id):
self.open_test_html(self._cursor_html)
el = self.marionette.find_element(By.ID, el_id)
sel = SelectionManager(el)
content_to_add = '!'
non_target_content = content_to_add + sel.content
# Set caret timeout to be 1 second.
timeout = 1
self.marionette.set_pref(self.caret_timeout_ms_pref, timeout * 1000)
# Set a 3x timeout margin to prevent intermittent test failures.
timeout *= 3
# Tap to make first caret appear. Note: it's strange that when the caret
# is at the end, the rect of the caret in <textarea> cannot be obtained.
# A bug perhaps.
el.tap()
sel.move_cursor_to_end()
sel.move_cursor_by_offset(1, backward=True)
el.tap(*sel.cursor_location())
# Wait until first caret disappears, then pretend to move it to the
# top-left corner of the input box.
src_x, src_y = sel.first_caret_location()
dest_x, dest_y = 0, 0
self.actions.wait(timeout).flick(el, src_x, src_y, dest_x, dest_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
self.assertNotEqual(non_target_content, sel.content)
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()
el.tap()
# 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)
def test_caret_not_jump_when_dragging_to_editable_content_boundary(self, el_id):
self.open_test_html(self._cursor_html)
el = self.marionette.find_element(By.ID, el_id)
sel = SelectionManager(el)
content_to_add = '!'
non_target_content = sel.content + content_to_add
# Goal: the cursor position is not changed after dragging the caret down
# on the Y-axis.
el.tap()
sel.move_cursor_to_front()
el.tap(*sel.cursor_location())
x, y = sel.first_caret_location()
# Drag the caret down by 50px, and insert '!'.
self.actions.flick(el, x, y, x, y + 50).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
self.assertNotEqual(non_target_content, sel.content)
def test_caret_does_not_jump_when_dragging_to_editable_content_boundary(self):
self.open_test_html()
el = self._input
sel = SelectionManager(el)
content_to_add = '!'
non_target_content = sel.content + content_to_add
# Goal: the cursor position does not being changed after dragging the
# caret down on the Y-axis.
el.tap()
sel.move_caret_to_front()
el.tap(*sel.caret_location())
x, y = sel.touch_caret_location()
# Drag the caret down by 50px, and insert '!'.
self.actions.flick(el, x, y, x, y + 50).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
self.assertNotEqual(non_target_content, sel.content)
def test_move_cursor_to_end_by_dragging_caret_to_bottom_right_corner(self, el_id):
self.open_test_html(self._cursor_html)
el = self.marionette.find_element(By.ID, el_id)
sel = SelectionManager(el)
content_to_add = '!'
target_content = sel.content + content_to_add
# Tap the front of the input to make first caret appear.
el.tap()
sel.move_cursor_to_front()
el.tap(*sel.cursor_location())
# Move first caret to the bottom-right corner of the element.
src_x, src_y = sel.first_caret_location()
dest_x, dest_y = el.size['width'], el.size['height']
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
self.assertEqual(target_content, sel.content)
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_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)
def test_drag_caret_over_non_selectable_field(self):
"""Testing drag caret over non selectable field.
So that the selected content should exclude non selectable field and
end selection caret should appear in last range's position."""
self.open_test_html_multirange()
# Select target element and get target caret location
self.long_press_on_word(self._sel4, 3)
sel = SelectionManager(self._body)
(_, _), (end_caret_x, end_caret_y) = sel.selection_carets_location()
self.long_press_on_word(self._sel6, 0)
(_, _), (end_caret2_x, end_caret2_y) = sel.selection_carets_location()
# Select start element
self.long_press_on_word(self._sel3, 3)
# Drag end caret to target location
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_carets_location()
self.actions.flick(self._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.selection_carets_location()
self.actions.flick(self._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.selection_carets_location()
self.actions.flick(self._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_minimum_select_one_character(self, el, assertFunc,
x=None, y=None):
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 selection carets at the end of the content for
# later use.
sel.select_all()
(_, _), (end_caret_x, end_caret_y) = sel.selection_carets_location()
el.tap()
# Goal: Select the first character.
target_content = original_content[0]
if x and y:
# If we got x and y from the arguments, use it as a hint of the
# location of the first word
pass
else:
x, y = self.word_location(el, 0)
self.long_press_on_location(el, x, y)
# Move the right caret to the end of the content.
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_carets_location()
self.actions.flick(el, caret2_x, caret2_y, end_caret_x, end_caret_y).perform()
# Move the right caret to the position of the left caret.
(caret1_x, caret1_y), (caret2_x, caret2_y) = sel.selection_carets_location()
self.actions.flick(el, caret2_x, caret2_y, caret1_x, caret1_y).perform()
assertFunc(target_content, sel.selected_content)
def _test_move_selection_carets(self, el, assertFunc):
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 selection carets at the end of the content for
# later use.
el.tap()
sel.select_all()
(_, _), (end_caret_x, end_caret_y) = sel.selection_carets_location()
self.long_press_on_word(el, 0)
# Move the right caret to the end of the content.
(caret1_x, caret1_y), (caret2_x,
caret2_y) = sel.selection_carets_location()
self.actions.flick(el, caret2_x, caret2_y, end_caret_x,
end_caret_y).perform()
# Move the left caret to the previous position of the right caret.
self.actions.flick(el, caret1_x, caret1_y, caret2_x,
caret2_y).perform()
assertFunc(target_content, sel.selected_content)
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.
el.tap()
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)
def test_drag_caret_from_front_to_end_across_columns(self):
self.open_test_html('test_carets_columns.html')
el = self.marionette.find_element(By.ID, 'columns-inner')
sel = SelectionManager(el)
content_to_add = '!'
target_content = sel.content + content_to_add
# Goal: the cursor position can be changed by dragging the caret from
# the front to the end of the content.
# Tap to make the cursor appear.
before_image_1 = self.marionette.find_element(By.ID, 'before-image-1')
before_image_1.tap()
# Tap the front of the content to make first caret appear.
sel.move_cursor_to_front()
el.tap(*sel.cursor_location())
src_x, src_y = sel.first_caret_location()
dest_x, dest_y = el.size['width'], el.size['height']
# Drag the first caret to the bottom-right corner of the element.
self.actions.flick(el, src_x, src_y, dest_x, dest_y).perform()
self.actions.key_down(content_to_add).key_up(content_to_add).perform()
self.assertEqual(target_content, sel.content)
def _test_long_press_to_select_a_word(self, el, assertFunc):
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.
x, y = self._first_word_location(el)
self._long_press_to_select(el, x, y)
# Ignore extra spaces selected after the word.
assertFunc(target_content, sel.selected_content.rstrip())
