ui::AXPlatformNodeTextRangeProviderTest Class Reference

Inheritance diagram for ui::AXPlatformNodeTextRangeProviderTest:

Public Member Functions
const AXNodePosition::AXPositionInstance &	GetStart (const AXPlatformNodeTextRangeProviderWin *text_range)
const AXNodePosition::AXPositionInstance &	GetEnd (const AXPlatformNodeTextRangeProviderWin *text_range)
ui::AXPlatformNodeWin *	GetOwner (const AXPlatformNodeTextRangeProviderWin *text_range)
void	CopyOwnerToClone (ITextRangeProvider *source_range, ITextRangeProvider *destination_range)
void	SetOwner (AXPlatformNodeWin *owner, ITextRangeProvider *destination_range)
void	NormalizeTextRange (AXPlatformNodeTextRangeProviderWin *text_range, AXNodePosition::AXPositionInstance &start, AXNodePosition::AXPositionInstance &end)
void	GetTextRangeProviderFromTextNode (ComPtr< ITextRangeProvider > &text_range_provider, ui::AXNode *text_node)
void	CreateTextRangeProviderWin (ComPtr< AXPlatformNodeTextRangeProviderWin > &text_range_provider_win, AXPlatformNodeWin *owner, const AXNode *start_anchor, int start_offset, ax::mojom::TextAffinity start_affinity, const AXNode *end_anchor, int end_offset, ax::mojom::TextAffinity end_affinity)
void	ComputeWordBoundariesOffsets (const std::string &text, std::vector< int > &word_start_offsets, std::vector< int > &word_end_offsets)
AXTreeUpdate	BuildTextDocument (const std::vector< std::string > &text_nodes_content, bool build_word_boundaries_offsets=false, bool place_text_on_one_line=false)
ui::AXTreeUpdate	BuildAXTreeForBoundingRectangles ()
ui::AXTreeUpdate	BuildAXTreeForMove ()
AXTreeUpdate	BuildAXTreeForMoveByFormat ()
void	ExpectPositionsEqual (const AXNodePosition::AXPositionInstance &a, const AXNodePosition::AXPositionInstance &b)
Public Member Functions inherited from ui::AXPlatformNodeWinTest
	AXPlatformNodeWinTest ()
	~AXPlatformNodeWinTest () override
void	SetUp () override
void	TearDown () override
template<typename T >
ComPtr< T >	QueryInterfaceFromNodeId (AXNode::AXID id)
template<typename T >
ComPtr< T >	QueryInterfaceFromNode (AXNode *node)
Public Member Functions inherited from ui::AXPlatformNodeTest
	AXPlatformNodeTest ()
	~AXPlatformNodeTest () override
	AXPlatformNodeTest (const AXPlatformNodeTest &)=delete
AXPlatformNodeTest &	operator= (const AXPlatformNodeTest &)=delete
Public Member Functions inherited from ui::TestAXTreeManager
	TestAXTreeManager ()
	TestAXTreeManager (std::unique_ptr< AXTree > tree)
virtual	~TestAXTreeManager ()
	TestAXTreeManager (const TestAXTreeManager &manager)=delete
TestAXTreeManager &	operator= (const TestAXTreeManager &manager)=delete
void	DestroyTree ()
AXTree *	GetTree () const
void	SetTree (std::unique_ptr< AXTree > tree)
AXNode *	GetNodeFromTree (const AXTreeID tree_id, const AXNode::AXID node_id) const override
AXNode *	GetNodeFromTree (const AXNode::AXID node_id) const override
AXTreeID	GetTreeID () const override
AXTreeID	GetParentTreeID () const override
AXNode *	GetRootAsAXNode () const override
AXNode *	GetParentNodeFromParentTreeAsAXNode () const override
Public Member Functions inherited from ui::AXTreeManager
virtual	~AXTreeManager ()=default
virtual AXNode *	GetNodeFromTree (const AXTreeID tree_id, const AXNode::AXID node_id) const =0
virtual AXNode *	GetNodeFromTree (const AXNode::AXID node_id) const =0
virtual AXTreeID	GetTreeID () const =0
virtual AXTreeID	GetParentTreeID () const =0
virtual AXNode *	GetRootAsAXNode () const =0
virtual AXNode *	GetParentNodeFromParentTreeAsAXNode () const =0
virtual AXTree *	GetTree () const =0

Public Attributes
const std::wstring	tree_for_move_full_text

