| // Copyright 2008 The Closure Library Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS-IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| goog.provide('goog.ui.MenuItemTest'); |
| goog.setTestOnly('goog.ui.MenuItemTest'); |
| |
| goog.require('goog.a11y.aria'); |
| goog.require('goog.a11y.aria.Role'); |
| goog.require('goog.array'); |
| goog.require('goog.dom'); |
| goog.require('goog.dom.NodeType'); |
| goog.require('goog.dom.classlist'); |
| goog.require('goog.events.KeyCodes'); |
| goog.require('goog.math.Coordinate'); |
| goog.require('goog.testing.events'); |
| goog.require('goog.testing.jsunit'); |
| goog.require('goog.testing.recordFunction'); |
| goog.require('goog.ui.Component'); |
| goog.require('goog.ui.MenuItem'); |
| goog.require('goog.ui.MenuItemRenderer'); |
| |
| var sandbox; |
| var item; |
| |
| function setUp() { |
| sandbox = goog.dom.getElement('sandbox'); |
| item = new goog.ui.MenuItem('Item'); |
| } |
| |
| function tearDown() { |
| item.dispose(); |
| goog.dom.removeChildren(sandbox); |
| } |
| |
| function testMenuItem() { |
| assertNotNull('Instance must not be null', item); |
| assertEquals('Renderer must default to MenuItemRenderer singleton', |
| goog.ui.MenuItemRenderer.getInstance(), item.getRenderer()); |
| assertEquals('Content must have expected value', 'Item', |
| item.getContent()); |
| assertEquals('Caption must default to the content', item.getContent(), |
| item.getCaption()); |
| assertEquals('Value must default to the caption', item.getCaption(), |
| item.getValue()); |
| } |
| |
| function testMenuItemConstructor() { |
| var model = 'Hello'; |
| var fakeDom = {}; |
| var fakeRenderer = {}; |
| |
| var menuItem = new goog.ui.MenuItem('Item', model, fakeDom, fakeRenderer); |
| assertEquals('Content must have expected value', 'Item', |
| menuItem.getContent()); |
| assertEquals('Caption must default to the content', menuItem.getContent(), |
| menuItem.getCaption()); |
| assertEquals('Model must be set', model, menuItem.getModel()); |
| assertNotEquals('Value must not equal the caption', menuItem.getCaption(), |
| menuItem.getValue()); |
| assertEquals('Value must equal the model', model, menuItem.getValue()); |
| assertEquals('DomHelper must be set', fakeDom, menuItem.getDomHelper()); |
| assertEquals('Renderer must be set', fakeRenderer, |
| menuItem.getRenderer()); |
| } |
| |
| function testGetValue() { |
| assertUndefined('Model must be undefined by default', item.getModel()); |
| assertEquals('Without a model, value must default to the caption', |
| item.getCaption(), item.getValue()); |
| item.setModel('Foo'); |
| assertEquals('With a model, value must default to the model', |
| item.getModel(), item.getValue()); |
| } |
| |
| function testSetValue() { |
| assertUndefined('Model must be undefined by default', item.getModel()); |
| assertEquals('Without a model, value must default to the caption', |
| item.getCaption(), item.getValue()); |
| item.setValue(17); |
| assertEquals('Value must be set', 17, item.getValue()); |
| assertEquals('Value and model must be the same', item.getValue(), |
| item.getModel()); |
| } |
| |
| function testGetSetContent() { |
| assertEquals('Content must have expected value', 'Item', |
| item.getContent()); |
| item.setContent(goog.dom.createDom('div', 'foo', 'Foo')); |
| assertEquals('Content must be an element', goog.dom.NodeType.ELEMENT, |
| item.getContent().nodeType); |
| assertHTMLEquals('Content must be the expected element', |
| '<div class="foo">Foo</div>', |
| goog.dom.getOuterHtml(item.getContent())); |
| } |
| |
| function testGetSetCaption() { |
| assertEquals('Caption must have expected value', 'Item', |
| item.getCaption()); |
| item.setCaption('Hello, world!'); |
| assertTrue('Caption must be a string', goog.isString(item.getCaption())); |
| assertEquals('Caption must have expected value', 'Hello, world!', |
| item.getCaption()); |
| item.setContent(goog.dom.createDom('div', 'foo', 'Foo')); |
| assertTrue('Caption must be a string', goog.isString(item.getCaption())); |
| assertEquals('Caption must have expected value', 'Foo', |
| item.getCaption()); |
| } |
| |
| function testGetSetContentAfterCreateDom() { |
| item.createDom(); |
| assertEquals('Content must have expected value', 'Item', |
| item.getContent()); |
| item.setContent(goog.dom.createDom('div', 'foo', 'Foo')); |
| assertEquals('Content must be an element', goog.dom.NodeType.ELEMENT, |
| item.getContent().nodeType); |
| assertHTMLEquals('Content must be the expected element', |
| '<div class="foo">Foo</div>', |
| goog.dom.getOuterHtml(item.getContent())); |
| } |
| |
| function testGetSetCaptionAfterCreateDom() { |
| item.createDom(); |
| assertEquals('Caption must have expected value', 'Item', |
| item.getCaption()); |
| item.setCaption('Hello, world!'); |
| assertTrue('Caption must be a string', goog.isString(item.getCaption())); |
| assertEquals('Caption must have expected value', 'Hello, world!', |
| item.getCaption()); |
| item.setContent(goog.dom.createDom('div', 'foo', 'Foo')); |
| assertTrue('Caption must be a string', goog.isString(item.getCaption())); |
| assertEquals('Caption must have expected value', 'Foo', |
| item.getCaption()); |
| |
| var arrayContent = goog.array.clone(goog.dom.htmlToDocumentFragment( |
| ' <b> \xa0foo</b><i> bar</i> ').childNodes); |
| item.setContent(arrayContent); |
| assertEquals('whitespaces must be normalized in the caption', |
| '\xa0foo bar', item.getCaption()); |
| } |
| |
| function testSetSelectable() { |
| assertFalse('Item must not be selectable by default', |
| item.isSupportedState(goog.ui.Component.State.SELECTED)); |
| item.setSelectable(true); |
| assertTrue('Item must be selectable', |
| item.isSupportedState(goog.ui.Component.State.SELECTED)); |
| item.setSelected(true); |
| assertTrue('Item must be selected', item.isSelected()); |
| assertFalse('Item must not be checked', item.isChecked()); |
| item.setSelectable(false); |
| assertFalse('Item must not no longer be selectable', |
| item.isSupportedState(goog.ui.Component.State.SELECTED)); |
| assertFalse('Item must no longer be selected', item.isSelected()); |
| assertFalse('Item must not be checked', item.isChecked()); |
| } |
| |
| function testSetCheckable() { |
| assertFalse('Item must not be checkable by default', |
| item.isSupportedState(goog.ui.Component.State.CHECKED)); |
| item.setCheckable(true); |
| assertTrue('Item must be checkable', |
| item.isSupportedState(goog.ui.Component.State.CHECKED)); |
| item.setChecked(true); |
| assertTrue('Item must be checked', item.isChecked()); |
| assertFalse('Item must not be selected', item.isSelected()); |
| item.setCheckable(false); |
| assertFalse('Item must not no longer be checkable', |
| item.isSupportedState(goog.ui.Component.State.CHECKED)); |
| assertFalse('Item must no longer be checked', item.isChecked()); |
| assertFalse('Item must not be selected', item.isSelected()); |
| } |
| |
| function testSetSelectableBeforeCreateDom() { |
| item.setSelectable(true); |
| item.createDom(); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| item.setSelectable(false); |
| assertFalse('Item must no longer have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| } |
| |
| function testSetCheckableBeforeCreateDom() { |
| item.setCheckable(true); |
| item.createDom(); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertEquals('Element must have ARIA role menuitemcheckbox', |
| goog.a11y.aria.Role.MENU_ITEM_CHECKBOX, |
| goog.a11y.aria.getRole(item.getElement())); |
| item.setCheckable(false); |
| assertFalse('Item must no longer have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| } |
| |
| function testSetSelectableAfterCreateDom() { |
| item.createDom(); |
| item.setSelectable(true); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertEquals('Element must have ARIA role menuitemradio', |
| goog.a11y.aria.Role.MENU_ITEM_RADIO, |
| goog.a11y.aria.getRole(item.getElement())); |
| item.setSelectable(false); |
| assertFalse('Item must no longer have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| } |
| |
| function testSetCheckableAfterCreateDom() { |
| item.createDom(); |
| item.setCheckable(true); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| item.setCheckable(false); |
| assertFalse('Item must no longer have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| } |
| |
| function testSelectableBehavior() { |
| item.setSelectable(true); |
| item.render(sandbox); |
| assertFalse('Item must not be selected by default', item.isSelected()); |
| item.performActionInternal(); |
| assertTrue('Item must be selected', item.isSelected()); |
| item.performActionInternal(); |
| assertTrue('Item must still be selected', item.isSelected()); |
| } |
| |
| function testCheckableBehavior() { |
| item.setCheckable(true); |
| item.render(sandbox); |
| assertFalse('Item must not be checked by default', item.isChecked()); |
| item.performActionInternal(); |
| assertTrue('Item must be checked', item.isChecked()); |
| item.performActionInternal(); |
| assertFalse('Item must no longer be checked', item.isChecked()); |
| } |
| |
| function testGetSetContentForItemWithCheckBox() { |
| item.setSelectable(true); |
| item.createDom(); |
| |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertEquals('getContent() must not return the checkbox structure', |
| 'Item', item.getContent()); |
| |
| item.setContent('Hello'); |
| assertEquals('getContent() must not return the checkbox structure', |
| 'Hello', item.getContent()); |
| assertTrue('Item must still have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| |
| item.setContent(goog.dom.createDom('span', 'foo', 'Foo')); |
| assertEquals('getContent() must return element', |
| goog.dom.NodeType.ELEMENT, item.getContent().nodeType); |
| assertTrue('Item must still have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| |
| item.setContent(null); |
| assertNull('getContent() must return null', item.getContent()); |
| assertTrue('Item must still have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| } |
| |
| function testGetSetCaptionForItemWithCheckBox() { |
| item.setCheckable(true); |
| item.createDom(); |
| |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertEquals('getCaption() must not return the checkbox structure', |
| 'Item', item.getCaption()); |
| |
| item.setCaption('Hello'); |
| assertEquals('getCaption() must not return the checkbox structure', |
| 'Hello', item.getCaption()); |
| assertTrue('Item must still have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| |
| item.setContent(goog.dom.createDom('span', 'foo', 'Foo')); |
| assertEquals('getCaption() must return text content', 'Foo', |
| item.getCaption()); |
| assertTrue('Item must still have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| |
| item.setCaption(''); |
| assertEquals('getCaption() must return empty string', '', |
| item.getCaption()); |
| assertTrue('Item must still have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| } |
| |
| function testGetSetCaptionForItemWithAccelerators() { |
| var contentArr = []; |
| contentArr.push(goog.dom.createDom('span', |
| goog.getCssName('goog-menuitem-accel'), 'Ctrl+1')); |
| contentArr.push(goog.dom.createTextNode('Hello')); |
| item.setCaption(contentArr); |
| assertEquals('getCaption() must not return the accelerator', 'Hello', |
| item.getCaption()); |
| |
| item.setCaption([ |
| goog.dom.createDom('span', goog.getCssName('goog-menuitem-accel'), 'Ctrl+1') |
| ]); |
| assertEquals('getCaption() must return empty string', '', |
| item.getCaption()); |
| |
| assertEquals('getAccelerator() should return the accelerator', 'Ctrl+1', |
| item.getAccelerator()); |
| } |
| |
| function testGetSetCaptionForItemWithMnemonics() { |
| var contentArr = []; |
| contentArr.push(goog.dom.createDom('span', |
| goog.getCssName('goog-menuitem-mnemonic-hint'), 'H')); |
| contentArr.push(goog.dom.createTextNode('ello')); |
| item.setCaption(contentArr); |
| assertEquals('getCaption() must not return hint markup', 'Hello', |
| item.getCaption()); |
| |
| contentArr = []; |
| contentArr.push(goog.dom.createTextNode('Hello')); |
| contentArr.push(goog.dom.createDom('span', |
| goog.getCssName('goog-menuitem-mnemonic-separator'), '(', |
| goog.dom.createDom('span', |
| goog.getCssName('goog-menuitem-mnemonic-hint'), 'J'), ')')); |
| item.setCaption(contentArr); |
| assertEquals('getCaption() must not return the paranethetical mnemonic', |
| 'Hello', item.getCaption()); |
| |
| item.setCaption(''); |
| assertEquals('getCaption() must return the empty string', '', |
| item.getCaption()); |
| } |
| |
| function testHandleKeyEventInternalWithMnemonic() { |
| item.performActionInternal = |
| goog.testing.recordFunction(item.performActionInternal); |
| item.setMnemonic(goog.events.KeyCodes.F); |
| item.handleKeyEventInternal({'keyCode': goog.events.KeyCodes.F}); |
| assertEquals('performActionInternal must be called', 1, |
| item.performActionInternal.getCallCount()); |
| } |
| |
| function testHandleKeyEventInternalWithoutMnemonic() { |
| item.performActionInternal = goog.testing.recordFunction( |
| item.performActionInternal); |
| item.handleKeyEventInternal({'keyCode': goog.events.KeyCodes.F}); |
| assertEquals('performActionInternal must not be called without a' + |
| ' mnemonic', 0, item.performActionInternal.getCallCount()); |
| } |
| |
| function testRender() { |
| item.render(sandbox); |
| var contentElement = item.getContentElement(); |
| assertNotNull('Content element must exist', contentElement); |
| assertTrue('Content element must have expected class name', |
| goog.dom.classlist.contains(contentElement, |
| item.getRenderer().getStructuralCssClass() + '-content')); |
| assertHTMLEquals('Content element must have expected structure', |
| 'Item', contentElement.innerHTML); |
| } |
| |
| function testRenderSelectableItem() { |
| item.setSelectable(true); |
| item.render(sandbox); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertEquals('getCaption() return expected value', 'Item', |
| item.getCaption()); |
| } |
| |
| function testRenderSelectedItem() { |
| item.setSelectable(true); |
| item.setSelected(true); |
| item.render(sandbox); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertTrue('Item must have selected style', |
| goog.dom.classlist.contains(item.getElement(), |
| item.getRenderer().getClassForState( |
| goog.ui.Component.State.SELECTED))); |
| } |
| |
| function testRenderCheckableItem() { |
| item.setCheckable(true); |
| item.render(sandbox); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertEquals('getCaption() return expected value', 'Item', |
| item.getCaption()); |
| } |
| |
| function testRenderCheckedItem() { |
| item.setCheckable(true); |
| item.setChecked(true); |
| item.render(sandbox); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertTrue('Item must have checked style', |
| goog.dom.classlist.contains(item.getElement(), |
| item.getRenderer().getClassForState( |
| goog.ui.Component.State.CHECKED))); |
| } |
| |
| function testDecorate() { |
| sandbox.innerHTML = '<div id="foo">Foo</div>'; |
| var foo = goog.dom.getElement('foo'); |
| item.decorate(foo); |
| assertEquals('Decorated element must be as expected', foo, |
| item.getElement()); |
| assertTrue('Decorated element must have expected class name', |
| goog.dom.classlist.contains(item.getElement(), |
| item.getRenderer().getCssClass())); |
| assertEquals('Content element must be the decorated element\'s child', |
| item.getContentElement(), item.getElement().firstChild); |
| assertHTMLEquals('Content must have expected structure', 'Foo', |
| item.getContentElement().innerHTML); |
| } |
| |
| function testDecorateCheckableItem() { |
| sandbox.innerHTML = '<div id="foo" class="goog-option">Foo</div>'; |
| var foo = goog.dom.getElement('foo'); |
| item.decorate(foo); |
| assertEquals('Decorated element must be as expected', foo, |
| item.getElement()); |
| assertTrue('Decorated element must have expected class name', |
| goog.dom.classlist.contains(item.getElement(), |
| item.getRenderer().getCssClass())); |
| assertEquals('Content element must be the decorated element\'s child', |
| item.getContentElement(), item.getElement().firstChild); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertFalse('Item must not be checked', item.isChecked()); |
| } |
| |
| function testDecorateCheckedItem() { |
| sandbox.innerHTML = |
| '<div id="foo" class="goog-option goog-option-selected">Foo</div>'; |
| var foo = goog.dom.getElement('foo'); |
| item.decorate(foo); |
| assertEquals('Decorated element must be as expected', foo, |
| item.getElement()); |
| assertSameElements('Decorated element must have expected class names', |
| ['goog-menuitem', 'goog-option', 'goog-option-selected'], |
| goog.dom.classlist.get(item.getElement())); |
| assertEquals('Content element must be the decorated element\'s child', |
| item.getContentElement(), item.getElement().firstChild); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertTrue('Item must be checked', item.isChecked()); |
| } |
| |
| function testDecorateTemplate() { |
| sandbox.innerHTML = '<div id="foo" class="goog-menuitem">' + |
| '<div class="goog-menuitem-content">Foo</div></div>'; |
| var foo = goog.dom.getElement('foo'); |
| item.decorate(foo); |
| assertEquals('Decorated element must be as expected', foo, |
| item.getElement()); |
| assertTrue('Decorated element must have expected class name', |
| goog.dom.classlist.contains(item.getElement(), |
| item.getRenderer().getCssClass())); |
| assertEquals('Content element must be the decorated element\'s child', |
| item.getContentElement(), item.getElement().firstChild); |
| assertHTMLEquals('Content must have expected structure', 'Foo', |
| item.getContentElement().innerHTML); |
| } |
| |
| function testDecorateCheckableItemTemplate() { |
| sandbox.innerHTML = '<div id="foo" class="goog-menuitem goog-option">' + |
| '<div class="goog-menuitem-content">' + |
| '<div class="goog-menuitem-checkbox"></div>' + |
| 'Foo</div></div>'; |
| var foo = goog.dom.getElement('foo'); |
| item.decorate(foo); |
| assertEquals('Decorated element must be as expected', foo, |
| item.getElement()); |
| assertTrue('Decorated element must have expected class name', |
| goog.dom.classlist.contains(item.getElement(), |
| item.getRenderer().getCssClass())); |
| assertEquals('Content element must be the decorated element\'s child', |
| item.getContentElement(), item.getElement().firstChild); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertEquals('Item must have exactly one checkbox structure', 1, |
| goog.dom.getElementsByTagNameAndClass('div', 'goog-menuitem-checkbox', |
| item.getElement()).length); |
| assertFalse('Item must not be checked', item.isChecked()); |
| } |
| |
| function testDecorateCheckedItemTemplate() { |
| sandbox.innerHTML = '<div id="foo" ' + |
| 'class="goog-menuitem goog-option goog-option-selected">' + |
| '<div class="goog-menuitem-content">' + |
| '<div class="goog-menuitem-checkbox"></div>' + |
| 'Foo</div></div>'; |
| var foo = goog.dom.getElement('foo'); |
| item.decorate(foo); |
| assertEquals('Decorated element must be as expected', foo, |
| item.getElement()); |
| assertSameElements('Decorated element must have expected class names', |
| ['goog-menuitem', 'goog-option', 'goog-option-selected'], |
| goog.dom.classlist.get(item.getElement())); |
| assertEquals('Content element must be the decorated element\'s child', |
| item.getContentElement(), item.getElement().firstChild); |
| assertTrue('Item must have checkbox structure', |
| item.getRenderer().hasCheckBoxStructure(item.getElement())); |
| assertEquals('Item must have exactly one checkbox structure', 1, |
| goog.dom.getElementsByTagNameAndClass('div', 'goog-menuitem-checkbox', |
| item.getElement()).length); |
| assertTrue('Item must be checked', item.isChecked()); |
| } |
| |
| |
| /** @bug 1463524 */ |
| function testHandleMouseUp() { |
| var COORDS_1 = new goog.math.Coordinate(1, 1); |
| var COORDS_2 = new goog.math.Coordinate(2, 2); |
| item.setActive(true); |
| // Override performActionInternal() for testing purposes. |
| var actionPerformed; |
| item.performActionInternal = function() { |
| actionPerformed = true; |
| return true; |
| }; |
| item.render(sandbox); |
| |
| // Scenario 1: item has no parent. |
| actionPerformed = false; |
| item.setActive(true); |
| goog.testing.events.fireMouseUpEvent(item.getElement()); |
| assertTrue('Action should be performed on mouseup', actionPerformed); |
| |
| // Scenario 2: item has a parent. |
| actionPerformed = false; |
| item.setActive(true); |
| var parent = new goog.ui.Component(); |
| var parentElem = goog.dom.getElement('parentComponent'); |
| parent.render(parentElem); |
| parent.addChild(item); |
| parent.openingCoords = COORDS_1; |
| goog.testing.events.fireMouseUpEvent( |
| item.getElement(), undefined, COORDS_2); |
| assertTrue('Action should be performed on mouseup', actionPerformed); |
| |
| // Scenario 3: item has a parent which was opened during mousedown, and |
| // item, and now the mouseup fires at the same coords. |
| actionPerformed = false; |
| item.setActive(true); |
| parent.openingCoords = COORDS_2; |
| goog.testing.events.fireMouseUpEvent( |
| item.getElement(), undefined, COORDS_2); |
| assertFalse('Action should not be performed on mouseup', actionPerformed); |
| } |
| |
| function testSetAriaLabel() { |
| assertNull('Item must not have aria label by default', item.getAriaLabel()); |
| item.setAriaLabel('Item 1'); |
| item.render(sandbox); |
| var el = item.getElementStrict(); |
| assertEquals('Item element must have expected aria-label', 'Item 1', |
| el.getAttribute('aria-label')); |
| assertEquals('Item element must have expected aria-role', 'menuitem', |
| el.getAttribute('role')); |
| item.setAriaLabel('Item 2'); |
| assertEquals('Item element must have updated aria-label', 'Item 2', |
| el.getAttribute('aria-label')); |
| assertEquals('Item element must have expected aria-role', 'menuitem', |
| el.getAttribute('role')); |
| } |