1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
// Copyright (c) 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <set>
#include <string>
#include <vector>
#include "base/path_service.h"
#include "base/strings/string16.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "content/browser/accessibility/accessibility_event_recorder.h"
#include "content/browser/accessibility/accessibility_tree_formatter.h"
#include "content/browser/accessibility/browser_accessibility.h"
#include "content/browser/accessibility/browser_accessibility_manager.h"
#include "content/browser/accessibility/dump_accessibility_browsertest_base.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/public/common/content_paths.h"
#include "content/shell/browser/shell.h"
#include "content/test/accessibility_browser_test_utils.h"
namespace content {
typedef AccessibilityTreeFormatter::Filter Filter;
// Tests that the right platform-specific accessibility events are fired
// in response to things that happen in a web document.
//
// Similar to DumpAccessibilityTree in that each test consists of a
// single HTML file, possibly with a few special directives in comments,
// and then expectation files in text format for each platform.
//
// While DumpAccessibilityTree just loads the document and then
// prints out a text representation of the accessibility tree,
// DumpAccessibilityEvents loads the document, then executes the
// JavaScript function "go()", then it records and dumps all accessibility
// events generated as a result of that "go" function executing.
//
// How each event is dumped is platform-specific, but should be of the
// form:
//
// <event> on <node>
//
// ...where <event> is the name of the event, and <node> is a description
// of the node the event fired on, such as the node's role and name.
//
// As with DumpAccessibilityTree, DumpAccessibilityEvents takes the events
// dumped from that particular html file and compares it to the expectation
// file in the same directory (for example, test-name-expected-win.txt)
// and the test fails if they don't agree.
//
// Currently it's not possible to test for accessibility events that
// don't fire immediately (i.e. within the call scope of the call to "go()");
// the test framework calls "go()" and then sends a sentinel event signaling
// the end of the test; anything received after that is too late.
class DumpAccessibilityEventsTest : public DumpAccessibilityTestBase {
public:
void AddDefaultFilters(std::vector<Filter>* filters) override {
}
std::vector<std::string> Dump() override;
void OnDiffFailed() override;
void RunEventTest(const base::FilePath::CharType* file_path);
private:
base::string16 initial_tree_;
base::string16 final_tree_;
};
std::vector<std::string> DumpAccessibilityEventsTest::Dump() {
WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
shell()->web_contents());
scoped_ptr<AccessibilityEventRecorder> event_recorder(
AccessibilityEventRecorder::Create(
web_contents->GetRootBrowserAccessibilityManager()));
// Save a copy of the accessibility tree (as a text dump); we'll
// log this for the user later if the test fails.
initial_tree_ = DumpUnfilteredAccessibilityTreeAsString();
// Create a waiter that waits for any one accessibility event.
// This will ensure that after calling the go() function, we
// block until we've received an accessibility event generated as
// a result of this function.
scoped_ptr<AccessibilityNotificationWaiter> waiter;
waiter.reset(new AccessibilityNotificationWaiter(
shell(), AccessibilityModeComplete, ui::AX_EVENT_NONE));
// Execute the "go" function in the script.
web_contents->GetMainFrame()->ExecuteJavaScript(
base::ASCIIToUTF16("go()"));
// Wait for at least one accessibility event generated in response to
// that function.
waiter->WaitForNotification();
// More than one accessibility event could have been generated.
// To make sure we've received all accessibility events, add a
// sentinel by calling AccessibilityHitTest and waiting for a HOVER
// event in response.
waiter.reset(new AccessibilityNotificationWaiter(
shell(), AccessibilityModeComplete, ui::AX_EVENT_HOVER));
BrowserAccessibilityManager* manager =
web_contents->GetRootBrowserAccessibilityManager();
manager->delegate()->AccessibilityHitTest(gfx::Point(0, 0));
waiter->WaitForNotification();
// Save a copy of the final accessibility tree (as a text dump); we'll
// log this for the user later if the test fails.
final_tree_ = DumpUnfilteredAccessibilityTreeAsString();
// Dump the event logs, running them through any filters specified
// in the HTML file.
std::vector<std::string> event_logs = event_recorder->event_logs();
std::vector<std::string> result;
for (size_t i = 0; i < event_logs.size(); ++i) {
if (AccessibilityTreeFormatter::MatchesFilters(
filters_, base::UTF8ToUTF16(event_logs[i]), true)) {
result.push_back(event_logs[i]);
}
}
return result;
}
void DumpAccessibilityEventsTest::OnDiffFailed() {
printf("\n");
printf("Initial accessibility tree (after load complete):\n");
printf("%s\n", base::UTF16ToUTF8(initial_tree_).c_str());
printf("\n");
printf("Final accessibility tree after events fired:\n");
printf("%s\n", base::UTF16ToUTF8(final_tree_).c_str());
printf("\n");
}
void DumpAccessibilityEventsTest::RunEventTest(
const base::FilePath::CharType* file_path) {
base::FilePath dir_test_data;
ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &dir_test_data));
base::FilePath test_path(
dir_test_data.AppendASCII("accessibility/event"));
ASSERT_TRUE(base::PathExists(test_path))
<< test_path.LossyDisplayName();
base::FilePath event_file = test_path.Append(base::FilePath(file_path));
RunTest(event_file, "accessibility/event");
}
// TODO(dmazzoni): port these tests to run on all platforms.
#if defined(OS_WIN) || defined(OS_MACOSX)
IN_PROC_BROWSER_TEST_F(DumpAccessibilityEventsTest,
AccessibilityEventsCheckedStateChanged) {
RunEventTest(FILE_PATH_LITERAL("events-checked-state-changed.html"));
}
IN_PROC_BROWSER_TEST_F(DumpAccessibilityEventsTest,
AccessibilityEventsInputTypeTextValueChanged) {
RunEventTest(FILE_PATH_LITERAL("events-input-type-text-value-changed.html"));
}
#endif // defined(OS_WIN)
} // namespace content
|