Additional Inherited Members
Protected Types inherited from ui::AXPlatformNodeWinTest
using	PatternSet = std::unordered_set< LONG >
Protected Member Functions inherited from ui::AXPlatformNodeWinTest
AXPlatformNode *	AXPlatformNodeFromNode (AXNode *node)
template<typename T >
Microsoft::WRL::ComPtr< T >	QueryInterfaceFromNodeId (AXNode::AXID id)
template<typename T >
Microsoft::WRL::ComPtr< T >	QueryInterfaceFromNode (AXNode *node)
Microsoft::WRL::ComPtr< IRawElementProviderSimple >	GetRootIRawElementProviderSimple ()
Microsoft::WRL::ComPtr< IRawElementProviderSimple >	GetIRawElementProviderSimpleFromChildIndex (int child_index)
Microsoft::WRL::ComPtr< IRawElementProviderSimple >	GetIRawElementProviderSimpleFromTree (const ui::AXTreeID tree_id, const AXNode::AXID node_id)
Microsoft::WRL::ComPtr< IRawElementProviderFragment >	GetRootIRawElementProviderFragment ()
Microsoft::WRL::ComPtr< IRawElementProviderFragment >	IRawElementProviderFragmentFromNode (AXNode *node)
Microsoft::WRL::ComPtr< IAccessible >	IAccessibleFromNode (AXNode *node)
Microsoft::WRL::ComPtr< IAccessible >	GetRootIAccessible ()
void	CheckVariantHasName (const base::win::ScopedVariant &variant, const wchar_t *expected_name)
void	CheckIUnknownHasName (Microsoft::WRL::ComPtr< IUnknown > unknown, const wchar_t *expected_name)
Microsoft::WRL::ComPtr< IAccessibleTableCell >	GetCellInTable ()
void	InitFragmentRoot ()
AXFragmentRootWin *	InitNodeAsFragmentRoot (AXNode *node, TestFragmentRootDelegate *delegate)
Microsoft::WRL::ComPtr< IRawElementProviderFragmentRoot >	GetFragmentRoot ()
PatternSet	GetSupportedPatternsFromNodeId (AXNode::AXID id)
Protected Member Functions inherited from ui::AXPlatformNodeTest
void	Init (const AXTreeUpdate &initial_state)
void	Init (const ui::AXNodeData &node1, const ui::AXNodeData &node2=ui::AXNodeData(), const ui::AXNodeData &node3=ui::AXNodeData(), const ui::AXNodeData &node4=ui::AXNodeData(), const ui::AXNodeData &node5=ui::AXNodeData(), const ui::AXNodeData &node6=ui::AXNodeData(), const ui::AXNodeData &node7=ui::AXNodeData(), const ui::AXNodeData &node8=ui::AXNodeData(), const ui::AXNodeData &node9=ui::AXNodeData(), const ui::AXNodeData &node10=ui::AXNodeData(), const ui::AXNodeData &node11=ui::AXNodeData(), const ui::AXNodeData &node12=ui::AXNodeData())
AXTreeUpdate	BuildTextField ()
AXTreeUpdate	BuildTextFieldWithSelectionRange (int32_t start, int32_t stop)
AXTreeUpdate	BuildContentEditable ()
AXTreeUpdate	BuildContentEditableWithSelectionRange (int32_t start, int32_t end)
AXTreeUpdate	Build3X3Table ()
AXTreeUpdate	BuildAriaColumnAndRowCountGrids ()
AXTreeUpdate	BuildListBox (bool option_1_is_selected, bool option_2_is_selected, bool option_3_is_selected, const std::vector< ax::mojom::State > &additional_state)
Protected Attributes inherited from ui::AXPlatformNodeWinTest
std::unique_ptr< AXFragmentRootWin >	ax_fragment_root_
std::unique_ptr< TestFragmentRootDelegate >	test_fragment_root_delegate_
Static Protected Attributes inherited from ui::AXPlatformNodeWinTest
static const std::u16string	kEmbeddedCharacterAsString

Detailed Description

Definition at line 233 of file ax_platform_node_textrangeprovider_win_unittest.cc.

Member Function Documentation

BuildAXTreeForBoundingRectangles()

ui::AXTreeUpdate ui::AXPlatformNodeTextRangeProviderTest::BuildAXTreeForBoundingRectangles ( )

inline

