| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 var ActiveDescendantMixin = [ 'activedescendant' ]; | |
| 6 var LinkMixins = [ 'url' ]; | |
| 7 var DocumentMixins = [ 'docUrl', | |
| 8 'docTitle', | |
| 9 'docLoaded', | |
| 10 'docLoadingProgress' ]; | |
| 11 var ScrollableMixins = [ 'scrollX', | |
| 12 'scrollXMin', | |
| 13 'scrollXMax', | |
| 14 'scrollY', | |
| 15 'scrollYMin', | |
| 16 'scrollYMax' ]; | |
| 17 var EditableTextMixins = [ 'textSelStart', | |
| 18 'textSelEnd' ]; | |
| 19 var RangeMixins = [ 'valueForRange', | |
| 20 'minValueForRange', | |
| 21 'maxValueForRange' ]; | |
| 22 var TableMixins = [ 'tableRowCount', | |
| 23 'tableColumnCount' ]; | |
| 24 var TableCellMixins = [ 'tableCellColumnIndex', | |
| 25 'tableCellColumnSpan', | |
| 26 'tableCellRowIndex', | |
| 27 'tableCellRowSpan' ]; | |
| 28 | |
| 29 var allTests = [ | |
| 30 function testDocumentAndScrollMixins() { | |
| 31 for (var i = 0; i < DocumentMixins.length; i++) { | |
| 32 var mixinAttribute = DocumentMixins[i]; | |
| 33 assertTrue(mixinAttribute in rootNode, | |
| 34 'rootNode should have a ' + mixinAttribute + ' attribute'); | |
| 35 } | |
| 36 for (var i = 0; i < ScrollableMixins.length; i++) { | |
| 37 var mixinAttribute = ScrollableMixins[i]; | |
| 38 assertTrue(mixinAttribute in rootNode, | |
| 39 'rootNode should have a ' + mixinAttribute + ' attribute'); | |
| 40 } | |
| 41 | |
| 42 assertEq(url, rootNode.docUrl); | |
| 43 assertEq('Automation Tests - Mixin attributes', rootNode.docTitle); | |
| 44 assertEq(true, rootNode.docLoaded); | |
| 45 assertEq(1, rootNode.docLoadingProgress); | |
| 46 assertEq(0, rootNode.scrollX); | |
| 47 assertEq(0, rootNode.scrollXMin); | |
| 48 assertEq(0, rootNode.scrollXMax); | |
| 49 assertEq(0, rootNode.scrollY); | |
| 50 assertEq(0, rootNode.scrollYMin); | |
| 51 assertEq(0, rootNode.scrollYMax); | |
| 52 chrome.test.succeed(); | |
| 53 }, | |
| 54 | |
| 55 function testActiveDescendantAndOwns() { | |
| 56 var combobox = rootNode.find({ role: 'comboBox' }); | |
| 57 | |
| 58 assertTrue('owns' in combobox, 'combobox should have an owns attribute'); | |
| 59 assertEq(1, combobox.owns.length); | |
| 60 var listbox = rootNode.find({ role: 'listBox' }); | |
| 61 assertEq(listbox, combobox.owns[0]); | |
| 62 | |
| 63 assertTrue('activedescendant' in combobox, | |
| 64 'combobox should have an activedescendant attribute'); | |
| 65 var opt6 = listbox.children[5]; | |
| 66 assertEq(opt6, combobox.activedescendant); | |
| 67 chrome.test.succeed(); | |
| 68 }, | |
| 69 | |
| 70 function testLinkMixins() { | |
| 71 var links = rootNode.findAll({ role: 'link' }); | |
| 72 assertEq(2, links.length); | |
| 73 | |
| 74 var realLink = links[0]; | |
| 75 assertEq('Real link', realLink.name); | |
| 76 assertTrue('url' in realLink, 'realLink should have a url attribute'); | |
| 77 assertEq('about://blank', realLink.url); | |
| 78 | |
| 79 var ariaLink = links[1]; | |
| 80 assertEq('ARIA link', ariaLink.name); | |
| 81 assertTrue('url' in ariaLink, 'ariaLink should have a url attribute'); | |
| 82 assertEq('', ariaLink.url); | |
| 83 chrome.test.succeed(); | |
| 84 }, | |
| 85 | |
| 86 function testEditableTextMixins() { | |
| 87 var textFields = rootNode.findAll({ role: 'textField' }); | |
| 88 assertEq(3, textFields.length); | |
| 89 var EditableTextMixins = [ 'textSelStart', 'textSelEnd' ]; | |
| 90 for (var i = 0; i < textFields.length; i++) { | |
| 91 var textField = textFields[i]; | |
| 92 var id = textField.attributes.id; | |
| 93 for (var j = 0; j < EditableTextMixins.length; j++) { | |
| 94 var mixinAttribute = EditableTextMixins[j]; | |
| 95 assertTrue(mixinAttribute in textField, | |
| 96 'textField (' + id + ') should have a ' + mixinAttribute + | |
| 97 ' attribute'); | |
| 98 } | |
| 99 } | |
| 100 var input = textFields[0]; | |
| 101 assertEq('text-input', input.attributes.id); | |
| 102 assertEq(2, input.textSelStart); | |
| 103 assertEq(8, input.textSelEnd); | |
| 104 | |
| 105 var textArea = textFields[1]; | |
| 106 assertEq('textarea', textArea.attributes.id); | |
| 107 for (var i = 0; i < EditableTextMixins.length; i++) { | |
| 108 var mixinAttribute = EditableTextMixins[i]; | |
| 109 assertTrue(mixinAttribute in textArea, | |
| 110 'textArea should have a ' + mixinAttribute + ' attribute'); | |
| 111 } | |
| 112 assertEq(0, textArea.textSelStart); | |
| 113 assertEq(0, textArea.textSelEnd); | |
| 114 | |
| 115 var ariaTextbox = textFields[2]; | |
| 116 assertEq('textbox-role', ariaTextbox.attributes.id); | |
| 117 assertEq(0, ariaTextbox.textSelStart); | |
| 118 assertEq(0, ariaTextbox.textSelEnd); | |
| 119 | |
| 120 chrome.test.succeed(); | |
| 121 }, | |
| 122 | |
| 123 function testRangeMixins() { | |
| 124 var sliders = rootNode.findAll({ role: 'slider' }); | |
| 125 assertEq(2, sliders.length); | |
| 126 var spinButtons = rootNode.findAll({ role: 'spinButton' }); | |
| 127 assertEq(1, spinButtons.length); | |
| 128 var progressIndicators = rootNode.findAll({ role: 'progressIndicator' }); | |
| 129 assertEq(1, progressIndicators.length); | |
| 130 assertEq('progressbar-role', progressIndicators[0].attributes.id); | |
| 131 var scrollBars = rootNode.findAll({ role: 'scrollBar' }); | |
| 132 assertEq(1, scrollBars.length); | |
| 133 | |
| 134 var ranges = sliders.concat(spinButtons, progressIndicators, scrollBars); | |
| 135 assertEq(5, ranges.length); | |
| 136 | |
| 137 for (var i = 0; i < ranges.length; i++) { | |
| 138 var range = ranges[i]; | |
| 139 for (var j = 0; j < RangeMixins.length; j++) { | |
| 140 var mixinAttribute = RangeMixins[j]; | |
| 141 assertTrue(mixinAttribute in range, | |
| 142 range.role + ' (' + range.attributes.id + ') should have a ' | |
| 143 + mixinAttribute + ' attribute'); | |
| 144 } | |
| 145 } | |
| 146 | |
| 147 var inputRange = sliders[0]; | |
| 148 assertEq('range-input', inputRange.attributes.id); | |
| 149 assertEq(4, inputRange.valueForRange); | |
| 150 assertEq(0, inputRange.minValueForRange); | |
| 151 assertEq(5, inputRange.maxValueForRange); | |
| 152 | |
| 153 var ariaSlider = sliders[1]; | |
| 154 assertEq('slider-role', ariaSlider.attributes.id); | |
| 155 assertEq(7, ariaSlider.valueForRange); | |
| 156 assertEq(1, ariaSlider.minValueForRange); | |
| 157 assertEq(10, ariaSlider.maxValueForRange); | |
| 158 | |
| 159 var spinButton = spinButtons[0]; | |
| 160 assertEq(14, spinButton.valueForRange); | |
| 161 assertEq(1, spinButton.minValueForRange); | |
| 162 assertEq(31, spinButton.maxValueForRange); | |
| 163 | |
| 164 assertEq('0.9', progressIndicators[0].valueForRange.toPrecision(1)); | |
| 165 assertEq(0, progressIndicators[0].minValueForRange); | |
| 166 assertEq(1, progressIndicators[0].maxValueForRange); | |
| 167 | |
| 168 assertEq(0, scrollBars[0].valueForRange); | |
| 169 assertEq(0, scrollBars[0].minValueForRange); | |
| 170 assertEq(1, scrollBars[0].maxValueForRange); | |
| 171 | |
| 172 chrome.test.succeed(); | |
| 173 }, | |
| 174 | |
| 175 function testTableMixins() { | |
| 176 var table = rootNode.find({ role: 'table' });; | |
| 177 assertEq(3, table.tableRowCount); | |
| 178 assertEq(3, table.tableColumnCount); | |
| 179 | |
| 180 var row1 = table.firstChild; | |
| 181 var cell1 = row1.firstChild; | |
| 182 assertEq(0, cell1.tableCellColumnIndex); | |
| 183 assertEq(1, cell1.tableCellColumnSpan); | |
| 184 assertEq(0, cell1.tableCellRowIndex); | |
| 185 assertEq(1, cell1.tableCellRowSpan); | |
| 186 | |
| 187 var cell2 = cell1.nextSibling; | |
| 188 assertEq(1, cell2.tableCellColumnIndex); | |
| 189 assertEq(1, cell2.tableCellColumnSpan); | |
| 190 assertEq(0, cell2.tableCellRowIndex); | |
| 191 assertEq(1, cell2.tableCellRowSpan); | |
| 192 | |
| 193 var cell3 = cell2.nextSibling; | |
| 194 assertEq(2, cell3.tableCellColumnIndex); | |
| 195 assertEq(1, cell3.tableCellColumnSpan); | |
| 196 assertEq(0, cell3.tableCellRowIndex); | |
| 197 assertEq(1, cell3.tableCellRowSpan); | |
| 198 | |
| 199 var row2 = row1.nextSibling; | |
| 200 var cell4 = row2.firstChild; | |
| 201 assertEq(0, cell4.tableCellColumnIndex); | |
| 202 assertEq(2, cell4.tableCellColumnSpan); | |
| 203 assertEq(1, cell4.tableCellRowIndex); | |
| 204 assertEq(1, cell4.tableCellRowSpan); | |
| 205 | |
| 206 var cell5 = cell4.nextSibling; | |
| 207 assertEq(2, cell5.tableCellColumnIndex); | |
| 208 assertEq(1, cell5.tableCellColumnSpan); | |
| 209 assertEq(1, cell5.tableCellRowIndex); | |
| 210 assertEq(2, cell5.tableCellRowSpan); | |
| 211 | |
| 212 var row3 = row2.nextSibling; | |
| 213 var cell6 = row3.firstChild; | |
| 214 assertEq(0, cell6.tableCellColumnIndex); | |
| 215 assertEq(1, cell6.tableCellColumnSpan); | |
| 216 assertEq(2, cell6.tableCellRowIndex); | |
| 217 assertEq(1, cell6.tableCellRowSpan); | |
| 218 | |
| 219 var cell7 = cell6.nextSibling; | |
| 220 assertEq(1, cell7.tableCellColumnIndex); | |
| 221 assertEq(1, cell7.tableCellColumnSpan); | |
| 222 assertEq(2, cell7.tableCellRowIndex); | |
| 223 assertEq(1, cell7.tableCellRowSpan); | |
| 224 | |
| 225 chrome.test.succeed(); | |
| 226 }, | |
| 227 | |
| 228 function testNoMixins() { | |
| 229 var div = rootNode.find({ attributes: { id: 'main' } }); | |
| 230 assertTrue(div !== undefined); | |
| 231 var allMixins = [].concat(ActiveDescendantMixin, | |
| 232 LinkMixins, | |
| 233 DocumentMixins, | |
| 234 ScrollableMixins, | |
| 235 EditableTextMixins, | |
| 236 RangeMixins, | |
| 237 TableMixins, | |
| 238 TableCellMixins); | |
| 239 for (var mixinAttr in allMixins) { | |
| 240 assertFalse(mixinAttr in div); | |
| 241 } | |
| 242 chrome.test.succeed(); | |
| 243 } | |
| 244 ]; | |
| 245 | |
| 246 setUpAndRunTests(allTests, 'mixins.html'); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1259703002:
Re-land (2): Reimplement automation API on top of C++-backed AXTree. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master