Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(69)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: ui/accessibility/ax_node_position_unittest.cc

Issue 2271893002: Creates AXPosition to uniquely identify a position in the accessibility tree (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Removed AXRange class. Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« ui/accessibility/BUILD.gn ('K') | « ui/accessibility/ax_node_position.cc ('k') | ui/accessibility/ax_position.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: ui/accessibility/ax_node_position_unittest.cc
diff --git a/ui/accessibility/ax_node_position_unittest.cc b/ui/accessibility/ax_node_position_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..139a9ab0e0731864e2c83bf8064531030b1a26b0
--- /dev/null
+++ b/ui/accessibility/ax_node_position_unittest.cc
@@ -0,0 +1,544 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <stdint.h>
+
+#include <memory>
+#include <vector>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/accessibility/ax_enums.h"
+#include "ui/accessibility/ax_node.h"
+#include "ui/accessibility/ax_node_data.h"
+#include "ui/accessibility/ax_node_position.h"
+#include "ui/accessibility/ax_serializable_tree.h"
+#include "ui/accessibility/ax_tree_serializer.h"
+#include "ui/accessibility/ax_tree_update.h"
+
+namespace ui {
+
+using TestPositionType = AXPosition<AXNodePosition, AXNode>;
+
+namespace {
+
+class AXPositionTest : public testing::Test {
+ public:
+ const char* TEXT_VALUE = "Line 1\nLine 2";
+
+ AXPositionTest();
+ ~AXPositionTest() override;
+
+ protected:
+ void SetUp() override;
+ void TearDown() override;
+
+ AXNodeData root_;
+ AXNodeData button_;
+ AXNodeData check_box_;
+ AXNodeData text_field_;
+ AXNodeData static_text1_;
+ AXNodeData line_break_;
+ AXNodeData static_text2_;
+ AXNodeData inline_box1_;
+ AXNodeData inline_box2_;
+
+ AXTree tree_;
+ DISALLOW_COPY_AND_ASSIGN(AXPositionTest);
+};
+
+AXPositionTest::AXPositionTest() {}
+
+AXPositionTest::~AXPositionTest() {}
+
+void AXPositionTest::SetUp() {
+ std::vector<int32_t> line_start_offsets{0, 6};
+ std::vector<int32_t> word_starts{0, 5};
+ std::vector<int32_t> word_ends{3, 6};
+
+ root_.id = 1;
+ button_.id = 2;
+ check_box_.id = 3;
+ text_field_.id = 4;
+ static_text1_.id = 5;
+ inline_box1_.id = 6;
+ line_break_.id = 7;
+ static_text2_.id = 8;
+ inline_box2_.id = 9;
+
+ root_.role = AX_ROLE_DIALOG;
+ root_.state = 1 << AX_STATE_FOCUSABLE;
+ root_.location = gfx::RectF(0, 0, 800, 600);
+
+ button_.role = AX_ROLE_BUTTON;
+ button_.state = 1 << AX_STATE_HASPOPUP;
+ button_.SetName("Sample button_");
+ button_.location = gfx::RectF(20, 20, 200, 30);
+ root_.child_ids.push_back(button_.id);
+
+ check_box_.role = AX_ROLE_CHECK_BOX;
+ check_box_.state = 1 << AX_STATE_CHECKED;
+ check_box_.SetName("Sample check box");
+ check_box_.location = gfx::RectF(20, 50, 200, 30);
+ root_.child_ids.push_back(check_box_.id);
+
+ text_field_.role = AX_ROLE_TEXT_FIELD;
+ text_field_.state = 1 << AX_STATE_EDITABLE;
+ text_field_.SetValue(TEXT_VALUE);
+ text_field_.AddIntListAttribute(AX_ATTR_CACHED_LINE_STARTS,
+ line_start_offsets);
+ text_field_.child_ids.push_back(static_text1_.id);
+ text_field_.child_ids.push_back(line_break_.id);
+ text_field_.child_ids.push_back(static_text2_.id);
+ root_.child_ids.push_back(text_field_.id);
+
+ static_text1_.role = AX_ROLE_STATIC_TEXT;
+ static_text1_.state = 1 << AX_STATE_EDITABLE;
+ static_text1_.SetName("Line 1");
+ static_text1_.child_ids.push_back(inline_box1_.id);
+
+ inline_box1_.role = AX_ROLE_INLINE_TEXT_BOX;
+ inline_box1_.state = 1 << AX_STATE_EDITABLE;
+ inline_box1_.SetName("Line 1");
+ inline_box1_.AddIntListAttribute(AX_ATTR_WORD_STARTS, word_starts);
+ inline_box1_.AddIntListAttribute(AX_ATTR_WORD_ENDS, word_ends);
+
+ line_break_.role = AX_ROLE_LINE_BREAK;
+ line_break_.state = 1 << AX_STATE_EDITABLE;
+ line_break_.SetName("\n");
+
+ static_text2_.role = AX_ROLE_STATIC_TEXT;
+ static_text2_.state = 1 << AX_STATE_EDITABLE;
+ static_text2_.SetName("Line 2");
+ static_text2_.child_ids.push_back(inline_box2_.id);
+
+ inline_box2_.role = AX_ROLE_INLINE_TEXT_BOX;
+ inline_box2_.state = 1 << AX_STATE_EDITABLE;
+ inline_box2_.SetName("Line 2");
+ inline_box2_.AddIntListAttribute(AX_ATTR_WORD_STARTS, word_starts);
+ inline_box2_.AddIntListAttribute(AX_ATTR_WORD_ENDS, word_ends);
+
+ AXTreeUpdate initial_state;
+ initial_state.root_id = 1;
+ initial_state.nodes.push_back(root_);
+ initial_state.nodes.push_back(button_);
+ initial_state.nodes.push_back(check_box_);
+ initial_state.nodes.push_back(text_field_);
+ initial_state.nodes.push_back(static_text1_);
+ initial_state.nodes.push_back(inline_box1_);
+ initial_state.nodes.push_back(line_break_);
+ initial_state.nodes.push_back(static_text2_);
+ initial_state.nodes.push_back(inline_box2_);
+ initial_state.has_tree_data = true;
+ initial_state.tree_data.tree_id = 0;
+ initial_state.tree_data.title = "Dialog title";
+ AXSerializableTree src_tree(initial_state);
+
+ std::unique_ptr<AXTreeSource<const AXNode*, AXNodeData, AXTreeData>>
+ tree_source(src_tree.CreateTreeSource());
+ AXTreeSerializer<const AXNode*, AXNodeData, AXTreeData> serializer(
+ tree_source.get());
+ AXTreeUpdate update;
+ serializer.SerializeChanges(src_tree.root(), &update);
+ ASSERT_TRUE(tree_.Unserialize(update));
+ AXNodePosition::SetTreeForTesting(&tree_);
+}
+
+void AXPositionTest::TearDown() {
+ AXNodePosition::SetTreeForTesting(nullptr);
+}
+
+} // namespace
+
+TEST_F(AXPositionTest, AtStartOfAnchorWithNullPosition) {
+ std::unique_ptr<TestPositionType> null_position(
+ AXNodePosition::CreateNullPosition());
+ ASSERT_NE(nullptr, null_position);
+ EXPECT_FALSE(null_position->AtStartOfAnchor());
+}
+
+TEST_F(AXPositionTest, AtStartOfAnchorWithTreePosition) {
+ std::unique_ptr<TestPositionType> tree_position(
+ AXNodePosition::CreateTreePosition(tree_.data().tree_id, root_.id,
+ 0 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ EXPECT_TRUE(tree_position->AtStartOfAnchor());
+
+ tree_position.reset(AXNodePosition::CreateTreePosition(
+ tree_.data().tree_id, root_.id, 1 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ EXPECT_FALSE(tree_position->AtStartOfAnchor());
+
+ tree_position.reset(AXNodePosition::CreateTreePosition(
+ tree_.data().tree_id, root_.id, 3 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ EXPECT_FALSE(tree_position->AtStartOfAnchor());
+}
+
+TEST_F(AXPositionTest, AtStartOfAnchorWithTextPosition) {
+ std::unique_ptr<TestPositionType> text_position(
+ AXNodePosition::CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+ 0 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ EXPECT_TRUE(text_position->AtStartOfAnchor());
+ text_position.reset(AXNodePosition::CreateTextPosition(
+ tree_.data().tree_id, inline_box1_.id, 1 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ EXPECT_FALSE(text_position->AtStartOfAnchor());
+
+ text_position.reset(AXNodePosition::CreateTextPosition(
+ tree_.data().tree_id, inline_box1_.id, 6 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ EXPECT_FALSE(text_position->AtStartOfAnchor());
+}
+
+TEST_F(AXPositionTest, AtEndOfAnchorWithNullPosition) {
+ std::unique_ptr<TestPositionType> null_position(
+ AXNodePosition::CreateNullPosition());
+ ASSERT_NE(nullptr, null_position);
+ EXPECT_FALSE(null_position->AtEndOfAnchor());
+}
+
+TEST_F(AXPositionTest, AtEndOfAnchorWithTreePosition) {
+ std::unique_ptr<TestPositionType> tree_position(
+ AXNodePosition::CreateTreePosition(tree_.data().tree_id, root_.id,
+ 3 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ EXPECT_TRUE(tree_position->AtEndOfAnchor());
+
+ tree_position.reset(AXNodePosition::CreateTreePosition(
+ tree_.data().tree_id, root_.id, 2 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ EXPECT_FALSE(tree_position->AtEndOfAnchor());
+
+ tree_position.reset(AXNodePosition::CreateTreePosition(
+ tree_.data().tree_id, root_.id, 0 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ EXPECT_FALSE(tree_position->AtEndOfAnchor());
+}
+
+TEST_F(AXPositionTest, AtEndOfAnchorWithTextPosition) {
+ std::unique_ptr<TestPositionType> text_position(
+ AXNodePosition::CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+ 6 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ EXPECT_TRUE(text_position->AtEndOfAnchor());
+
+ text_position.reset(AXNodePosition::CreateTextPosition(
+ tree_.data().tree_id, inline_box1_.id, 5 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ EXPECT_FALSE(text_position->AtEndOfAnchor());
+
+ text_position.reset(AXNodePosition::CreateTextPosition(
+ tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ EXPECT_FALSE(text_position->AtEndOfAnchor());
+}
+
+TEST_F(AXPositionTest, CreatePositionAtStartOfAnchorWithNullPosition) {
+ std::unique_ptr<TestPositionType> null_position(
+ AXNodePosition::CreateNullPosition());
+ ASSERT_NE(nullptr, null_position);
+ std::unique_ptr<TestPositionType> test_position(
+ null_position->CreatePositionAtStartOfAnchor());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsNullPosition());
+}
+
+TEST_F(AXPositionTest, CreatePositionAtStartOfAnchorWithTreePosition) {
+ std::unique_ptr<TestPositionType> tree_position(
+ AXNodePosition::CreateTreePosition(tree_.data().tree_id, root_.id,
+ 0 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ std::unique_ptr<TestPositionType> test_position(
+ tree_position->CreatePositionAtStartOfAnchor());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTreePosition());
+ EXPECT_EQ(root_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->child_index());
+
+ tree_position.reset(AXNodePosition::CreateTreePosition(
+ tree_.data().tree_id, root_.id, 1 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ test_position.reset(tree_position->CreatePositionAtStartOfAnchor());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTreePosition());
+ EXPECT_EQ(root_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->child_index());
+}
+
+TEST_F(AXPositionTest, CreatePositionAtStartOfAnchorWithTextPosition) {
+ std::unique_ptr<TestPositionType> text_position(
+ AXNodePosition::CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+ 0 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ std::unique_ptr<TestPositionType> test_position(
+ text_position->CreatePositionAtStartOfAnchor());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->text_offset());
+
+ text_position.reset(AXNodePosition::CreateTextPosition(
+ tree_.data().tree_id, inline_box1_.id, 1 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ test_position.reset(text_position->CreatePositionAtStartOfAnchor());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->text_offset());
+}
+
+TEST_F(AXPositionTest, CreatePositionAtEndOfAnchorWithNullPosition) {
+ std::unique_ptr<TestPositionType> null_position(
+ AXNodePosition::CreateNullPosition());
+ ASSERT_NE(nullptr, null_position);
+ std::unique_ptr<TestPositionType> test_position(
+ null_position->CreatePositionAtEndOfAnchor());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsNullPosition());
+}
+
+TEST_F(AXPositionTest, CreatePositionAtEndOfAnchorWithTreePosition) {
+ std::unique_ptr<TestPositionType> tree_position(
+ AXNodePosition::CreateTreePosition(tree_.data().tree_id, root_.id,
+ 3 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ std::unique_ptr<TestPositionType> test_position(
+ tree_position->CreatePositionAtEndOfAnchor());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTreePosition());
+ EXPECT_EQ(root_.id, test_position->anchor_id());
+ EXPECT_EQ(3, test_position->child_index());
+
+ tree_position.reset(AXNodePosition::CreateTreePosition(
+ tree_.data().tree_id, root_.id, 1 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ test_position.reset(tree_position->CreatePositionAtEndOfAnchor());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTreePosition());
+ EXPECT_EQ(root_.id, test_position->anchor_id());
+ EXPECT_EQ(3, test_position->child_index());
+}
+
+TEST_F(AXPositionTest, CreatePositionAtEndOfAnchorWithTextPosition) {
+ std::unique_ptr<TestPositionType> text_position(
+ AXNodePosition::CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+ 6 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ std::unique_ptr<TestPositionType> test_position(
+ text_position->CreatePositionAtEndOfAnchor());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
+ EXPECT_EQ(6, test_position->text_offset());
+
+ text_position.reset(AXNodePosition::CreateTextPosition(
+ tree_.data().tree_id, inline_box1_.id, 5 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ test_position.reset(text_position->CreatePositionAtEndOfAnchor());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
+ EXPECT_EQ(6, test_position->text_offset());
+}
+
+TEST_F(AXPositionTest, CreateChildPositionAtWithNullPosition) {
+ std::unique_ptr<TestPositionType> null_position(
+ AXNodePosition::CreateNullPosition());
+ ASSERT_NE(nullptr, null_position);
+ std::unique_ptr<TestPositionType> test_position(
+ null_position->CreateChildPositionAt(0));
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsNullPosition());
+}
+
+TEST_F(AXPositionTest, CreateChildPositionAtWithTreePosition) {
+ std::unique_ptr<TestPositionType> tree_position(
+ AXNodePosition::CreateTreePosition(tree_.data().tree_id, root_.id,
+ 2 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ std::unique_ptr<TestPositionType> test_position(
+ tree_position->CreateChildPositionAt(1));
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTreePosition());
+ EXPECT_EQ(check_box_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->child_index());
+
+ tree_position.reset(AXNodePosition::CreateTreePosition(
+ tree_.data().tree_id, button_.id, 0 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ test_position.reset(tree_position->CreateChildPositionAt(0));
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsNullPosition());
+}
+
+TEST_F(AXPositionTest, CreateChildPositionAtWithTextPosition) {
+ std::unique_ptr<TestPositionType> text_position(
+ AXNodePosition::CreateTextPosition(tree_.data().tree_id, static_text1_.id,
+ 5 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ std::unique_ptr<TestPositionType> test_position(
+ text_position->CreateChildPositionAt(0));
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->text_offset());
+
+ text_position.reset(AXNodePosition::CreateTextPosition(
+ tree_.data().tree_id, static_text2_.id, 4 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ test_position.reset(text_position->CreateChildPositionAt(1));
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsNullPosition());
+}
+
+TEST_F(AXPositionTest, CreateParentPositionWithNullPosition) {
+ std::unique_ptr<TestPositionType> null_position(
+ AXNodePosition::CreateNullPosition());
+ ASSERT_NE(nullptr, null_position);
+ std::unique_ptr<TestPositionType> test_position(
+ null_position->CreateParentPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsNullPosition());
+}
+
+TEST_F(AXPositionTest, CreateParentPositionWithTreePosition) {
+ std::unique_ptr<TestPositionType> tree_position(
+ AXNodePosition::CreateTreePosition(tree_.data().tree_id, check_box_.id,
+ 0 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ std::unique_ptr<TestPositionType> test_position(
+ tree_position->CreateParentPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTreePosition());
+ EXPECT_EQ(root_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->child_index());
+
+ tree_position.reset(AXNodePosition::CreateTreePosition(
+ tree_.data().tree_id, root_.id, 1 /* child_index */));
+ ASSERT_NE(nullptr, tree_position);
+ test_position.reset(tree_position->CreateParentPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsNullPosition());
+}
+
+TEST_F(AXPositionTest, CreateParentPositionWithTextPosition) {
+ std::unique_ptr<TestPositionType> text_position(
+ AXNodePosition::CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+ 5 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ std::unique_ptr<TestPositionType> test_position(
+ text_position->CreateParentPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(static_text1_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->text_offset());
+}
+
+TEST_F(AXPositionTest, CreateNextCharacterPositionWithNullPosition) {
+ std::unique_ptr<TestPositionType> null_position(
+ AXNodePosition::CreateNullPosition());
+ ASSERT_NE(nullptr, null_position);
+ std::unique_ptr<TestPositionType> test_position(
+ null_position->CreateNextCharacterPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsNullPosition());
+}
+
+TEST_F(AXPositionTest, CreateNextCharacterPositionWithTextPosition) {
+ std::unique_ptr<TestPositionType> text_position(
+ AXNodePosition::CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+ 4 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ std::unique_ptr<TestPositionType> test_position(
+ text_position->CreateNextCharacterPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
+ EXPECT_EQ(5, test_position->text_offset());
+
+ text_position.reset(AXNodePosition::CreateTextPosition(
+ tree_.data().tree_id, inline_box1_.id, 5 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ test_position.reset(text_position->CreateNextCharacterPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(line_break_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->text_offset());
+
+ test_position.reset(test_position->CreateNextCharacterPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->text_offset());
+
+ test_position.reset(test_position->CreateNextCharacterPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
+ EXPECT_EQ(1, test_position->text_offset());
+}
+
+TEST_F(AXPositionTest, CreatePreviousCharacterPositionWithNullPosition) {
+ std::unique_ptr<TestPositionType> null_position(
+ AXNodePosition::CreateNullPosition());
+ ASSERT_NE(nullptr, null_position);
+ std::unique_ptr<TestPositionType> test_position(
+ null_position->CreatePreviousCharacterPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsNullPosition());
+}
+
+TEST_F(AXPositionTest, CreatePreviousCharacterPositionWithTextPosition) {
+ std::unique_ptr<TestPositionType> text_position(
+ AXNodePosition::CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+ 5 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ std::unique_ptr<TestPositionType> test_position(
+ text_position->CreatePreviousCharacterPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
+ EXPECT_EQ(4, test_position->text_offset());
+
+ text_position.reset(AXNodePosition::CreateTextPosition(
+ tree_.data().tree_id, inline_box2_.id, 0 /* text_offset */,
+ AX_TEXT_AFFINITY_UPSTREAM));
+ ASSERT_NE(nullptr, text_position);
+ test_position.reset(text_position->CreatePreviousCharacterPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(line_break_.id, test_position->anchor_id());
+ EXPECT_EQ(0, test_position->text_offset());
+
+ test_position.reset(test_position->CreatePreviousCharacterPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
+ EXPECT_EQ(5, test_position->text_offset());
+
+ test_position.reset(test_position->CreatePreviousCharacterPosition());
+ EXPECT_NE(nullptr, test_position);
+ EXPECT_TRUE(test_position->IsTextPosition());
+ EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
+ EXPECT_EQ(4, test_position->text_offset());
+}
+
+} // namespace ui
« ui/accessibility/BUILD.gn ('K') | « ui/accessibility/ax_node_position.cc ('k') | ui/accessibility/ax_position.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698