Definition at line 408 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                                    {
    // AXTree content:
    // <button>Button</button><input type="checkbox">Line 1<br>Line 2
    ui::AXNodeData root;
    ui::AXNodeData button;
    ui::AXNodeData check_box;
    ui::AXNodeData text_field;
    ui::AXNodeData static_text1;
    ui::AXNodeData line_break;
    ui::AXNodeData static_text2;
    ui::AXNodeData inline_box1;
    ui::AXNodeData inline_box2;
    ui::AXNodeData inline_box_line_break;
 
    const int ROOT_ID = 1;
    const int BUTTON_ID = 2;
    const int CHECK_BOX_ID = 3;
    const int TEXT_FIELD_ID = 4;
    const int STATIC_TEXT1_ID = 5;
    const int INLINE_BOX1_ID = 6;
    const int LINE_BREAK_ID = 7;
    const int INLINE_BOX_LINE_BREAK_ID = 8;
    const int STATIC_TEXT2_ID = 9;
    const int INLINE_BOX2_ID = 10;
 
    root.id = ROOT_ID;
    button.id = BUTTON_ID;
    check_box.id = CHECK_BOX_ID;
    text_field.id = TEXT_FIELD_ID;
    static_text1.id = STATIC_TEXT1_ID;
    inline_box1.id = INLINE_BOX1_ID;
    line_break.id = LINE_BREAK_ID;
    inline_box_line_break.id = INLINE_BOX_LINE_BREAK_ID;
    static_text2.id = STATIC_TEXT2_ID;
    inline_box2.id = INLINE_BOX2_ID;
 
    std::string LINE_1_TEXT = "Line 1";
    std::string LINE_2_TEXT = "Line 2";
    std::string LINE_BREAK_TEXT = "\n";
    std::string ALL_TEXT = LINE_1_TEXT + LINE_BREAK_TEXT + LINE_2_TEXT;
    std::string BUTTON_TEXT = "Button";
    std::string CHECKBOX_TEXT = "Check box";
 
    root.role = ax::mojom::Role::kRootWebArea;
 
    button.role = ax::mojom::Role::kButton;
    button.SetHasPopup(ax::mojom::HasPopup::kMenu);
    button.SetName(BUTTON_TEXT);
    button.SetValue(BUTTON_TEXT);
    button.relative_bounds.bounds = gfx::RectF(20, 20, 200, 30);
    button.AddIntAttribute(ax::mojom::IntAttribute::kNextOnLineId,
                           check_box.id);
    root.child_ids.push_back(button.id);
 
    check_box.role = ax::mojom::Role::kCheckBox;
    check_box.SetCheckedState(ax::mojom::CheckedState::kTrue);
    check_box.SetName(CHECKBOX_TEXT);
    check_box.relative_bounds.bounds = gfx::RectF(20, 50, 200, 30);
    check_box.AddIntAttribute(ax::mojom::IntAttribute::kPreviousOnLineId,
                              button.id);
    root.child_ids.push_back(check_box.id);
 
    text_field.role = ax::mojom::Role::kTextField;
    text_field.AddState(ax::mojom::State::kEditable);
    text_field.AddStringAttribute(ax::mojom::StringAttribute::kHtmlTag,
                                  "input");
    text_field.AddStringAttribute(ax::mojom::StringAttribute::kInputType,
                                  "text");
    text_field.SetValue(ALL_TEXT);
    text_field.AddIntListAttribute(
        ax::mojom::IntListAttribute::kCachedLineStarts,
        std::vector<int32_t>{0, 7});
    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::mojom::Role::kStaticText;
    static_text1.AddState(ax::mojom::State::kEditable);
    static_text1.SetName(LINE_1_TEXT);
    static_text1.child_ids.push_back(inline_box1.id);
 
    inline_box1.role = ax::mojom::Role::kInlineTextBox;
    inline_box1.AddState(ax::mojom::State::kEditable);
    inline_box1.SetName(LINE_1_TEXT);
    inline_box1.relative_bounds.bounds = gfx::RectF(220, 20, 100, 30);
    std::vector<int32_t> character_offsets1;
    // The width of each character is 5px.
    character_offsets1.push_back(225);  // "L" {220, 20, 5x30}
    character_offsets1.push_back(230);  // "i" {225, 20, 5x30}
    character_offsets1.push_back(235);  // "n" {230, 20, 5x30}
    character_offsets1.push_back(240);  // "e" {235, 20, 5x30}
    character_offsets1.push_back(245);  // " " {240, 20, 5x30}
    character_offsets1.push_back(250);  // "1" {245, 20, 5x30}
    inline_box1.AddIntListAttribute(
        ax::mojom::IntListAttribute::kCharacterOffsets, character_offsets1);
    inline_box1.AddIntListAttribute(ax::mojom::IntListAttribute::kWordStarts,
                                    std::vector<int32_t>{0, 5});
    inline_box1.AddIntListAttribute(ax::mojom::IntListAttribute::kWordEnds,
                                    std::vector<int32_t>{4, 6});
    inline_box1.AddIntAttribute(ax::mojom::IntAttribute::kNextOnLineId,
                                line_break.id);
 
    line_break.role = ax::mojom::Role::kLineBreak;
    line_break.AddState(ax::mojom::State::kEditable);
    line_break.SetName(LINE_BREAK_TEXT);
    line_break.relative_bounds.bounds = gfx::RectF(250, 20, 0, 30);
    line_break.AddIntAttribute(ax::mojom::IntAttribute::kPreviousOnLineId,
                               inline_box1.id);
    line_break.child_ids.push_back(inline_box_line_break.id);
 
    inline_box_line_break.role = ax::mojom::Role::kInlineTextBox;
    inline_box_line_break.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
    inline_box_line_break.SetName(LINE_BREAK_TEXT);
    inline_box_line_break.relative_bounds.bounds = gfx::RectF(250, 20, 0, 30);
    inline_box_line_break.AddIntListAttribute(
        ax::mojom::IntListAttribute::kCharacterOffsets, {0});
    inline_box_line_break.AddIntListAttribute(
        ax::mojom::IntListAttribute::kWordStarts, std::vector<int32_t>{0});
    inline_box_line_break.AddIntListAttribute(
        ax::mojom::IntListAttribute::kWordEnds, std::vector<int32_t>{0});
 
    static_text2.role = ax::mojom::Role::kStaticText;
    static_text2.AddState(ax::mojom::State::kEditable);
    static_text2.SetName(LINE_2_TEXT);
    static_text2.child_ids.push_back(inline_box2.id);
 
    inline_box2.role = ax::mojom::Role::kInlineTextBox;
    inline_box2.AddState(ax::mojom::State::kEditable);
    inline_box2.SetName(LINE_2_TEXT);
    inline_box2.relative_bounds.bounds = gfx::RectF(220, 50, 100, 30);
    std::vector<int32_t> character_offsets2;
    // The width of each character is 7 px.
    character_offsets2.push_back(227);  // "L" {220, 50, 7x30}
    character_offsets2.push_back(234);  // "i" {227, 50, 7x30}
    character_offsets2.push_back(241);  // "n" {234, 50, 7x30}
    character_offsets2.push_back(248);  // "e" {241, 50, 7x30}
    character_offsets2.push_back(255);  // " " {248, 50, 7x30}
    character_offsets2.push_back(262);  // "2" {255, 50, 7x30}
    inline_box2.AddIntListAttribute(
        ax::mojom::IntListAttribute::kCharacterOffsets, character_offsets2);
    inline_box2.AddIntListAttribute(ax::mojom::IntListAttribute::kWordStarts,
                                    std::vector<int32_t>{0, 5});
    inline_box2.AddIntListAttribute(ax::mojom::IntListAttribute::kWordEnds,
                                    std::vector<int32_t>{4, 6});
 
    AXTreeUpdate update;
    update.has_tree_data = true;
    update.root_id = ROOT_ID;
    update.nodes = {
        root,         button,      check_box,  text_field,
        static_text1, inline_box1, line_break, inline_box_line_break,
        static_text2, inline_box2};
    update.tree_data.tree_id = ui::AXTreeID::CreateNewAXTreeID();
    return update;
  }

