48 { \
50 ASSERT_EQ(VT_BSTR, expectedVariant.type()); \
51 ASSERT_NE(nullptr, expectedVariant.ptr()->bstrVal); \
53 ASSERT_HRESULT_SUCCEEDED( \
54 node->GetPropertyValue(property_id, actual.
Receive())); \
55 ASSERT_EQ(VT_BSTR, actual.
type()); \
56 ASSERT_NE(
nullptr, actual.
ptr()->bstrVal); \
57 EXPECT_STREQ(expectedVariant.ptr()->bstrVal, actual.
ptr()->bstrVal); \
58 }
59
60#define EXPECT_UIA_ELEMENT_ARRAY_BSTR_EQ(array, element_test_property_id, \
61 expected_property_values) \
62 { \
63 ASSERT_EQ(1u, SafeArrayGetDim(array)); \
64 LONG array_lower_bound; \
65 ASSERT_HRESULT_SUCCEEDED( \
66 SafeArrayGetLBound(array, 1, &array_lower_bound)); \
67 LONG array_upper_bound; \
68 ASSERT_HRESULT_SUCCEEDED( \
69 SafeArrayGetUBound(array, 1, &array_upper_bound)); \
70 IUnknown** array_data; \
71 ASSERT_HRESULT_SUCCEEDED( \
72 ::SafeArrayAccessData(array, reinterpret_cast<void**>(&array_data))); \
73 size_t count = array_upper_bound - array_lower_bound + 1; \
74 ASSERT_EQ(expected_property_values.size(), count); \
75 for (size_t i = 0; i < count; ++i) { \
76 ComPtr<IRawElementProviderSimple> element; \
77 ASSERT_HRESULT_SUCCEEDED( \
78 array_data[i]->QueryInterface(IID_PPV_ARGS(&element))); \
79 EXPECT_UIA_GETPROPERTYVALUE_EQ(element, element_test_property_id, \
80 expected_property_values[i].c_str()); \
81 } \
82 ASSERT_HRESULT_SUCCEEDED(::SafeArrayUnaccessData(array)); \
83 }
84
85#define EXPECT_UIA_SAFEARRAY_EQ(safearray, expected_property_values) \
86 { \
87 using T = typename decltype(expected_property_values)::value_type; \
88 EXPECT_EQ(sizeof(T), ::SafeArrayGetElemsize(safearray)); \
89 EXPECT_EQ(1u, SafeArrayGetDim(safearray)); \
90 LONG array_lower_bound; \
91 EXPECT_HRESULT_SUCCEEDED( \
92 SafeArrayGetLBound(safearray, 1, &array_lower_bound)); \
93 LONG array_upper_bound; \
94 EXPECT_HRESULT_SUCCEEDED( \
95 SafeArrayGetUBound(safearray, 1, &array_upper_bound)); \
96 const size_t count = array_upper_bound - array_lower_bound + 1; \
97 EXPECT_EQ(expected_property_values.size(), count); \
98 if (sizeof(T) == ::SafeArrayGetElemsize(safearray) && \
99 count == expected_property_values.size()) { \
100 T* array_data; \
101 EXPECT_HRESULT_SUCCEEDED(::SafeArrayAccessData( \
102 safearray, reinterpret_cast<void**>(&array_data))); \
103 for (size_t i = 0; i < count; ++i) { \
104 EXPECT_EQ(array_data[i], expected_property_values[i]); \
105 } \
106 EXPECT_HRESULT_SUCCEEDED(::SafeArrayUnaccessData(safearray)); \
107 } \
108 }
109
110#define EXPECT_UIA_TEXTATTRIBUTE_EQ(provider, attribute, variant) \
111 { \
112 base::win::ScopedVariant scoped_variant; \
113 EXPECT_HRESULT_SUCCEEDED( \
114 provider->GetAttributeValue(attribute, scoped_variant.Receive())); \
115 EXPECT_EQ(0, scoped_variant.Compare(variant)); \
116 }
117
118#define EXPECT_UIA_TEXTATTRIBUTE_MIXED(provider, attribute) \
119 { \
120 ComPtr<IUnknown> expected_mixed; \
121 EXPECT_HRESULT_SUCCEEDED( \
122 ::UiaGetReservedMixedAttributeValue(&expected_mixed)); \
123 base::win::ScopedVariant scoped_variant; \
124 EXPECT_HRESULT_SUCCEEDED( \
125 provider->GetAttributeValue(attribute, scoped_variant.Receive())); \
126 EXPECT_EQ(VT_UNKNOWN, scoped_variant.type()); \
127 EXPECT_EQ(expected_mixed.Get(), V_UNKNOWN(scoped_variant.ptr())); \
128 }
129
130#define EXPECT_UIA_TEXTATTRIBUTE_NOTSUPPORTED(provider, attribute) \
131 { \
132 ComPtr<IUnknown> expected_notsupported; \
133 EXPECT_HRESULT_SUCCEEDED( \
134 ::UiaGetReservedNotSupportedValue(&expected_notsupported)); \
135 base::win::ScopedVariant scoped_variant; \
136 EXPECT_HRESULT_SUCCEEDED( \
137 provider->GetAttributeValue(attribute, scoped_variant.Receive())); \
138 EXPECT_EQ(VT_UNKNOWN, scoped_variant.type()); \
139 EXPECT_EQ(expected_notsupported.Get(), V_UNKNOWN(scoped_variant.ptr())); \
140 }
141
142#define EXPECT_UIA_TEXTRANGE_EQ(provider, expected_content) \
143 { \
144 base::win::ScopedBstr provider_content; \
145 EXPECT_HRESULT_SUCCEEDED( \
146 provider->GetText(-1, provider_content.Receive())); \
147 EXPECT_STREQ(expected_content, provider_content.Get()); \
148 }
149
150#define EXPECT_UIA_FIND_TEXT(text_range_provider, search_term, ignore_case, \
151 owner) \
152 { \
153 base::win::ScopedBstr find_string(search_term); \
154 ComPtr<ITextRangeProvider> text_range_provider_found; \
155 EXPECT_HRESULT_SUCCEEDED(text_range_provider->FindText( \
156 find_string.Get(), false, ignore_case, &text_range_provider_found)); \
157 if (text_range_provider_found == nullptr) { \
158 EXPECT_TRUE(false); \
159 } else { \
160 SetOwner(owner, text_range_provider_found.Get()); \
161 base::win::ScopedBstr found_content; \
162 EXPECT_HRESULT_SUCCEEDED( \
163 text_range_provider_found->GetText(-1, found_content.Receive())); \
164 if (ignore_case) \
165 EXPECT_TRUE(StringCompareICU(found_content.Get(), find_string.Get())); \
166 else \
167 EXPECT_EQ(0, wcscmp(found_content.Get(), find_string.Get())); \
168 } \
169 }
170
171#define EXPECT_UIA_FIND_TEXT_NO_MATCH(text_range_provider, search_term, \
172 ignore_case, owner) \
173 { \
174 base::win::ScopedBstr find_string(search_term); \
175 ComPtr<ITextRangeProvider> text_range_provider_found; \
176 EXPECT_HRESULT_SUCCEEDED(text_range_provider->FindText( \
177 find_string.Get(), false, ignore_case, &text_range_provider_found)); \
178 EXPECT_EQ(nullptr, text_range_provider_found); \
179 }
180
181#define EXPECT_UIA_MOVE_ENDPOINT_BY_UNIT(text_range_provider, endpoint, unit, \
182 count, expected_text, expected_count) \
183 { \
184 int result_count; \
185 EXPECT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit( \
186 endpoint, unit, count, &result_count)); \
187 EXPECT_EQ(expected_count, result_count); \
188 EXPECT_UIA_TEXTRANGE_EQ(text_range_provider, expected_text); \
189 }
190
191#define EXPECT_UIA_MOVE(text_range_provider, unit, count, expected_text, \
192 expected_count) \
193 { \
194 int result_count; \
195 EXPECT_HRESULT_SUCCEEDED( \
196 text_range_provider->Move(unit, count, &result_count)); \
197 EXPECT_EQ(expected_count, result_count); \
198 EXPECT_UIA_TEXTRANGE_EQ(text_range_provider, expected_text); \
199 }
200
201#define EXPECT_ENCLOSING_ELEMENT(ax_node_given, ax_node_expected) \
202 { \
203 ComPtr<ITextRangeProvider> text_range_provider; \
204 GetTextRangeProviderFromTextNode(text_range_provider, ax_node_given); \
205 ComPtr<IRawElementProviderSimple> enclosing_element; \
206 ASSERT_HRESULT_SUCCEEDED( \
207 text_range_provider->GetEnclosingElement(&enclosing_element)); \
208 ComPtr<IRawElementProviderSimple> expected_text_provider = \
209 QueryInterfaceFromNode<IRawElementProviderSimple>(ax_node_expected); \
210 EXPECT_EQ(expected_text_provider.Get(), enclosing_element.Get()); \
211 }
212
213#define DCHECK_EQ(a, b) BASE_DCHECK((a) == (b))
214
219 false)) {
220 return false;
221 }
223}
224
226 const AXNode& anchor,
227 int text_offset,
229 return AXNodePosition::CreateTextPosition(anchor.tree()->GetAXTreeID(),
230 anchor.id(), text_offset, affinity);
231}
232
234 public:
235 const AXNodePosition::AXPositionInstance& GetStart(
236 const AXPlatformNodeTextRangeProviderWin* text_range) {
237 return text_range->start();
238 }
239
240 const AXNodePosition::AXPositionInstance& GetEnd(
241 const AXPlatformNodeTextRangeProviderWin* text_range) {
242 return text_range->end();
243 }
244
245 ui::AXPlatformNodeWin* GetOwner(
246 const AXPlatformNodeTextRangeProviderWin* text_range) {
247 return text_range->GetOwner();
248 }
249
250 void CopyOwnerToClone(ITextRangeProvider* source_range,
251 ITextRangeProvider* destination_range) {
252 ComPtr<ITextRangeProvider> source_provider = source_range;
253 ComPtr<ITextRangeProvider> destination_provider = destination_range;
254
255 ComPtr<AXPlatformNodeTextRangeProviderWin> source_provider_internal;
256 ComPtr<AXPlatformNodeTextRangeProviderWin> destination_provider_internal;
257
258 source_provider->QueryInterface(IID_PPV_ARGS(&source_provider_internal));
259 destination_provider->QueryInterface(
260 IID_PPV_ARGS(&destination_provider_internal));
261 destination_provider_internal->SetOwnerForTesting(
262 source_provider_internal->GetOwner());
263 }
264
265 void SetOwner(AXPlatformNodeWin* owner,
266 ITextRangeProvider* destination_range) {
267 ComPtr<AXPlatformNodeTextRangeProviderWin> destination_provider_internal;
268 auto as =
269 static_cast<AXPlatformNodeTextRangeProviderWin*>(destination_range);
270 destination_range->QueryInterface(
271 IID_PPV_ARGS(&destination_provider_internal));
272 destination_provider_internal->SetOwnerForTesting(owner);
273 }
274
275 void NormalizeTextRange(AXPlatformNodeTextRangeProviderWin* text_range,
276 AXNodePosition::AXPositionInstance&
start,
277 AXNodePosition::AXPositionInstance&
end) {
280 text_range->NormalizeTextRange(
start,
end);
281 }
282
283 void GetTextRangeProviderFromTextNode(
284 ComPtr<ITextRangeProvider>& text_range_provider,
286 ComPtr<IRawElementProviderSimple> provider_simple =
287 QueryInterfaceFromNode<IRawElementProviderSimple>(text_node);
288 ASSERT_NE(nullptr, provider_simple.Get());
289
290 ComPtr<ITextProvider> text_provider;
291 EXPECT_HRESULT_SUCCEEDED(
292 provider_simple->GetPatternProvider(UIA_TextPatternId, &text_provider));
293 ASSERT_NE(nullptr, text_provider.Get());
294
295 EXPECT_HRESULT_SUCCEEDED(
296 text_provider->get_DocumentRange(&text_range_provider));
297 ASSERT_NE(nullptr, text_range_provider.Get());
298
299 ComPtr<AXPlatformNodeTextRangeProviderWin> text_range_provider_interal;
300 EXPECT_HRESULT_SUCCEEDED(text_range_provider->QueryInterface(
301 IID_PPV_ARGS(&text_range_provider_interal)));
303 ASSERT_NE(ax_platform_node, nullptr);
304 text_range_provider_interal->SetOwnerForTesting(
305 static_cast<AXPlatformNodeWin*>(ax_platform_node));
306 }
307
308 void CreateTextRangeProviderWin(
309 ComPtr<AXPlatformNodeTextRangeProviderWin>& text_range_provider_win,
310 AXPlatformNodeWin* owner,
311 const AXNode* start_anchor,
312 int start_offset,
314 const AXNode* end_anchor,
315 int end_offset,
317 AXNodePosition::AXPositionInstance range_start =
319 AXNodePosition::AXPositionInstance range_end =
321
322 ComPtr<ITextRangeProvider> text_range_provider =
323 AXPlatformNodeTextRangeProviderWin::CreateTextRangeProviderForTesting(
324 owner, std::move(range_start), std::move(range_end));
325
326 text_range_provider->QueryInterface(IID_PPV_ARGS(&text_range_provider_win));
327 }
328
329 void ComputeWordBoundariesOffsets(
const std::string&
text,
330 std::vector<int>& word_start_offsets,
331 std::vector<int>& word_end_offsets) {
332 char previous_char = ' ';
333 word_start_offsets = std::vector<int>();
334 for (
size_t i = 0; i <
text.size(); ++i) {
335 if (previous_char ==
' ' &&
text[i] !=
' ')
336 word_start_offsets.push_back(i);
337 previous_char =
text[i];
338 }
339
340 previous_char = ' ';
341 word_end_offsets = std::vector<int>();
342 for (
size_t i =
text.size(); i > 0; --i) {
343 if (previous_char ==
' ' &&
text[i - 1] !=
' ')
344 word_end_offsets.push_back(i);
345 previous_char =
text[i - 1];
346 }
347 std::reverse(word_end_offsets.begin(), word_end_offsets.end());
348 }
349
351 const std::vector<std::string>& text_nodes_content,
352 bool build_word_boundaries_offsets = false,
353 bool place_text_on_one_line = false) {
354 int current_id = 0;
355 AXNodeData root_data;
356 root_data.id = ++current_id;
358
361 update.has_tree_data =
true;
362
363 for (const std::string& text_content : text_nodes_content) {
364 AXNodeData static_text_data;
365 static_text_data.id = ++current_id;
367 static_text_data.SetName(text_content);
368 root_data.child_ids.push_back(static_text_data.id);
369
370 AXNodeData inline_box_data;
371 inline_box_data.id = ++current_id;
373 inline_box_data.SetName(text_content);
374 static_text_data.child_ids = {inline_box_data.id};
375
376 if (build_word_boundaries_offsets) {
377 std::vector<int> word_end_offsets;
378 std::vector<int> word_start_offsets;
379 ComputeWordBoundariesOffsets(text_content, word_start_offsets,
380 word_end_offsets);
381 inline_box_data.AddIntListAttribute(
383 inline_box_data.AddIntListAttribute(
385 }
386
387 if (place_text_on_one_line && !
update.nodes.empty()) {
388 AXNodeData* previous_inline_box_data = &
update.nodes.back();
389 static_text_data.AddIntAttribute(
391 previous_inline_box_data->id);
392 inline_box_data.AddIntAttribute(
394 previous_inline_box_data->id);
395 previous_inline_box_data->AddIntAttribute(
397 }
398
399 update.nodes.push_back(static_text_data);
400 update.nodes.push_back(inline_box_data);
401 }
402
404 update.root_id = root_data.id;
406 }
407
409
410
421
422 const int ROOT_ID = 1;
423 const int BUTTON_ID = 2;
424 const int CHECK_BOX_ID = 3;
425 const int TEXT_FIELD_ID = 4;
426 const int STATIC_TEXT1_ID = 5;
427 const int INLINE_BOX1_ID = 6;
428 const int LINE_BREAK_ID = 7;
429 const int INLINE_BOX_LINE_BREAK_ID = 8;
430 const int STATIC_TEXT2_ID = 9;
431 const int INLINE_BOX2_ID = 10;
432
434 button.
id = BUTTON_ID;
435 check_box.
id = CHECK_BOX_ID;
436 text_field.
id = TEXT_FIELD_ID;
437 static_text1.
id = STATIC_TEXT1_ID;
438 inline_box1.
id = INLINE_BOX1_ID;
439 line_break.
id = LINE_BREAK_ID;
440 inline_box_line_break.
id = INLINE_BOX_LINE_BREAK_ID;
441 static_text2.
id = STATIC_TEXT2_ID;
442 inline_box2.
id = INLINE_BOX2_ID;
443
444 std::string LINE_1_TEXT = "Line 1";
445 std::string LINE_2_TEXT = "Line 2";
446 std::string LINE_BREAK_TEXT = "\n";
447 std::string ALL_TEXT = LINE_1_TEXT + LINE_BREAK_TEXT + LINE_2_TEXT;
448 std::string BUTTON_TEXT = "Button";
449 std::string CHECKBOX_TEXT = "Check box";
450
452
460 root.child_ids.push_back(button.
id);
461
464 check_box.
SetName(CHECKBOX_TEXT);
468 root.child_ids.push_back(check_box.
id);
469
473 "input");
475 "text");
479 std::vector<int32_t>{0, 7});
483 root.child_ids.push_back(text_field.
id);
484
487 static_text1.
SetName(LINE_1_TEXT);
489
492 inline_box1.
SetName(LINE_1_TEXT);
494 std::vector<int32_t> character_offsets1;
495
496 character_offsets1.push_back(225);
497 character_offsets1.push_back(230);
498 character_offsets1.push_back(235);
499 character_offsets1.push_back(240);
500 character_offsets1.push_back(245);
501 character_offsets1.push_back(250);
505 std::vector<int32_t>{0, 5});
507 std::vector<int32_t>{4, 6});
510
513 line_break.
SetName(LINE_BREAK_TEXT);
517 line_break.
child_ids.push_back(inline_box_line_break.
id);
518
522 inline_box_line_break.
SetName(LINE_BREAK_TEXT);
530
533 static_text2.
SetName(LINE_2_TEXT);
535
538 inline_box2.
SetName(LINE_2_TEXT);
540 std::vector<int32_t> character_offsets2;
541
542 character_offsets2.push_back(227);
543 character_offsets2.push_back(234);
544 character_offsets2.push_back(241);
545 character_offsets2.push_back(248);
546 character_offsets2.push_back(255);
547 character_offsets2.push_back(262);
551 std::vector<int32_t>{0, 5});
553 std::vector<int32_t>{4, 6});
554
556 update.has_tree_data =
true;
559 root, button, check_box, text_field,
560 static_text1, inline_box1, line_break, inline_box_line_break,
561 static_text2, inline_box2};
564 }
565
566 const std::wstring tree_for_move_full_text =
567 L"First line of text\nStandalone line\n"
568 L"bold text\nParagraph 1\nParagraph 2";
569
576
580 std::string text_content = "First line of text";
581 text_data.
SetName(text_content);
582 std::vector<int> word_end_offsets;
583 std::vector<int> word_start_offsets;
584 ComputeWordBoundariesOffsets(text_content, word_start_offsets,
585 word_end_offsets);
587 word_start_offsets);
589 word_end_offsets);
591
595
597 line_break1_data.
id = 5;
601 line_break1_data.
SetName(
"\n");
602
604 standalone_text_data.
id = 6;
606 text_content = "Standalone line";
607 standalone_text_data.
SetName(text_content);
608 ComputeWordBoundariesOffsets(text_content, word_start_offsets,
609 word_end_offsets);
614
616 line_break2_data.
id = 7;
620 line_break2_data.
SetName(
"\n");
621
622 group2_data.
child_ids = {line_break1_data.
id, standalone_text_data.
id,
623 line_break2_data.
id};
625 line_break2_data.
id);
627 standalone_text_data.
id);
628
630 bold_text_data.
id = 8;
635 text_content = "bold text";
636 bold_text_data.
SetName(text_content);
637 ComputeWordBoundariesOffsets(text_content, word_start_offsets,
638 word_end_offsets);
640 word_start_offsets);
642 word_end_offsets);
643
645 paragraph1_data.
id = 9;
649
651 paragraph1_text_data.
id = 10;
653 text_content = "Paragraph 1";
654 paragraph1_text_data.
SetName(text_content);
655 ComputeWordBoundariesOffsets(text_content, word_start_offsets,
656 word_end_offsets);
663
665 ignored_text_data.
id = 11;
668 text_content = "ignored text";
669 ignored_text_data.
SetName(text_content);
670
671 paragraph1_data.
child_ids = {paragraph1_text_data.
id, ignored_text_data.
id};
672
674 paragraph2_data.
id = 12;
678
680 paragraph2_text_data.
id = 13;
682 text_content = "Paragraph 2";
683 paragraph2_text_data.
SetName(text_content);
684 ComputeWordBoundariesOffsets(text_content, word_start_offsets,
685 word_end_offsets);
692 paragraph2_data.
child_ids = {paragraph2_text_data.
id};
693
697 root_data.
child_ids = {group1_data.
id, group2_data.
id, bold_text_data.
id,
698 paragraph1_data.
id, paragraph2_data.
id};
699
701 update.has_tree_data =
true;
703 update.nodes = {root_data, group1_data,
704 text_data, group2_data,
705 line_break1_data, standalone_text_data,
706 line_break2_data, bold_text_data,
707 paragraph1_data, paragraph1_text_data,
708 ignored_text_data, paragraph2_data,
709 paragraph2_text_data};
712 }
713
715
716
717
718
719
720
721
722
723
724
725 AXNodeData group1_data;
729 "test font");
730 group1_data.AddBoolAttribute(
732
733 AXNodeData text_data;
736 text_data.SetName("Text with formatting");
737 group1_data.child_ids = {text_data.id};
738
739 AXNodeData group2_data;
742 group2_data.AddBoolAttribute(
744
745 AXNodeData line_break1_data;
746 line_break1_data.
id = 5;
748 line_break1_data.SetName("\n");
749
750 AXNodeData standalone_text_data;
751 standalone_text_data.
id = 6;
753 standalone_text_data.SetName("Standalone line with no formatting");
754
755 AXNodeData line_break2_data;
756 line_break2_data.
id = 7;
758 line_break2_data.SetName("\n");
759
760 group2_data.child_ids = {line_break1_data.id, standalone_text_data.id,
761 line_break2_data.id};
762
763 AXNodeData group3_data;
764 group3_data.id = 8;
766 group3_data.AddIntAttribute(
769 group3_data.AddBoolAttribute(
771
772 AXNodeData bold_text_data;
773 bold_text_data.
id = 9;
775 bold_text_data.SetName("bold text");
776 group3_data.child_ids = {bold_text_data.id};
777
778 AXNodeData paragraph1_data;
779 paragraph1_data.
id = 10;
782 paragraph1_data.AddBoolAttribute(
784
785 AXNodeData paragraph1_text_data;
786 paragraph1_text_data.
id = 11;
788 paragraph1_text_data.SetName("Paragraph 1");
789 paragraph1_data.child_ids = {paragraph1_text_data.id};
790
791 AXNodeData paragraph2_data;
792 paragraph2_data.
id = 12;
795 1.0f);
796 paragraph2_data.AddBoolAttribute(
798
799 AXNodeData paragraph2_text_data;
800 paragraph2_text_data.
id = 13;
802 paragraph2_text_data.SetName("Paragraph 2");
803 paragraph2_data.child_ids = {paragraph2_text_data.id};
804
805 AXNodeData paragraph3_data;
806 paragraph3_data.id = 14;
809 1.0f);
810 paragraph3_data.AddBoolAttribute(
812
813 AXNodeData paragraph3_text_data;
814 paragraph3_text_data.id = 15;
816 paragraph3_text_data.SetName("Paragraph 3");
817 paragraph3_data.child_ids = {paragraph3_text_data.id};
818
819 AXNodeData paragraph4_data;
820 paragraph4_data.id = 16;
823 2.0f);
824 paragraph4_data.AddBoolAttribute(
826
827 AXNodeData paragraph4_text_data;
828 paragraph4_text_data.id = 17;
830 paragraph4_text_data.SetName("Paragraph 4");
831 paragraph4_data.child_ids = {paragraph4_text_data.id};
832
833 AXNodeData root_data;
834 root_data.id = 1;
836 root_data.child_ids = {group1_data.id, group2_data.id,
837 group3_data.id, paragraph1_data.id,
838 paragraph2_data.id, paragraph3_data.id,
839 paragraph4_data.id};
840
842 update.has_tree_data =
true;
843 update.root_id = root_data.id;
844 update.nodes = {root_data,
845 group1_data,
846 text_data,
847 group2_data,
848 line_break1_data,
849 standalone_text_data,
850 line_break2_data,
851 group3_data,
852 bold_text_data,
853 paragraph1_data,
854 paragraph1_text_data,
855 paragraph2_data,
856 paragraph2_text_data,
857 paragraph3_data,
858 paragraph3_text_data,
859 paragraph4_data,
860 paragraph4_text_data};
863 }
864
865 void ExpectPositionsEqual(
const AXNodePosition::AXPositionInstance&
a,
866 const AXNodePosition::AXPositionInstance&
b) {
868 EXPECT_EQ(
a->anchor_id(),
b->anchor_id());
869 EXPECT_EQ(
a->text_offset(),
b->text_offset());
870 }
871};
872
873class MockAXPlatformNodeTextRangeProviderWin
874 : public CComObjectRootEx<CComMultiThreadModel>,
875 public ITextRangeProvider {
876 public:
877 BEGIN_COM_MAP(MockAXPlatformNodeTextRangeProviderWin)
878 COM_INTERFACE_ENTRY(ITextRangeProvider)
879 END_COM_MAP()
880
881 MockAXPlatformNodeTextRangeProviderWin() {}
882 ~MockAXPlatformNodeTextRangeProviderWin() {}
883
884 static HRESULT CreateMockTextRangeProvider(ITextRangeProvider** provider) {
885 CComObject<MockAXPlatformNodeTextRangeProviderWin>* text_range_provider =
886 nullptr;
887 HRESULT hr =
888 CComObject<MockAXPlatformNodeTextRangeProviderWin>::CreateInstance(
889 &text_range_provider);
891 *provider = text_range_provider;
892 }
893
894 return hr;
895 }
896
897
898
899
900 IFACEMETHODIMP Clone(ITextRangeProvider** clone) override {
901 return E_NOTIMPL;
902 }
903
905 return E_NOTIMPL;
906 }
907
908 IFACEMETHODIMP CompareEndpoints(TextPatternRangeEndpoint this_endpoint,
909 ITextRangeProvider* other,
910 TextPatternRangeEndpoint other_endpoint,
912 return E_NOTIMPL;
913 }
914
915 IFACEMETHODIMP ExpandToEnclosingUnit(TextUnit unit) override {
916 return E_NOTIMPL;
917 }
918
919 IFACEMETHODIMP FindAttribute(TEXTATTRIBUTEID attribute_id,
920 VARIANT val,
922 ITextRangeProvider**
result)
override {
923 return E_NOTIMPL;
924 }
925
926 IFACEMETHODIMP FindText(BSTR string,
929 ITextRangeProvider**
result)
override {
930 return E_NOTIMPL;
931 }
932
933 IFACEMETHODIMP GetAttributeValue(TEXTATTRIBUTEID attribute_id,
934 VARIANT* value) override {
935 return E_NOTIMPL;
936 }
937
938 IFACEMETHODIMP GetBoundingRectangles(SAFEARRAY** rectangles) override {
939 return E_NOTIMPL;
940 }
941
942 IFACEMETHODIMP GetEnclosingElement(
943 IRawElementProviderSimple** element) override {
944 return E_NOTIMPL;
945 }
946
947 IFACEMETHODIMP GetText(
int max_count, BSTR*
text)
override {
948 return E_NOTIMPL;
949 }
950
951 IFACEMETHODIMP Move(TextUnit unit,
int count,
int* units_moved)
override {
952 return E_NOTIMPL;
953 }
954
955 IFACEMETHODIMP MoveEndpointByUnit(TextPatternRangeEndpoint endpoint,
956 TextUnit unit,
958 int* units_moved) override {
959 return E_NOTIMPL;
960 }
961
962 IFACEMETHODIMP MoveEndpointByRange(
963 TextPatternRangeEndpoint this_endpoint,
964 ITextRangeProvider* other,
965 TextPatternRangeEndpoint other_endpoint) override {
966 return E_NOTIMPL;
967 }
968
969 IFACEMETHODIMP Select() override { return E_NOTIMPL; }
970
971 IFACEMETHODIMP AddToSelection() override { return E_NOTIMPL; }
972
973 IFACEMETHODIMP RemoveFromSelection() override { return E_NOTIMPL; }
974
975 IFACEMETHODIMP ScrollIntoView(
BOOL align_to_top)
override {
976 return E_NOTIMPL;
977 }
978
979 IFACEMETHODIMP GetChildren(SAFEARRAY** children) override {
980 return E_NOTIMPL;
981 }
982};
983
984TEST_F(AXPlatformNodeTextRangeProviderTest, TestITextRangeProviderClone) {
985 Init(BuildTextDocument({
"some text"}));
986
987 ComPtr<ITextRangeProvider> text_range_provider;
988 GetTextRangeProviderFromTextNode(text_range_provider,
989 GetRootAsAXNode()->children()[0]);
991
992 ComPtr<ITextRangeProvider> text_range_provider_clone;
993 text_range_provider->Clone(&text_range_provider_clone);
994 CopyOwnerToClone(text_range_provider.Get(), text_range_provider_clone.Get());
995 ComPtr<AXPlatformNodeTextRangeProviderWin> original_range;
996 ComPtr<AXPlatformNodeTextRangeProviderWin> clone_range;
997
998 text_range_provider->QueryInterface(IID_PPV_ARGS(&original_range));
999 text_range_provider_clone->QueryInterface(IID_PPV_ARGS(&clone_range));
1000
1001 EXPECT_EQ(*GetStart(original_range.Get()), *GetStart(clone_range.Get()));
1002 EXPECT_EQ(*GetEnd(original_range.Get()), *GetEnd(clone_range.Get()));
1003 EXPECT_EQ(GetOwner(original_range.Get()), GetOwner(clone_range.Get()));
1004
1005
1006 text_range_provider.Reset();
1007 EXPECT_EQ(nullptr, text_range_provider.Get());
1008
1009
1011}
1012
1013TEST_F(AXPlatformNodeTextRangeProviderTest,
1014 TestITextRangeProviderCompareEndpoints) {
1015 Init(BuildTextDocument({
"some text",
"more text"},
1016 false ,
1017 true ));
1018
1019 AXNode* root_node = GetRootAsAXNode();
1020
1021
1022
1023 ComPtr<ITextRangeProvider> document_text_range_provider;
1024 GetTextRangeProviderFromTextNode(document_text_range_provider, root_node);
1025
1026
1027 ComPtr<ITextRangeProvider> text_range_provider;
1028 GetTextRangeProviderFromTextNode(text_range_provider,
1029 root_node->children()[0]);
1030
1031
1032 ComPtr<ITextRangeProvider> more_text_range_provider;
1033 GetTextRangeProviderFromTextNode(more_text_range_provider,
1034 root_node->children()[1]);
1035
1036
1038 EXPECT_HRESULT_SUCCEEDED(document_text_range_provider->CompareEndpoints(
1039 TextPatternRangeEndpoint_Start, document_text_range_provider.Get(),
1040 TextPatternRangeEndpoint_Start, &
result));
1042
1043 EXPECT_HRESULT_SUCCEEDED(document_text_range_provider->CompareEndpoints(
1044 TextPatternRangeEndpoint_End, document_text_range_provider.Get(),
1045 TextPatternRangeEndpoint_End, &
result));
1047
1048 EXPECT_HRESULT_SUCCEEDED(document_text_range_provider->CompareEndpoints(
1049 TextPatternRangeEndpoint_Start, document_text_range_provider.Get(),
1050 TextPatternRangeEndpoint_End, &
result));
1052
1053 EXPECT_HRESULT_SUCCEEDED(document_text_range_provider->CompareEndpoints(
1054 TextPatternRangeEndpoint_End, document_text_range_provider.Get(),
1055 TextPatternRangeEndpoint_Start, &
result));
1057
1058
1059
1060
1061 EXPECT_HRESULT_SUCCEEDED(text_range_provider->CompareEndpoints(
1062 TextPatternRangeEndpoint_Start, more_text_range_provider.Get(),
1063 TextPatternRangeEndpoint_Start, &
result));
1065
1066 EXPECT_HRESULT_SUCCEEDED(text_range_provider->CompareEndpoints(
1067 TextPatternRangeEndpoint_End, more_text_range_provider.Get(),
1068 TextPatternRangeEndpoint_Start, &
result));
1070
1071
1072
1073
1074 EXPECT_HRESULT_SUCCEEDED(text_range_provider->CompareEndpoints(
1075 TextPatternRangeEndpoint_Start, document_text_range_provider.Get(),
1076 TextPatternRangeEndpoint_Start, &
result));
1078
1079 EXPECT_HRESULT_SUCCEEDED(text_range_provider->CompareEndpoints(
1080 TextPatternRangeEndpoint_End, document_text_range_provider.Get(),
1081 TextPatternRangeEndpoint_End, &
result));
1083
1084
1085 EXPECT_HRESULT_SUCCEEDED(more_text_range_provider->CompareEndpoints(
1086 TextPatternRangeEndpoint_Start, document_text_range_provider.Get(),
1087 TextPatternRangeEndpoint_Start, &
result));
1089
1090 EXPECT_HRESULT_SUCCEEDED(more_text_range_provider->CompareEndpoints(
1091 TextPatternRangeEndpoint_End, document_text_range_provider.Get(),
1092 TextPatternRangeEndpoint_End, &
result));
1094}
1095
1096TEST_F(AXPlatformNodeTextRangeProviderTest,
1097 TestITextRangeProviderExpandToEnclosingCharacter) {
1100 AXNode* root_node = GetRootAsAXNode();
1101
1102 ComPtr<ITextRangeProvider> text_range_provider;
1103 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
1104 ASSERT_HRESULT_SUCCEEDED(
1105 text_range_provider->ExpandToEnclosingUnit(TextUnit_Character));
1107
1109 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1110 TextPatternRangeEndpoint_End, TextUnit_Character, 2, &
count));
1111 ASSERT_EQ(2,
count);
1112 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1113 TextPatternRangeEndpoint_Start, TextUnit_Character, 1, &
count));
1114 ASSERT_EQ(1,
count);
1116
1117 ASSERT_HRESULT_SUCCEEDED(
1118 text_range_provider->ExpandToEnclosingUnit(TextUnit_Character));
1120
1121 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1122 TextPatternRangeEndpoint_End, TextUnit_Character, 9, &
count));
1123 ASSERT_EQ(9,
count);
1124 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1125 TextPatternRangeEndpoint_Start, TextUnit_Character, 8, &
count));
1126 ASSERT_EQ(8,
count);
1128
1129 ASSERT_HRESULT_SUCCEEDED(
1130 text_range_provider->ExpandToEnclosingUnit(TextUnit_Character));
1132
1133
1134
1135 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1136 TextPatternRangeEndpoint_End, TextUnit_Character, 9, &
count));
1137 ASSERT_EQ(8,
count);
1138 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1139 TextPatternRangeEndpoint_Start, TextUnit_Character, 9, &
count));
1140 ASSERT_EQ(9,
count);
1141
1142 ASSERT_HRESULT_SUCCEEDED(
1143 text_range_provider->ExpandToEnclosingUnit(TextUnit_Character));
1145
1146
1147
1148
1149 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1150 TextPatternRangeEndpoint_End, TextUnit_Character, -9, &
count));
1151 ASSERT_EQ(-9,
count);
1152 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1153 TextPatternRangeEndpoint_Start, TextUnit_Character, -1,
1155 ASSERT_EQ(-1,
count);
1156 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1157 TextPatternRangeEndpoint_Start, TextUnit_Character, 1, &
count));
1158 ASSERT_EQ(1,
count);
1159 ASSERT_HRESULT_SUCCEEDED(
1160 text_range_provider->ExpandToEnclosingUnit(TextUnit_Character));
1162
1163
1164 ComPtr<IRawElementProviderSimple> more_text_provider =
1165 QueryInterfaceFromNode<IRawElementProviderSimple>(
1166 root_node->children()[1]->children()[0]);
1167 ComPtr<IRawElementProviderSimple> enclosing_element;
1168 ASSERT_HRESULT_SUCCEEDED(
1169 text_range_provider->GetEnclosingElement(&enclosing_element));
1170 EXPECT_EQ(more_text_provider.Get(), enclosing_element.Get());
1171}
1172
1173TEST_F(AXPlatformNodeTextRangeProviderTest,
1174 TestITextRangeProviderExpandToEnclosingWord) {
1175 Init(BuildTextDocument({
"some text",
"definitely not text"},
1176 true));
1177
1178 ComPtr<ITextRangeProvider> text_range_provider;
1179 GetTextRangeProviderFromTextNode(text_range_provider,
1180 GetRootAsAXNode()->children()[1]);
1182
1183
1184 ASSERT_HRESULT_SUCCEEDED(
1185 text_range_provider->ExpandToEnclosingUnit(TextUnit_Word));
1187
1188
1190 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1191 TextPatternRangeEndpoint_Start, TextUnit_Character, -2,
1193 ASSERT_EQ(-2,
count);
1195
1196 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1197 TextPatternRangeEndpoint_End, TextUnit_Character, 4, &
count));
1198 ASSERT_EQ(4,
count);
1200
1201 ASSERT_HRESULT_SUCCEEDED(
1202 text_range_provider->ExpandToEnclosingUnit(TextUnit_Word));
1204
1205
1206 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1207 TextPatternRangeEndpoint_Start, TextUnit_Character, 18,
1209 ASSERT_EQ(18,
count);
1211
1212 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1213 TextPatternRangeEndpoint_End, TextUnit_Character, 1, &
count));
1214 ASSERT_EQ(1,
count);
1216
1217 ASSERT_HRESULT_SUCCEEDED(
1218 text_range_provider->ExpandToEnclosingUnit(TextUnit_Word));
1220}
1221
1222TEST_F(AXPlatformNodeTextRangeProviderTest,
1223 TestITextRangeProviderExpandToEnclosingLine) {
1224 Init(BuildTextDocument({
"line #1",
"maybe line #1?",
"not line #1"}));
1225
1226 ComPtr<ITextRangeProvider> text_range_provider;
1227 GetTextRangeProviderFromTextNode(text_range_provider,
1228 GetRootAsAXNode()->children()[0]);
1230
1231
1233 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1234 TextPatternRangeEndpoint_End, TextUnit_Character, -11, &
count));
1235 ASSERT_EQ(-7,
count);
1237
1238 ASSERT_HRESULT_SUCCEEDED(
1239 text_range_provider->ExpandToEnclosingUnit(TextUnit_Line));
1241
1242
1243 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1244 TextPatternRangeEndpoint_Start, TextUnit_Character, 13,
1246 ASSERT_EQ(13,
count);
1248
1249 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1250 TextPatternRangeEndpoint_End, TextUnit_Character, 4, &
count));
1251 ASSERT_EQ(4,
count);
1253
1254 ASSERT_HRESULT_SUCCEEDED(
1255 text_range_provider->ExpandToEnclosingUnit(TextUnit_Line));
1257
1258
1259 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1260 TextPatternRangeEndpoint_Start, TextUnit_Character, 29,
1262 ASSERT_EQ(25,
count);
1264
1265 ASSERT_HRESULT_SUCCEEDED(
1266 text_range_provider->ExpandToEnclosingUnit(TextUnit_Line));
1268}
1269
1270
1271TEST_F(AXPlatformNodeTextRangeProviderTest,
1272 DISABLED_TestITextRangeProviderExpandToEnclosingParagraph) {
1273 Init(BuildAXTreeForMove());
1274 AXNode* root_node = GetRootAsAXNode();
1275
1276 ComPtr<ITextRangeProvider> text_range_provider;
1277 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
1278
1280 tree_for_move_full_text.data());
1281
1282
1283
1284
1285
1286
1287
1289 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1290 TextPatternRangeEndpoint_End, TextUnit_Paragraph, -5, &
count));
1291 EXPECT_EQ(-5,
count);
1293
1294 ASSERT_HRESULT_SUCCEEDED(
1295 text_range_provider->ExpandToEnclosingUnit(TextUnit_Paragraph));
1297
1298
1299
1300 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1301 TextPatternRangeEndpoint_Start, TextUnit_Line, 2, &
count));
1302 EXPECT_EQ(2,
count);
1304
1305 ASSERT_HRESULT_SUCCEEDED(
1306 text_range_provider->ExpandToEnclosingUnit(TextUnit_Paragraph));
1308
1309
1310
1311 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1312 TextPatternRangeEndpoint_Start, TextUnit_Line, 1, &
count));
1313 EXPECT_EQ(1,
count);
1316 1,
1317
1318 L"",
1319 1);
1320 ASSERT_HRESULT_SUCCEEDED(
1321 text_range_provider->ExpandToEnclosingUnit(TextUnit_Paragraph));
1323
1324
1325
1326 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1327 TextPatternRangeEndpoint_Start, TextUnit_Document, 1, &
count));
1328 EXPECT_EQ(1,
count);
1330 ASSERT_HRESULT_SUCCEEDED(
1331 text_range_provider->ExpandToEnclosingUnit(TextUnit_Paragraph));
1333}
1334
1335
1336TEST_F(AXPlatformNodeTextRangeProviderTest,
1337 DISABLED_TestITextRangeProviderExpandToEnclosingFormat) {
1338 Init(BuildAXTreeForMoveByFormat());
1339 AXNode* root_node = GetRootAsAXNode();
1340 ComPtr<ITextRangeProvider> text_range_provider;
1341 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
1342 ComPtr<AXPlatformNodeTextRangeProviderWin> text_range_provider_internal;
1343 ASSERT_HRESULT_SUCCEEDED(text_range_provider->QueryInterface(
1344 IID_PPV_ARGS(&text_range_provider_internal)));
1345
1347 text_range_provider,
1348 L"Text with formatting\nStandalone line with no formatting\nbold "
1349 L"text\nParagraph 1\nParagraph 2\nParagraph 3\nParagraph 4");
1350
1351
1352
1353
1354
1355
1356
1357
1358 ComPtr<ITextRangeProvider> units_a_b_provider;
1359 ASSERT_HRESULT_SUCCEEDED(text_range_provider->Clone(&units_a_b_provider));
1360 CopyOwnerToClone(text_range_provider.Get(), units_a_b_provider.Get());
1361
1363 ASSERT_HRESULT_SUCCEEDED(units_a_b_provider->MoveEndpointByUnit(
1364 TextPatternRangeEndpoint_Start, TextUnit_Line, 5, &
count));
1365 ASSERT_EQ(5,
count);
1366 ASSERT_HRESULT_SUCCEEDED(units_a_b_provider->MoveEndpointByUnit(
1367 TextPatternRangeEndpoint_End, TextUnit_Line, -1, &
count));
1368 ASSERT_EQ(-1,
count);
1370 L"Paragraph 1\nParagraph 2\nParagraph 3");
1371
1372
1373
1374 ComPtr<ITextRangeProvider> unit_a_provider;
1375 ASSERT_HRESULT_SUCCEEDED(units_a_b_provider->Clone(&unit_a_provider));
1376 CopyOwnerToClone(units_a_b_provider.Get(), unit_a_provider.Get());
1377 ASSERT_HRESULT_SUCCEEDED(unit_a_provider->MoveEndpointByUnit(
1378 TextPatternRangeEndpoint_End, TextUnit_Line, -2, &
count));
1379 ASSERT_EQ(-2,
count);
1381
1382
1383 {
1384 SCOPED_TRACE("Case 1: Degenerate range at start of A.");
1385 ComPtr<ITextRangeProvider> test_case_provider;
1386 ASSERT_HRESULT_SUCCEEDED(unit_a_provider->Clone(&test_case_provider));
1387 CopyOwnerToClone(unit_a_provider.Get(), test_case_provider.Get());
1388 ASSERT_HRESULT_SUCCEEDED(test_case_provider->MoveEndpointByRange(
1389 TextPatternRangeEndpoint_End, test_case_provider.Get(),
1390 TextPatternRangeEndpoint_Start));
1392
1393 ASSERT_HRESULT_SUCCEEDED(
1394 test_case_provider->ExpandToEnclosingUnit(TextUnit_Format));
1396 ASSERT_HRESULT_SUCCEEDED(
1397 test_case_provider->Compare(unit_a_provider.Get(), &are_same));
1399 }
1400
1401
1402 {
1403 SCOPED_TRACE("Case 2: Range from start of A to middle of A.");
1404 ComPtr<ITextRangeProvider> test_case_provider;
1405 ASSERT_HRESULT_SUCCEEDED(unit_a_provider->Clone(&test_case_provider));
1406 CopyOwnerToClone(unit_a_provider.Get(), test_case_provider.Get());
1407 ASSERT_HRESULT_SUCCEEDED(test_case_provider->MoveEndpointByUnit(
1408 TextPatternRangeEndpoint_End, TextUnit_Character, -7,
1410 ASSERT_EQ(-7,
count);
1412
1413 ASSERT_HRESULT_SUCCEEDED(
1414 test_case_provider->ExpandToEnclosingUnit(TextUnit_Format));
1416 ASSERT_HRESULT_SUCCEEDED(
1417 test_case_provider->Compare(unit_a_provider.Get(), &are_same));
1419 }
1420
1421
1422 {
1423 SCOPED_TRACE("Case 3: Range from start of A to end of A.");
1424 ComPtr<ITextRangeProvider> test_case_provider;
1425 ASSERT_HRESULT_SUCCEEDED(unit_a_provider->Clone(&test_case_provider));
1426 CopyOwnerToClone(unit_a_provider.Get(), test_case_provider.Get());
1428
1429 ASSERT_HRESULT_SUCCEEDED(
1430 test_case_provider->ExpandToEnclosingUnit(TextUnit_Format));
1432 ASSERT_HRESULT_SUCCEEDED(
1433 test_case_provider->Compare(unit_a_provider.Get(), &are_same));
1435 }
1436
1437
1438 {
1439 SCOPED_TRACE("Case 4: Range from start of A to middle of B.");
1440 ComPtr<ITextRangeProvider> test_case_provider;
1441 ASSERT_HRESULT_SUCCEEDED(unit_a_provider->Clone(&test_case_provider));
1442 CopyOwnerToClone(unit_a_provider.Get(), test_case_provider.Get());
1443 ASSERT_HRESULT_SUCCEEDED(test_case_provider->MoveEndpointByUnit(
1444 TextPatternRangeEndpoint_End, TextUnit_Character, 5, &
count));
1445 ASSERT_EQ(5,
count);
1447
1448 ASSERT_HRESULT_SUCCEEDED(
1449 test_case_provider->ExpandToEnclosingUnit(TextUnit_Format));
1451 ASSERT_HRESULT_SUCCEEDED(
1452 test_case_provider->Compare(unit_a_provider.Get(), &are_same));
1454 }
1455
1456
1457 {
1458 SCOPED_TRACE("Case 5: Degenerate range in middle of A.");
1459 ComPtr<ITextRangeProvider> test_case_provider;
1460 ASSERT_HRESULT_SUCCEEDED(unit_a_provider->Clone(&test_case_provider));
1461 CopyOwnerToClone(unit_a_provider.Get(), test_case_provider.Get());
1462 ASSERT_HRESULT_SUCCEEDED(test_case_provider->MoveEndpointByUnit(
1463 TextPatternRangeEndpoint_Start, TextUnit_Character, 4,
1465 ASSERT_EQ(4,
count);
1466 ASSERT_HRESULT_SUCCEEDED(test_case_provider->MoveEndpointByRange(
1467 TextPatternRangeEndpoint_End, test_case_provider.Get(),
1468 TextPatternRangeEndpoint_Start));
1470
1471 ASSERT_HRESULT_SUCCEEDED(
1472 test_case_provider->ExpandToEnclosingUnit(TextUnit_Format));
1474 ASSERT_HRESULT_SUCCEEDED(
1475 test_case_provider->Compare(unit_a_provider.Get(), &are_same));
1477 }
1478
1479
1480 {
1481 SCOPED_TRACE("Case 6: Range from middle of A to middle of A.");
1482 ComPtr<ITextRangeProvider> test_case_provider;
1483 ASSERT_HRESULT_SUCCEEDED(unit_a_provider->Clone(&test_case_provider));
1484 CopyOwnerToClone(unit_a_provider.Get(), test_case_provider.Get());
1485 ASSERT_HRESULT_SUCCEEDED(test_case_provider->MoveEndpointByUnit(
1486 TextPatternRangeEndpoint_Start, TextUnit_Character, 4,
1488 ASSERT_EQ(4,
count);
1489 ASSERT_HRESULT_SUCCEEDED(test_case_provider->MoveEndpointByUnit(
1490 TextPatternRangeEndpoint_End, TextUnit_Character, -2,
1492 ASSERT_EQ(-2,
count);
1494
1495 ASSERT_HRESULT_SUCCEEDED(
1496 test_case_provider->ExpandToEnclosingUnit(TextUnit_Format));
1498 ASSERT_HRESULT_SUCCEEDED(
1499 test_case_provider->Compare(unit_a_provider.Get(), &are_same));
1501 }
1502
1503
1504 {
1505 SCOPED_TRACE("Case 7: Range from middle of A to end of A.");
1506 ComPtr<ITextRangeProvider> test_case_provider;
1507 ASSERT_HRESULT_SUCCEEDED(unit_a_provider->Clone(&test_case_provider));
1508 CopyOwnerToClone(unit_a_provider.Get(), test_case_provider.Get());
1509 ASSERT_HRESULT_SUCCEEDED(test_case_provider->MoveEndpointByUnit(
1510 TextPatternRangeEndpoint_Start, TextUnit_Character, 4,
1512 ASSERT_EQ(4,
count);
1514
1515 ASSERT_HRESULT_SUCCEEDED(
1516 test_case_provider->ExpandToEnclosingUnit(TextUnit_Format));
1518 ASSERT_HRESULT_SUCCEEDED(
1519 test_case_provider->Compare(unit_a_provider.Get(), &are_same));
1521 }
1522
1523
1524 {
1525 SCOPED_TRACE("Case 8: Range from middle of A to middle of B.");
1526 ComPtr<ITextRangeProvider> test_case_provider;
1527 ASSERT_HRESULT_SUCCEEDED(unit_a_provider->Clone(&test_case_provider));
1528 CopyOwnerToClone(unit_a_provider.Get(), test_case_provider.Get());
1529 ASSERT_HRESULT_SUCCEEDED(test_case_provider->MoveEndpointByUnit(
1530 TextPatternRangeEndpoint_Start, TextUnit_Character, 5,
1532 ASSERT_EQ(5,
count);
1533 ASSERT_HRESULT_SUCCEEDED(test_case_provider->MoveEndpointByUnit(
1534 TextPatternRangeEndpoint_End, TextUnit_Character, 5, &
count));
1535 ASSERT_EQ(5,
count);
1537
1538 ASSERT_HRESULT_SUCCEEDED(
1539 test_case_provider->ExpandToEnclosingUnit(TextUnit_Format));
1541 ASSERT_HRESULT_SUCCEEDED(
1542 test_case_provider->Compare(unit_a_provider.Get(), &are_same));
1544 }
1545}
1546
1547
1548TEST_F(AXPlatformNodeTextRangeProviderTest,
1549 DISABLED_TestITextRangeProviderExpandToEnclosingFormatWithEmptyObjects) {
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1576
1579 static_text_3.
id = 3;
1580 inline_box_4.
id = 4;
1581 generic_container_5.
id = 5;
1583
1585 root_1.
child_ids = {heading_2.
id, generic_container_5.
id, button_6.
id};
1586
1589
1592 static_text_3.
SetName(
"3.14");
1593
1596
1601
1603
1607 update.tree_data = tree_data;
1608 update.has_tree_data =
true;
1610 update.nodes.push_back(root_1);
1611 update.nodes.push_back(heading_2);
1612 update.nodes.push_back(static_text_3);
1613 update.nodes.push_back(inline_box_4);
1614 update.nodes.push_back(generic_container_5);
1615 update.nodes.push_back(button_6);
1616
1618
1619 AXNode* root_node = GetRootAsAXNode();
1620 ComPtr<ITextRangeProvider> text_range_provider;
1621 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
1622
1624
1625
1626
1628 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1629 TextPatternRangeEndpoint_Start, TextUnit_Character, 5, &
count));
1630 ASSERT_EQ(5,
count);
1631 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1632 TextPatternRangeEndpoint_End, TextUnit_Character, -1, &
count));
1633 ASSERT_EQ(-1,
count);
1635
1636
1637
1638 ASSERT_HRESULT_SUCCEEDED(
1639 text_range_provider->ExpandToEnclosingUnit(TextUnit_Format));
1641}
1642
1643TEST_F(AXPlatformNodeTextRangeProviderTest,
1644 TestITextRangeProviderExpandToEnclosingDocument) {
1645 Init(BuildTextDocument({
"some text",
"more text",
"even more text"}));
1646
1647 AXNode* root_node = GetRootAsAXNode();
1648 AXNode* text_node = root_node->
children()[0];
1649 AXNode* more_text_node = root_node->children()[1];
1650 AXNode* even_more_text_node = root_node->children()[2];
1651
1652
1653
1654 const TextUnit textunit_types[] = {TextUnit_Document, TextUnit_Page};
1655 ComPtr<ITextRangeProvider> text_range_provider;
1656
1657 for (auto& textunit : textunit_types) {
1658 GetTextRangeProviderFromTextNode(text_range_provider, text_node);
1659 ASSERT_HRESULT_SUCCEEDED(
1660 text_range_provider->ExpandToEnclosingUnit(textunit));
1662 L"some textmore texteven more text");
1663
1664 GetTextRangeProviderFromTextNode(text_range_provider, more_text_node);
1665 ASSERT_HRESULT_SUCCEEDED(
1666 text_range_provider->ExpandToEnclosingUnit(textunit));
1668 L"some textmore texteven more text");
1669
1670 GetTextRangeProviderFromTextNode(text_range_provider, even_more_text_node);
1671 ASSERT_HRESULT_SUCCEEDED(
1672 text_range_provider->ExpandToEnclosingUnit(textunit));
1674 L"some textmore texteven more text");
1675 }
1676}
1677
1678
1679
1680TEST_F(AXPlatformNodeTextRangeProviderTest,
1681 DISABLED_TestITextRangeProviderIgnoredForTextNavigation) {
1682
1683
1684
1685
1686
1687
1688
1689
1690
1700
1702 static_text_2.
id = 2;
1703 inline_box_3.
id = 3;
1705 static_text_5.
id = 5;
1706 inline_box_6.
id = 6;
1707 generic_container_7.
id = 7;
1708 static_text_8.
id = 8;
1709 inline_box_9.
id = 9;
1710
1712 root_1.
child_ids = {static_text_2.
id, splitter_4.
id, static_text_5.
id,
1713 generic_container_7.
id, static_text_8.
id};
1714
1718
1721
1724 true);
1725
1729
1732
1736
1740
1743
1747 update.tree_data = tree_data;
1748 update.has_tree_data =
true;
1751 root_1, static_text_2, inline_box_3, splitter_4,
1752 static_text_5, inline_box_6, generic_container_7, static_text_8,
1753 inline_box_9};
1754
1756
1757 AXNode* root_node = GetRootAsAXNode();
1758 ComPtr<ITextRangeProvider> text_range_provider;
1759 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
1760
1762 L"foo\n\xFFFC\nbar\n\xFFFC\nbaz");
1763
1765 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1766 TextPatternRangeEndpoint_Start, TextUnit_Paragraph, 1, &
count));
1767 ASSERT_EQ(1,
count);
1769
1770 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
1771 TextPatternRangeEndpoint_Start, TextUnit_Paragraph, 1, &
count));
1772 ASSERT_EQ(1,
count);
1774}
1775
1776
1777
1778TEST_F(AXPlatformNodeTextRangeProviderTest,
1779 DISABLED_TestITextRangeProviderInvalidCalls) {
1780
1781
1782
1783 {
1784 Init(BuildTextDocument({}));
1785
1786 ComPtr<ITextRangeProvider> text_range_provider;
1787 GetTextRangeProviderFromTextNode(text_range_provider, GetRootAsAXNode());
1788
1789 DestroyTree();
1790 ComPtr<ITextRangeProvider> text_range_provider_clone;
1792 text_range_provider->Clone(&text_range_provider_clone));
1793
1794 BOOL compare_result;
1796 text_range_provider.Get(), &compare_result));
1797
1798 int compare_endpoints_result;
1800 TextPatternRangeEndpoint_Start, text_range_provider.Get(),
1801 TextPatternRangeEndpoint_Start, &compare_endpoints_result));
1802
1804 V_VT(&attr_val) = VT_BOOL;
1805 V_BOOL(&attr_val) = VARIANT_TRUE;
1806 ComPtr<ITextRangeProvider> matched_range_provider;
1808 UIA_IsHiddenAttributeId, attr_val, true, &matched_range_provider));
1809
1811 TextPatternRangeEndpoint_Start, text_range_provider.Get(),
1812 TextPatternRangeEndpoint_Start));
1813
1815 }
1816
1817
1818
1819
1820 {
1821 Init(BuildTextDocument({}));
1822
1823 ComPtr<ITextRangeProvider> this_provider;
1824 GetTextRangeProviderFromTextNode(this_provider, GetRootAsAXNode());
1825
1826 ComPtr<ITextRangeProvider> other_provider_different_type;
1827 MockAXPlatformNodeTextRangeProviderWin::CreateMockTextRangeProvider(
1828 &other_provider_different_type);
1829
1830 BOOL compare_result;
1832 other_provider_different_type.Get(), &compare_result));
1833
1834 int compare_endpoints_result;
1836 TextPatternRangeEndpoint_Start, other_provider_different_type.Get(),
1837 TextPatternRangeEndpoint_Start, &compare_endpoints_result));
1838
1840 TextPatternRangeEndpoint_Start, other_provider_different_type.Get(),
1841 TextPatternRangeEndpoint_Start));
1842 }
1843}
1844
1845TEST_F(AXPlatformNodeTextRangeProviderTest, TestITextRangeProviderGetText) {
1846 Init(BuildTextDocument({
"some text",
"more text"}));
1847
1848 AXNode* root_node = GetRootAsAXNode();
1849 AXNode* text_node = root_node->children()[0];
1850
1851 ComPtr<ITextRangeProvider> text_range_provider;
1852 GetTextRangeProviderFromTextNode(text_range_provider, text_node);
1853
1855 EXPECT_HRESULT_SUCCEEDED(
1856 text_range_provider->GetText(-1, text_content.
Receive()));
1857 EXPECT_STREQ(text_content.
Get(), L
"some text");
1858 text_content.
Reset();
1859
1860 EXPECT_HRESULT_SUCCEEDED(
1861 text_range_provider->GetText(4, text_content.
Receive()));
1862 EXPECT_STREQ(text_content.
Get(), L
"some");
1863 text_content.
Reset();
1864
1865 EXPECT_HRESULT_SUCCEEDED(
1866 text_range_provider->GetText(0, text_content.
Receive()));
1867 EXPECT_STREQ(text_content.
Get(), L
"");
1868 text_content.
Reset();
1869
1870 EXPECT_HRESULT_SUCCEEDED(
1871 text_range_provider->GetText(9, text_content.
Receive()));
1872 EXPECT_STREQ(text_content.
Get(), L
"some text");
1873 text_content.
Reset();
1874
1875 EXPECT_HRESULT_SUCCEEDED(
1876 text_range_provider->GetText(10, text_content.
Receive()));
1877 EXPECT_STREQ(text_content.
Get(), L
"some text");
1878 text_content.
Reset();
1879
1880 EXPECT_HRESULT_FAILED(text_range_provider->GetText(-1, nullptr));
1881
1882 EXPECT_HRESULT_FAILED(
1883 text_range_provider->GetText(-2, text_content.
Receive()));
1884 text_content.
Reset();
1885
1886 ComPtr<ITextRangeProvider> document_textrange;
1887 GetTextRangeProviderFromTextNode(document_textrange, root_node);
1888
1889 EXPECT_HRESULT_SUCCEEDED(
1890 document_textrange->GetText(-1, text_content.
Receive()));
1891 EXPECT_STREQ(text_content.
Get(), L
"some textmore text");
1892 text_content.
Reset();
1893}
1894
1895TEST_F(AXPlatformNodeTextRangeProviderTest,
1896 TestITextRangeProviderMoveCharacter) {
1897 Init(BuildAXTreeForMove());
1898 AXNode* root_node = GetRootAsAXNode();
1899
1900 ComPtr<ITextRangeProvider> text_range_provider;
1901 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
1902
1903
1905
1906 L"First line of text\nStandalone line\n"
1907 L"bold textParagraph 1Paragraph 2",
1908 0);
1909
1910
1912 1,
1913 L"i",
1914 1);
1916 18,
1917 L"S",
1918 18);
1920 16,
1921 L"b",
1922 16);
1924 60,
1925 L"2",
1926 30);
1927
1928
1930 1,
1931 L"2",
1932 0);
1933
1934
1936 -2,
1937 L"h",
1938 -2);
1940 -9,
1941 L"1",
1942 -9);
1944 -60,
1945 L"F",
1946 -54);
1947
1948
1949
1951 -1,
1952
1953 L"F",
1954 0);
1955
1956
1958 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
1959 -1,
1960 L"",
1961 -1);
1963 4,
1964 L"",
1965 4);
1967 70,
1968 L"",
1969 62);
1970
1971
1973 70,
1974 L"",
1975 0);
1977 -2,
1978 L"",
1979 -2);
1980}
1981
1982
1983TEST_F(AXPlatformNodeTextRangeProviderTest,
1984 DISABLED_TestITextRangeProviderMoveFormat) {
1985 Init(BuildAXTreeForMoveByFormat());
1986 AXNode* root_node = GetRootAsAXNode();
1987
1988 ComPtr<ITextRangeProvider> text_range_provider;
1989 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
1990
1991
1993 text_range_provider, TextUnit_Format,
1994 0,
1995
1996 L"Text with formatting\nStandalone line with no formatting\nbold "
1997 L"text\nParagraph 1\nParagraph 2\nParagraph 3\nParagraph 4",
1998 0);
1999
2000
2002 1,
2003 L"\nStandalone line with no formatting\n",
2004 1);
2006 2,
2007 L"Paragraph 1",
2008 2);
2010 1,
2011 L"Paragraph 2\nParagraph 3",
2012 1);
2014 1,
2015 L"Paragraph 4",
2016 1);
2017
2018
2020 1,
2021 L"Paragraph 4",
2022 0);
2023
2024
2026 -3,
2027 L"bold text",
2028 -3);
2030 -1,
2031 L"\nStandalone line with no formatting\n",
2032 -1);
2034 -1,
2035 L"Text with formatting",
2036 -1);
2037
2038
2039
2041 -1,
2042
2043 L"Text with formatting",
2044 0);
2045
2046
2048 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Format,
2049 -1,
2050 L"",
2051 -1);
2053 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Format,
2054 1,
2055 L"Text with formatting",
2056 1);
2057
2058
2060 5,
2061 L"Paragraph 4",
2062 5);
2064 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Format,
2065 1,
2066 L"",
2067 1);
2069 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Format,
2070 -1,
2071 L"Paragraph 4",
2072 -1);
2074 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Format,
2075 1,
2076 L"",
2077 1);
2079 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Format,
2080 -1,
2081 L"Paragraph 4",
2082 -1);
2083
2084
2086 -5,
2087 L"Text with formatting",
2088 -5);
2090 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Format,
2091 -1,
2092 L"",
2093 -1);
2095 3,
2096 L"",
2097 3);
2099 70,
2100 L"",
2101 3);
2102
2103
2105 70,
2106 L"",
2107 0);
2109 -2,
2110 L"",
2111 -2);
2112}
2113
2114
2115TEST_F(AXPlatformNodeTextRangeProviderTest,
2116 DISABLED_TestITextRangeProviderMoveWord) {
2117 Init(BuildAXTreeForMove());
2118 AXNode* root_node = GetRootAsAXNode();
2119
2120 ComPtr<ITextRangeProvider> text_range_provider;
2121 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
2122
2123
2125 tree_for_move_full_text.data(),
2126 0);
2127
2128
2130 1,
2131 L"line ",
2132 1);
2134 2,
2135 L"text",
2136 2);
2138 2,
2139 L"line",
2140 2);
2142 3,
2143 L"Paragraph ",
2144 3);
2146 6,
2147 L"2",
2148 3);
2149
2150
2152 1,
2153 L"2",
2154 0);
2155
2156
2158 -3,
2159 L"Paragraph ",
2160 -3);
2162 -3,
2163 L"line",
2164 -3);
2166 -2,
2167 L"text",
2168 -2);
2170 -6,
2171 L"First ",
2172 -3);
2173
2174
2175
2177 -20,
2178 L"First ",
2179 0);
2180
2181
2183 TextPatternRangeEndpoint_End, TextUnit_Word,
2184 -1,
2185 L"",
2186 -1);
2188 4,
2189 L"",
2190 4);
2192 70,
2193 L"",
2194 8);
2195
2196
2198 70,
2199 L"",
2200 0);
2202 -2,
2203 L"",
2204 -2);
2205}
2206
2207
2208TEST_F(AXPlatformNodeTextRangeProviderTest,
2209 DISABLED_TestITextRangeProviderMoveLine) {
2210 Init(BuildAXTreeForMove());
2211 AXNode* root_node = GetRootAsAXNode();
2212
2213 ComPtr<ITextRangeProvider> text_range_provider;
2214 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
2215
2216
2218 tree_for_move_full_text.data(),
2219 0);
2220
2221
2223 2,
2224 L"Standalone line",
2225 2);
2227 1,
2228 L"bold text",
2229 1);
2231 10,
2232 L"Paragraph 2",
2233 2);
2234
2235
2237 1,
2238 L"Paragraph 2",
2239 0);
2240
2241
2243 -1,
2244 L"Paragraph 1",
2245 -1);
2247 -5,
2248 L"First line of text",
2249 -4);
2250
2251
2252
2254 -20,
2255 L"First line of text",
2256 0);
2257
2258
2260 TextPatternRangeEndpoint_End, TextUnit_Line,
2261 -1,
2262 L"",
2263 -1);
2265 4,
2266 L"",
2267 4);
2269 70,
2270 L"",
2271 2);
2272
2273
2275 70,
2276 L"",
2277 0);
2279 -2,
2280 L"",
2281 -2);
2282}
2283
2284
2285TEST_F(AXPlatformNodeTextRangeProviderTest,
2286 DISABLED_TestITextRangeProviderMoveParagraph) {
2287 Init(BuildAXTreeForMove());
2288 AXNode* root_node = GetRootAsAXNode();
2289
2290 ComPtr<ITextRangeProvider> text_range_provider;
2291 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
2292
2293
2295 tree_for_move_full_text.data(),
2296 0);
2297
2299 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Paragraph,
2300 -4,
2301 L"First line of text\n",
2302 -4);
2303
2304
2305
2306
2307
2308
2310 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Paragraph,
2311 -1,
2312 L"",
2313 -1);
2315 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Paragraph,
2316 1,
2317 L"First line of text\n",
2318 1);
2319
2320
2321
2322
2323
2325 1,
2326 L"Standalone line\n",
2327 1);
2329 1,
2330 L"bold text\n",
2331 1);
2333 1,
2334 L"Paragraph 1\n",
2335 1);
2337 1,
2338 L"Paragraph 2",
2339 1);
2341 2,
2342 L"Paragraph 2",
2343 0);
2344
2345
2347 1,
2348 L"Paragraph 2",
2349 0);
2350
2351
2352
2353
2354
2356 -1,
2357 L"Paragraph 1\n",
2358 -1);
2360 -1,
2361 L"bold text\n",
2362 -1);
2364 -1,
2365 L"Standalone line\n",
2366 -1);
2367
2368
2369
2371 -1,
2372 L"First line of text\n",
2373 -1);
2375 -1,
2376 L"First line of text\n",
2377 0);
2378
2379
2380
2382 -1,
2383 L"First line of text\n",
2384 0);
2385
2386
2388 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Paragraph,
2389 -1,
2390 L"",
2391 -1);
2393 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Paragraph,
2394 1,
2395 L"First line of text\n",
2396 1);
2397
2398
2400 5,
2401 L"Paragraph 2",
2402 4);
2404 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Paragraph,
2405 1,
2406 L"",
2407 1);
2409 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Paragraph,
2410 -1,
2411 L"Paragraph 2",
2412 -1);
2414 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Paragraph,
2415 1,
2416 L"",
2417 1);
2419 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Paragraph,
2420 -1,
2421 L"Paragraph 2",
2422 -1);
2423
2424
2425
2426
2427
2429 -6,
2430 L"First line of text\n",
2431 -4);
2433 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Paragraph,
2434 -1,
2435 L"",
2436 -1);
2438 3,
2439 L"",
2440 3);
2442 70,
2443 L"",
2444 2);
2445
2446
2448 70,
2449 L"",
2450 0);
2452 -2,
2453 L"",
2454 -2);
2455}
2456
2457
2458TEST_F(AXPlatformNodeTextRangeProviderTest,
2459 DISABLED_TestITextRangeProviderMoveDocument) {
2460 Init(BuildAXTreeForMove());
2461 AXNode* root_node = GetRootAsAXNode();
2462
2463 ComPtr<ITextRangeProvider> text_range_provider;
2464 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
2465
2466
2468 tree_for_move_full_text.data(),
2469 0);
2470
2472 tree_for_move_full_text.data(),
2473 0);
2475 tree_for_move_full_text.data(),
2476 0);
2478 tree_for_move_full_text.data(),
2479 0);
2481 tree_for_move_full_text.data(),
2482 0);
2483
2484
2486 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Document,
2487 -2,
2488 L"",
2489 -1);
2491 4,
2492 L"",
2493 1);
2494
2495
2497 1,
2498 L"",
2499 0);
2501 -2,
2502 L"",
2503 -1);
2505 -1,
2506 L"",
2507 0);
2508}
2509
2510TEST_F(AXPlatformNodeTextRangeProviderTest, TestITextRangeProviderMove) {
2511 Init(BuildAXTreeForMove());
2512 AXNode* root_node = GetRootAsAXNode();
2513
2514 ComPtr<ITextRangeProvider> text_range_provider;
2515 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
2516
2517
2518}
2519
2520TEST_F(AXPlatformNodeTextRangeProviderTest,
2521 TestITextRangeProviderMoveEndpointByDocument) {
2522 Init(BuildTextDocument({
"some text",
"more text",
"even more text"}));
2523 AXNode* text_node = GetRootAsAXNode()->children()[1];
2524
2525
2526
2527 const TextUnit textunit_types[] = {TextUnit_Document, TextUnit_Page};
2528 ComPtr<ITextRangeProvider> text_range_provider;
2529
2530 for (auto& textunit : textunit_types) {
2531 GetTextRangeProviderFromTextNode(text_range_provider, text_node);
2532
2533
2535 TextPatternRangeEndpoint_End, textunit,
2536 0,
2537 L"more text",
2538 0);
2539
2540
2542 text_range_provider, TextPatternRangeEndpoint_End, textunit,
2543 1,
2544 L"more texteven more text",
2545 1);
2546
2547
2549 text_range_provider, TextPatternRangeEndpoint_End, textunit,
2550 5,
2551 L"more texteven more text",
2552 0);
2553
2554
2556 TextPatternRangeEndpoint_End, textunit,
2557 -4,
2558 L"",
2559 -1);
2560
2561
2562
2563
2565 text_range_provider, TextPatternRangeEndpoint_End, textunit,
2566 1,
2567 L"some textmore texteven more text",
2568 1);
2569
2570
2572 TextPatternRangeEndpoint_Start, textunit,
2573 3,
2574 L"",
2575 1);
2576
2577
2579 text_range_provider, TextPatternRangeEndpoint_Start, textunit,
2580 -3,
2581 L"some textmore texteven more text",
2582 -1);
2583 }
2584}
2585
2586
2587
2588TEST_F(AXPlatformNodeTextRangeProviderTest,
2589 DISABLED_TestITextRangeProviderMoveEndpointByCharacterMultilingual) {
2590
2591 const std::string english = "hey";
2592
2593
2594
2595 const std::string hindi =
2597
2598
2599
2600 const std::string thai =
2602
2603 Init(BuildTextDocument({english, hindi, thai}));
2604
2605 ComPtr<ITextRangeProvider> text_range_provider;
2606 GetTextRangeProviderFromTextNode(text_range_provider,
2607 GetRootAsAXNode()->children()[0]);
2608
2609
2612 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Character,
2613 0,
2614 L"hey",
2615 0);
2616
2618 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Character,
2619 1,
2620 L"ey",
2621 1);
2622
2624 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
2625 -1,
2626 L"e",
2627 -1);
2628
2629
2630
2631
2633 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
2634 2,
2635 L"ey\x0939\x093F",
2636 2);
2637
2638
2640 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
2641 1,
2642 L"ey\x939\x93F\x928\x94D\x926\x940",
2643 1);
2644
2645
2647 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Character,
2648 2,
2649 L"\x939\x93F\x928\x94D\x926\x940",
2650 2);
2651
2652
2653
2654
2656 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
2657 1,
2658 L"\x939\x93F\x928\x94D\x926\x940\xE23\xE39\xE49",
2659 1);
2660
2661
2663 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
2664 -2,
2665 L"\x939\x93F",
2666 -2);
2667
2669 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
2670 3,
2671
2672 L"\x939\x93F\x928\x94D\x926\x940\xE23\xE39\xE49\xE2A\xE36",
2673 3);
2674
2675
2677 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
2678 1,
2679
2680 L"\x939\x93F\x928\x94D\x926\x940\xE23\xE39\xE49\xE2A\xE36\xE01",
2681 1);
2682
2683
2685 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Character,
2686 3,
2687 L"\x0E2A\x0E36\x0E01",
2688 3);
2689
2691 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Character,
2692 -1,
2693 L"\x0E23\x0E39\x0E49\x0E2A\x0E36\x0E01",
2694 -1);
2695}
2696
2697
2698TEST_F(AXPlatformNodeTextRangeProviderTest,
2699 DISABLED_TestITextRangeProviderMoveEndpointByWord) {
2700 Init(BuildTextDocument({
"some text",
"more text",
"even more text"},
2701 true));
2702
2703 ComPtr<ITextRangeProvider> text_range_provider;
2704 GetTextRangeProviderFromTextNode(text_range_provider,
2705 GetRootAsAXNode()->children()[1]);
2707
2708
2710 TextPatternRangeEndpoint_End, TextUnit_Word,
2711 0,
2712 L"more text",
2713 0);
2714
2715
2717 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Word,
2718 1,
2719 L"text",
2720 1);
2722 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Word,
2723 -1,
2724 L"more text",
2725 -1);
2726
2727
2729 TextPatternRangeEndpoint_End, TextUnit_Word,
2730 -1,
2731 L"more ",
2732 -1);
2734 TextPatternRangeEndpoint_End, TextUnit_Word,
2735 1,
2736 L"more text",
2737 1);
2738
2739
2741 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Word,
2742 3,
2743 L"",
2744 3);
2746 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Word,
2747 -3,
2748 L"more texteven ",
2749 -3);
2751 TextPatternRangeEndpoint_End, TextUnit_Word,
2752 -1,
2753 L"more text",
2754 -1);
2755
2756
2758 TextPatternRangeEndpoint_End, TextUnit_Word,
2759 -3,
2760 L"",
2761 -3);
2763 TextPatternRangeEndpoint_End, TextUnit_Word,
2764 3,
2765 L"textmore text",
2766 3);
2768 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Word,
2769 1,
2770 L"more text",
2771 1);
2772
2773
2775 TextPatternRangeEndpoint_End, TextUnit_Word,
2776 5,
2777 L"more texteven more text",
2778 3);
2780 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Word,
2781 6,
2782 L"",
2783 5);
2785 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Word,
2786 -8,
2787 L"some textmore texteven more text",
2788 -7);
2790 TextPatternRangeEndpoint_End, TextUnit_Word,
2791 -8,
2792 L"",
2793 -7);
2794}
2795
2796
2797TEST_F(AXPlatformNodeTextRangeProviderTest,
2798 DISABLED_TestITextRangeProviderMoveEndpointByLine) {
2799 Init(BuildTextDocument({
"0",
"1",
"2",
"3",
"4",
"5",
"6"}));
2800
2801 ComPtr<ITextRangeProvider> text_range_provider;
2802 GetTextRangeProviderFromTextNode(text_range_provider,
2803 GetRootAsAXNode()->children()[3]);
2805
2806
2808 TextPatternRangeEndpoint_End, TextUnit_Line,
2809 0,
2810 L"3",
2811 0);
2812
2813
2815 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Line,
2816 -2,
2817 L"123",
2818 -2);
2820 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Line,
2821 1,
2822 L"23",
2823 1);
2824
2825
2827 TextPatternRangeEndpoint_End, TextUnit_Line,
2828 3,
2829 L"23456",
2830 3);
2832 TextPatternRangeEndpoint_End, TextUnit_Line,
2833 -2,
2834 L"234",
2835 -2);
2836
2837
2839 TextPatternRangeEndpoint_End, TextUnit_Line,
2840 -4,
2841 L"",
2842 -4);
2844 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Line,
2845 -1,
2846 L"0",
2847 -1);
2849 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Line,
2850 6,
2851 L"",
2852 6);
2854 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Line,
2855 -6,
2856 L"012345",
2857 -6);
2858
2859
2861 TextPatternRangeEndpoint_End, TextUnit_Line,
2862 -13,
2863 L"",
2864 -6);
2866 TextPatternRangeEndpoint_End, TextUnit_Line,
2867 11,
2868 L"0123456",
2869 7);
2871 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Line,
2872 9,
2873 L"",
2874 7);
2876 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Line,
2877 -7,
2878 L"0123456",
2879 -7);
2880}
2881
2882
2883
2884TEST_F(AXPlatformNodeTextRangeProviderTest,
2885 DISABLED_TestITextRangeProviderMoveEndpointByUnitTextField) {
2886
2890
2894
2898 std::string text_content = "some text";
2899 text_data.
SetName(text_content);
2900 std::vector<int> word_start_offsets, word_end_offsets;
2901 ComputeWordBoundariesOffsets(text_content, word_start_offsets,
2902 word_end_offsets);
2904 word_start_offsets);
2906 word_end_offsets);
2907
2909 text_input_data.
id = 4;
2913 "input");
2915 "text");
2916
2920
2922 more_text_data.
id = 6;
2924 text_content = "more text";
2925 more_text_data.
SetName(text_content);
2926 ComputeWordBoundariesOffsets(text_content, word_start_offsets,
2927 word_end_offsets);
2929 word_start_offsets);
2931 word_end_offsets);
2932
2934 empty_text_data.
id = 7;
2937 text_content = "";
2939 ComputeWordBoundariesOffsets(text_content, word_start_offsets,
2940 word_end_offsets);
2942 word_start_offsets);
2944 word_end_offsets);
2945
2946 root_data.
child_ids = {group1_data.
id, text_input_data.
id, group2_data.
id};
2950
2954 update.tree_data = tree_data;
2955 update.has_tree_data =
true;
2957 update.nodes = {root_data, group1_data, text_data, text_input_data,
2958 group2_data, more_text_data, empty_text_data};
2959
2961
2962
2963 AXNode* root_node = GetRootAsAXNode();
2964 AXNode* text_node = root_node->children()[0]->children()[0];
2965
2966 ComPtr<ITextRangeProvider> text_range_provider;
2967 GetTextRangeProviderFromTextNode(text_range_provider, text_node);
2968
2970
2972
2973 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
2974 TextPatternRangeEndpoint_End, TextUnit_Character, 2, &
count));
2975 ASSERT_EQ(2,
count);
2976
2977
2979
2980 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
2981 TextPatternRangeEndpoint_End, TextUnit_Character, 2, &
count));
2982 ASSERT_EQ(2,
count);
2984
2985 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
2986 TextPatternRangeEndpoint_End, TextUnit_Character, -1, &
count));
2987 ASSERT_EQ(-1,
count);
2989
2990 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
2991 TextPatternRangeEndpoint_End, TextUnit_Character, -2, &
count));
2992 ASSERT_EQ(-2,
count);
2994
2995
2996 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
2997 TextPatternRangeEndpoint_End, TextUnit_Word, 1, &
count));
2998 ASSERT_EQ(1,
count);
3000
3001 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
3002 TextPatternRangeEndpoint_End, TextUnit_Word, 1, &
count));
3003 ASSERT_EQ(1,
count);
3005
3006 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
3007 TextPatternRangeEndpoint_End, TextUnit_Word, -1, &
count));
3008 ASSERT_EQ(-1,
count);
3010
3011 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
3012 TextPatternRangeEndpoint_End, TextUnit_Word, -1, &
count));
3013 ASSERT_EQ(-1,
count);
3015
3016
3017 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
3018 TextPatternRangeEndpoint_End, TextUnit_Line, 1, &
count));
3019 ASSERT_EQ(1,
count);
3021
3022 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
3023 TextPatternRangeEndpoint_End, TextUnit_Line, 1, &
count));
3024 ASSERT_EQ(1,
count);
3026
3027 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
3028 TextPatternRangeEndpoint_End, TextUnit_Line, -1, &
count));
3029 ASSERT_EQ(-1,
count);
3031
3032 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
3033 TextPatternRangeEndpoint_End, TextUnit_Line, -1, &
count));
3034 ASSERT_EQ(-1,
count);
3036}
3037
3038
3039TEST_F(AXPlatformNodeTextRangeProviderTest,
3040 DISABLED_TestITextRangeProviderMoveEndpointByFormat) {
3041 Init(BuildAXTreeForMoveByFormat());
3042 AXNode* root_node = GetRootAsAXNode();
3043
3044 ComPtr<ITextRangeProvider> text_range_provider;
3045 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
3046
3048 text_range_provider,
3049 L"Text with formatting\nStandalone line with no formatting\nbold "
3050 L"text\nParagraph 1\nParagraph 2\nParagraph 3\nParagraph 4");
3052 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Format,
3053 -2,
3054
3055 L"Text with formatting\nStandalone line with no formatting\nbold "
3056 L"text\nParagraph 1",
3057 -2);
3058
3060 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Format,
3061 -1,
3062
3063 L"Text with formatting\nStandalone line with no formatting\nbold text",
3064 -1);
3065
3067 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Format,
3068 -1,
3069
3070 L"Text with formatting\nStandalone line with no formatting\n",
3071 -1);
3072
3074 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Format,
3075 -1,
3076 L"Text with formatting",
3077 -1);
3078
3080 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Format,
3081 -1,
3082 L"",
3083 -1);
3084
3086 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Format,
3087 7,
3088
3089 L"Text with formatting\nStandalone line with no formatting\nbold "
3090 L"text\nParagraph 1\nParagraph 2\nParagraph 3\nParagraph 4",
3091 6);
3092
3094 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Format,
3095 -8,
3096 L"",
3097 -6);
3098}
3099
3100TEST_F(AXPlatformNodeTextRangeProviderTest, TestITextRangeProviderCompare) {
3101 Init(BuildTextDocument({
"some text",
"some text"}));
3102 AXNode* root_node = GetRootAsAXNode();
3103
3104
3105
3106 ComPtr<ITextRangeProvider> document_text_range_provider;
3107 GetTextRangeProviderFromTextNode(document_text_range_provider, root_node);
3108
3109
3110 ComPtr<ITextRangeProvider> text_range_provider;
3111 GetTextRangeProviderFromTextNode(text_range_provider,
3112 root_node->children()[0]);
3113
3114
3115 ComPtr<ITextRangeProvider> more_text_range_provider;
3116 GetTextRangeProviderFromTextNode(more_text_range_provider,
3117 root_node->children()[1]);
3118
3119
3120
3122 EXPECT_HRESULT_SUCCEEDED(document_text_range_provider->Compare(
3123 document_text_range_provider.Get(), &
result));
3125
3126
3127
3128 EXPECT_HRESULT_SUCCEEDED(document_text_range_provider->Compare(
3129 text_range_provider.Get(), &
result));
3131
3132
3133
3134
3135
3136 EXPECT_HRESULT_SUCCEEDED(
3137 text_range_provider->Compare(more_text_range_provider.Get(), &
result));
3139}
3140
3141TEST_F(AXPlatformNodeTextRangeProviderTest, TestITextRangeProviderSelection) {
3142 Init(BuildTextDocument({
"some text"}));
3143
3144 ComPtr<ITextRangeProvider> text_range_provider;
3145 GetTextRangeProviderFromTextNode(text_range_provider, GetRootAsAXNode());
3146
3149}
3150
3151
3152
3153TEST_F(AXPlatformNodeTextRangeProviderTest,
3154 DISABLED_TestITextRangeProviderGetBoundingRectangles) {
3157 ComPtr<ITextRangeProvider> text_range_provider;
3159 int units_moved;
3160
3161
3162
3163
3164 GetTextRangeProviderFromTextNode(text_range_provider, GetRootAsAXNode());
3165 EXPECT_HRESULT_SUCCEEDED(
3166 text_range_provider->GetBoundingRectangles(rectangles.
Receive()));
3167 std::vector<double> expected_values = {20, 20, 200, 30,
3168 20, 50, 200, 30,
3169 220, 20, 30, 30,
3170 220, 50, 42, 30 };
3173
3174
3175
3176
3177
3178 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
3179 TextPatternRangeEndpoint_End, TextUnit_Character, -1,
3180 &units_moved));
3181 ASSERT_EQ(-1, units_moved);
3182 EXPECT_HRESULT_SUCCEEDED(
3183 text_range_provider->GetBoundingRectangles(rectangles.
Receive()));
3184 expected_values = {20, 20, 200, 30,
3185 20, 50, 200, 30,
3186 220, 20, 30, 30,
3187 220, 50, 35, 30 };
3190
3191
3192
3193
3194
3195 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
3196 TextPatternRangeEndpoint_End, TextUnit_Line, -1, &units_moved));
3197 ASSERT_EQ(-1, units_moved);
3198 EXPECT_HRESULT_SUCCEEDED(
3199 text_range_provider->GetBoundingRectangles(rectangles.
Receive()));
3200 expected_values = {20, 20, 200, 30,
3201 20, 50, 200, 30,
3202 220, 20, 30, 30 };
3205
3206
3207
3208
3209
3210 ASSERT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByUnit(
3211 TextPatternRangeEndpoint_End, TextUnit_Word, -3, &units_moved));
3212 ASSERT_EQ(-3, units_moved);
3213 EXPECT_HRESULT_SUCCEEDED(
3214 text_range_provider->GetBoundingRectangles(rectangles.
Receive()));
3215 expected_values = {20, 20, 200, 30,
3216 20, 50, 200, 30 };
3218}
3219
3220TEST_F(AXPlatformNodeTextRangeProviderTest,
3221 TestITextRangeProviderGetEnclosingElement) {
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3241
3243 paragraph_data.
id = 2;
3246
3248 static_text_data1.
id = 3;
3250 paragraph_data.
child_ids.push_back(static_text_data1.
id);
3251
3253 inline_text_data1.
id = 4;
3255 static_text_data1.
child_ids.push_back(inline_text_data1.
id);
3256
3261
3263 static_text_data2.
id = 6;
3265 link_data.
child_ids.push_back(static_text_data2.
id);
3266
3268 inline_text_data2.
id = 7;
3270 static_text_data2.
child_ids.push_back(inline_text_data2.
id);
3271
3275 paragraph_data.
child_ids.push_back(link_data2.
id);
3276
3281
3283 list_item_data.
id = 10;
3286
3288 static_text_data3.
id = 11;
3290 list_item_data.
child_ids.push_back(static_text_data3.
id);
3291
3293 inline_text_data3.
id = 12;
3295 static_text_data3.
child_ids.push_back(inline_text_data3.
id);
3296
3303 "search");
3304 paragraph_data.
child_ids.push_back(search_box.
id);
3305
3307 search_text.
id = 14;
3310 search_text.
SetName(
"placeholder");
3312
3314 pdf_highlight_data.
id = 15;
3316 paragraph_data.
child_ids.push_back(pdf_highlight_data.
id);
3317
3319 static_text_data4.
id = 16;
3321 pdf_highlight_data.
child_ids.push_back(static_text_data4.
id);
3322
3324 inline_text_data4.
id = 17;
3326 static_text_data4.
child_ids.push_back(inline_text_data4.
id);
3327
3331 update.tree_data = tree_data;
3332 update.has_tree_data =
true;
3334 update.nodes = {root_data, paragraph_data, static_text_data1,
3335 inline_text_data1, link_data, static_text_data2,
3336 inline_text_data2, link_data2, list_data,
3337 list_item_data, static_text_data3, inline_text_data3,
3338 search_box, search_text, pdf_highlight_data,
3339 static_text_data4, inline_text_data4};
3341
3342
3343 AXNode* paragraph_node = GetRootAsAXNode()->children()[0];
3344 AXNode* static_text_node1 = paragraph_node->children()[0];
3345 AXNode* link_node = paragraph_node->children()[1];
3346 AXNode* inline_text_node1 = static_text_node1->children()[0];
3347 AXNode* static_text_node2 = link_node->children()[0];
3348 AXNode* inline_text_node2 = static_text_node2->children()[0];
3349 AXNode* link_node2 = paragraph_node->children()[2];
3350 AXNode* list_node = link_node2->children()[0];
3351 AXNode* list_item_node = list_node->children()[0];
3352 AXNode* static_text_node3 = list_item_node->children()[0];
3353 AXNode* inline_text_node3 = static_text_node3->children()[0];
3354 AXNode* search_box_node = paragraph_node->children()[3];
3355 AXNode* search_text_node = search_box_node->children()[0];
3356 AXNode* pdf_highlight_node = paragraph_node->children()[4];
3357 AXNode* static_text_node4 = pdf_highlight_node->children()[0];
3358 AXNode* inline_text_node4 = static_text_node4->children()[0];
3359 AXPlatformNodeWin* owner =
3360 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(paragraph_node));
3361 ASSERT_NE(owner, nullptr);
3362
3363 ComPtr<IRawElementProviderSimple> link_node_raw =
3364 QueryInterfaceFromNode<IRawElementProviderSimple>(link_node);
3365 ComPtr<IRawElementProviderSimple> static_text_node_raw1 =
3366 QueryInterfaceFromNode<IRawElementProviderSimple>(static_text_node1);
3367 ComPtr<IRawElementProviderSimple> static_text_node_raw2 =
3368 QueryInterfaceFromNode<IRawElementProviderSimple>(static_text_node2);
3369 ComPtr<IRawElementProviderSimple> static_text_node_raw3 =
3370 QueryInterfaceFromNode<IRawElementProviderSimple>(static_text_node3);
3371 ComPtr<IRawElementProviderSimple> inline_text_node_raw1 =
3372 QueryInterfaceFromNode<IRawElementProviderSimple>(inline_text_node1);
3373 ComPtr<IRawElementProviderSimple> inline_text_node_raw2 =
3374 QueryInterfaceFromNode<IRawElementProviderSimple>(inline_text_node2);
3375 ComPtr<IRawElementProviderSimple> inline_text_node_raw3 =
3376 QueryInterfaceFromNode<IRawElementProviderSimple>(inline_text_node3);
3377 ComPtr<IRawElementProviderSimple> search_box_node_raw =
3378 QueryInterfaceFromNode<IRawElementProviderSimple>(search_box_node);
3379 ComPtr<IRawElementProviderSimple> search_text_node_raw =
3380 QueryInterfaceFromNode<IRawElementProviderSimple>(search_text_node);
3381 ComPtr<IRawElementProviderSimple> pdf_highlight_node_raw =
3382 QueryInterfaceFromNode<IRawElementProviderSimple>(pdf_highlight_node);
3383 ComPtr<IRawElementProviderSimple> inline_text_node_raw4 =
3384 QueryInterfaceFromNode<IRawElementProviderSimple>(inline_text_node4);
3385
3386
3387
3388
3389
3390
3391
3392 ComPtr<ITextProvider> text_provider;
3393 EXPECT_HRESULT_SUCCEEDED(inline_text_node_raw1->GetPatternProvider(
3394 UIA_TextPatternId, &text_provider));
3395
3396 ComPtr<ITextRangeProvider> text_range_provider;
3397 EXPECT_HRESULT_SUCCEEDED(
3398 text_provider->get_DocumentRange(&text_range_provider));
3399 SetOwner(owner, text_range_provider.Get());
3400
3401 ComPtr<IRawElementProviderSimple> enclosing_element;
3402 EXPECT_HRESULT_SUCCEEDED(
3403 text_range_provider->GetEnclosingElement(&enclosing_element));
3404 EXPECT_EQ(inline_text_node_raw1.Get(), enclosing_element.Get());
3405
3406 EXPECT_HRESULT_SUCCEEDED(inline_text_node_raw2->GetPatternProvider(
3407 UIA_TextPatternId, &text_provider));
3408
3409 EXPECT_HRESULT_SUCCEEDED(
3410 text_provider->get_DocumentRange(&text_range_provider));
3411 SetOwner(owner, text_range_provider.Get());
3412
3413 EXPECT_HRESULT_SUCCEEDED(
3414 text_range_provider->GetEnclosingElement(&enclosing_element));
3415 EXPECT_EQ(link_node_raw.Get(), enclosing_element.Get());
3416
3417 EXPECT_HRESULT_SUCCEEDED(inline_text_node_raw3->GetPatternProvider(
3418 UIA_TextPatternId, &text_provider));
3419
3420 EXPECT_HRESULT_SUCCEEDED(
3421 text_provider->get_DocumentRange(&text_range_provider));
3422 SetOwner(owner, text_range_provider.Get());
3423
3424 EXPECT_HRESULT_SUCCEEDED(
3425 text_range_provider->GetEnclosingElement(&enclosing_element));
3426 EXPECT_EQ(inline_text_node_raw3.Get(), enclosing_element.Get());
3427
3428
3429
3430 EXPECT_HRESULT_SUCCEEDED(search_text_node_raw->GetPatternProvider(
3431 UIA_TextPatternId, &text_provider));
3432
3433 EXPECT_HRESULT_SUCCEEDED(
3434 text_provider->get_DocumentRange(&text_range_provider));
3435 SetOwner(owner, text_range_provider.Get());
3436
3437 EXPECT_HRESULT_SUCCEEDED(
3438 text_range_provider->ExpandToEnclosingUnit(TextUnit_Character));
3439
3440 EXPECT_HRESULT_SUCCEEDED(
3441 text_range_provider->GetEnclosingElement(&enclosing_element));
3442 EXPECT_EQ(search_box_node_raw.Get(), enclosing_element.Get());
3443
3444
3445
3446 EXPECT_HRESULT_SUCCEEDED(inline_text_node_raw4->GetPatternProvider(
3447 UIA_TextPatternId, &text_provider));
3448
3449 EXPECT_HRESULT_SUCCEEDED(
3450 text_provider->get_DocumentRange(&text_range_provider));
3451 SetOwner(owner, text_range_provider.Get());
3452
3453 EXPECT_HRESULT_SUCCEEDED(
3454 text_range_provider->GetEnclosingElement(&enclosing_element));
3455 EXPECT_EQ(pdf_highlight_node_raw.Get(), enclosing_element.Get());
3456}
3457
3458TEST_F(AXPlatformNodeTextRangeProviderTest,
3459 TestITextRangeProviderGetEnclosingElementRichButton) {
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3479
3482 static_text_1.
id = 3;
3483 inline_text_1.
id = 4;
3486 static_text_2.
id = 7;
3487 inline_text_2.
id = 8;
3488
3490 root.child_ids = {button_1.
id, button_2.
id};
3491
3494
3496 static_text_1.
child_ids.push_back(inline_text_1.
id);
3497
3499
3502
3505
3507 static_text_2.
child_ids.push_back(inline_text_2.
id);
3508
3510
3514 update.tree_data = tree_data;
3515 update.has_tree_data =
true;
3517 update.nodes = {
root, button_1, static_text_1, inline_text_1,
3518 button_2, heading, static_text_2, inline_text_2};
3520
3521
3522 AXNode* button_1_node = GetRootAsAXNode()->children()[0];
3523 AXNode* static_text_1_node = button_1_node->children()[0];
3524 AXNode* inline_text_1_node = static_text_1_node->children()[0];
3525 AXNode* button_2_node = GetRootAsAXNode()->children()[1];
3526 AXNode* heading_node = button_2_node->children()[0];
3527 AXNode* static_text_2_node = heading_node->children()[0];
3528 AXNode* inline_text_2_node = static_text_2_node->children()[0];
3529 AXPlatformNodeWin* owner =
3530 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(button_1_node));
3531 ASSERT_NE(owner, nullptr);
3532
3533 ComPtr<IRawElementProviderSimple> button_1_node_raw =
3534 QueryInterfaceFromNode<IRawElementProviderSimple>(button_1_node);
3535 ComPtr<IRawElementProviderSimple> inline_text_1_node_raw =
3536 QueryInterfaceFromNode<IRawElementProviderSimple>(inline_text_1_node);
3537
3538 ComPtr<IRawElementProviderSimple> button_2_node_raw =
3539 QueryInterfaceFromNode<IRawElementProviderSimple>(button_2_node);
3540 ComPtr<IRawElementProviderSimple> static_text_2_node_raw =
3541 QueryInterfaceFromNode<IRawElementProviderSimple>(static_text_2_node);
3542 ComPtr<IRawElementProviderSimple> inline_text_2_node_raw =
3543 QueryInterfaceFromNode<IRawElementProviderSimple>(inline_text_2_node);
3544
3545
3546
3547
3548 ComPtr<ITextProvider> text_provider;
3549 EXPECT_HRESULT_SUCCEEDED(inline_text_1_node_raw->GetPatternProvider(
3550 UIA_TextPatternId, &text_provider));
3551
3552 ComPtr<ITextRangeProvider> text_range_provider;
3553 EXPECT_HRESULT_SUCCEEDED(
3554 text_provider->get_DocumentRange(&text_range_provider));
3555 SetOwner(owner, text_range_provider.Get());
3556
3557 ComPtr<IRawElementProviderSimple> enclosing_element;
3558 EXPECT_HRESULT_SUCCEEDED(
3559 text_range_provider->GetEnclosingElement(&enclosing_element));
3560 EXPECT_EQ(button_1_node_raw.Get(), enclosing_element.Get());
3561
3562
3563
3564
3565
3566 EXPECT_HRESULT_SUCCEEDED(inline_text_2_node_raw->GetPatternProvider(
3567 UIA_TextPatternId, &text_provider));
3568
3569 EXPECT_HRESULT_SUCCEEDED(
3570 text_provider->get_DocumentRange(&text_range_provider));
3571 SetOwner(owner, text_range_provider.Get());
3572
3573 EXPECT_HRESULT_SUCCEEDED(
3574 text_range_provider->GetEnclosingElement(&enclosing_element));
3575 EXPECT_EQ(button_2_node_raw.Get(), enclosing_element.Get());
3576}
3577
3578TEST_F(AXPlatformNodeTextRangeProviderTest,
3579 TestITextRangeProviderMoveEndpointByRange) {
3580 Init(BuildTextDocument({
"some text",
"more text"}));
3581
3582 AXNode* root_node = GetRootAsAXNode();
3583 AXNode* text_node = root_node->children()[0];
3584 AXNode* more_text_node = root_node->children()[1];
3585 AXPlatformNodeWin* owner =
3586 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(root_node));
3587 ASSERT_NE(owner, nullptr);
3588
3589
3590 ComPtr<IRawElementProviderSimple> root_node_raw =
3591 QueryInterfaceFromNode<IRawElementProviderSimple>(root_node);
3592 ComPtr<ITextProvider> document_provider;
3593 EXPECT_HRESULT_SUCCEEDED(
3594 root_node_raw->GetPatternProvider(UIA_TextPatternId, &document_provider));
3595 ComPtr<ITextRangeProvider> document_text_range_provider;
3596 ComPtr<AXPlatformNodeTextRangeProviderWin> document_text_range;
3597
3598
3599 ComPtr<IRawElementProviderSimple> text_node_raw =
3600 QueryInterfaceFromNode<IRawElementProviderSimple>(text_node);
3601 ComPtr<ITextProvider> text_provider;
3602 EXPECT_HRESULT_SUCCEEDED(
3603 text_node_raw->GetPatternProvider(UIA_TextPatternId, &text_provider));
3604 ComPtr<ITextRangeProvider> text_range_provider;
3605 ComPtr<AXPlatformNodeTextRangeProviderWin> text_range;
3606
3607
3608 ComPtr<IRawElementProviderSimple> more_text_node_raw =
3609 QueryInterfaceFromNode<IRawElementProviderSimple>(more_text_node);
3610 ComPtr<ITextProvider> more_text_provider;
3611 EXPECT_HRESULT_SUCCEEDED(more_text_node_raw->GetPatternProvider(
3612 UIA_TextPatternId, &more_text_provider));
3613 ComPtr<ITextRangeProvider> more_text_range_provider;
3614 ComPtr<AXPlatformNodeTextRangeProviderWin> more_text_range;
3615
3616
3617
3618
3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629
3630
3631 EXPECT_HRESULT_SUCCEEDED(
3632 document_provider->get_DocumentRange(&document_text_range_provider));
3633 SetOwner(owner, document_text_range_provider.Get());
3634
3635 EXPECT_HRESULT_SUCCEEDED(document_text_range_provider->MoveEndpointByRange(
3636 TextPatternRangeEndpoint_Start, document_text_range_provider.Get(),
3637 TextPatternRangeEndpoint_End));
3638
3639 document_text_range_provider->QueryInterface(
3640 IID_PPV_ARGS(&document_text_range));
3641 EXPECT_EQ(*GetStart(document_text_range.Get()),
3642 *GetEnd(document_text_range.Get()));
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659 EXPECT_HRESULT_SUCCEEDED(
3660 document_provider->get_DocumentRange(&document_text_range_provider));
3661 SetOwner(owner, document_text_range_provider.Get());
3662
3663 EXPECT_HRESULT_SUCCEEDED(document_text_range_provider->MoveEndpointByRange(
3664 TextPatternRangeEndpoint_Start, document_text_range_provider.Get(),
3665 TextPatternRangeEndpoint_End));
3666
3667 document_text_range_provider->QueryInterface(
3668 IID_PPV_ARGS(&document_text_range));
3669 EXPECT_EQ(*GetStart(document_text_range.Get()),
3670 *GetEnd(document_text_range.Get()));
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686 EXPECT_HRESULT_SUCCEEDED(
3687 document_provider->get_DocumentRange(&document_text_range_provider));
3688 SetOwner(owner, document_text_range_provider.Get());
3689
3690 EXPECT_HRESULT_SUCCEEDED(
3691 more_text_provider->get_DocumentRange(&more_text_range_provider));
3692 SetOwner(owner, more_text_range_provider.Get());
3693
3694 EXPECT_HRESULT_SUCCEEDED(document_text_range_provider->MoveEndpointByRange(
3695 TextPatternRangeEndpoint_Start, more_text_range_provider.Get(),
3696 TextPatternRangeEndpoint_Start));
3697
3698 document_text_range_provider->QueryInterface(
3699 IID_PPV_ARGS(&document_text_range));
3700 more_text_range_provider->QueryInterface(IID_PPV_ARGS(&more_text_range));
3701 EXPECT_EQ(*GetStart(document_text_range.Get()),
3702 *GetStart(more_text_range.Get()));
3703
3704
3705
3706
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716
3717
3718 EXPECT_HRESULT_SUCCEEDED(
3719 document_provider->get_DocumentRange(&document_text_range_provider));
3720 SetOwner(owner, document_text_range_provider.Get());
3721
3722 EXPECT_HRESULT_SUCCEEDED(
3723 text_provider->get_DocumentRange(&text_range_provider));
3724 SetOwner(owner, text_range_provider.Get());
3725
3726 EXPECT_HRESULT_SUCCEEDED(document_text_range_provider->MoveEndpointByRange(
3727 TextPatternRangeEndpoint_End, text_range_provider.Get(),
3728 TextPatternRangeEndpoint_End));
3729
3730 document_text_range_provider->QueryInterface(
3731 IID_PPV_ARGS(&document_text_range));
3732 text_range_provider->QueryInterface(IID_PPV_ARGS(&text_range));
3733 EXPECT_EQ(*GetEnd(document_text_range.Get()), *GetEnd(text_range.Get()));
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749 EXPECT_HRESULT_SUCCEEDED(
3750 text_provider->get_DocumentRange(&text_range_provider));
3751 SetOwner(owner, document_text_range_provider.Get());
3752
3753 EXPECT_HRESULT_SUCCEEDED(
3754 more_text_provider->get_DocumentRange(&more_text_range_provider));
3755 SetOwner(owner, more_text_range_provider.Get());
3756
3757 EXPECT_HRESULT_SUCCEEDED(more_text_range_provider->MoveEndpointByRange(
3758 TextPatternRangeEndpoint_End, text_range_provider.Get(),
3759 TextPatternRangeEndpoint_Start));
3760
3761 text_range_provider->QueryInterface(IID_PPV_ARGS(&text_range));
3762 more_text_range_provider->QueryInterface(IID_PPV_ARGS(&more_text_range));
3763 EXPECT_EQ(*GetEnd(more_text_range.Get()), *GetStart(text_range.Get()));
3764 EXPECT_EQ(*GetStart(more_text_range.Get()), *GetStart(text_range.Get()));
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
3777
3778
3779
3780 EXPECT_HRESULT_SUCCEEDED(
3781 text_provider->get_DocumentRange(&text_range_provider));
3782 SetOwner(owner, text_range_provider.Get());
3783
3784 EXPECT_HRESULT_SUCCEEDED(
3785 more_text_provider->get_DocumentRange(&more_text_range_provider));
3786 SetOwner(owner, more_text_range_provider.Get());
3787
3788 EXPECT_HRESULT_SUCCEEDED(text_range_provider->MoveEndpointByRange(
3789 TextPatternRangeEndpoint_Start, more_text_range_provider.Get(),
3790 TextPatternRangeEndpoint_End));
3791
3792 text_range_provider->QueryInterface(IID_PPV_ARGS(&text_range));
3793 more_text_range_provider->QueryInterface(IID_PPV_ARGS(&more_text_range));
3794 EXPECT_EQ(*GetStart(text_range.Get()), *GetEnd(more_text_range.Get()));
3795 EXPECT_EQ(*GetEnd(text_range.Get()), *GetEnd(more_text_range.Get()));
3796}
3797
3798
3799TEST_F(AXPlatformNodeTextRangeProviderTest,
3800 DISABLED_TestITextRangeProviderGetAttributeValue) {
3809 2);
3812 0xFFADBEEFU);
3824 {0, 5, 0, 14, 19});
3826 {9, 9, 4, 18, 24});
3827 text_data.
SetName(
"some text and some other text");
3828
3830 heading_data.
id = 3;
3834 0xFFADBEEFU);
3840
3842 heading_text_data.
id = 4;
3846 0xFFADBEEFU);
3848 0xFFADC0DEU);
3860 heading_text_data.
SetName(
"more text");
3861
3866 0xFFADBEEFU);
3870
3872 mark_text_data.
id = 6;
3875 0xFFADBEEFU);
3879 mark_text_data.
SetName(
"marked text");
3880
3886 0xFFADBEEFU);
3888
3890 list_item_data.
id = 8;
3897 0xFFADBEEFU);
3899
3901 list_item_text_data.
id = 9;
3904 0xFFADBEEFU);
3906 0xFFADC0DEU);
3907 list_item_text_data.
SetName(
"list item");
3908
3910 list_item2_data.
id = 10;
3917 0xFFADBEEFU);
3919
3921 list_item2_text_data.
id = 11;
3926 0xFFADC0DEU);
3927 list_item2_text_data.
SetName(
"list item 2");
3928
3930 input_text_data.
id = 12;
3937 "placeholder2");
3939 0xFFADBEEFU);
3942 "input");
3944 "text");
3945 input_text_data.
SetName(
"placeholder");
3947
3949 placeholder_text_data.
id = 13;
3954 0xFFADC0DEU);
3955 placeholder_text_data.
SetName(
"placeholder");
3956
3958 input_text_data2.
id = 14;
3963 "placeholder2");
3965 0xFFADBEEFU);
3967 0xFFADC0DEU);
3969 "input");
3971 "text");
3972 input_text_data2.
SetName(
"foo");
3974
3976 placeholder_text_data2.
id = 15;
3981 0xFFADC0DEU);
3982 placeholder_text_data2.
SetName(
"placeholder2");
3983
3988 0xFFADBEEFU);
3990
3992 link_text_data.
id = 17;
3995 0xFFADBEEFU);
3998
4002 root_data.
child_ids = {2, 3, 5, 7, 12, 14, 16};
4003
4007 update.tree_data = tree_data;
4008 update.has_tree_data =
true;
4010 update.nodes.push_back(root_data);
4011 update.nodes.push_back(text_data);
4012 update.nodes.push_back(heading_data);
4013 update.nodes.push_back(heading_text_data);
4014 update.nodes.push_back(mark_data);
4015 update.nodes.push_back(mark_text_data);
4016 update.nodes.push_back(list_data);
4017 update.nodes.push_back(list_item_data);
4018 update.nodes.push_back(list_item_text_data);
4019 update.nodes.push_back(list_item2_data);
4020 update.nodes.push_back(list_item2_text_data);
4021 update.nodes.push_back(input_text_data);
4022 update.nodes.push_back(placeholder_text_data);
4023 update.nodes.push_back(input_text_data2);
4024 update.nodes.push_back(placeholder_text_data2);
4025 update.nodes.push_back(link_data);
4026 update.nodes.push_back(link_text_data);
4027
4029
4030 AXNode* root_node = GetRootAsAXNode();
4031 AXNode* text_node = root_node->children()[0];
4032 AXNode* heading_node = root_node->children()[1];
4033 AXNode* heading_text_node = heading_node->children()[0];
4034 AXNode* mark_node = root_node->children()[2];
4035 AXNode* mark_text_node = mark_node->children()[0];
4036 AXNode* list_node = root_node->children()[3];
4037 AXNode* list_item_node = list_node->children()[0];
4038 AXNode* list_item_text_node = list_item_node->children()[0];
4039 AXNode* list_item2_node = list_node->children()[1];
4040 AXNode* list_item2_text_node = list_item2_node->children()[0];
4041 AXNode* input_text_node = root_node->children()[4];
4042 AXNode* placeholder_text_node = input_text_node->children()[0];
4043 AXNode* input_text_node2 = root_node->children()[5];
4044 AXNode* placeholder_text_node2 = input_text_node2->children()[0];
4045 AXNode* link_node = root_node->children()[6];
4046 AXNode* link_text_node = link_node->children()[0];
4047
4048 ComPtr<ITextRangeProvider> document_range_provider;
4049 GetTextRangeProviderFromTextNode(document_range_provider, root_node);
4050 ComPtr<ITextRangeProvider> text_range_provider;
4051 GetTextRangeProviderFromTextNode(text_range_provider, text_node);
4052 ComPtr<ITextRangeProvider> heading_text_range_provider;
4053 GetTextRangeProviderFromTextNode(heading_text_range_provider,
4054 heading_text_node);
4055 ComPtr<ITextRangeProvider> mark_text_range_provider;
4056 GetTextRangeProviderFromTextNode(mark_text_range_provider, mark_text_node);
4057 ComPtr<ITextRangeProvider> list_item_text_range_provider;
4058 GetTextRangeProviderFromTextNode(list_item_text_range_provider,
4059 list_item_text_node);
4060 ComPtr<ITextRangeProvider> list_item2_text_range_provider;
4061 GetTextRangeProviderFromTextNode(list_item2_text_range_provider,
4062 list_item2_text_node);
4063
4064 ComPtr<ITextRangeProvider> placeholder_text_range_provider;
4065 GetTextRangeProviderFromTextNode(placeholder_text_range_provider,
4066 placeholder_text_node);
4067
4068 ComPtr<ITextRangeProvider> placeholder_text_range_provider2;
4069 GetTextRangeProviderFromTextNode(placeholder_text_range_provider2,
4070 placeholder_text_node2);
4071
4072 ComPtr<ITextRangeProvider> link_text_range_provider;
4073 GetTextRangeProviderFromTextNode(link_text_range_provider, link_text_node);
4074
4076
4077
4078 expected_variant.
Set(
static_cast<int32_t
>(0x00EFBEADU));
4080 UIA_BackgroundColorAttributeId, expected_variant);
4081
4082
4084 UIA_BackgroundColorAttributeId, expected_variant);
4085 expected_variant.
Reset();
4086
4087 expected_variant.
Set(
static_cast<int32_t
>(BulletStyle::BulletStyle_None));
4089 UIA_BulletStyleAttributeId, expected_variant);
4090 expected_variant.
Reset();
4091
4092 expected_variant.
Set(
4093 static_cast<int32_t>(BulletStyle::BulletStyle_FilledRoundBullet));
4095 UIA_BulletStyleAttributeId, expected_variant);
4096 expected_variant.
Reset();
4097
4098 {
4100 EXPECT_HRESULT_SUCCEEDED(text_range_provider->GetAttributeValue(
4101 UIA_CultureAttributeId, lang_variant.
Receive()));
4102
4103 EXPECT_EQ(lang_variant.
type(), VT_I4);
4104 const LCID lcid = V_I4(lang_variant.
ptr());
4105 EXPECT_EQ(LANG_FRENCH, PRIMARYLANGID(lcid));
4106 EXPECT_EQ(SUBLANG_FRENCH_CANADIAN, SUBLANGID(lcid));
4107 EXPECT_EQ(SORT_DEFAULT, SORTIDFROMLCID(lcid));
4108 }
4109
4110 std::wstring font_name =
L"sans";
4111 expected_variant.
Set(SysAllocString(font_name.c_str()));
4113 expected_variant);
4114 expected_variant.
Reset();
4115
4116 expected_variant.
Set(12.0);
4118 expected_variant);
4119 expected_variant.
Reset();
4120
4121 expected_variant.
Set(300);
4123 expected_variant);
4124 expected_variant.
Reset();
4125
4126
4127 expected_variant.
Set(
static_cast<int32_t
>(0x00DEC0ADU));
4129 UIA_ForegroundColorAttributeId, expected_variant);
4131 UIA_ForegroundColorAttributeId, expected_variant);
4132 expected_variant.
Reset();
4133
4134 expected_variant.
Set(
false);
4136 expected_variant);
4137 expected_variant.
Reset();
4138
4140 UIA_IsHiddenAttributeId);
4141
4142 expected_variant.
Set(
true);
4144 expected_variant);
4145 expected_variant.
Reset();
4146
4147 expected_variant.
Set(
false);
4149 UIA_IsItalicAttributeId, expected_variant);
4150 expected_variant.
Reset();
4151
4152 expected_variant.
Set(
true);
4154 expected_variant);
4155 expected_variant.
Reset();
4156
4157 expected_variant.
Set(
false);
4159 UIA_IsReadOnlyAttributeId, expected_variant);
4160 expected_variant.
Reset();
4161
4162 expected_variant.
Set(
false);
4164 UIA_IsReadOnlyAttributeId, expected_variant);
4165 expected_variant.
Reset();
4166
4167 expected_variant.
Set(
true);
4169 UIA_IsReadOnlyAttributeId, expected_variant);
4170 expected_variant.
Reset();
4171
4172 expected_variant.
Set(
true);
4174 UIA_IsReadOnlyAttributeId, expected_variant);
4175 expected_variant.
Reset();
4176
4177 expected_variant.
Set(HorizontalTextAlignment_Centered);
4179 UIA_HorizontalTextAlignmentAttributeId,
4180 expected_variant);
4181 expected_variant.
Reset();
4182
4183 expected_variant.
Set(HorizontalTextAlignment_Justified);
4185 UIA_HorizontalTextAlignmentAttributeId,
4186 expected_variant);
4187 expected_variant.
Reset();
4188
4189 expected_variant.
Set(
true);
4191 expected_variant);
4192 expected_variant.
Reset();
4193
4194 expected_variant.
Set(
false);
4196 UIA_IsSubscriptAttributeId, expected_variant);
4197 expected_variant.
Reset();
4198
4199 expected_variant.
Set(
false);
4201 expected_variant);
4202 expected_variant.
Reset();
4203
4204 expected_variant.
Set(
true);
4206 UIA_IsSuperscriptAttributeId, expected_variant);
4207 expected_variant.
Reset();
4208
4209 expected_variant.
Set(TextDecorationLineStyle::TextDecorationLineStyle_Dot);
4211 expected_variant);
4212 expected_variant.
Reset();
4213
4214 expected_variant.
Set(TextDecorationLineStyle::TextDecorationLineStyle_Dash);
4216 text_range_provider, UIA_StrikethroughStyleAttributeId, expected_variant);
4217 expected_variant.
Reset();
4218
4219 expected_variant.
Set(TextDecorationLineStyle::TextDecorationLineStyle_Single);
4221 UIA_UnderlineStyleAttributeId, expected_variant);
4222 expected_variant.
Reset();
4223
4224 std::wstring style_name;
4225 expected_variant.
Set(SysAllocString(style_name.c_str()));
4227 expected_variant);
4228 expected_variant.
Reset();
4229
4230 expected_variant.
Set(
static_cast<int32_t
>(StyleId_Heading6));
4232 UIA_StyleIdAttributeId, expected_variant);
4233 expected_variant.
Reset();
4234
4235 style_name =
L"mark";
4236 expected_variant.
Set(SysAllocString(style_name.c_str()));
4238 UIA_StyleNameAttributeId, expected_variant);
4239 expected_variant.
Reset();
4240
4241 expected_variant.
Set(
static_cast<int32_t
>(StyleId_NumberedList));
4243 UIA_StyleIdAttributeId, expected_variant);
4244 expected_variant.
Reset();
4245
4246 expected_variant.
Set(
static_cast<int32_t
>(StyleId_BulletedList));
4248 UIA_StyleIdAttributeId, expected_variant);
4249 expected_variant.
Reset();
4250
4251 expected_variant.
Set(
4252 static_cast<int32_t>(FlowDirections::FlowDirections_RightToLeft));
4254 text_range_provider, UIA_TextFlowDirectionsAttributeId, expected_variant);
4256 UIA_TextFlowDirectionsAttributeId);
4257 expected_variant.
Reset();
4258
4259
4260
4261
4263 TextPatternRangeEndpoint_Start,
4264 TextUnit_Character,
4265 -1,
4266 L"tmarked text",
4267 -1);
4269 TextPatternRangeEndpoint_Start,
4270 TextUnit_Character,
4271 1,
4272 L"marked text",
4273 1);
4274 expected_variant.
Set(
false);
4276 UIA_IsSuperscriptAttributeId, expected_variant);
4277 expected_variant.
Reset();
4278
4279
4280
4282 TextPatternRangeEndpoint_End,
4283 TextUnit_Character,
4284 1,
4285 L"marked textl",
4286 1);
4288 TextPatternRangeEndpoint_End,
4289 TextUnit_Character,
4290 -1,
4291 L"marked text",
4292 -1);
4293 expected_variant.
Set(
4294 static_cast<int32_t>(FlowDirections::FlowDirections_RightToLeft));
4296 UIA_TextFlowDirectionsAttributeId,
4297 expected_variant);
4298 expected_variant.
Reset();
4299
4300 {
4301
4302
4303
4304
4306 UIA_AnnotationTypesAttributeId);
4307
4308
4309
4310
4311
4312
4313 AXPlatformNodeWin* owner =
4314 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(text_node));
4315 ComPtr<AXPlatformNodeTextRangeProviderWin> range_with_annotations;
4316 CreateTextRangeProviderWin(
4317 range_with_annotations, owner,
4318 text_node, 5,
4320 text_node, 9,
4322
4324 EXPECT_HRESULT_SUCCEEDED(range_with_annotations->GetAttributeValue(
4325 UIA_AnnotationTypesAttributeId, annotation_types_variant.
Receive()));
4326
4327 EXPECT_EQ(annotation_types_variant.
type(), VT_ARRAY | VT_I4);
4328 std::vector<int> expected_annotations = {AnnotationType_SpellingError,
4329 AnnotationType_GrammarError};
4331 expected_annotations);
4332 }
4333
4334 {
4335
4336
4337
4338
4339
4340 AXPlatformNodeWin* owner =
4341 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(text_node));
4342 ComPtr<AXPlatformNodeTextRangeProviderWin> range_with_annotations;
4343 CreateTextRangeProviderWin(
4344 range_with_annotations, owner,
4345 text_node, 0,
4347 text_node, 4,
4349
4351 EXPECT_HRESULT_SUCCEEDED(range_with_annotations->GetAttributeValue(
4352 UIA_AnnotationTypesAttributeId, annotation_types_variant.
Receive()));
4353
4354 EXPECT_EQ(annotation_types_variant.
type(), VT_ARRAY | VT_I4);
4355 std::vector<int> expected_annotations = {AnnotationType_GrammarError,
4356 AnnotationType_Highlighted};
4358 expected_annotations);
4359 }
4360
4361 {
4362
4363
4364
4365
4366
4367 AXPlatformNodeWin* owner =
4368 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(text_node));
4369 ComPtr<AXPlatformNodeTextRangeProviderWin> range_with_annotations;
4370 CreateTextRangeProviderWin(
4371 range_with_annotations, owner,
4372 text_node, 14,
4374 text_node, 18,
4376
4378 EXPECT_HRESULT_SUCCEEDED(range_with_annotations->GetAttributeValue(
4379 UIA_AnnotationTypesAttributeId, annotation_types_variant.
Receive()));
4380
4381 EXPECT_EQ(annotation_types_variant.
type(), VT_ARRAY | VT_I4);
4382 std::vector<int> expected_annotations = {AnnotationType_SpellingError};
4384 expected_annotations);
4385 }
4386
4387 {
4388
4389
4390
4391
4392
4393 AXPlatformNodeWin* owner =
4394 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(text_node));
4395 ComPtr<AXPlatformNodeTextRangeProviderWin> range_with_annotations;
4396 CreateTextRangeProviderWin(
4397 range_with_annotations, owner,
4398 text_node, 19,
4400 text_node, 24,
4402
4404 EXPECT_HRESULT_SUCCEEDED(range_with_annotations->GetAttributeValue(
4405 UIA_AnnotationTypesAttributeId, annotation_types_variant.
Receive()));
4406
4407 EXPECT_EQ(annotation_types_variant.
type(), VT_ARRAY | VT_I4);
4408 std::vector<int> expected_annotations = {AnnotationType_GrammarError};
4410 expected_annotations);
4411 }
4412
4413 {
4414
4415
4417 UIA_AnnotationTypesAttributeId);
4418
4419
4420
4421
4422
4423 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
4424 AXPlatformNodeFromNode(heading_text_node));
4425 ComPtr<AXPlatformNodeTextRangeProviderWin> range_with_annotations;
4426 CreateTextRangeProviderWin(
4427 range_with_annotations, owner,
4428 heading_text_node, 5,
4430 heading_text_node, 9,
4432
4434 EXPECT_HRESULT_SUCCEEDED(range_with_annotations->GetAttributeValue(
4435 UIA_AnnotationTypesAttributeId, annotation_types_variant.
Receive()));
4436
4437 std::vector<int> expected_annotations = {AnnotationType_SpellingError};
4439 expected_annotations);
4440 }
4441
4442 {
4445 UIA_AnnotationTypesAttributeId, empty_variant);
4446 }
4447}
4448
4449TEST_F(AXPlatformNodeTextRangeProviderTest,
4450 DISABLED_TestITextRangeProviderGetAttributeValueAnnotationObjects) {
4451
4452
4453
4454
4455
4456
4457
4458
4459
4460
4462 AXNodeData annotation_target;
4463 AXNodeData some_text;
4464 AXNodeData comment1;
4465 AXNodeData comment1_text;
4466 AXNodeData comment2;
4467 AXNodeData comment2_text;
4468 AXNodeData highlighted;
4469 AXNodeData highlighted_text;
4470
4472 annotation_target.id = 2;
4473 some_text.id = 3;
4474 comment1.id = 4;
4475 comment1_text.id = 5;
4476 comment2.id = 6;
4477 comment2_text.id = 7;
4478 highlighted.id = 8;
4479 highlighted_text.id = 9;
4480
4482 root.SetName(
"root");
4483 root.child_ids = {annotation_target.id, comment1.id, comment2.id,
4484 highlighted.id};
4485
4487 annotation_target.child_ids = {some_text.id};
4488 annotation_target.AddIntListAttribute(
4490 {comment1.id, comment2.id, highlighted.id});
4491
4493 some_text.SetName("some text");
4494
4496 comment1.SetName("comment 1");
4497 comment1.child_ids = {comment1_text.id};
4498
4500 comment1_text.SetName("comment 1");
4501
4503 comment2.SetName("comment 2");
4504 comment2.child_ids = {comment2_text.id};
4505
4507 comment2_text.SetName("comment 2");
4508
4510 highlighted.SetName("highlighted");
4511 highlighted.child_ids = {highlighted_text.id};
4512
4514 highlighted_text.SetName("highlighted");
4515
4517 update.has_tree_data =
true;
4519 update.nodes = {
root, annotation_target, some_text,
4520 comment1, comment1_text, comment2,
4521 comment2_text, highlighted, highlighted_text};
4523
4525
4526 AXNode* root_node = GetRootAsAXNode();
4527 AXNode* annotation_target_node = root_node->children()[0];
4528 AXNode* comment1_node = root_node->children()[1];
4529 AXNode* comment2_node = root_node->children()[2];
4530 AXNode* highlighted_node = root_node->children()[3];
4531
4532 ComPtr<AXPlatformNodeTextRangeProviderWin> some_text_range_provider;
4533
4534
4535
4536
4537
4538 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
4539 AXPlatformNodeFromNode(annotation_target_node));
4540 CreateTextRangeProviderWin(
4541 some_text_range_provider, owner,
4542 annotation_target_node, 0,
4544 annotation_target_node, 9,
4546 ASSERT_NE(nullptr, some_text_range_provider.Get());
4548
4549 ComPtr<IRawElementProviderSimple> comment1_provider =
4550 QueryInterfaceFromNode<IRawElementProviderSimple>(comment1_node);
4551 ASSERT_NE(nullptr, comment1_provider.Get());
4552 ComPtr<IRawElementProviderSimple> comment2_provider =
4553 QueryInterfaceFromNode<IRawElementProviderSimple>(comment2_node);
4554 ASSERT_NE(nullptr, comment2_provider.Get());
4555 ComPtr<IRawElementProviderSimple> highlighted_provider =
4556 QueryInterfaceFromNode<IRawElementProviderSimple>(highlighted_node);
4557 ASSERT_NE(nullptr, highlighted_provider.Get());
4558
4559 ComPtr<IAnnotationProvider> annotation_provider;
4560 int annotation_type;
4561
4562
4563 EXPECT_HRESULT_SUCCEEDED(comment1_provider->GetPatternProvider(
4564 UIA_AnnotationPatternId, &annotation_provider));
4565 ASSERT_NE(nullptr, annotation_provider.Get());
4566 EXPECT_HRESULT_SUCCEEDED(
4567 annotation_provider->get_AnnotationTypeId(&annotation_type));
4568 EXPECT_EQ(AnnotationType_Comment, annotation_type);
4569 annotation_provider.Reset();
4570
4571
4572 EXPECT_HRESULT_SUCCEEDED(comment2_provider->GetPatternProvider(
4573 UIA_AnnotationPatternId, &annotation_provider));
4574 ASSERT_NE(nullptr, annotation_provider.Get());
4575 EXPECT_HRESULT_SUCCEEDED(
4576 annotation_provider->get_AnnotationTypeId(&annotation_type));
4577 EXPECT_EQ(AnnotationType_Comment, annotation_type);
4578 annotation_provider.Reset();
4579
4580
4581
4582 EXPECT_HRESULT_SUCCEEDED(highlighted_provider->GetPatternProvider(
4583 UIA_AnnotationPatternId, &annotation_provider));
4584 ASSERT_NE(nullptr, annotation_provider.Get());
4585 EXPECT_HRESULT_SUCCEEDED(
4586 annotation_provider->get_AnnotationTypeId(&annotation_type));
4587 EXPECT_EQ(AnnotationType_Highlighted, annotation_type);
4588 annotation_provider.Reset();
4589
4591 EXPECT_HRESULT_SUCCEEDED(some_text_range_provider->GetAttributeValue(
4592 UIA_AnnotationObjectsAttributeId, annotation_objects_variant.
Receive()));
4593 EXPECT_EQ(VT_UNKNOWN | VT_ARRAY, annotation_objects_variant.
type());
4594
4595 std::vector<std::wstring> expected_names = {
L"comment 1",
L"comment 2",
4598 UIA_NamePropertyId, expected_names);
4599}
4600
4601TEST_F(AXPlatformNodeTextRangeProviderTest,
4602 DISABLED_TestITextRangeProviderGetAttributeValueAnnotationObjectsMixed) {
4603
4604
4605
4606
4607
4608
4609
4611 AXNodeData highlighted;
4612 AXNodeData some_text;
4613 AXNodeData readonly_text;
4614 AXNodeData comment1;
4615 AXNodeData comment1_text;
4616
4618 highlighted.id = 2;
4619 some_text.id = 3;
4620 readonly_text.id = 4;
4621 comment1.id = 5;
4622 comment1_text.id = 6;
4623
4625 root.SetName(
"root");
4626 root.child_ids = {highlighted.id, readonly_text.id, comment1.id};
4627
4629 highlighted.child_ids = {some_text.id};
4631 {comment1.id});
4632
4634 some_text.SetName("some text");
4635
4638 readonly_text.SetName("read only");
4639
4641 comment1.SetName("comment 1");
4642 comment1.child_ids = {comment1_text.id};
4643
4645 comment1_text.SetName("comment 1");
4646
4648 update.has_tree_data =
true;
4650 update.nodes = {
root, highlighted, some_text,
4651 readonly_text, comment1, comment1_text};
4653
4655
4656 AXNode* root_node = GetRootAsAXNode();
4657 AXNode* highlighted_node = root_node->children()[0];
4658 AXNode* some_text_node = highlighted_node->children()[0];
4659 AXNode* readonly_text_node = root_node->children()[1];
4660 AXNode* comment1_node = root_node->children()[2];
4661
4662
4663
4664
4665
4666 ComPtr<AXPlatformNodeTextRangeProviderWin> some_text_range_provider;
4667 AXPlatformNodeWin* owner =
4668 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(highlighted_node));
4669 CreateTextRangeProviderWin(
4670 some_text_range_provider, owner,
4671 highlighted_node, 0,
4673 highlighted_node, 9,
4675 ASSERT_NE(nullptr, some_text_range_provider.Get());
4677
4678 ComPtr<ITextRangeProvider> readonly_text_range_provider;
4679 GetTextRangeProviderFromTextNode(readonly_text_range_provider,
4680 readonly_text_node);
4681 ASSERT_NE(nullptr, readonly_text_range_provider.Get());
4682
4683 ComPtr<IRawElementProviderSimple> comment1_provider =
4684 QueryInterfaceFromNode<IRawElementProviderSimple>(comment1_node);
4685 ASSERT_NE(nullptr, comment1_provider.Get());
4686
4687 ComPtr<IAnnotationProvider> annotation_provider;
4688 int annotation_type;
4690
4691
4692 EXPECT_HRESULT_SUCCEEDED(comment1_provider->GetPatternProvider(
4693 UIA_AnnotationPatternId, &annotation_provider));
4694 ASSERT_NE(nullptr, annotation_provider.Get());
4695 EXPECT_HRESULT_SUCCEEDED(
4696 annotation_provider->get_AnnotationTypeId(&annotation_type));
4697 EXPECT_EQ(AnnotationType_Comment, annotation_type);
4698 annotation_provider.Reset();
4699
4700
4701 EXPECT_HRESULT_SUCCEEDED(some_text_range_provider->GetAttributeValue(
4702 UIA_AnnotationObjectsAttributeId, expected_variant.
Receive()));
4703 EXPECT_EQ(VT_UNKNOWN | VT_ARRAY, expected_variant.
type());
4704
4705 std::vector<std::wstring> expected_names = {
L"comment 1"};
4707 UIA_NamePropertyId, expected_names);
4708 expected_variant.
Reset();
4709
4710
4711
4712
4713 expected_variant.
Set(
true);
4715 UIA_IsReadOnlyAttributeId, expected_variant);
4716
4717
4718
4719
4720 ComPtr<AXPlatformNodeTextRangeProviderWin> mixed_text_range_provider;
4721 CreateTextRangeProviderWin(
4722 mixed_text_range_provider, owner,
4723 some_text_node, 0,
4725 readonly_text_node, 9,
4727
4730 UIA_AnnotationObjectsAttributeId);
4731}
4732
4733TEST_F(AXPlatformNodeTextRangeProviderTest,
4734 TestITextRangeProviderGetAttributeValueNotSupported) {
4738
4740 text_data_first.
id = 2;
4742 text_data_first.
SetName(
"first");
4743 root_data.
child_ids.push_back(text_data_first.
id);
4744
4746 text_data_second.
id = 3;
4748 text_data_second.
SetName(
"second");
4749 root_data.
child_ids.push_back(text_data_second.
id);
4750
4754 update.tree_data = tree_data;
4755 update.has_tree_data =
true;
4757 update.nodes.push_back(root_data);
4758 update.nodes.push_back(text_data_first);
4759 update.nodes.push_back(text_data_second);
4760
4762
4763 ComPtr<ITextRangeProvider> document_range_provider;
4764 GetTextRangeProviderFromTextNode(document_range_provider, GetRootAsAXNode());
4765
4767 UIA_AfterParagraphSpacingAttributeId);
4769 UIA_AnimationStyleAttributeId);
4771 UIA_BeforeParagraphSpacingAttributeId);
4773 UIA_CapStyleAttributeId);
4775 UIA_CaretBidiModeAttributeId);
4777 UIA_CaretPositionAttributeId);
4779 UIA_IndentationFirstLineAttributeId);
4781 UIA_IndentationLeadingAttributeId);
4783 UIA_IndentationTrailingAttributeId);
4785 UIA_IsActiveAttributeId);
4787 UIA_LineSpacingAttributeId);
4789 UIA_LinkAttributeId);
4791 UIA_MarginBottomAttributeId);
4793 UIA_MarginLeadingAttributeId);
4795 UIA_MarginTopAttributeId);
4797 UIA_MarginTrailingAttributeId);
4799 UIA_OutlineStylesAttributeId);
4801 UIA_OverlineColorAttributeId);
4803 UIA_SelectionActiveEndAttributeId);
4805 UIA_StrikethroughColorAttributeId);
4807 UIA_TabsAttributeId);
4809 UIA_UnderlineColorAttributeId);
4810}
4811
4812TEST_F(AXPlatformNodeTextRangeProviderTest,
4813 TestITextRangeProviderGetAttributeValueWithAncestorTextPosition) {
4819 initial_state.
nodes.resize(5);
4820 initial_state.
nodes[0].id = 1;
4821 initial_state.
nodes[0].child_ids = {2};
4823 initial_state.
nodes[1].id = 2;
4824 initial_state.
nodes[1].child_ids = {3};
4826 initial_state.
nodes[2].id = 3;
4827 initial_state.
nodes[2].child_ids = {4, 5};
4829 initial_state.
nodes[3].id = 4;
4831 initial_state.
nodes[3].SetName(
"some text");
4832 initial_state.
nodes[3].AddIntAttribute(
4834 initial_state.
nodes[4].id = 5;
4836 initial_state.
nodes[4].SetName(
"more text");
4837 initial_state.
nodes[4].AddIntAttribute(
4839
4840 Init(initial_state);
4841 const AXTree* tree = GetTree();
4842 const AXNode* some_text_node = tree->GetFromId(4);
4843 const AXNode* more_text_node = tree->GetFromId(5);
4844
4845
4846
4847 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
4848 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 2)));
4849
4850
4851
4852
4853 ComPtr<AXPlatformNodeTextRangeProviderWin> text_range_provider_win;
4854 CreateTextRangeProviderWin(
4855 text_range_provider_win, owner,
4856 some_text_node, 0,
4858 more_text_node, 8,
4860
4861 ASSERT_TRUE(GetStart(text_range_provider_win.Get())->IsTextPosition());
4862 ASSERT_EQ(4, GetStart(text_range_provider_win.Get())->anchor_id());
4863 ASSERT_EQ(0, GetStart(text_range_provider_win.Get())->text_offset());
4864 ASSERT_TRUE(GetEnd(text_range_provider_win.Get())->IsTextPosition());
4865 ASSERT_EQ(5, GetEnd(text_range_provider_win.Get())->anchor_id());
4866 ASSERT_EQ(8, GetEnd(text_range_provider_win.Get())->text_offset());
4867
4869
4870 expected_variant.
Set(
static_cast<int32_t
>(0x00EFBEADU));
4872 UIA_BackgroundColorAttributeId, expected_variant);
4873}
4874
4875TEST_F(AXPlatformNodeTextRangeProviderTest, TestITextRangeProviderSelect) {
4876 Init(BuildTextDocument({
"some text",
"more text2"}));
4877 AXNode* root_node = GetRootAsAXNode();
4878
4879
4880 ComPtr<IRawElementProviderSimple> root_node_raw =
4881 QueryInterfaceFromNode<IRawElementProviderSimple>(root_node);
4882 ComPtr<ITextProvider> document_provider;
4883 ComPtr<ITextRangeProvider> document_text_range_provider;
4884 ComPtr<AXPlatformNodeTextRangeProviderWin> document_text_range;
4885 EXPECT_HRESULT_SUCCEEDED(
4886 root_node_raw->GetPatternProvider(UIA_TextPatternId, &document_provider));
4887 EXPECT_HRESULT_SUCCEEDED(
4888 document_provider->get_DocumentRange(&document_text_range_provider));
4889 document_text_range_provider->QueryInterface(
4890 IID_PPV_ARGS(&document_text_range));
4891 AXPlatformNodeWin* owner_platform =
4892 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(root_node));
4893 ASSERT_NE(owner_platform, nullptr);
4894 SetOwner(owner_platform, document_text_range_provider.Get());
4895
4896
4897 ComPtr<ITextRangeProvider> text_range_provider;
4898 GetTextRangeProviderFromTextNode(text_range_provider,
4899 root_node->children()[0]);
4900 ComPtr<AXPlatformNodeTextRangeProviderWin> text_range;
4901 EXPECT_HRESULT_SUCCEEDED(
4902 text_range_provider->QueryInterface(IID_PPV_ARGS(&text_range)));
4903
4904
4905 ComPtr<ITextRangeProvider> more_text_range_provider;
4906 GetTextRangeProviderFromTextNode(more_text_range_provider,
4907 root_node->children()[1]);
4908 SetOwner(owner_platform, more_text_range_provider.Get());
4909 ComPtr<AXPlatformNodeTextRangeProviderWin> more_text_range;
4910 more_text_range_provider->QueryInterface(IID_PPV_ARGS(&more_text_range));
4911
4912 AXPlatformNodeDelegate* delegate =
4913 GetOwner(document_text_range.Get())->GetDelegate();
4914
4915 ComPtr<ITextRangeProvider> selected_text_range_provider;
4920
4921
4922 {
4923 text_range_provider->Select();
4924
4925
4926 AXTree::Selection unignored_selection = delegate->GetUnignoredSelection();
4927 EXPECT_EQ(3, unignored_selection.anchor_object_id);
4928 EXPECT_EQ(3, unignored_selection.focus_object_id);
4929 EXPECT_EQ(0, unignored_selection.anchor_offset);
4930 EXPECT_EQ(9, unignored_selection.focus_offset);
4931
4932
4933 document_provider->GetSelection(selection.
Receive());
4934 ASSERT_NE(
nullptr, selection.
Get());
4935
4936 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetUBound(selection.
Get(), 1, &ubound));
4937 EXPECT_EQ(0, ubound);
4938 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetLBound(selection.
Get(), 1, &lbound));
4939 EXPECT_EQ(0, lbound);
4940 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetElement(
4941 selection.
Get(), &index,
4942 static_cast<void**>(&selected_text_range_provider)));
4943 SetOwner(owner_platform, selected_text_range_provider.Get());
4945
4946 selected_text_range_provider.Reset();
4948 }
4949
4950
4951 {
4952 more_text_range_provider->Select();
4953
4954
4955 AXTree::Selection unignored_selection = delegate->GetUnignoredSelection();
4956 EXPECT_EQ(5, unignored_selection.anchor_object_id);
4957 EXPECT_EQ(5, unignored_selection.focus_object_id);
4958 EXPECT_EQ(0, unignored_selection.anchor_offset);
4959 EXPECT_EQ(10, unignored_selection.focus_offset);
4960
4961
4962 document_provider->GetSelection(selection.
Receive());
4963 ASSERT_NE(
nullptr, selection.
Get());
4964
4965 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetUBound(selection.
Get(), 1, &ubound));
4966 EXPECT_EQ(0, ubound);
4967 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetLBound(selection.
Get(), 1, &lbound));
4968 EXPECT_EQ(0, lbound);
4969 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetElement(
4970 selection.
Get(), &index,
4971 static_cast<void**>(&selected_text_range_provider)));
4972 SetOwner(owner_platform, selected_text_range_provider.Get());
4974
4975 selected_text_range_provider.Reset();
4977 }
4978
4979
4980 {
4981 document_text_range_provider->Select();
4982
4983
4984 AXTree::Selection unignored_selection = delegate->GetUnignoredSelection();
4985 EXPECT_EQ(3, unignored_selection.anchor_object_id);
4986 EXPECT_EQ(5, unignored_selection.focus_object_id);
4987 EXPECT_EQ(0, unignored_selection.anchor_offset);
4988 EXPECT_EQ(10, unignored_selection.focus_offset);
4989
4990
4991 document_provider->GetSelection(selection.
Receive());
4992 ASSERT_NE(
nullptr, selection.
Get());
4993
4994 document_provider->GetSelection(selection.
Receive());
4995 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetUBound(selection.
Get(), 1, &ubound));
4996 EXPECT_EQ(0, ubound);
4997 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetLBound(selection.
Get(), 1, &lbound));
4998 EXPECT_EQ(0, lbound);
4999 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetElement(
5000 selection.
Get(), &index,
5001 static_cast<void**>(&selected_text_range_provider)));
5002 SetOwner(owner_platform, selected_text_range_provider.Get());
5004 L"some textmore text2");
5005 }
5006
5007
5008 {
5009
5010 text_range_provider->MoveEndpointByRange(TextPatternRangeEndpoint_Start,
5011 text_range_provider.Get(),
5012 TextPatternRangeEndpoint_End);
5013 text_range_provider->Select();
5014
5015
5016 AXTree::Selection unignored_selection = delegate->GetUnignoredSelection();
5017 EXPECT_EQ(3, unignored_selection.anchor_object_id);
5018 EXPECT_EQ(3, unignored_selection.focus_object_id);
5019 EXPECT_EQ(9, unignored_selection.anchor_offset);
5020 EXPECT_EQ(9, unignored_selection.focus_offset);
5021
5022
5023 document_provider->GetSelection(selection.
Receive());
5024 ASSERT_NE(
nullptr, selection.
Get());
5025
5026 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetUBound(selection.
Get(), 1, &ubound));
5027 EXPECT_EQ(0, ubound);
5028 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetLBound(selection.
Get(), 1, &lbound));
5029 EXPECT_EQ(0, lbound);
5030 EXPECT_HRESULT_SUCCEEDED(SafeArrayGetElement(
5031 selection.
Get(), &index,
5032 static_cast<void**>(&selected_text_range_provider)));
5033 SetOwner(owner_platform, selected_text_range_provider.Get());
5035
5036 selected_text_range_provider.Reset();
5038 }
5039}
5040
5041
5042TEST_F(AXPlatformNodeTextRangeProviderTest,
5043 TestITextRangeProviderSelectListMarker) {
5047
5052
5054 list_item_data.
id = 3;
5057
5061 list_item_data.
child_ids.push_back(list_marker.
id);
5062
5064 static_text_data.
id = 5;
5066 static_text_data.
SetName(
"1. ");
5067 list_marker.
child_ids.push_back(static_text_data.
id);
5068
5070 list_item_text_data.
id = 6;
5072 list_item_text_data.
SetName(
"First Item");
5073 list_item_data.
child_ids.push_back(list_item_text_data.
id);
5074
5078 update.tree_data = tree_data;
5079 update.has_tree_data =
true;
5081 update.nodes = {root_data, list_data, list_item_data,
5082 list_marker, static_text_data, list_item_text_data};
5084 AXNode* root_node = GetRootAsAXNode();
5085
5086
5087 AXNode* list_node = root_node->children()[0];
5088 AXNode* list_item_node = list_node->children()[0];
5089 AXNode* list_marker_node = list_item_node->children()[0];
5090 ComPtr<ITextRangeProvider> list_marker_text_range_provider;
5091 GetTextRangeProviderFromTextNode(list_marker_text_range_provider,
5092 list_marker_node->children()[0]);
5093
5094
5095 EXPECT_HRESULT_SUCCEEDED(list_marker_text_range_provider->Select());
5096
5097
5099 ComPtr<IRawElementProviderSimple> root_node_raw =
5100 QueryInterfaceFromNode<IRawElementProviderSimple>(root_node);
5101 ComPtr<ITextProvider> document_provider;
5102 EXPECT_HRESULT_SUCCEEDED(
5103 root_node_raw->GetPatternProvider(UIA_TextPatternId, &document_provider));
5104 EXPECT_HRESULT_SUCCEEDED(
5105 document_provider->GetSelection(selection.
Receive()));
5106 ASSERT_EQ(
nullptr, selection.
Get());
5108}
5109
5110TEST_F(AXPlatformNodeTextRangeProviderTest, TestITextRangeProviderFindText) {
5111
5114 std::filesystem::path exec_path(
buffer);
5115 exec_path.remove_filename();
5116 exec_path.append("icudtl.dat");
5117 const std::string icudtl_path = exec_path.string();
5118 if (std::filesystem::exists(icudtl_path)) {
5120 }
5121
5122
5123 Init(BuildTextDocument({
"some text",
"more text",
"resum\xC3\xA9"},
5124 false ,
5125 true ));
5126
5127 AXNode* root_node = GetRootAsAXNode();
5128 AXPlatformNodeWin* owner =
5129 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(root_node));
5130 ASSERT_NE(owner, nullptr);
5131 ComPtr<ITextRangeProvider> range;
5132
5133
5134 GetTextRangeProviderFromTextNode(range, root_node->children()[0]);
5137 GetTextRangeProviderFromTextNode(range, root_node->children()[1]);
5140
5141
5142 GetTextRangeProviderFromTextNode(range, root_node);
5148
5150
5154
5156
5159
5160
5161 GetTextRangeProviderFromTextNode(range, root_node->children()[1]);
5163 Microsoft::WRL::ComPtr<ITextRangeProvider> text_range_provider_found;
5164 EXPECT_HRESULT_SUCCEEDED(range->FindText(
find_string.Get(),
false,
false,
5165 &text_range_provider_found));
5166 Microsoft::WRL::ComPtr<AXPlatformNodeTextRangeProviderWin>
5167 text_range_provider_win;
5168 text_range_provider_found->QueryInterface(
5169 IID_PPV_ARGS(&text_range_provider_win));
5170 ASSERT_TRUE(GetStart(text_range_provider_win.Get())->IsTextPosition());
5171 EXPECT_EQ(5, GetStart(text_range_provider_win.Get())->anchor_id());
5172 EXPECT_EQ(0, GetStart(text_range_provider_win.Get())->text_offset());
5173 ASSERT_TRUE(GetEnd(text_range_provider_win.Get())->IsTextPosition());
5174 EXPECT_EQ(5, GetEnd(text_range_provider_win.Get())->anchor_id());
5175 EXPECT_EQ(9, GetEnd(text_range_provider_win.Get())->text_offset());
5176}
5177
5178TEST_F(AXPlatformNodeTextRangeProviderTest,
5179 FindTextWithEmbeddedObjectCharacter) {
5180
5181
5182
5183
5184
5185
5186
5187
5196
5200 static_text_4.
id = 4;
5201 inline_box_5.
id = 5;
5203 static_text_7.
id = 7;
5204 inline_box_8.
id = 8;
5205
5208
5211
5214
5218
5221
5224
5228
5231
5235 update.tree_data = tree_data;
5236 update.has_tree_data =
true;
5238 update.nodes = {root_1, list_2, list_item_3, static_text_4,
5239 inline_box_5, list_item_6, static_text_7, inline_box_8};
5240
5242
5243 AXNode* root_node = GetRootAsAXNode();
5244 ComPtr<ITextRangeProvider> text_range_provider;
5245 GetTextRangeProviderFromTextNode(text_range_provider, root_node);
5246
5248 Microsoft::WRL::ComPtr<ITextRangeProvider> text_range_provider_found;
5249 EXPECT_HRESULT_SUCCEEDED(text_range_provider->FindText(
5250 find_string.Get(),
false,
false, &text_range_provider_found));
5251 ASSERT_TRUE(text_range_provider_found.Get());
5252 Microsoft::WRL::ComPtr<AXPlatformNodeTextRangeProviderWin>
5253 text_range_provider_win;
5254 text_range_provider_found->QueryInterface(
5255 IID_PPV_ARGS(&text_range_provider_win));
5256 ASSERT_TRUE(GetStart(text_range_provider_win.Get())->IsTextPosition());
5257 EXPECT_EQ(5, GetStart(text_range_provider_win.Get())->anchor_id());
5258 EXPECT_EQ(1, GetStart(text_range_provider_win.Get())->text_offset());
5259 ASSERT_TRUE(GetEnd(text_range_provider_win.Get())->IsTextPosition());
5260 EXPECT_EQ(8, GetEnd(text_range_provider_win.Get())->anchor_id());
5261 EXPECT_EQ(3, GetEnd(text_range_provider_win.Get())->text_offset());
5262}
5263
5264TEST_F(AXPlatformNodeTextRangeProviderTest,
5265 TestITextRangeProviderFindTextBackwards) {
5266 Init(BuildTextDocument({
"text",
"some",
"text"},
5267 false ,
5268 true ));
5269 AXNode* root_node = GetRootAsAXNode();
5270
5271 ComPtr<ITextRangeProvider> root_range_provider;
5272 GetTextRangeProviderFromTextNode(root_range_provider, root_node);
5273 ComPtr<ITextRangeProvider> text_node1_range;
5274 GetTextRangeProviderFromTextNode(text_node1_range, root_node->children()[0]);
5275 ComPtr<ITextRangeProvider> text_node3_range;
5276 GetTextRangeProviderFromTextNode(text_node3_range, root_node->children()[2]);
5277
5278 ComPtr<ITextRangeProvider> text_range_provider_found;
5281
5282
5283 EXPECT_HRESULT_SUCCEEDED(root_range_provider->FindText(
5284 find_string.Get(),
false,
false, &text_range_provider_found));
5285 CopyOwnerToClone(root_range_provider.Get(), text_range_provider_found.Get());
5287
5288 range_equal = false;
5289 EXPECT_HRESULT_SUCCEEDED(
5290 text_range_provider_found->Compare(text_node1_range.Get(), &range_equal));
5292
5293
5294 EXPECT_HRESULT_SUCCEEDED(root_range_provider->FindText(
5295 find_string.Get(),
true,
false, &text_range_provider_found));
5296 CopyOwnerToClone(root_range_provider.Get(), text_range_provider_found.Get());
5298
5299 range_equal = false;
5300 EXPECT_HRESULT_SUCCEEDED(
5301 text_range_provider_found->Compare(text_node3_range.Get(), &range_equal));
5303}
5304
5305TEST_F(AXPlatformNodeTextRangeProviderTest,
5306 TestITextRangeProviderFindAttribute) {
5307
5308
5309
5310
5311
5312
5313
5314
5315
5316
5317
5318
5319
5320
5321
5322
5323
5324
5325 {
5329
5332 update.has_tree_data =
true;
5334 update.nodes = {root_data};
5335
5337
5338 bool is_search_backward;
5340 V_VT(&is_hidden_attr_val) = VT_BOOL;
5341 ComPtr<ITextRangeProvider> matched_range_provider;
5342 ComPtr<ITextRangeProvider> document_range_provider;
5343 GetTextRangeProviderFromTextNode(document_range_provider,
5344 GetRootAsAXNode());
5345
5346
5347
5348 V_BOOL(&is_hidden_attr_val) = VARIANT_TRUE;
5349 is_search_backward = false;
5350 document_range_provider->FindAttribute(
5351 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5352 &matched_range_provider);
5353 ASSERT_EQ(nullptr, matched_range_provider.Get());
5354
5355
5356
5357
5358
5359
5360 V_BOOL(&is_hidden_attr_val) = VARIANT_FALSE;
5361 is_search_backward = false;
5362 document_range_provider->FindAttribute(
5363 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5364 &matched_range_provider);
5365 ASSERT_NE(nullptr, matched_range_provider.Get());
5366 CopyOwnerToClone(document_range_provider.Get(),
5367 matched_range_provider.Get());
5369 matched_range_provider.Reset();
5370
5371
5372
5373 V_BOOL(&is_hidden_attr_val) = VARIANT_TRUE;
5374 is_search_backward = true;
5375 document_range_provider->FindAttribute(
5376 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5377 &matched_range_provider);
5378 ASSERT_EQ(nullptr, matched_range_provider.Get());
5379
5380
5381
5382
5383
5384
5385 V_BOOL(&is_hidden_attr_val) = VARIANT_FALSE;
5386 is_search_backward = true;
5387 document_range_provider->FindAttribute(
5388 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5389 &matched_range_provider);
5390 ASSERT_NE(nullptr, matched_range_provider.Get());
5391 CopyOwnerToClone(document_range_provider.Get(),
5392 matched_range_provider.Get());
5394 }
5395
5396
5397
5398
5399
5400
5401
5402
5403
5404
5405
5406
5407 {
5413
5418
5421 update.has_tree_data =
true;
5423 update.nodes = {root_data, text_data1};
5424
5426
5427 bool is_search_backward;
5429 V_VT(&is_hidden_attr_val) = VT_BOOL;
5430 ComPtr<ITextRangeProvider> matched_range_provider;
5431 ComPtr<ITextRangeProvider> document_range_provider;
5432 GetTextRangeProviderFromTextNode(document_range_provider,
5433 GetRootAsAXNode());
5434
5435
5436
5437 V_BOOL(&is_hidden_attr_val) = VARIANT_TRUE;
5438 is_search_backward = false;
5439 document_range_provider->FindAttribute(
5440 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5441 &matched_range_provider);
5442 ASSERT_NE(nullptr, matched_range_provider.Get());
5443 CopyOwnerToClone(document_range_provider.Get(),
5444 matched_range_provider.Get());
5446 matched_range_provider.Reset();
5447
5448
5449
5450 V_BOOL(&is_hidden_attr_val) = VARIANT_FALSE;
5451 is_search_backward = false;
5452 document_range_provider->FindAttribute(
5453 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5454 &matched_range_provider);
5455 ASSERT_EQ(nullptr, matched_range_provider.Get());
5456
5457
5458
5459 V_BOOL(&is_hidden_attr_val) = VARIANT_TRUE;
5460 is_search_backward = true;
5461 document_range_provider->FindAttribute(
5462 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5463 &matched_range_provider);
5464 ASSERT_NE(nullptr, matched_range_provider.Get());
5465 CopyOwnerToClone(document_range_provider.Get(),
5466 matched_range_provider.Get());
5468 matched_range_provider.Reset();
5469
5470
5471
5472 V_BOOL(&is_hidden_attr_val) = VARIANT_FALSE;
5473 is_search_backward = true;
5474 document_range_provider->FindAttribute(
5475 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5476 &matched_range_provider);
5477 ASSERT_EQ(nullptr, matched_range_provider.Get());
5478 }
5479
5480
5481
5482
5483
5484
5485
5486
5487
5488
5489
5490
5491
5492 {
5497
5502
5507
5510 update.has_tree_data =
true;
5512 update.nodes = {root_data, text_data1, text_data2};
5513
5515
5516 bool is_search_backward;
5518 V_VT(&is_hidden_attr_val) = VT_BOOL;
5519 ComPtr<ITextRangeProvider> matched_range_provider;
5520 ComPtr<ITextRangeProvider> document_range_provider;
5521 GetTextRangeProviderFromTextNode(document_range_provider,
5522 GetRootAsAXNode());
5523
5524
5525
5526 V_BOOL(&is_hidden_attr_val) = VARIANT_TRUE;
5527 is_search_backward = false;
5528 document_range_provider->FindAttribute(
5529 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5530 &matched_range_provider);
5531 ASSERT_EQ(nullptr, matched_range_provider.Get());
5532
5533
5534
5535 V_BOOL(&is_hidden_attr_val) = VARIANT_FALSE;
5536 is_search_backward = false;
5537 document_range_provider->FindAttribute(
5538 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5539 &matched_range_provider);
5540 ASSERT_NE(nullptr, matched_range_provider.Get());
5541 CopyOwnerToClone(document_range_provider.Get(),
5542 matched_range_provider.Get());
5544 matched_range_provider.Reset();
5545
5546
5547
5548 V_BOOL(&is_hidden_attr_val) = VARIANT_TRUE;
5549 is_search_backward = true;
5550 document_range_provider->FindAttribute(
5551 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5552 &matched_range_provider);
5553 ASSERT_EQ(nullptr, matched_range_provider.Get());
5554
5555
5556
5557 V_BOOL(&is_hidden_attr_val) = VARIANT_FALSE;
5558 is_search_backward = true;
5559 document_range_provider->FindAttribute(
5560 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5561 &matched_range_provider);
5562 ASSERT_NE(nullptr, matched_range_provider.Get());
5563 CopyOwnerToClone(document_range_provider.Get(),
5564 matched_range_provider.Get());
5566 }
5567
5568
5569
5570
5571
5572
5573
5574
5575
5576
5577
5578
5579
5580
5581
5582
5583 {
5588
5594
5600
5605
5611
5616
5619 update.has_tree_data =
true;
5621 update.nodes = {root_data, text_data1, text_data2,
5622 text_data3, text_data4, text_data5};
5623
5625
5626 bool is_search_backward;
5628 V_VT(&is_hidden_attr_val) = VT_BOOL;
5629 ComPtr<ITextRangeProvider> matched_range_provider;
5630 ComPtr<ITextRangeProvider> document_range_provider;
5631 GetTextRangeProviderFromTextNode(document_range_provider,
5632 GetRootAsAXNode());
5633
5634
5635
5636 V_BOOL(&is_hidden_attr_val) = VARIANT_TRUE;
5637 is_search_backward = false;
5638 document_range_provider->FindAttribute(
5639 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5640 &matched_range_provider);
5641 ASSERT_NE(nullptr, matched_range_provider.Get());
5642 CopyOwnerToClone(document_range_provider.Get(),
5643 matched_range_provider.Get());
5645 matched_range_provider.Reset();
5646
5647
5648
5649 V_BOOL(&is_hidden_attr_val) = VARIANT_FALSE;
5650 is_search_backward = false;
5651 document_range_provider->FindAttribute(
5652 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5653 &matched_range_provider);
5654 ASSERT_NE(nullptr, matched_range_provider.Get());
5655 CopyOwnerToClone(document_range_provider.Get(),
5656 matched_range_provider.Get());
5658 matched_range_provider.Reset();
5659
5660
5661
5662 V_BOOL(&is_hidden_attr_val) = VARIANT_TRUE;
5663 is_search_backward = true;
5664 document_range_provider->FindAttribute(
5665 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5666 &matched_range_provider);
5667 ASSERT_NE(nullptr, matched_range_provider.Get());
5668 CopyOwnerToClone(document_range_provider.Get(),
5669 matched_range_provider.Get());
5671 matched_range_provider.Reset();
5672
5673
5674
5675 V_BOOL(&is_hidden_attr_val) = VARIANT_FALSE;
5676 is_search_backward = true;
5677 document_range_provider->FindAttribute(
5678 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5679 &matched_range_provider);
5680 ASSERT_NE(nullptr, matched_range_provider.Get());
5681 CopyOwnerToClone(document_range_provider.Get(),
5682 matched_range_provider.Get());
5684 }
5685
5686
5687
5688
5689
5690
5691
5692
5693
5694
5695
5696
5697
5698
5699
5700
5701 {
5706
5712
5718
5724
5729
5734
5737 update.has_tree_data =
true;
5739 update.nodes = {root_data, text_data1, text_data2,
5740 text_data3, text_data4, text_data5};
5741
5743
5744 bool is_search_backward;
5746 V_VT(&is_hidden_attr_val) = VT_BOOL;
5747 ComPtr<ITextRangeProvider> matched_range_provider;
5748 ComPtr<ITextRangeProvider> document_range_provider;
5749 GetTextRangeProviderFromTextNode(document_range_provider,
5750 GetRootAsAXNode());
5751
5752
5753
5754 V_BOOL(&is_hidden_attr_val) = VARIANT_TRUE;
5755 is_search_backward = false;
5756 document_range_provider->FindAttribute(
5757 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5758 &matched_range_provider);
5759 ASSERT_NE(nullptr, matched_range_provider.Get());
5760 CopyOwnerToClone(document_range_provider.Get(),
5761 matched_range_provider.Get());
5763 matched_range_provider.Reset();
5764
5765
5766
5767 V_BOOL(&is_hidden_attr_val) = VARIANT_FALSE;
5768 is_search_backward = false;
5769 document_range_provider->FindAttribute(
5770 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5771 &matched_range_provider);
5772 ASSERT_NE(nullptr, matched_range_provider.Get());
5773 CopyOwnerToClone(document_range_provider.Get(),
5774 matched_range_provider.Get());
5776 matched_range_provider.Reset();
5777
5778
5779
5780 V_BOOL(&is_hidden_attr_val) = VARIANT_TRUE;
5781 is_search_backward = true;
5782 document_range_provider->FindAttribute(
5783 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5784 &matched_range_provider);
5785 ASSERT_NE(nullptr, matched_range_provider.Get());
5786 CopyOwnerToClone(document_range_provider.Get(),
5787 matched_range_provider.Get());
5789 matched_range_provider.Reset();
5790
5791
5792
5793 V_BOOL(&is_hidden_attr_val) = VARIANT_FALSE;
5794 is_search_backward = true;
5795 document_range_provider->FindAttribute(
5796 UIA_IsHiddenAttributeId, is_hidden_attr_val, is_search_backward,
5797 &matched_range_provider);
5798 ASSERT_NE(nullptr, matched_range_provider.Get());
5799 CopyOwnerToClone(document_range_provider.Get(),
5800 matched_range_provider.Get());
5802 }
5803}
5804
5805TEST_F(AXPlatformNodeTextRangeProviderTest, ElementNotAvailable) {
5806 AXNodeData root_ax_node_data;
5807 root_ax_node_data.id = 1;
5809
5810 Init(root_ax_node_data);
5811
5812 ComPtr<IRawElementProviderSimple> raw_element_provider_simple =
5813 QueryInterfaceFromNode<IRawElementProviderSimple>(GetRootAsAXNode());
5814 ASSERT_NE(nullptr, raw_element_provider_simple.Get());
5815
5816 ComPtr<ITextProvider> text_provider;
5817 ASSERT_HRESULT_SUCCEEDED(raw_element_provider_simple->GetPatternProvider(
5818 UIA_TextPatternId, &text_provider));
5819 ASSERT_NE(nullptr, text_provider.Get());
5820
5821 ComPtr<ITextRangeProvider> text_range_provider;
5822 ASSERT_HRESULT_SUCCEEDED(
5823 text_provider->get_DocumentRange(&text_range_provider));
5824 ASSERT_NE(nullptr, text_range_provider.Get());
5825
5826
5827 SetTree(std::make_unique<AXTree>());
5828
5830 ASSERT_EQ(static_cast<HRESULT>(UIA_E_ELEMENTNOTAVAILABLE),
5831 text_range_provider->ScrollIntoView(bool_arg));
5832}
5833
5834
5835
5836TEST_F(AXPlatformNodeTextRangeProviderTest,
5837 DISABLED_TestITextRangeProviderIgnoredNodes) {
5838
5839
5840
5841
5842
5843
5844
5845
5846
5847
5848
5849
5850
5851
5857 tree_update.
nodes.resize(14);
5858 tree_update.
nodes[0].id = 1;
5859 tree_update.
nodes[0].child_ids = {2};
5861
5862 tree_update.
nodes[1].id = 2;
5863 tree_update.
nodes[1].child_ids = {3, 4, 5, 6, 7, 8};
5864
5865
5869
5870
5872
5873 tree_update.
nodes[2].id = 3;
5875 tree_update.
nodes[2].SetName(
".3.");
5876
5877 tree_update.
nodes[3].id = 4;
5879 tree_update.
nodes[3].SetName(
".4.");
5880
5881 tree_update.
nodes[4].id = 5;
5883 tree_update.
nodes[4].SetName(
".5.");
5884
5885 tree_update.
nodes[5].id = 6;
5887 tree_update.
nodes[5].child_ids = {9};
5888
5889 tree_update.
nodes[6].id = 7;
5890 tree_update.
nodes[6].child_ids = {10, 11};
5893
5894 tree_update.
nodes[7].id = 8;
5897 tree_update.
nodes[7].SetName(
".8.");
5898
5899 tree_update.
nodes[8].id = 9;
5900 tree_update.
nodes[8].child_ids = {12};
5903
5904 tree_update.
nodes[9].id = 10;
5905 tree_update.
nodes[9].child_ids = {13, 14};
5908
5909 tree_update.
nodes[10].id = 11;
5911 tree_update.
nodes[10].SetName(
".11.");
5912
5913 tree_update.
nodes[11].id = 12;
5916 tree_update.
nodes[11].SetName(
".12.");
5917
5918 tree_update.
nodes[12].id = 13;
5920 tree_update.
nodes[12].SetName(
".13.");
5921
5922 tree_update.
nodes[13].id = 14;
5924 tree_update.
nodes[13].SetName(
".14.");
5925
5928 GetNodeFromTree(tree_id, 1));
5930 GetNodeFromTree(tree_id, 1));
5932 GetNodeFromTree(tree_id, 3));
5934 GetNodeFromTree(tree_id, 4));
5936 GetNodeFromTree(tree_id, 5));
5938 GetNodeFromTree(tree_id, 1));
5940 GetNodeFromTree(tree_id, 11));
5942 GetNodeFromTree(tree_id, 13));
5944 GetNodeFromTree(tree_id, 14));
5945
5946
5947 ComPtr<ITextRangeProvider> text_range_provider;
5948 GetTextRangeProviderFromTextNode(text_range_provider,
5949 GetNodeFromTree(tree_id, 1));
5950
5951 ASSERT_HRESULT_SUCCEEDED(
5952 text_range_provider->ExpandToEnclosingUnit(TextUnit_Character));
5954
5956 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
5957 2,
5958 L".3.",
5959 2);
5960
5962 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
5963 6,
5964 L".3..4..5.",
5965 6);
5966
5967
5968
5970 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
5971 15,
5972 L".3..4..5.\n\xFFFC\n.13..14..11.",
5973 15);
5974}
5975
5976TEST_F(AXPlatformNodeTextRangeProviderTest,
5977 TestNormalizeTextRangePastEndOfDocument) {
5983 initial_state.
nodes.resize(3);
5984 initial_state.
nodes[0].id = 1;
5985 initial_state.
nodes[0].child_ids = {2};
5987 initial_state.
nodes[1].id = 2;
5988 initial_state.
nodes[1].child_ids = {3};
5990 initial_state.
nodes[1].SetName(
"aaa");
5991 initial_state.
nodes[2].id = 3;
5993 initial_state.
nodes[2].SetName(
"aaa");
5994
5995 Init(initial_state);
5996
5997 ComPtr<ITextRangeProvider> text_range_provider;
5998 GetTextRangeProviderFromTextNode(text_range_provider,
5999 GetNodeFromTree(tree_id, 3));
6000
6003 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Character,
6004 2,
6005 L"a",
6006 2);
6007
6008 ComPtr<AXPlatformNodeTextRangeProviderWin> text_range_provider_win;
6009 text_range_provider->QueryInterface(IID_PPV_ARGS(&text_range_provider_win));
6010
6011 const AXNodePosition::AXPositionInstance start_after_move =
6012 GetStart(text_range_provider_win.Get())->Clone();
6013 const AXNodePosition::AXPositionInstance end_after_move =
6014 GetEnd(text_range_provider_win.Get())->Clone();
6015 EXPECT_LT(*start_after_move, *end_after_move);
6016
6020 update.nodes[0].SetName(
"aa");
6022 update.nodes[1].SetName(
"aa");
6023 ASSERT_TRUE(GetTree()->Unserialize(
update));
6024
6025 auto* text_range = text_range_provider_win.Get();
6026
6027 auto original_start = GetStart(text_range)->Clone();
6028 auto original_end = GetEnd(text_range)->Clone();
6029
6030 auto normalized_start = GetStart(text_range)->Clone();
6031 auto normalized_end = GetEnd(text_range)->Clone();
6032 NormalizeTextRange(text_range, normalized_start, normalized_end);
6033
6034 ExpectPositionsEqual(original_start, GetStart(text_range));
6035 ExpectPositionsEqual(original_end, GetEnd(text_range));
6036
6037 EXPECT_EQ(*start_after_move, *normalized_start);
6038 EXPECT_EQ(*end_after_move, *normalized_end);
6039}
6040
6041TEST_F(AXPlatformNodeTextRangeProviderTest,
6042 TestNormalizeTextRangePastEndOfDocumentWithIgnoredNodes) {
6048 initial_state.
nodes.resize(4);
6049 initial_state.
nodes[0].id = 1;
6050 initial_state.
nodes[0].child_ids = {2};
6052 initial_state.
nodes[1].id = 2;
6053 initial_state.
nodes[1].child_ids = {3, 4};
6055 initial_state.
nodes[1].SetName(
"aaa");
6056 initial_state.
nodes[2].id = 3;
6058 initial_state.
nodes[2].SetName(
"aaa");
6059 initial_state.
nodes[3].id = 4;
6062 initial_state.
nodes[3].SetName(
"ignored");
6063
6064 Init(initial_state);
6065
6066 ComPtr<ITextRangeProvider> text_range_provider;
6067 GetTextRangeProviderFromTextNode(text_range_provider,
6068 GetNodeFromTree(tree_id, 3));
6069
6072 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Character,
6073 2,
6074 L"a",
6075 2);
6076
6077 ComPtr<AXPlatformNodeTextRangeProviderWin> text_range_provider_win;
6078 text_range_provider->QueryInterface(IID_PPV_ARGS(&text_range_provider_win));
6079
6080 const AXNodePosition::AXPositionInstance start_after_move =
6081 GetStart(text_range_provider_win.Get())->Clone();
6082 const AXNodePosition::AXPositionInstance end_after_move =
6083 GetEnd(text_range_provider_win.Get())->Clone();
6084 EXPECT_LT(*start_after_move, *end_after_move);
6085
6089 update.nodes[0].SetName(
"aa");
6091 update.nodes[1].SetName(
"aa");
6092 ASSERT_TRUE(GetTree()->Unserialize(
update));
6093
6094 auto* text_range = text_range_provider_win.Get();
6095
6096 auto original_start = GetStart(text_range)->Clone();
6097 auto original_end = GetEnd(text_range)->Clone();
6098
6099 auto normalized_start = GetStart(text_range)->Clone();
6100 auto normalized_end = GetEnd(text_range)->Clone();
6101 NormalizeTextRange(text_range, normalized_start, normalized_end);
6102
6103 ExpectPositionsEqual(original_start, GetStart(text_range));
6104 ExpectPositionsEqual(original_end, GetEnd(text_range));
6105
6106 EXPECT_EQ(*start_after_move, *normalized_start);
6107 EXPECT_EQ(*end_after_move, *normalized_end);
6108}
6109
6110TEST_F(AXPlatformNodeTextRangeProviderTest,
6111 TestNormalizeTextRangeInsideIgnoredNodes) {
6117 initial_state.
nodes.resize(4);
6118 initial_state.
nodes[0].id = 1;
6119 initial_state.
nodes[0].child_ids = {2, 3, 4};
6121 initial_state.
nodes[1].id = 2;
6123 initial_state.
nodes[1].SetName(
"before");
6124 initial_state.
nodes[2].id = 3;
6127 initial_state.
nodes[2].SetName(
"ignored");
6128 initial_state.
nodes[3].id = 4;
6130 initial_state.
nodes[3].SetName(
"after");
6131
6132 Init(initial_state);
6133 const AXTree* tree = GetTree();
6134 const AXNode* ignored_node = tree->GetFromId(3);
6135
6136
6137
6138 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
6139 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
6140
6141
6142
6143 ComPtr<AXPlatformNodeTextRangeProviderWin> ignored_range_win;
6144 CreateTextRangeProviderWin(
6145 ignored_range_win, owner,
6146 ignored_node, 0,
6148 ignored_node, 0,
6150
6151 EXPECT_TRUE(GetStart(ignored_range_win.Get())->IsIgnored());
6152 EXPECT_TRUE(GetEnd(ignored_range_win.Get())->IsIgnored());
6153
6154 auto original_start = GetStart(ignored_range_win.Get())->Clone();
6155 auto original_end = GetEnd(ignored_range_win.Get())->Clone();
6156
6157 auto normalized_start = GetStart(ignored_range_win.Get())->Clone();
6158 auto normalized_end = GetEnd(ignored_range_win.Get())->Clone();
6159 NormalizeTextRange(ignored_range_win.Get(), normalized_start, normalized_end);
6160
6161 ExpectPositionsEqual(original_start, GetStart(ignored_range_win.Get()));
6162 ExpectPositionsEqual(original_end, GetEnd(ignored_range_win.Get()));
6163
6164 EXPECT_FALSE(normalized_start->IsIgnored());
6165 EXPECT_FALSE(normalized_end->IsIgnored());
6166 EXPECT_LE(*GetStart(ignored_range_win.Get()), *normalized_start);
6167 EXPECT_LE(*GetEnd(ignored_range_win.Get()), *normalized_end);
6168 EXPECT_LE(*normalized_start, *normalized_end);
6169
6170
6171
6175 update.nodes[0].child_ids = {2, 3};
6176 ASSERT_TRUE(GetTree()->Unserialize(
update));
6177
6178 original_start = GetStart(ignored_range_win.Get())->Clone();
6179 original_end = GetEnd(ignored_range_win.Get())->Clone();
6180
6181 normalized_start = GetStart(ignored_range_win.Get())->Clone();
6182 normalized_end = GetEnd(ignored_range_win.Get())->Clone();
6183 NormalizeTextRange(ignored_range_win.Get(), normalized_start, normalized_end);
6184
6185 ExpectPositionsEqual(original_start, GetStart(ignored_range_win.Get()));
6186 ExpectPositionsEqual(original_end, GetEnd(ignored_range_win.Get()));
6187
6188 EXPECT_FALSE(normalized_start->IsIgnored());
6189 EXPECT_FALSE(normalized_end->IsIgnored());
6190 EXPECT_GE(*GetStart(ignored_range_win.Get()), *normalized_start);
6191 EXPECT_GE(*GetEnd(ignored_range_win.Get()), *normalized_end);
6192 EXPECT_LE(*normalized_start, *normalized_end);
6193}
6194
6195TEST_F(AXPlatformNodeTextRangeProviderTest,
6196 TestNormalizeTextRangeSpanIgnoredNodes) {
6200
6204 before_text.
SetName(
"before");
6206
6208 ignored_text1.
id = 3;
6211 ignored_text1.
SetName(
"ignored1");
6213
6215 ignored_text2.
id = 4;
6218 ignored_text2.
SetName(
"ignored2");
6220
6226
6230 update.tree_data.tree_id = tree_id;
6231 update.has_tree_data =
true;
6232 update.nodes = {root_data, before_text, ignored_text1, ignored_text2,
6233 after_text};
6234
6236 const AXTree* tree = GetTree();
6237
6238 const AXNode* before_text_node = tree->GetFromId(before_text.
id);
6239 const AXNode* after_text_node = tree->GetFromId(after_text.
id);
6240
6241
6242
6243 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
6244 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
6245
6246
6247
6248
6249
6250
6251 ComPtr<AXPlatformNodeTextRangeProviderWin> range_span_ignored_nodes;
6252 CreateTextRangeProviderWin(
6253 range_span_ignored_nodes, owner,
6254 before_text_node, 6,
6256 after_text_node, 0,
6258
6259 auto original_start = GetStart(range_span_ignored_nodes.Get())->Clone();
6260 auto original_end = GetEnd(range_span_ignored_nodes.Get())->Clone();
6261
6262
6263
6264
6265 AXNodePosition::AXPositionInstance normalized_start =
6266 GetStart(range_span_ignored_nodes.Get())->Clone();
6267 AXNodePosition::AXPositionInstance normalized_end =
6268 GetEnd(range_span_ignored_nodes.Get())->Clone();
6269 NormalizeTextRange(range_span_ignored_nodes.Get(), normalized_start,
6270 normalized_end);
6271
6272 ExpectPositionsEqual(original_start,
6273 GetStart(range_span_ignored_nodes.Get()));
6274 ExpectPositionsEqual(original_end, GetEnd(range_span_ignored_nodes.Get()));
6275
6276 EXPECT_EQ(*normalized_start, *normalized_end);
6277
6280 EXPECT_EQ(5, normalized_start->anchor_id());
6281 EXPECT_EQ(0, normalized_start->text_offset());
6282
6285 EXPECT_EQ(5, normalized_end->anchor_id());
6286 EXPECT_EQ(0, normalized_end->text_offset());
6287}
6288
6289
6290
6291TEST_F(AXPlatformNodeTextRangeProviderTest,
6292 DISABLED_TestNormalizeTextRangeForceSameAnchorOnDegenerateRange) {
6293
6294
6295
6296
6297
6298
6299
6307
6309 generic_container_2.
id = 2;
6310 line_break_3.
id = 3;
6311 text_field_4.
id = 4;
6312 generic_container_5.
id = 5;
6313 static_text_6.
id = 6;
6314 inline_box_7.
id = 7;
6315
6317 root_1.
child_ids = {generic_container_2.
id, text_field_4.
id};
6318
6322 generic_container_2.
child_ids = {line_break_3.
id};
6323
6325
6328 text_field_4.
child_ids = {generic_container_5.
id};
6330
6332 generic_container_5.
child_ids = {static_text_6.
id};
6333
6336 static_text_6.
SetName(
"3.14");
6337
6340
6344 update.tree_data = tree_data;
6345 update.has_tree_data =
true;
6347 update.nodes.push_back(root_1);
6348 update.nodes.push_back(generic_container_2);
6349 update.nodes.push_back(line_break_3);
6350 update.nodes.push_back(text_field_4);
6351 update.nodes.push_back(generic_container_5);
6352 update.nodes.push_back(static_text_6);
6353 update.nodes.push_back(inline_box_7);
6354
6356 const AXTree* tree = GetTree();
6357
6358 const AXNode* line_break_3_node = tree->GetFromId(line_break_3.
id);
6359 const AXNode* inline_box_7_node = tree->GetFromId(inline_box_7.
id);
6360
6361 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
6362 AXPlatformNodeFromNode(GetNodeFromTree(tree_data.
tree_id, 1)));
6363
6364
6365
6366 ComPtr<AXPlatformNodeTextRangeProviderWin> range;
6367 CreateTextRangeProviderWin(
6368 range, owner,
6369 line_break_3_node, 1,
6371 inline_box_7_node, 0,
6373
6374 auto original_start = GetStart(range.Get())->Clone();
6375 auto original_end = GetEnd(range.Get())->Clone();
6376
6377 AXNodePosition::AXPositionInstance normalized_start =
6378 GetStart(range.Get())->Clone();
6379 AXNodePosition::AXPositionInstance normalized_end =
6380 GetEnd(range.Get())->Clone();
6381 NormalizeTextRange(range.Get(), normalized_start, normalized_end);
6382
6383 ExpectPositionsEqual(original_start, GetStart(range.Get()));
6384 ExpectPositionsEqual(original_end, GetEnd(range.Get()));
6385
6386 EXPECT_EQ(*normalized_start, *normalized_start);
6387
6390 EXPECT_EQ(7, normalized_start->anchor_id());
6391 EXPECT_EQ(7, normalized_end->anchor_id());
6392}
6393
6394
6395TEST_F(AXPlatformNodeTextRangeProviderTest, DISABLED_TestValidateStartAndEnd) {
6396
6397
6398
6399 AXNodeData root_data;
6402
6403 AXNodeData text_data;
6406 text_data.SetName("some text");
6407
6408 AXNodeData more_text_data;
6409 more_text_data.
id = 3;
6411 more_text_data.SetName("more text");
6412
6413 root_data.child_ids = {text_data.id, more_text_data.id};
6414
6417 update.root_id = root_data.id;
6418 update.tree_data.tree_id = tree_id;
6419 update.has_tree_data =
true;
6420 update.nodes = {root_data, text_data, more_text_data};
6421
6423 const AXTree* tree = GetTree();
6424
6425 const AXNode* root_node = tree->GetFromId(root_data.id);
6426 const AXNode* more_text_node = tree->GetFromId(more_text_data.id);
6427
6428
6429
6430
6431 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
6432 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
6433
6434
6435
6436 ComPtr<AXPlatformNodeTextRangeProviderWin> text_range_provider;
6437 CreateTextRangeProviderWin(
6438 text_range_provider, owner,
6439 root_node, 0,
6441 more_text_node, 9,
6443
6444
6445
6447 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
6448 1,
6449 L"some textmore text",
6450 0);
6451
6452
6453
6454
6455 more_text_data.SetName("ore tex");
6457 test_update.nodes = {more_text_data};
6458 ASSERT_TRUE(GetTree()->Unserialize(test_update));
6459
6461 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
6462 1,
6463 L"some textore tex",
6464 0);
6465
6466
6467
6468 text_data.SetNameExplicitlyEmpty();
6470 test_update2.nodes = {text_data};
6471 ASSERT_TRUE(GetTree()->Unserialize(test_update2));
6472
6474 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Character,
6475 1,
6476 L"re tex",
6477 1);
6478
6479
6480
6481
6482 text_data.SetName("some text");
6484 test_update3.nodes = {text_data};
6485 ASSERT_TRUE(GetTree()->Unserialize(test_update3));
6486
6488 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Character,
6489 -10,
6490 L"some textore tex",
6491 -10);
6492
6493
6494
6496 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
6497 -8,
6498 L"some tex",
6499 -8);
6500
6501
6503 text_range_provider, TextPatternRangeEndpoint_End, TextUnit_Character,
6504 1,
6505 L"some text",
6506 1);
6507
6508
6509
6510
6511
6512 text_data.SetName("some tex");
6514 test_update4.nodes = {text_data};
6515 ASSERT_TRUE(GetTree()->Unserialize(test_update4));
6516
6518 text_range_provider, TextPatternRangeEndpoint_Start, TextUnit_Character,
6519 1,
6520 L"ome tex",
6521 1);
6522}
6523
6524TEST_F(AXPlatformNodeTextRangeProviderTest,
6525 TestReplaceStartAndEndEndpointNode) {
6526
6527
6528
6529
6530
6531
6532
6533
6534
6535 AXNodeData root_1;
6536 AXNodeData group_2;
6537 AXNodeData text_3;
6538 AXNodeData text_4;
6539 AXNodeData text_5;
6540 AXNodeData text_6;
6541
6543 group_2.id = 2;
6544 text_3.id = 3;
6545 text_4.id = 4;
6546 text_5.id = 5;
6547 text_6.id = 6;
6548
6550 root_1.child_ids = {text_3.id, text_5.id};
6551
6554 group_2.child_ids = {text_3.id};
6555
6557 text_3.SetName("some text");
6558
6559
6561 text_4.SetName("some text");
6562
6564 text_5.SetName("more text");
6565
6566
6568 text_6.SetName("more text");
6569
6572 update.root_id = root_1.id;
6573 update.tree_data.tree_id = tree_id;
6574 update.has_tree_data =
true;
6575 update.nodes = {root_1, text_3, text_5};
6576
6578 const AXTree* tree = GetTree();
6579
6580 const AXNode* text_3_node = tree->GetFromId(text_3.id);
6581 const AXNode* text_5_node = tree->GetFromId(text_5.id);
6582
6583
6584
6585
6586 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
6587 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
6588
6589
6590
6591 ComPtr<AXPlatformNodeTextRangeProviderWin> range;
6592 CreateTextRangeProviderWin(
6593 range, owner,
6594 text_3_node, 0,
6596 text_5_node, 9,
6598
6600
6601
6602 {
6603
6604 root_1.child_ids = {text_4.id, text_5.id};
6606 test_update.nodes = {root_1, text_4};
6607 ASSERT_TRUE(GetTree()->Unserialize(test_update));
6608
6609
6611 range->GetChildren(children.
Receive());
6613
6614
6615
6616 EXPECT_EQ(root_1.id, GetStart(range.Get())->anchor_id());
6617 EXPECT_EQ(0, GetStart(range.Get())->text_offset());
6618
6619
6620 EXPECT_EQ(text_5.id, GetEnd(range.Get())->anchor_id());
6621 EXPECT_EQ(9, GetEnd(range.Get())->text_offset());
6622 }
6623
6624
6625 {
6626
6627 root_1.child_ids = {text_4.id, text_6.id};
6629 test_update.nodes = {root_1, text_6};
6630 ASSERT_TRUE(GetTree()->Unserialize(test_update));
6631
6632
6634 range->GetChildren(children.
Receive());
6636
6637
6638 EXPECT_EQ(root_1.id, GetStart(range.Get())->anchor_id());
6639 EXPECT_EQ(0, GetStart(range.Get())->text_offset());
6640
6641
6642 EXPECT_EQ(root_1.id, GetEnd(range.Get())->anchor_id());
6643 EXPECT_EQ(18, GetEnd(range.Get())->text_offset());
6644 }
6645
6646
6647 {
6648
6649
6650 const AXNode* text_4_node = tree->GetFromId(text_4.id);
6651 ComPtr<AXPlatformNodeTextRangeProviderWin> range_2;
6652 CreateTextRangeProviderWin(
6653 range_2, owner,
6654 text_4_node, 0,
6656 text_4_node, 4,
6658
6660
6661
6662 root_1.child_ids = {text_3.id, text_6.id};
6664 test_update.nodes = {root_1, text_3};
6665 ASSERT_TRUE(GetTree()->Unserialize(test_update));
6666
6667
6669 range_2->GetChildren(children.
Receive());
6671
6672
6673 EXPECT_EQ(root_1.id, GetStart(range_2.Get())->anchor_id());
6674 EXPECT_EQ(0, GetStart(range_2.Get())->text_offset());
6675
6676
6677 EXPECT_EQ(root_1.id, GetEnd(range_2.Get())->anchor_id());
6678 EXPECT_EQ(4, GetEnd(range_2.Get())->text_offset());
6679 }
6680}
6681
6682TEST_F(AXPlatformNodeTextRangeProviderTest,
6683 TestDeleteSubtreeThatIncludesEndpoints) {
6684
6685
6686
6687
6688
6689
6690
6691
6692
6693
6694
6695 AXNodeData root_1;
6696 AXNodeData text_2;
6697 AXNodeData gc_3;
6698 AXNodeData gc_4;
6699 AXNodeData text_5;
6700 AXNodeData gc_6;
6701 AXNodeData text_7;
6702
6703 root_1.id = 1;
6704 text_2.id = 2;
6705 gc_3.id = 3;
6706 gc_4.id = 4;
6707 text_5.id = 5;
6708 gc_6.id = 6;
6709 text_7.id = 7;
6710
6712 root_1.child_ids = {text_2.id, gc_3.id};
6713
6715 text_2.SetName("one");
6716
6718 gc_3.child_ids = {gc_4.id, gc_6.id};
6719
6721 gc_4.child_ids = {text_5.id};
6722
6724 text_5.SetName(" two");
6725
6727 gc_6.child_ids = {text_7.id};
6728
6730 text_7.SetName(" three");
6731
6734 update.root_id = root_1.id;
6735 update.tree_data.tree_id = tree_id;
6736 update.has_tree_data =
true;
6737 update.nodes = {root_1, text_2, gc_3, gc_4, text_5, gc_6, text_7};
6738
6740 const AXTree* tree = GetTree();
6741
6742 const AXNode* text_5_node = tree->GetFromId(text_5.id);
6743 const AXNode* text_7_node = tree->GetFromId(text_7.id);
6744
6745
6746
6747 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
6748 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
6749
6750
6751
6752
6753
6754 ComPtr<AXPlatformNodeTextRangeProviderWin> range;
6755 CreateTextRangeProviderWin(
6756 range, owner,
6757 text_5_node, 0,
6759 text_7_node, 6,
6761
6763
6764
6765
6767 root_1.child_ids = {text_2.id};
6768 test_update.nodes = {root_1};
6769 ASSERT_TRUE(GetTree()->Unserialize(test_update));
6770
6771
6772
6773 EXPECT_EQ(root_1.id, GetStart(range.Get())->anchor_id());
6774 EXPECT_EQ(3, GetStart(range.Get())->text_offset());
6775
6776 EXPECT_EQ(root_1.id, GetEnd(range.Get())->anchor_id());
6777 EXPECT_EQ(3, GetEnd(range.Get())->text_offset());
6778}
6779
6780
6781TEST_F(AXPlatformNodeTextRangeProviderTest,
6782 DISABLED_TestDeleteSubtreeWithIgnoredAncestors) {
6783
6784
6785
6786
6787
6788
6789
6790
6791
6792
6793
6794
6795
6796
6797
6798
6799 AXNodeData root_1;
6800 AXNodeData text_2;
6801 AXNodeData gc_3;
6802 AXNodeData gc_4;
6803 AXNodeData gc_5;
6804 AXNodeData text_6;
6805 AXNodeData gc_7;
6806 AXNodeData text_8;
6807 AXNodeData gc_9;
6808 AXNodeData text_10;
6809 AXNodeData gc_11;
6810 AXNodeData text_12;
6811
6812 root_1.id = 1;
6813 text_2.id = 2;
6814 gc_3.id = 3;
6815 gc_4.id = 4;
6816 gc_5.id = 5;
6817 text_6.id = 6;
6818 gc_7.id = 7;
6819 text_8.id = 8;
6820 gc_9.id = 9;
6821 text_10.id = 10;
6822 gc_11.id = 11;
6823 text_12.id = 12;
6824
6826 root_1.child_ids = {text_2.id, gc_3.id, gc_11.id};
6828
6830 text_2.SetName("one");
6831
6834 gc_3.child_ids = {gc_4.id};
6835
6837 gc_4.child_ids = {gc_5.id, gc_7.id, gc_9.id};
6838
6840 gc_5.child_ids = {text_6.id};
6841
6843 text_6.SetName(" two");
6844
6847 gc_7.child_ids = {text_8.id};
6848
6851 text_8.SetName(" ignored");
6852
6854 gc_9.child_ids = {text_10.id};
6855
6857 text_10.SetName(" three");
6858
6860 gc_11.child_ids = {text_12.id};
6861
6863 text_12.SetName("four");
6864
6867 update.root_id = root_1.id;
6868 update.tree_data.tree_id = tree_id;
6869 update.has_tree_data =
true;
6870 update.nodes = {root_1, text_2, gc_3, gc_4, gc_5, text_6,
6871 gc_7, text_8, gc_9, text_10, gc_11, text_12};
6872
6874 const AXTree* tree = GetTree();
6875
6876 const AXNode* text_6_node = tree->GetFromId(text_6.id);
6877 const AXNode* text_10_node = tree->GetFromId(text_10.id);
6878
6879
6880
6881 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
6882 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
6883
6884
6885
6886
6887
6888 ComPtr<AXPlatformNodeTextRangeProviderWin> range;
6889 CreateTextRangeProviderWin(
6890 range, owner,
6891 text_6_node, 2,
6893 text_10_node, 6,
6895
6897
6898
6899
6901 gc_3.child_ids = {};
6902 test_update.nodes = {gc_3};
6903 ASSERT_TRUE(GetTree()->Unserialize(test_update));
6904
6905
6906
6907 EXPECT_TRUE(GetStart(range.Get())->IsNullPosition());
6908 EXPECT_TRUE(GetEnd(range.Get())->IsNullPosition());
6909}
6910
6911
6912TEST_F(AXPlatformNodeTextRangeProviderTest,
6913 DISABLED_TestDeleteSubtreeThatIncludesEndpointsNormalizeMoves) {
6914
6915
6916
6917
6918
6919
6920
6921
6922
6923
6924
6925
6926
6927
6928
6929
6930 AXNodeData root_1;
6931 AXNodeData text_2;
6932 AXNodeData gc_3;
6933 AXNodeData gc_4;
6934 AXNodeData gc_5;
6935 AXNodeData text_6;
6936 AXNodeData gc_7;
6937 AXNodeData text_8;
6938 AXNodeData gc_9;
6939 AXNodeData text_10;
6940 AXNodeData gc_11;
6941 AXNodeData text_12;
6942
6943 root_1.id = 1;
6944 text_2.id = 2;
6945 gc_3.id = 3;
6946 gc_4.id = 4;
6947 gc_5.id = 5;
6948 text_6.id = 6;
6949 gc_7.id = 7;
6950 text_8.id = 8;
6951 gc_9.id = 9;
6952 text_10.id = 10;
6953 gc_11.id = 11;
6954 text_12.id = 12;
6955
6957 root_1.child_ids = {text_2.id, gc_3.id, gc_11.id};
6958
6960 text_2.SetName("one");
6961
6964 gc_3.child_ids = {gc_4.id};
6965
6967 gc_4.child_ids = {gc_5.id, gc_7.id, gc_9.id};
6968
6970 gc_5.child_ids = {text_6.id};
6971
6973 text_6.SetName(" two");
6974
6976 gc_7.child_ids = {text_8.id};
6977
6979 text_8.SetName(" three");
6980
6983 gc_9.child_ids = {text_10.id};
6984
6987 text_10.SetName(" ignored");
6988
6990 gc_11.child_ids = {text_12.id};
6991
6993 text_12.SetName("four");
6994
6997 update.root_id = root_1.id;
6998 update.tree_data.tree_id = tree_id;
6999 update.has_tree_data =
true;
7000 update.nodes = {root_1, text_2, gc_3, gc_4, gc_5, text_6,
7001 gc_7, text_8, gc_9, text_10, gc_11, text_12};
7002
7004 const AXTree* tree = GetTree();
7005
7006 const AXNode* text_6_node = tree->GetFromId(text_6.id);
7007 const AXNode* text_8_node = tree->GetFromId(text_8.id);
7008
7009
7010
7011 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
7012 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
7013
7014
7015
7016
7017
7018 ComPtr<AXPlatformNodeTextRangeProviderWin> range;
7019 CreateTextRangeProviderWin(
7020 range, owner,
7021 text_6_node, 2,
7023 text_8_node, 6,
7025
7027
7028
7029
7031 gc_3.child_ids = {};
7032 test_update.nodes = {gc_3};
7033 ASSERT_TRUE(GetTree()->Unserialize(test_update));
7034
7035
7036
7037 EXPECT_EQ(text_12.id, GetStart(range.Get())->anchor_id());
7038 EXPECT_EQ(0, GetStart(range.Get())->text_offset());
7039
7040 EXPECT_EQ(text_12.id, GetEnd(range.Get())->anchor_id());
7041 EXPECT_EQ(0, GetEnd(range.Get())->text_offset());
7042}
7043
7044TEST_F(AXPlatformNodeTextRangeProviderTest,
7045 TestDeleteTreePositionPreviousSibling) {
7046
7047
7048
7049
7050
7051
7052
7053
7054
7055
7056
7057
7065
7067 generic_container_2.
id = 2;
7069 static_text_4.
id = 4;
7070 inline_box_5.
id = 5;
7071 generic_container_6.
id = 6;
7073
7076
7078 generic_container_2.
child_ids = {heading_3.
id, generic_container_6.
id,
7080
7083
7086 static_text_4.
SetName(
"3.14");
7087
7090
7094
7096
7100 update.tree_data = tree_data;
7101 update.has_tree_data =
true;
7103 update.nodes = {root_1, generic_container_2, heading_3, static_text_4,
7104 inline_box_5, generic_container_6, button_7};
7105
7107 AXTree* tree = GetTree();
7108
7109 AXNode* root_node = GetRootAsAXNode();
7110 AXNodePosition::AXPositionInstance range_start =
7111 AXNodePosition::CreateTreePosition(tree->GetAXTreeID(),
7112 generic_container_2.
id,
7113 3);
7114 AXNodePosition::AXPositionInstance range_end = range_start->Clone();
7115
7116 AXPlatformNodeWin* owner =
7117 static_cast<AXPlatformNodeWin*>(AXPlatformNodeFromNode(root_node));
7118 ComPtr<ITextRangeProvider> text_range_provider =
7119 AXPlatformNodeTextRangeProviderWin::CreateTextRangeProviderForTesting(
7120 owner, std::move(range_start), std::move(range_end));
7122
7123 generic_container_2.
child_ids = {heading_3.
id, button_7.
id};
7125 test_update.nodes = {generic_container_2};
7126 ASSERT_TRUE(tree->Unserialize(test_update));
7127
7129 test_update.nodes = {root_1};
7130 ASSERT_TRUE(tree->Unserialize(test_update));
7131}
7132
7133TEST_F(AXPlatformNodeTextRangeProviderTest,
7134 TestReplaceStartAndEndEndpointRepeatRemoval) {
7135
7136
7137
7138
7139
7140
7141
7142
7143 AXNodeData root_1;
7144 AXNodeData text_2;
7145 AXNodeData group_3;
7146 AXNodeData text_4;
7147 AXNodeData text_5;
7148
7150 text_2.id = 2;
7151 group_3.id = 3;
7152 text_4.id = 4;
7153 text_5.id = 5;
7154
7156 root_1.child_ids = {text_2.id, group_3.id, text_5.id};
7157
7159 text_2.SetName("text 2");
7160
7163 group_3.child_ids = {text_4.id};
7164
7166 text_4.SetName("text 4");
7167
7169 text_5.SetName("text 5");
7170
7173 update.root_id = root_1.id;
7174 update.tree_data.tree_id = tree_id;
7175 update.has_tree_data =
true;
7176 update.nodes = {root_1, text_2, group_3, text_4, text_5};
7177
7179 const AXTree* tree = GetTree();
7180
7181 const AXNode* text_2_node = tree->GetFromId(text_2.id);
7182 const AXNode* text_4_node = tree->GetFromId(text_4.id);
7183
7184
7185
7186 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
7187 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
7188
7189 ComPtr<AXPlatformNodeTextRangeProviderWin> range;
7190 CreateTextRangeProviderWin(
7191 range, owner,
7192 text_2_node, 0,
7194 text_4_node, 0,
7196
7198
7199
7200
7201
7202 {
7203
7204 group_3.child_ids = {};
7206 test_update.nodes = {root_1, group_3};
7207 ASSERT_TRUE(GetTree()->Unserialize(test_update));
7208
7209
7211 }
7212
7213
7214
7215
7216
7217 {
7218 root_1.child_ids = {group_3.id, text_5.id};
7220 test_update.nodes = {root_1, group_3};
7221 ASSERT_TRUE(GetTree()->Unserialize(test_update));
7222
7223
7224
7226 }
7227
7228
7229
7230
7231 {
7232 root_1.child_ids = {group_3.id};
7234 test_update.nodes = {root_1, group_3};
7235 ASSERT_TRUE(GetTree()->Unserialize(test_update));
7236
7237
7239 }
7240}
7241
7242TEST_F(AXPlatformNodeTextRangeProviderTest, CaretAtEndOfTextFieldReadOnly) {
7243
7244
7245
7246
7247
7248
7249
7250
7251
7252
7253
7254 AXNodeData root_1;
7255 AXNodeData text_field_2;
7256 AXNodeData generic_container_3;
7257 AXNodeData static_text_4;
7258 AXNodeData inline_text_5;
7259 AXNodeData static_text_6;
7260 AXNodeData inline_text_7;
7261
7263 text_field_2.id = 2;
7264 generic_container_3.id = 3;
7265 static_text_4.id = 4;
7266 inline_text_5.id = 5;
7267 static_text_6.id = 6;
7268 inline_text_7.id = 7;
7269
7271 root_1.child_ids = {text_field_2.id, static_text_6.id};
7272
7275 text_field_2.SetValue("hello");
7276 text_field_2.child_ids = {generic_container_3.id};
7277
7280 generic_container_3.AddBoolAttribute(
7282 generic_container_3.child_ids = {static_text_4.id};
7283
7285 static_text_4.SetName("hello");
7287 static_text_4.child_ids = {inline_text_5.id};
7288
7290 inline_text_5.SetName("hello");
7292
7294 static_text_6.SetName("abc");
7295 static_text_6.child_ids = {inline_text_7.id};
7296
7298 inline_text_7.SetName("abc");
7299
7302 update.root_id = root_1.id;
7303 update.tree_data.tree_id = tree_id;
7304 update.has_tree_data =
true;
7305 update.nodes = {root_1, text_field_2, generic_container_3,
7306 static_text_4, inline_text_5, static_text_6,
7307 inline_text_7};
7308
7310 const AXTree* tree = GetTree();
7311 const AXNode* inline_text_5_node = tree->GetFromId(inline_text_5.id);
7312
7313
7314
7315 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
7316 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
7317
7318 ComPtr<AXPlatformNodeTextRangeProviderWin> range;
7320
7321 CreateTextRangeProviderWin(
7322 range, owner,
7323 inline_text_5_node, 3,
7325 inline_text_5_node, 4,
7327
7329
7330 expected_variant.
Set(
false);
7332 expected_variant);
7333
7335 TextUnit_Character,
7336 1,
7337 L"",
7338 1);
7339 expected_variant.
Set(
false);
7341 expected_variant);
7342
7344 1,
7345
7346 L"",
7347 1);
7348 expected_variant.
Set(
false);
7350 expected_variant);
7351 const AXNodePosition::AXPositionInstance&
start = GetStart(range.Get());
7352 const AXNodePosition::AXPositionInstance&
end = GetEnd(range.Get());
7354 EXPECT_EQ(5,
start->anchor_id());
7355 EXPECT_EQ(5,
start->text_offset());
7356
7358 EXPECT_EQ(5,
end->anchor_id());
7359 EXPECT_EQ(5,
end->text_offset());
7360}
7361
7362
7363
7364TEST_F(AXPlatformNodeTextRangeProviderTest,
7365 DISABLED_GeneratedNewlineReturnsCommonAnchorReadonly) {
7366
7367
7368
7369
7370
7371
7372
7373
7374
7375
7376
7377
7378
7379
7380
7381 AXNodeData root_1;
7382 AXNodeData generic_container_2;
7383 AXNodeData image_3;
7384 AXNodeData text_field_4;
7385 AXNodeData generic_container_5;
7386 AXNodeData image_6;
7387 AXNodeData text_field_7;
7388 AXNodeData generic_container_8;
7389 AXNodeData text_field_9;
7390 AXNodeData text_field_10;
7391
7393 generic_container_2.id = 2;
7394 image_3.id = 3;
7395 text_field_4.id = 4;
7396 generic_container_5.id = 5;
7397 image_6.id = 6;
7398 text_field_7.id = 7;
7399 generic_container_8.id = 8;
7400 text_field_9.id = 9;
7401 text_field_10.id = 10;
7402
7404 root_1.child_ids = {generic_container_2.id, generic_container_5.id,
7405 generic_container_8.id};
7406
7408 generic_container_2.child_ids = {image_3.id, text_field_4.id};
7409
7412 true);
7413
7416
7419 generic_container_5.child_ids = {image_6.id, text_field_7.id};
7420
7423 true);
7424
7427
7429 generic_container_8.child_ids = {text_field_9.id, text_field_10.id};
7430
7434 true);
7435
7438
7441 update.root_id = root_1.id;
7442 update.tree_data.tree_id = tree_id;
7443 update.has_tree_data =
true;
7444 update.nodes = {root_1, generic_container_2, image_3,
7445 text_field_4, generic_container_5, image_6,
7446 text_field_7, generic_container_8, text_field_9,
7447 text_field_10};
7448
7450 const AXTree* tree = GetTree();
7451
7452 const AXNode* image_3_node = tree->GetFromId(image_3.id);
7453 const AXNode* image_6_node = tree->GetFromId(image_6.id);
7454 const AXNode* text_field_4_node = tree->GetFromId(text_field_4.id);
7455 const AXNode* text_field_7_node = tree->GetFromId(text_field_7.id);
7456 const AXNode* text_field_9_node = tree->GetFromId(text_field_9.id);
7457 const AXNode* text_field_10_node = tree->GetFromId(text_field_10.id);
7458
7459
7460
7461 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
7462 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
7463
7465
7466 ComPtr<AXPlatformNodeTextRangeProviderWin> range_1;
7467 CreateTextRangeProviderWin(
7468 range_1, owner,
7469 image_3_node, 1,
7471 text_field_4_node, 0,
7473
7475
7476 expected_variant.
Set(
true);
7478 expected_variant);
7479 expected_variant.
Reset();
7480
7481 ComPtr<AXPlatformNodeTextRangeProviderWin> range_2;
7482 CreateTextRangeProviderWin(
7483 range_2, owner,
7484 image_6_node, 1,
7486 text_field_7_node, 0,
7488
7490
7491 expected_variant.
Set(
false);
7493 expected_variant);
7494 expected_variant.
Reset();
7495
7496
7497
7498
7499
7500 ComPtr<AXPlatformNodeTextRangeProviderWin> range_3;
7501 CreateTextRangeProviderWin(
7502 range_3, owner,
7503 text_field_9_node, 1,
7505 text_field_10_node, 0,
7507
7509
7510 expected_variant.
Set(
true);
7512 expected_variant);
7513 expected_variant.
Reset();
7514}
7515
7516
7517TEST_F(AXPlatformNodeTextRangeProviderTest,
7518 DISABLED_MoveEndpointToLastIgnoredForTextNavigationNode) {
7519
7520
7521
7522
7523
7524
7525
7526
7527
7528 AXNodeData root_1;
7529 AXNodeData static_text_2;
7530 AXNodeData inline_text_3;
7531 AXNodeData generic_container_4;
7532
7534 static_text_2.id = 2;
7535 inline_text_3.id = 3;
7536 generic_container_4.id = 4;
7537
7539 root_1.child_ids = {static_text_2.id, generic_container_4.id};
7540
7542 static_text_2.SetName("abc");
7543 static_text_2.child_ids = {inline_text_3.id};
7544
7546 inline_text_3.SetName("abc");
7547
7549
7552 update.root_id = root_1.id;
7553 update.tree_data.tree_id = tree_id;
7554 update.has_tree_data =
true;
7555 update.nodes = {root_1, static_text_2, inline_text_3, generic_container_4};
7556
7558 const AXTree* tree = GetTree();
7559 const AXNode* inline_text_3_node = tree->GetFromId(inline_text_3.id);
7560
7561
7562
7563 AXPlatformNodeWin* owner = static_cast<AXPlatformNodeWin*>(
7564 AXPlatformNodeFromNode(GetNodeFromTree(tree_id, 1)));
7565
7566 ComPtr<AXPlatformNodeTextRangeProviderWin> range;
7568
7569 CreateTextRangeProviderWin(
7570 range, owner,
7571 inline_text_3_node, 0,
7573 inline_text_3_node, 3,
7575
7577
7579 TextUnit_Paragraph,
7580 1,
7581 L"abc\xFFFC",
7582 1);
7583}
7584
7585}
static int find_string(const TArray< SkString > &strings, const char ext[])
static bool left(const SkPoint &p0, const SkPoint &p1)
static bool right(const SkPoint &p0, const SkPoint &p1)
Type::kYUV Type::kRGBA() int(0.7 *637)
void Reset(BSTR bstr=nullptr)
void Reset(SAFEARRAY *safearray=nullptr)
const VARIANT * ptr() const
void Set(const wchar_t *str)
void Reset(const VARIANT &var=kEmptyVariant)
const std::vector< AXNode * > & children() const
static AXTreeID CreateNewAXTreeID()
TEST_F(FlGnomeSettingsTest, ClockFormat)
static const uint8_t buffer[]
@ kPdfActionableHighlight
@ kTextStrikethroughStyle
std::string UTF16ToUTF8(std::u16string src)
Compare(symbols1, symbols2)
void InitializeICU(const std::string &icu_data_path)
static bool StringCompareICU(BSTR left, BSTR right)
AXTreeUpdateBase< AXNodeData, AXTreeData > AXTreeUpdate
bool StringSearch(std::u16string_view search_string, std::u16string_view find_in, size_t *find_start, size_t *find_length, bool ignore_case, bool backwards)
static AXNodePosition::AXPositionInstance CreateTextPosition(const AXNode &anchor, int text_offset, ax::mojom::TextAffinity affinity)
AXRelativeBounds relative_bounds
void AddFloatAttribute(ax::mojom::FloatAttribute attribute, float value)
void SetRestriction(ax::mojom::Restriction restriction)
void AddIntListAttribute(ax::mojom::IntListAttribute attribute, const std::vector< int32_t > &value)
void AddState(ax::mojom::State state)
void AddIntAttribute(ax::mojom::IntAttribute attribute, int32_t value)
void SetTextAlign(ax::mojom::TextAlign text_align)
std::vector< int32_t > child_ids
void SetValue(const std::string &value)
void SetHasPopup(ax::mojom::HasPopup has_popup)
void SetTextDirection(ax::mojom::WritingDirection text_direction)
void SetName(const std::string &name)
void AddStringAttribute(ax::mojom::StringAttribute attribute, const std::string &value)
void SetNameExplicitlyEmpty()
void AddTextStyle(ax::mojom::TextStyle text_style)
void AddBoolAttribute(ax::mojom::BoolAttribute attribute, bool value)
void SetTextPosition(ax::mojom::TextPosition text_position)
void SetCheckedState(ax::mojom::CheckedState checked_state)
std::vector< AXNodeData > nodes
#define EXPECT_TRUE(handle)