1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <set> 6 #include <string> 7 #include <vector> 8 9 #include "base/command_line.h" 10 #include "base/file_util.h" 11 #include "base/logging.h" 12 #include "base/path_service.h" 13 #include "base/strings/string16.h" 14 #include "base/strings/string_split.h" 15 #include "base/strings/string_util.h" 16 #include "base/strings/utf_string_conversions.h" 17 #include "content/browser/accessibility/accessibility_tree_formatter.h" 18 #include "content/browser/accessibility/browser_accessibility.h" 19 #include "content/browser/accessibility/browser_accessibility_manager.h" 20 #include "content/browser/renderer_host/render_view_host_impl.h" 21 #include "content/browser/renderer_host/render_widget_host_view_base.h" 22 #include "content/public/browser/web_contents.h" 23 #include "content/public/common/content_paths.h" 24 #include "content/public/common/content_switches.h" 25 #include "content/public/common/url_constants.h" 26 #include "content/public/test/content_browser_test.h" 27 #include "content/public/test/content_browser_test_utils.h" 28 #include "content/shell/browser/shell.h" 29 #include "content/test/accessibility_browser_test_utils.h" 30 #include "testing/gtest/include/gtest/gtest.h" 31 32 // TODO(aboxhall): Create expectations on Android for these 33 #if defined(OS_ANDROID) 34 #define MAYBE(x) DISABLED_##x 35 #else 36 #define MAYBE(x) x 37 #endif 38 39 namespace content { 40 41 namespace { 42 43 const char kCommentToken = '#'; 44 const char kMarkSkipFile[] = "#<skip"; 45 const char kMarkEndOfFile[] = "<-- End-of-file -->"; 46 const char kSignalDiff[] = "*"; 47 48 } // namespace 49 50 typedef AccessibilityTreeFormatter::Filter Filter; 51 52 // This test takes a snapshot of the platform BrowserAccessibility tree and 53 // tests it against an expected baseline. 54 // 55 // The flow of the test is as outlined below. 56 // 1. Load an html file from chrome/test/data/accessibility. 57 // 2. Read the expectation. 58 // 3. Browse to the page and serialize the platform specific tree into a human 59 // readable string. 60 // 4. Perform a comparison between actual and expected and fail if they do not 61 // exactly match. 62 class DumpAccessibilityTreeTest : public ContentBrowserTest { 63 public: 64 // Utility helper that does a comment aware equality check. 65 // Returns array of lines from expected file which are different. 66 std::vector<int> DiffLines(const std::vector<std::string>& expected_lines, 67 const std::vector<std::string>& actual_lines) { 68 int actual_lines_count = actual_lines.size(); 69 int expected_lines_count = expected_lines.size(); 70 std::vector<int> diff_lines; 71 int i = 0, j = 0; 72 while (i < actual_lines_count && j < expected_lines_count) { 73 if (expected_lines[j].size() == 0 || 74 expected_lines[j][0] == kCommentToken) { 75 // Skip comment lines and blank lines in expected output. 76 ++j; 77 continue; 78 } 79 80 if (actual_lines[i] != expected_lines[j]) 81 diff_lines.push_back(j); 82 ++i; 83 ++j; 84 } 85 86 // Actual file has been fully checked. 87 return diff_lines; 88 } 89 90 void AddDefaultFilters(std::vector<Filter>* filters) { 91 filters->push_back(Filter(base::ASCIIToUTF16("FOCUSABLE"), Filter::ALLOW)); 92 filters->push_back(Filter(base::ASCIIToUTF16("READONLY"), Filter::ALLOW)); 93 filters->push_back(Filter(base::ASCIIToUTF16("*=''"), Filter::DENY)); 94 } 95 96 // Parse the test html file and parse special directives, usually 97 // beginning with an '@' and inside an HTML comment, that control how the 98 // test is run and how the results are interpreted. 99 // 100 // When the accessibility tree is dumped as text, each attribute is 101 // run through filters before being appended to the string. An "allow" 102 // filter specifies attribute strings that should be dumped, and a "deny" 103 // filter specifies strings that should be suppressed. As an example, 104 // @MAC-ALLOW:AXSubrole=* means that the AXSubrole attribute should be 105 // printed, while @MAC-ALLOW:AXSubrole=AXList* means that any subrole 106 // beginning with the text "AXList" should be printed. 107 // 108 // The @WAIT-FOR:text directive allows the test to specify that the document 109 // may dynamically change after initial load, and the test is to wait 110 // until the given string (e.g., "text") appears in the resulting dump. 111 // A test can make some changes to the document, then append a magic string 112 // indicating that the test is done, and this framework will wait for that 113 // string to appear before comparing the results. 114 void ParseHtmlForExtraDirectives(const std::string& test_html, 115 std::vector<Filter>* filters, 116 std::string* wait_for) { 117 std::vector<std::string> lines; 118 base::SplitString(test_html, '\n', &lines); 119 for (std::vector<std::string>::const_iterator iter = lines.begin(); 120 iter != lines.end(); 121 ++iter) { 122 const std::string& line = *iter; 123 const std::string& allow_empty_str = 124 AccessibilityTreeFormatter::GetAllowEmptyString(); 125 const std::string& allow_str = 126 AccessibilityTreeFormatter::GetAllowString(); 127 const std::string& deny_str = 128 AccessibilityTreeFormatter::GetDenyString(); 129 const std::string& wait_str = "@WAIT-FOR:"; 130 if (StartsWithASCII(line, allow_empty_str, true)) { 131 filters->push_back( 132 Filter(base::UTF8ToUTF16(line.substr(allow_empty_str.size())), 133 Filter::ALLOW_EMPTY)); 134 } else if (StartsWithASCII(line, allow_str, true)) { 135 filters->push_back(Filter(base::UTF8ToUTF16( 136 line.substr(allow_str.size())), 137 Filter::ALLOW)); 138 } else if (StartsWithASCII(line, deny_str, true)) { 139 filters->push_back(Filter(base::UTF8ToUTF16( 140 line.substr(deny_str.size())), 141 Filter::DENY)); 142 } else if (StartsWithASCII(line, wait_str, true)) { 143 *wait_for = line.substr(wait_str.size()); 144 } 145 } 146 } 147 148 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { 149 ContentBrowserTest::SetUpCommandLine(command_line); 150 // Enable <dialog>, which is used in some tests. 151 CommandLine::ForCurrentProcess()->AppendSwitch( 152 switches::kEnableExperimentalWebPlatformFeatures); 153 } 154 155 void RunTest(const base::FilePath::CharType* file_path); 156 }; 157 158 void DumpAccessibilityTreeTest::RunTest( 159 const base::FilePath::CharType* file_path) { 160 NavigateToURL(shell(), GURL(url::kAboutBlankURL)); 161 162 // Setup test paths. 163 base::FilePath dir_test_data; 164 ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &dir_test_data)); 165 base::FilePath test_path( 166 dir_test_data.Append(FILE_PATH_LITERAL("accessibility"))); 167 ASSERT_TRUE(base::PathExists(test_path)) 168 << test_path.LossyDisplayName(); 169 170 base::FilePath html_file = test_path.Append(base::FilePath(file_path)); 171 // Output the test path to help anyone who encounters a failure and needs 172 // to know where to look. 173 printf("Testing: %s\n", html_file.MaybeAsASCII().c_str()); 174 175 std::string html_contents; 176 base::ReadFileToString(html_file, &html_contents); 177 178 // Read the expected file. 179 std::string expected_contents_raw; 180 base::FilePath expected_file = 181 base::FilePath(html_file.RemoveExtension().value() + 182 AccessibilityTreeFormatter::GetExpectedFileSuffix()); 183 base::ReadFileToString(expected_file, &expected_contents_raw); 184 185 // Tolerate Windows-style line endings (\r\n) in the expected file: 186 // normalize by deleting all \r from the file (if any) to leave only \n. 187 std::string expected_contents; 188 base::RemoveChars(expected_contents_raw, "\r", &expected_contents); 189 190 if (!expected_contents.compare(0, strlen(kMarkSkipFile), kMarkSkipFile)) { 191 printf("Skipping this test on this platform.\n"); 192 return; 193 } 194 195 // Parse filters and other directives in the test file. 196 std::vector<Filter> filters; 197 std::string wait_for; 198 AddDefaultFilters(&filters); 199 ParseHtmlForExtraDirectives(html_contents, &filters, &wait_for); 200 201 // Load the page. 202 base::string16 html_contents16; 203 html_contents16 = base::UTF8ToUTF16(html_contents); 204 GURL url = GetTestUrl("accessibility", 205 html_file.BaseName().MaybeAsASCII().c_str()); 206 207 // If there's a @WAIT-FOR directive, set up an accessibility notification 208 // waiter that returns on any event; we'll stop when we get the text we're 209 // waiting for, or time out. Otherwise just wait specifically for 210 // the "load complete" event. 211 scoped_ptr<AccessibilityNotificationWaiter> waiter; 212 if (!wait_for.empty()) { 213 waiter.reset(new AccessibilityNotificationWaiter( 214 shell(), AccessibilityModeComplete, ui::AX_EVENT_NONE)); 215 } else { 216 waiter.reset(new AccessibilityNotificationWaiter( 217 shell(), AccessibilityModeComplete, ui::AX_EVENT_LOAD_COMPLETE)); 218 } 219 220 // Load the test html. 221 NavigateToURL(shell(), url); 222 223 // Wait for notifications. If there's a @WAIT-FOR directive, break when 224 // the text we're waiting for appears in the dump, otherwise break after 225 // the first notification, which will be a load complete. 226 RenderWidgetHostViewBase* host_view = static_cast<RenderWidgetHostViewBase*>( 227 shell()->web_contents()->GetRenderWidgetHostView()); 228 std::string actual_contents; 229 do { 230 waiter->WaitForNotification(); 231 base::string16 actual_contents_utf16; 232 AccessibilityTreeFormatter formatter( 233 host_view->GetBrowserAccessibilityManager()->GetRoot()); 234 formatter.SetFilters(filters); 235 formatter.FormatAccessibilityTree(&actual_contents_utf16); 236 actual_contents = base::UTF16ToUTF8(actual_contents_utf16); 237 } while (!wait_for.empty() && 238 actual_contents.find(wait_for) == std::string::npos); 239 240 // Perform a diff (or write the initial baseline). 241 std::vector<std::string> actual_lines, expected_lines; 242 Tokenize(actual_contents, "\n", &actual_lines); 243 Tokenize(expected_contents, "\n", &expected_lines); 244 // Marking the end of the file with a line of text ensures that 245 // file length differences are found. 246 expected_lines.push_back(kMarkEndOfFile); 247 actual_lines.push_back(kMarkEndOfFile); 248 249 std::vector<int> diff_lines = DiffLines(expected_lines, actual_lines); 250 bool is_different = diff_lines.size() > 0; 251 EXPECT_FALSE(is_different); 252 if (is_different) { 253 // Mark the expected lines which did not match actual output with a *. 254 printf("* Line Expected\n"); 255 printf("- ---- --------\n"); 256 for (int line = 0, diff_index = 0; 257 line < static_cast<int>(expected_lines.size()); 258 ++line) { 259 bool is_diff = false; 260 if (diff_index < static_cast<int>(diff_lines.size()) && 261 diff_lines[diff_index] == line) { 262 is_diff = true; 263 ++diff_index; 264 } 265 printf("%1s %4d %s\n", is_diff? kSignalDiff : "", line + 1, 266 expected_lines[line].c_str()); 267 } 268 printf("\nActual\n"); 269 printf("------\n"); 270 printf("%s\n", actual_contents.c_str()); 271 } 272 273 if (!base::PathExists(expected_file)) { 274 base::FilePath actual_file = 275 base::FilePath(html_file.RemoveExtension().value() + 276 AccessibilityTreeFormatter::GetActualFileSuffix()); 277 278 EXPECT_TRUE(base::WriteFile( 279 actual_file, actual_contents.c_str(), actual_contents.size())); 280 281 ADD_FAILURE() << "No expectation found. Create it by doing:\n" 282 << "mv " << actual_file.LossyDisplayName() << " " 283 << expected_file.LossyDisplayName(); 284 } 285 } 286 287 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityA) { 288 RunTest(FILE_PATH_LITERAL("a.html")); 289 } 290 291 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityAddress) { 292 RunTest(FILE_PATH_LITERAL("address.html")); 293 } 294 295 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityAName) { 296 RunTest(FILE_PATH_LITERAL("a-name.html")); 297 } 298 299 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityANoText) { 300 RunTest(FILE_PATH_LITERAL("a-no-text.html")); 301 } 302 303 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityAOnclick) { 304 RunTest(FILE_PATH_LITERAL("a-onclick.html")); 305 } 306 307 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 308 AccessibilityAriaApplication) { 309 RunTest(FILE_PATH_LITERAL("aria-application.html")); 310 } 311 312 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 313 AccessibilityAriaAutocomplete) { 314 RunTest(FILE_PATH_LITERAL("aria-autocomplete.html")); 315 } 316 317 // crbug.com/98976 will cause new elements to be added to the Blink a11y tree 318 // Re-baseline after the Blink change goes in 319 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 320 DISABLED_AccessibilityAriaCombobox) { 321 RunTest(FILE_PATH_LITERAL("aria-combobox.html")); 322 } 323 324 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 325 MAYBE(AccessibilityAriaFlowto)) { 326 RunTest(FILE_PATH_LITERAL("aria-flowto.html")); 327 } 328 329 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityAriaInvalid) { 330 RunTest(FILE_PATH_LITERAL("aria-invalid.html")); 331 } 332 333 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 334 AccessibilityAriaLabelledByHeading) { 335 RunTest(FILE_PATH_LITERAL("aria-labelledby-heading.html")); 336 } 337 338 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityAriaLevel) { 339 RunTest(FILE_PATH_LITERAL("aria-level.html")); 340 } 341 342 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityAriaList) { 343 RunTest(FILE_PATH_LITERAL("aria-list.html")); 344 } 345 346 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityAriaMenu) { 347 RunTest(FILE_PATH_LITERAL("aria-menu.html")); 348 } 349 350 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 351 AccessibilityAriaMenuitemradio) { 352 RunTest(FILE_PATH_LITERAL("aria-menuitemradio.html")); 353 } 354 355 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 356 AccessibilityAriaPressed) { 357 RunTest(FILE_PATH_LITERAL("aria-pressed.html")); 358 } 359 360 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 361 AccessibilityAriaProgressbar) { 362 RunTest(FILE_PATH_LITERAL("aria-progressbar.html")); 363 } 364 365 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 366 AccessibilityAriaToolbar) { 367 RunTest(FILE_PATH_LITERAL("toolbar.html")); 368 } 369 370 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 371 AccessibilityAriaValueMin) { 372 RunTest(FILE_PATH_LITERAL("aria-valuemin.html")); 373 } 374 375 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 376 AccessibilityAriaValueMax) { 377 RunTest(FILE_PATH_LITERAL("aria-valuemax.html")); 378 } 379 380 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityArticle) { 381 RunTest(FILE_PATH_LITERAL("article.html")); 382 } 383 384 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityAWithImg) { 385 RunTest(FILE_PATH_LITERAL("a-with-img.html")); 386 } 387 388 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityBdo) { 389 RunTest(FILE_PATH_LITERAL("bdo.html")); 390 } 391 392 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityBR) { 393 RunTest(FILE_PATH_LITERAL("br.html")); 394 } 395 396 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityButtonNameCalc) { 397 RunTest(FILE_PATH_LITERAL("button-name-calc.html")); 398 } 399 400 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityCanvas) { 401 RunTest(FILE_PATH_LITERAL("canvas.html")); 402 } 403 404 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 405 AccessibilityCheckboxNameCalc) { 406 RunTest(FILE_PATH_LITERAL("checkbox-name-calc.html")); 407 } 408 409 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityDialog) { 410 RunTest(FILE_PATH_LITERAL("dialog.html")); 411 } 412 413 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityDiv) { 414 RunTest(FILE_PATH_LITERAL("div.html")); 415 } 416 417 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityDl) { 418 RunTest(FILE_PATH_LITERAL("dl.html")); 419 } 420 421 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 422 AccessibilityContenteditableDescendants) { 423 RunTest(FILE_PATH_LITERAL("contenteditable-descendants.html")); 424 } 425 426 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityEm) { 427 RunTest(FILE_PATH_LITERAL("em.html")); 428 } 429 430 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityFooter) { 431 RunTest(FILE_PATH_LITERAL("footer.html")); 432 } 433 434 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityForm) { 435 RunTest(FILE_PATH_LITERAL("form.html")); 436 } 437 438 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityHeading) { 439 RunTest(FILE_PATH_LITERAL("heading.html")); 440 } 441 442 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityHR) { 443 RunTest(FILE_PATH_LITERAL("hr.html")); 444 } 445 446 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 447 AccessibilityIframeCoordinates) { 448 RunTest(FILE_PATH_LITERAL("iframe-coordinates.html")); 449 } 450 451 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityInputButton) { 452 RunTest(FILE_PATH_LITERAL("input-button.html")); 453 } 454 455 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 456 AccessibilityInputButtonInMenu) { 457 RunTest(FILE_PATH_LITERAL("input-button-in-menu.html")); 458 } 459 460 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityInputColor) { 461 RunTest(FILE_PATH_LITERAL("input-color.html")); 462 } 463 464 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 465 AccessibilityInputImageButtonInMenu) { 466 RunTest(FILE_PATH_LITERAL("input-image-button-in-menu.html")); 467 } 468 469 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityInputRange) { 470 RunTest(FILE_PATH_LITERAL("input-range.html")); 471 } 472 473 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 474 AccessibilityInputTextNameCalc) { 475 RunTest(FILE_PATH_LITERAL("input-text-name-calc.html")); 476 } 477 478 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityInputTextValue) { 479 RunTest(FILE_PATH_LITERAL("input-text-value.html")); 480 } 481 482 // crbug.com/98976 will cause new elements to be added to the Blink a11y tree 483 // Re-baseline after the Blink change goes in 484 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 485 DISABLED_AccessibilityInputTypes) { 486 RunTest(FILE_PATH_LITERAL("input-types.html")); 487 } 488 489 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityLabel) { 490 RunTest(FILE_PATH_LITERAL("label.html")); 491 } 492 493 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityLandmark) { 494 RunTest(FILE_PATH_LITERAL("landmark.html")); 495 } 496 497 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityListMarkers) { 498 RunTest(FILE_PATH_LITERAL("list-markers.html")); 499 } 500 501 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 502 AccessibilityModalDialogClosed) { 503 RunTest(FILE_PATH_LITERAL("modal-dialog-closed.html")); 504 } 505 506 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 507 AccessibilityModalDialogOpened) { 508 RunTest(FILE_PATH_LITERAL("modal-dialog-opened.html")); 509 } 510 511 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 512 AccessibilityModalDialogInIframeClosed) { 513 RunTest(FILE_PATH_LITERAL("modal-dialog-in-iframe-closed.html")); 514 } 515 516 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 517 AccessibilityModalDialogInIframeOpened) { 518 RunTest(FILE_PATH_LITERAL("modal-dialog-in-iframe-opened.html")); 519 } 520 521 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 522 AccessibilityModalDialogStack) { 523 RunTest(FILE_PATH_LITERAL("modal-dialog-stack.html")); 524 } 525 526 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityP) { 527 RunTest(FILE_PATH_LITERAL("p.html")); 528 } 529 530 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityRegion) { 531 RunTest(FILE_PATH_LITERAL("region.html")); 532 } 533 534 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilitySelect) { 535 RunTest(FILE_PATH_LITERAL("select.html")); 536 } 537 538 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilitySpan) { 539 RunTest(FILE_PATH_LITERAL("span.html")); 540 } 541 542 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilitySpinButton) { 543 RunTest(FILE_PATH_LITERAL("spinbutton.html")); 544 } 545 546 // TODO(dmazzoni): Rebaseline this test after Blink rolls past r155083. 547 // See http://crbug.com/265619 548 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, DISABLED_AccessibilitySvg) { 549 RunTest(FILE_PATH_LITERAL("svg.html")); 550 } 551 552 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityTab) { 553 RunTest(FILE_PATH_LITERAL("tab.html")); 554 } 555 556 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityTableSimple) { 557 RunTest(FILE_PATH_LITERAL("table-simple.html")); 558 } 559 560 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityTableSpans) { 561 RunTest(FILE_PATH_LITERAL("table-spans.html")); 562 } 563 564 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityTransition) { 565 RunTest(FILE_PATH_LITERAL("transition.html")); 566 } 567 568 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 569 AccessibilityToggleButton) { 570 RunTest(FILE_PATH_LITERAL("togglebutton.html")); 571 } 572 573 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityUl) { 574 RunTest(FILE_PATH_LITERAL("ul.html")); 575 } 576 577 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, AccessibilityWbr) { 578 RunTest(FILE_PATH_LITERAL("wbr.html")); 579 } 580 581 IN_PROC_BROWSER_TEST_F(DumpAccessibilityTreeTest, 582 AccessibilityAriaActivedescendant) { 583 RunTest(FILE_PATH_LITERAL("aria-activedescendant.html")); 584 } 585 586 } // namespace content 587