BuildAXTreeForMove()

ui::AXTreeUpdate ui::AXPlatformNodeTextRangeProviderTest::BuildAXTreeForMove ( )

inline

Definition at line 570 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                      {
    ui::AXNodeData group1_data;
    group1_data.id = 2;
    group1_data.role = ax::mojom::Role::kGenericContainer;
    group1_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    ui::AXNodeData text_data;
    text_data.id = 3;
    text_data.role = ax::mojom::Role::kStaticText;
    std::string text_content = "First line of text";
    text_data.SetName(text_content);
    std::vector<int> word_end_offsets;
    std::vector<int> word_start_offsets;
    ComputeWordBoundariesOffsets(text_content, word_start_offsets,
                                 word_end_offsets);
    text_data.AddIntListAttribute(ax::mojom::IntListAttribute::kWordStarts,
                                  word_start_offsets);
    text_data.AddIntListAttribute(ax::mojom::IntListAttribute::kWordEnds,
                                  word_end_offsets);
    group1_data.child_ids = {text_data.id};
 
    ui::AXNodeData group2_data;
    group2_data.id = 4;
    group2_data.role = ax::mojom::Role::kGenericContainer;
 
    ui::AXNodeData line_break1_data;
    line_break1_data.id = 5;
    line_break1_data.role = ax::mojom::Role::kLineBreak;
    line_break1_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
    line_break1_data.SetName("\n");
 
    ui::AXNodeData standalone_text_data;
    standalone_text_data.id = 6;
    standalone_text_data.role = ax::mojom::Role::kStaticText;
    text_content = "Standalone line";
    standalone_text_data.SetName(text_content);
    ComputeWordBoundariesOffsets(text_content, word_start_offsets,
                                 word_end_offsets);
    standalone_text_data.AddIntListAttribute(
        ax::mojom::IntListAttribute::kWordStarts, word_start_offsets);
    standalone_text_data.AddIntListAttribute(
        ax::mojom::IntListAttribute::kWordEnds, word_end_offsets);
 
    ui::AXNodeData line_break2_data;
    line_break2_data.id = 7;
    line_break2_data.role = ax::mojom::Role::kLineBreak;
    line_break2_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
    line_break2_data.SetName("\n");
 
    group2_data.child_ids = {line_break1_data.id, standalone_text_data.id,
                             line_break2_data.id};
    standalone_text_data.AddIntAttribute(ax::mojom::IntAttribute::kNextOnLineId,
                                         line_break2_data.id);
    line_break2_data.AddIntAttribute(ax::mojom::IntAttribute::kPreviousOnLineId,
                                     standalone_text_data.id);
 
    ui::AXNodeData bold_text_data;
    bold_text_data.id = 8;
    bold_text_data.role = ax::mojom::Role::kStaticText;
    bold_text_data.AddIntAttribute(
        ax::mojom::IntAttribute::kTextStyle,
        static_cast<int32_t>(ax::mojom::TextStyle::kBold));
    text_content = "bold text";
    bold_text_data.SetName(text_content);
    ComputeWordBoundariesOffsets(text_content, word_start_offsets,
                                 word_end_offsets);
    bold_text_data.AddIntListAttribute(ax::mojom::IntListAttribute::kWordStarts,
                                       word_start_offsets);
    bold_text_data.AddIntListAttribute(ax::mojom::IntListAttribute::kWordEnds,
                                       word_end_offsets);
 
    ui::AXNodeData paragraph1_data;
    paragraph1_data.id = 9;
    paragraph1_data.role = ax::mojom::Role::kParagraph;
    paragraph1_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    ui::AXNodeData paragraph1_text_data;
    paragraph1_text_data.id = 10;
    paragraph1_text_data.role = ax::mojom::Role::kStaticText;
    text_content = "Paragraph 1";
    paragraph1_text_data.SetName(text_content);
    ComputeWordBoundariesOffsets(text_content, word_start_offsets,
                                 word_end_offsets);
    paragraph1_text_data.AddIntListAttribute(
        ax::mojom::IntListAttribute::kWordStarts, word_start_offsets);
    paragraph1_text_data.AddIntListAttribute(
        ax::mojom::IntListAttribute::kWordEnds, word_end_offsets);
    paragraph1_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    ui::AXNodeData ignored_text_data;
    ignored_text_data.id = 11;
    ignored_text_data.role = ax::mojom::Role::kStaticText;
    ignored_text_data.AddState(ax::mojom::State::kIgnored);
    text_content = "ignored text";
    ignored_text_data.SetName(text_content);
 
    paragraph1_data.child_ids = {paragraph1_text_data.id, ignored_text_data.id};
 
    ui::AXNodeData paragraph2_data;
    paragraph2_data.id = 12;
    paragraph2_data.role = ax::mojom::Role::kParagraph;
    paragraph2_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    ui::AXNodeData paragraph2_text_data;
    paragraph2_text_data.id = 13;
    paragraph2_text_data.role = ax::mojom::Role::kStaticText;
    text_content = "Paragraph 2";
    paragraph2_text_data.SetName(text_content);
    ComputeWordBoundariesOffsets(text_content, word_start_offsets,
                                 word_end_offsets);
    paragraph2_text_data.AddIntListAttribute(
        ax::mojom::IntListAttribute::kWordStarts, word_start_offsets);
    paragraph2_text_data.AddIntListAttribute(
        ax::mojom::IntListAttribute::kWordEnds, word_end_offsets);
    paragraph1_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
    paragraph2_data.child_ids = {paragraph2_text_data.id};
 
    ui::AXNodeData root_data;
    root_data.id = 1;
    root_data.role = ax::mojom::Role::kRootWebArea;
    root_data.child_ids = {group1_data.id, group2_data.id, bold_text_data.id,
                           paragraph1_data.id, paragraph2_data.id};
 
    ui::AXTreeUpdate update;
    update.has_tree_data = true;
    update.root_id = root_data.id;
    update.nodes = {root_data,           group1_data,
                    text_data,           group2_data,
                    line_break1_data,    standalone_text_data,
                    line_break2_data,    bold_text_data,
                    paragraph1_data,     paragraph1_text_data,
                    ignored_text_data,   paragraph2_data,
                    paragraph2_text_data};
    update.tree_data.tree_id = ui::AXTreeID::CreateNewAXTreeID();
    return update;
  }

