Creates AXPosition to uniquely identify a position in the accessibility tree

ui/accessibility/ax_node_position_unittest.cc

+// 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());
+
+  text_position.reset(AXNodePosition::CreateTextPosition(
+      tree_.data().tree_id, check_box_.id, 15 /* 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(inline_box1_.id, test_position->anchor_id());
+  EXPECT_EQ(0, 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());
+
+  text_position.reset(AXNodePosition::CreateTextPosition(
+      tree_.data().tree_id, inline_box1_.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(check_box_.id, test_position->anchor_id());
+  EXPECT_EQ(15, test_position->text_offset());
+}
+
+}  // namespace ui