BuildAXTreeForMoveByFormat()

AXTreeUpdate ui::AXPlatformNodeTextRangeProviderTest::BuildAXTreeForMoveByFormat ( )

inline

Definition at line 714 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                            {
    //                    1
    //                    |
    //    -------------------------------------
    //    |       |       |    |    |    |    |
    //    2       4       8   10   12   14   16
    //    |       |       |    |    |    |    |
    //    |   ---------   |    |    |    |    |
    //    |   |   |   |   |    |    |    |    |
    //    3   5   6   7   9   11   13   15   17
 
    AXNodeData group1_data;
    group1_data.id = 2;
    group1_data.role = ax::mojom::Role::kGenericContainer;
    group1_data.AddStringAttribute(ax::mojom::StringAttribute::kFontFamily,
                                   "test font");
    group1_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    AXNodeData text_data;
    text_data.id = 3;
    text_data.role = ax::mojom::Role::kStaticText;
    text_data.SetName("Text with formatting");
    group1_data.child_ids = {text_data.id};
 
    AXNodeData group2_data;
    group2_data.id = 4;
    group2_data.role = ax::mojom::Role::kGenericContainer;
    group2_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    AXNodeData line_break1_data;
    line_break1_data.id = 5;
    line_break1_data.role = ax::mojom::Role::kLineBreak;
    line_break1_data.SetName("\n");
 
    AXNodeData standalone_text_data;
    standalone_text_data.id = 6;
    standalone_text_data.role = ax::mojom::Role::kStaticText;
    standalone_text_data.SetName("Standalone line with no formatting");
 
    AXNodeData line_break2_data;
    line_break2_data.id = 7;
    line_break2_data.role = ax::mojom::Role::kLineBreak;
    line_break2_data.SetName("\n");
 
    group2_data.child_ids = {line_break1_data.id, standalone_text_data.id,
                             line_break2_data.id};
 
    AXNodeData group3_data;
    group3_data.id = 8;
    group3_data.role = ax::mojom::Role::kGenericContainer;
    group3_data.AddIntAttribute(
        ax::mojom::IntAttribute::kTextStyle,
        static_cast<int32_t>(ax::mojom::TextStyle::kBold));
    group3_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    AXNodeData bold_text_data;
    bold_text_data.id = 9;
    bold_text_data.role = ax::mojom::Role::kStaticText;
    bold_text_data.SetName("bold text");
    group3_data.child_ids = {bold_text_data.id};
 
    AXNodeData paragraph1_data;
    paragraph1_data.id = 10;
    paragraph1_data.role = ax::mojom::Role::kParagraph;
    paragraph1_data.AddIntAttribute(ax::mojom::IntAttribute::kColor, 100);
    paragraph1_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    AXNodeData paragraph1_text_data;
    paragraph1_text_data.id = 11;
    paragraph1_text_data.role = ax::mojom::Role::kStaticText;
    paragraph1_text_data.SetName("Paragraph 1");
    paragraph1_data.child_ids = {paragraph1_text_data.id};
 
    AXNodeData paragraph2_data;
    paragraph2_data.id = 12;
    paragraph2_data.role = ax::mojom::Role::kParagraph;
    paragraph2_data.AddFloatAttribute(ax::mojom::FloatAttribute::kFontSize,
                                      1.0f);
    paragraph2_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    AXNodeData paragraph2_text_data;
    paragraph2_text_data.id = 13;
    paragraph2_text_data.role = ax::mojom::Role::kStaticText;
    paragraph2_text_data.SetName("Paragraph 2");
    paragraph2_data.child_ids = {paragraph2_text_data.id};
 
    AXNodeData paragraph3_data;
    paragraph3_data.id = 14;
    paragraph3_data.role = ax::mojom::Role::kParagraph;
    paragraph3_data.AddFloatAttribute(ax::mojom::FloatAttribute::kFontSize,
                                      1.0f);
    paragraph3_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    AXNodeData paragraph3_text_data;
    paragraph3_text_data.id = 15;
    paragraph3_text_data.role = ax::mojom::Role::kStaticText;
    paragraph3_text_data.SetName("Paragraph 3");
    paragraph3_data.child_ids = {paragraph3_text_data.id};
 
    AXNodeData paragraph4_data;
    paragraph4_data.id = 16;
    paragraph4_data.role = ax::mojom::Role::kParagraph;
    paragraph4_data.AddFloatAttribute(ax::mojom::FloatAttribute::kFontSize,
                                      2.0f);
    paragraph4_data.AddBoolAttribute(
        ax::mojom::BoolAttribute::kIsLineBreakingObject, true);
 
    AXNodeData paragraph4_text_data;
    paragraph4_text_data.id = 17;
    paragraph4_text_data.role = ax::mojom::Role::kStaticText;
    paragraph4_text_data.SetName("Paragraph 4");
    paragraph4_data.child_ids = {paragraph4_text_data.id};
 
    AXNodeData root_data;
    root_data.id = 1;
    root_data.role = ax::mojom::Role::kRootWebArea;
    root_data.child_ids = {group1_data.id,     group2_data.id,
                           group3_data.id,     paragraph1_data.id,
                           paragraph2_data.id, paragraph3_data.id,
                           paragraph4_data.id};
 
    AXTreeUpdate update;
    update.has_tree_data = true;
    update.root_id = root_data.id;
    update.nodes = {root_data,
                    group1_data,
                    text_data,
                    group2_data,
                    line_break1_data,
                    standalone_text_data,
                    line_break2_data,
                    group3_data,
                    bold_text_data,
                    paragraph1_data,
                    paragraph1_text_data,
                    paragraph2_data,
                    paragraph2_text_data,
                    paragraph3_data,
                    paragraph3_text_data,
                    paragraph4_data,
                    paragraph4_text_data};
    update.tree_data.tree_id = ui::AXTreeID::CreateNewAXTreeID();
    return update;
  }

BuildTextDocument()

AXTreeUpdate ui::AXPlatformNodeTextRangeProviderTest::BuildTextDocument ( const std::vector< std::string > &  text_nodes_content, bool  build_word_boundaries_offsets = false, bool  place_text_on_one_line = false  )

inline

Definition at line 350 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                           {
    int current_id = 0;
    AXNodeData root_data;
    root_data.id = ++current_id;
    root_data.role = ax::mojom::Role::kRootWebArea;
 
    AXTreeUpdate update;
    update.tree_data.tree_id = ui::AXTreeID::CreateNewAXTreeID();
    update.has_tree_data = true;
 
    for (const std::string& text_content : text_nodes_content) {
      AXNodeData static_text_data;
      static_text_data.id = ++current_id;
      static_text_data.role = ax::mojom::Role::kStaticText;
      static_text_data.SetName(text_content);
      root_data.child_ids.push_back(static_text_data.id);
 
      AXNodeData inline_box_data;
      inline_box_data.id = ++current_id;
      inline_box_data.role = ax::mojom::Role::kInlineTextBox;
      inline_box_data.SetName(text_content);
      static_text_data.child_ids = {inline_box_data.id};
 
      if (build_word_boundaries_offsets) {
        std::vector<int> word_end_offsets;
        std::vector<int> word_start_offsets;
        ComputeWordBoundariesOffsets(text_content, word_start_offsets,
                                     word_end_offsets);
        inline_box_data.AddIntListAttribute(
            ax::mojom::IntListAttribute::kWordStarts, word_start_offsets);
        inline_box_data.AddIntListAttribute(
            ax::mojom::IntListAttribute::kWordEnds, word_end_offsets);
      }
 
      if (place_text_on_one_line && !update.nodes.empty()) {
        AXNodeData* previous_inline_box_data = &update.nodes.back();
        static_text_data.AddIntAttribute(
            ax::mojom::IntAttribute::kPreviousOnLineId,
            previous_inline_box_data->id);
        inline_box_data.AddIntAttribute(
            ax::mojom::IntAttribute::kPreviousOnLineId,
            previous_inline_box_data->id);
        previous_inline_box_data->AddIntAttribute(
            ax::mojom::IntAttribute::kNextOnLineId, inline_box_data.id);
      }
 
      update.nodes.push_back(static_text_data);
      update.nodes.push_back(inline_box_data);
    }
 
    update.nodes.insert(update.nodes.begin(), root_data);
    update.root_id = root_data.id;
    return update;
  }

ComputeWordBoundariesOffsets()

void ui::AXPlatformNodeTextRangeProviderTest::ComputeWordBoundariesOffsets ( const std::string &  text, std::vector< int > &  word_start_offsets, std::vector< int > &  word_end_offsets  )

inline

Definition at line 329 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                                                      {
    char previous_char = ' ';
    word_start_offsets = std::vector<int>();
    for (size_t i = 0; i < text.size(); ++i) {
      if (previous_char == ' ' && text[i] != ' ')
        word_start_offsets.push_back(i);
      previous_char = text[i];
    }
 
    previous_char = ' ';
    word_end_offsets = std::vector<int>();
    for (size_t i = text.size(); i > 0; --i) {
      if (previous_char == ' ' && text[i - 1] != ' ')
        word_end_offsets.push_back(i);
      previous_char = text[i - 1];
    }
    std::reverse(word_end_offsets.begin(), word_end_offsets.end());
  }

CopyOwnerToClone()

void ui::AXPlatformNodeTextRangeProviderTest::CopyOwnerToClone ( ITextRangeProvider *  source_range, ITextRangeProvider *  destination_range  )

inline

Definition at line 250 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                                               {
    ComPtr<ITextRangeProvider> source_provider = source_range;
    ComPtr<ITextRangeProvider> destination_provider = destination_range;
 
    ComPtr<AXPlatformNodeTextRangeProviderWin> source_provider_internal;
    ComPtr<AXPlatformNodeTextRangeProviderWin> destination_provider_internal;
 
    source_provider->QueryInterface(IID_PPV_ARGS(&source_provider_internal));
    destination_provider->QueryInterface(
        IID_PPV_ARGS(&destination_provider_internal));
    destination_provider_internal->SetOwnerForTesting(
        source_provider_internal->GetOwner());
  }

CreateTextRangeProviderWin()

void ui::AXPlatformNodeTextRangeProviderTest::CreateTextRangeProviderWin ( ComPtr< AXPlatformNodeTextRangeProviderWin > &  text_range_provider_win, AXPlatformNodeWin *  owner, const AXNode *  start_anchor, int  start_offset, ax::mojom::TextAffinity  start_affinity, const AXNode *  end_anchor, int  end_offset, ax::mojom::TextAffinity  end_affinity  )

inline

Definition at line 308 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                        {
    AXNodePosition::AXPositionInstance range_start =
        CreateTextPosition(*start_anchor, start_offset, start_affinity);
    AXNodePosition::AXPositionInstance range_end =
        CreateTextPosition(*end_anchor, end_offset, end_affinity);
 
    ComPtr<ITextRangeProvider> text_range_provider =
        AXPlatformNodeTextRangeProviderWin::CreateTextRangeProviderForTesting(
            owner, std::move(range_start), std::move(range_end));
 
    text_range_provider->QueryInterface(IID_PPV_ARGS(&text_range_provider_win));
  }

ExpectPositionsEqual()

void ui::AXPlatformNodeTextRangeProviderTest::ExpectPositionsEqual ( const AXNodePosition::AXPositionInstance &  a, const AXNodePosition::AXPositionInstance &  b  )

inline

Definition at line 865 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                                                       {
    EXPECT_EQ(*a, *b);
    EXPECT_EQ(a->anchor_id(), b->anchor_id());
    EXPECT_EQ(a->text_offset(), b->text_offset());
  }

GetEnd()

const AXNodePosition::AXPositionInstance & ui::AXPlatformNodeTextRangeProviderTest::GetEnd ( const AXPlatformNodeTextRangeProviderWin *  text_range )

inline

Definition at line 240 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                                            {
    return text_range->end();
  }

GetOwner()

ui::AXPlatformNodeWin * ui::AXPlatformNodeTextRangeProviderTest::GetOwner ( const AXPlatformNodeTextRangeProviderWin *  text_range )

inline

Definition at line 245 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                                            {
    return text_range->GetOwner();
  }

GetStart()

const AXNodePosition::AXPositionInstance & ui::AXPlatformNodeTextRangeProviderTest::GetStart ( const AXPlatformNodeTextRangeProviderWin *  text_range )

inline

Definition at line 235 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                                            {
    return text_range->start();
  }

GetTextRangeProviderFromTextNode()

void ui::AXPlatformNodeTextRangeProviderTest::GetTextRangeProviderFromTextNode ( ComPtr< ITextRangeProvider > &  text_range_provider, ui::AXNode *  text_node  )

inline

Definition at line 283 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                           {
    ComPtr<IRawElementProviderSimple> provider_simple =
        QueryInterfaceFromNode<IRawElementProviderSimple>(text_node);
    ASSERT_NE(nullptr, provider_simple.Get());
 
    ComPtr<ITextProvider> text_provider;
    EXPECT_HRESULT_SUCCEEDED(
        provider_simple->GetPatternProvider(UIA_TextPatternId, &text_provider));
    ASSERT_NE(nullptr, text_provider.Get());
 
    EXPECT_HRESULT_SUCCEEDED(
        text_provider->get_DocumentRange(&text_range_provider));
    ASSERT_NE(nullptr, text_range_provider.Get());
 
    ComPtr<AXPlatformNodeTextRangeProviderWin> text_range_provider_interal;
    EXPECT_HRESULT_SUCCEEDED(text_range_provider->QueryInterface(
        IID_PPV_ARGS(&text_range_provider_interal)));
    AXPlatformNode* ax_platform_node = AXPlatformNodeFromNode(text_node);
    ASSERT_NE(ax_platform_node, nullptr);
    text_range_provider_interal->SetOwnerForTesting(
        static_cast<AXPlatformNodeWin*>(ax_platform_node));
  }

NormalizeTextRange()

void ui::AXPlatformNodeTextRangeProviderTest::NormalizeTextRange ( AXPlatformNodeTextRangeProviderWin *  text_range, AXNodePosition::AXPositionInstance &  start, AXNodePosition::AXPositionInstance &  end  )

inline

Definition at line 275 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                                                 {
    DCHECK_EQ(*GetStart(text_range), *start);
    DCHECK_EQ(*GetEnd(text_range), *end);
    text_range->NormalizeTextRange(start, end);
  }

SetOwner()

void ui::AXPlatformNodeTextRangeProviderTest::SetOwner ( AXPlatformNodeWin *  owner, ITextRangeProvider *  destination_range  )

inline

Definition at line 265 of file ax_platform_node_textrangeprovider_win_unittest.cc.

                                                       {
    ComPtr<AXPlatformNodeTextRangeProviderWin> destination_provider_internal;
    auto as =
        static_cast<AXPlatformNodeTextRangeProviderWin*>(destination_range);
    destination_range->QueryInterface(
        IID_PPV_ARGS(&destination_provider_internal));
    destination_provider_internal->SetOwnerForTesting(owner);
  }

Member Data Documentation

tree_for_move_full_text

const std::wstring ui::AXPlatformNodeTextRangeProviderTest::tree_for_move_full_text

Initial value:

=
      L"First line of text\nStandalone line\n"
      L"bold text\nParagraph 1\nParagraph 2"

Definition at line 566 of file ax_platform_node_textrangeprovider_win_unittest.cc.

---

The documentation for this class was generated from the following file:

• third_party/accessibility/ax/platform/ax_platform_node_textrangeprovider_win_unittest.cc