RubyGems - closure - Versions diffs - 1.2.701 → 1.3.0 - Mend

closure 1.2.701 → 1.3.0

Files changed (1566) hide show

data/closure-library/closure/goog/ui/controlrenderer_test.html DELETED Viewed

@@ -1,840 +0,0 @@
-<!DOCTYPE html>
-<html>
-<!--
-Copyright 2008 The Closure Library Authors. All Rights Reserved.
-Use of this source code is governed by the Apache License, Version 2.0.
-See the COPYING file for details.
--->
-<!--
--->
-<head>
-<meta http-equiv="X-UA-Compatible" content="IE=edge">
-  <title>Closure Unit Tests - goog.ui.ControlRenderer</title>
-  <script src="../base.js"></script>
-  <script>
-    goog.require('goog.dom.NodeType');
-    goog.require('goog.dom.a11y');
-    goog.require('goog.dom.a11y.Role');
-    goog.require('goog.dom.a11y.State');
-    goog.require('goog.dom.classes');
-    goog.require('goog.style');
-    goog.require('goog.testing.ExpectedFailures');
-    goog.require('goog.testing.jsunit');
-    goog.require('goog.ui.Component.State');
-    goog.require('goog.ui.Control');
-    goog.require('goog.ui.ControlRenderer');
-    goog.require('goog.userAgent');
-  </script>
-</head>
-<body>
-  <div id="sandbox"></div>
-  <script>
-    var control, controlRenderer, testRenderer;
-    var sandbox = goog.dom.getElement('sandbox');
-    var expectedFailures = new goog.testing.ExpectedFailures();
-    /**
-     * A subclass of ControlRenderer that overrides {@code getAriaRole} and
-     * {@code getStructuralCssClass} for testing purposes.
-     * @constructor
-     * @extends {goog.ui.ControlRenderer}
-     */
-    function TestRenderer() {
-      goog.ui.ControlRenderer.call(this);
-    };
-    goog.inherits(TestRenderer, goog.ui.ControlRenderer);
-    goog.addSingletonGetter(TestRenderer);
-    TestRenderer.CSS_CLASS = 'goog-button';
-    TestRenderer.IE6_CLASS_COMBINATIONS = [
-      ['combined', 'goog-base-hover', 'goog-button'],
-      ['combined', 'goog-base-disabled', 'goog-button'],
-      ['combined', 'combined2', 'goog-base-hover', 'goog-base-rtl',
-       'goog-button']
-    ];
-    /** {@inheritDoc} */
-    TestRenderer.prototype.getAriaRole = function() {
-      return goog.dom.a11y.Role.BUTTON;
-    };
-    /** {@inheritDoc} */
-    TestRenderer.prototype.getCssClass = function() {
-      return TestRenderer.CSS_CLASS;
-    };
-    /** {@inheritDoc} */
-    TestRenderer.prototype.getStructuralCssClass = function() {
-      return 'goog-base';
-    };
-    /** {@inheritDoc} */
-    TestRenderer.prototype.getIe6ClassCombinations = function() {
-      return TestRenderer.IE6_CLASS_COMBINATIONS;
-    };
-    /**
-     * @return {boolean} Whether we're on Mac Safari 3.x.
-     */
-    function isMacSafari3() {
-      return goog.userAgent.WEBKIT && goog.userAgent.MAC &&
-          !goog.userAgent.isVersion('527');
-    }
-    /**
-     * @return {boolean} Whether we're on IE6 or lower.
-     */
-    function isIe6() {
-      return goog.userAgent.IE && !goog.userAgent.isVersion('7');
-    }
-    function setUp() {
-      control = new goog.ui.Control('Hello');
-      controlRenderer = goog.ui.ControlRenderer.getInstance();
-      testRenderer = TestRenderer.getInstance();
-    }
-    function tearDown() {
-      control.dispose();
-      expectedFailures.handleTearDown();
-      control = null;
-      controlRenderer = null;
-      testRenderer = null;
-      goog.dom.removeChildren(sandbox);
-    }
-    function testConstructor() {
-      assertNotNull('ControlRenderer singleton instance must not be null',
-          controlRenderer);
-      assertNotNull('TestRenderer singleton instance must not be null',
-          testRenderer);
-    }
-    function testGetCustomRenderer() {
-      var cssClass = 'special-css-class';
-      var renderer = goog.ui.ControlRenderer.getCustomRenderer(
-          goog.ui.ControlRenderer, cssClass);
-      assertEquals(
-          'Renderer should have returned the custom CSS class.',
-          cssClass,
-          renderer.getCssClass());
-    }
-    function testGetAriaRole() {
-      assertUndefined('ControlRenderer\'s ARIA role must be undefined',
-          controlRenderer.getAriaRole());
-      assertEquals('TestRenderer\'s ARIA role must have expected value',
-          goog.dom.a11y.Role.BUTTON, testRenderer.getAriaRole());
-    }
-    function testCreateDom() {
-      assertHTMLEquals('ControlRenderer must create correct DOM',
-          '<div class="goog-control">Hello</div>',
-          goog.dom.getOuterHtml(controlRenderer.createDom(control)));
-      assertHTMLEquals('TestRenderer must create correct DOM',
-          '<div class="goog-button goog-base">Hello</div>',
-          goog.dom.getOuterHtml(testRenderer.createDom(control)));
-    }
-    function testGetContentElement() {
-      assertEquals('getContentElement() must return its argument', sandbox,
-          controlRenderer.getContentElement(sandbox));
-    }
-    function testEnableExtraClassName() {
-      // enableExtraClassName() must be a no-op if control has no DOM.
-      controlRenderer.enableExtraClassName(control, 'foo', true);
-      control.createDom();
-      var element = control.getElement();
-      controlRenderer.enableExtraClassName(control, 'foo', true);
-      assertSameElements('Extra class name must have been added',
-          ['goog-control', 'foo'], goog.dom.classes.get(element));
-      controlRenderer.enableExtraClassName(control, 'foo', true);
-      assertSameElements('Enabling existing extra class name must be a no-op',
-          ['goog-control', 'foo'], goog.dom.classes.get(element));
-      controlRenderer.enableExtraClassName(control, 'bar', false);
-      assertSameElements('Disabling nonexistent class name must be a no-op',
-          ['goog-control', 'foo'], goog.dom.classes.get(element));
-      controlRenderer.enableExtraClassName(control, 'foo', false);
-      assertSameElements('Extra class name must have been removed',
-          ['goog-control'], goog.dom.classes.get(element));
-    }
-    function testCanDecorate() {
-      assertTrue('canDecorate() must return true',
-          controlRenderer.canDecorate());
-    }
-    function testDecorate() {
-      sandbox.innerHTML = '<div id="foo">Hello, world!</div>';
-      var foo = goog.dom.getElement('foo');
-      var element = controlRenderer.decorate(control, foo);
-      assertEquals('decorate() must return its argument', foo, element);
-      assertEquals('Decorated control\'s ID must be set', 'foo',
-          control.getId());
-      assertTrue('Decorated control\'s content must be a text node',
-          control.getContent().nodeType == goog.dom.NodeType.TEXT);
-      assertEquals('Decorated control\'s content must have expected value',
-          'Hello, world!', control.getContent().nodeValue);
-      assertEquals('Decorated control\'s state must be as expected', 0x00,
-          control.getState());
-      assertSameElements('Decorated element\'s classes must be as expected',
-          ['goog-control'], goog.dom.classes.get(element));
-    }
-    function testDecorateComplexDom() {
-      sandbox.innerHTML = '<div id="foo"><i>Hello</i>,<b>world</b>!</div>';
-      var foo = goog.dom.getElement('foo');
-      var element = controlRenderer.decorate(control, foo);
-      assertEquals('decorate() must return its argument', foo, element);
-      assertEquals('Decorated control\'s ID must be set', 'foo',
-          control.getId());
-      assertTrue('Decorated control\'s content must be an array',
-          goog.isArray(control.getContent()));
-      assertEquals('Decorated control\'s content must have expected length', 4,
-          control.getContent().length);
-      assertEquals('Decorated control\'s state must be as expected', 0x00,
-          control.getState());
-      assertSameElements('Decorated element\'s classes must be as expected',
-          ['goog-control'], goog.dom.classes.get(element));
-    }
-    function testDecorateWithClasses() {
-      sandbox.innerHTML =
-          '<div id="foo" class="app goog-base-disabled goog-base-hover"></div>';
-      var foo = goog.dom.getElement('foo');
-      control.addClassName('extra');
-      var element = testRenderer.decorate(control, foo);
-      assertEquals('decorate() must return its argument', foo, element);
-      assertEquals('Decorated control\'s ID must be set', 'foo',
-          control.getId());
-      assertNull('Decorated control\'s content must be null',
-          control.getContent());
-      assertEquals('Decorated control\'s state must be as expected',
-          goog.ui.Component.State.DISABLED | goog.ui.Component.State.HOVER,
-          control.getState());
-      assertSameElements('Decorated element\'s classes must be as expected', [
-        'app',
-        'extra',
-        'goog-base',
-        'goog-base-disabled',
-        'goog-base-hover',
-        'goog-button'
-      ], goog.dom.classes.get(element));
-    }
-    function testDecorateOptimization() {
-      // Temporarily replace goog.dom.classes.set().
-      var goog$dom$classes$set = goog.dom.classes.set;
-      goog.dom.classes.set = function() {
-        fail('goog.dom.classes.set() must not be called');
-      };
-      // Since foo has all required classes, goog.dom.classes.set() must not be
-      // called at all.
-      sandbox.innerHTML = '<div id="foo" class="goog-control">Foo</div>';
-      controlRenderer.decorate(control, goog.dom.getElement('foo'));
-      // Since bar has all required classes, goog.dom.classes.set() must not be
-      // called at all.
-      sandbox.innerHTML = '<div id="bar" class="goog-base goog-button">Bar' +
-          '</div>';
-      testRenderer.decorate(control, goog.dom.getElement('bar'));
-      // Since baz has all required classes, goog.dom.classes.set() must not be
-      // called at all.
-      sandbox.innerHTML = '<div id="baz" class="goog-base goog-button ' +
-          'goog-button-disabled">Baz</div>';
-      testRenderer.decorate(control, goog.dom.getElement('baz'));
-      // Restore goog.dom.classes.set().
-      goog.dom.classes.set = goog$dom$classes$set;
-    }
-    function testInitializeDom() {
-      var renderer = new goog.ui.ControlRenderer();
-      // Replace setRightToLeft().
-      renderer.setRightToLeft = function() {
-        fail('setRightToLeft() must not be called');
-      };
-      // When a control with default render direction enters the document,
-      // setRightToLeft() must not be called.
-      control.setRenderer(renderer);
-      control.render(sandbox);
-      // When a control in the default state (enabled, visible, focusable)
-      // enters the document, it must get a tab index.
-      // Expected to fail on Mac Safari 3, because it doesn't support tab index.
-      expectedFailures.expectFailureFor(isMacSafari3());
-      try {
-        assertTrue('Enabled, visible, focusable control must have tab index',
-            goog.dom.isFocusableTabIndex(control.getElement()));
-      } catch (e) {
-        expectedFailures.handleException(e);
-      }
-    }
-    function testInitializeDomDecorated() {
-      var renderer = new goog.ui.ControlRenderer();
-      // Replace setRightToLeft().
-      renderer.setRightToLeft = function() {
-        fail('setRightToLeft() must not be called');
-      };
-      sandbox.innerHTML = '<div id="foo" class="goog-control">Foo</div>';
-      // When a control with default render direction enters the document,
-      // setRightToLeft() must not be called.
-      control.setRenderer(renderer);
-      control.decorate(goog.dom.getElement('foo'));
-      // When a control in the default state (enabled, visible, focusable)
-      // enters the document, it must get a tab index.
-      // Expected to fail on Mac Safari 3, because it doesn't support tab index.
-      expectedFailures.expectFailureFor(isMacSafari3());
-      try {
-        assertTrue('Enabled, visible, focusable control must have tab index',
-            goog.dom.isFocusableTabIndex(control.getElement()));
-      } catch (e) {
-        expectedFailures.handleException(e);
-      }
-    }
-    function testInitializeDomDisabledBiDi() {
-      var renderer = new goog.ui.ControlRenderer();
-      // Replace setFocusable().
-      renderer.setFocusable = function() {
-        fail('setFocusable() must not be called');
-      };
-      // When a disabled control enters the document, setFocusable() must not
-      // be called.
-      control.setEnabled(false);
-      control.setRightToLeft(true);
-      control.setRenderer(renderer);
-      control.render(sandbox);
-      // When a right-to-left control enters the document, special stying must
-      // be applied.
-      assertSameElements('BiDi control must have right-to-left class',
-          ['goog-control', 'goog-control-disabled', 'goog-control-rtl'],
-          goog.dom.classes.get(control.getElement()));
-    }
-    function testInitializeDomDisabledBiDiDecorated() {
-      var renderer = new goog.ui.ControlRenderer();
-      // Replace setFocusable().
-      renderer.setFocusable = function() {
-        fail('setFocusable() must not be called');
-      };
-      sandbox.innerHTML =
-          '<div dir="rtl">\n' +
-          '  <div id="foo" class="goog-control-disabled">Foo</div>\n' +
-          '</div>\n';
-      // When a disabled control enters the document, setFocusable() must not
-      // be called.
-      control.setRenderer(renderer);
-      control.decorate(goog.dom.getElement('foo'));
-      // When a right-to-left control enters the document, special stying must
-      // be applied.
-      assertSameElements('BiDi control must have right-to-left class',
-          ['goog-control', 'goog-control-disabled', 'goog-control-rtl'],
-          goog.dom.classes.get(control.getElement()));
-    }
-    function testSetAriaRole() {
-      sandbox.innerHTML = '<div id="foo">Foo</div><div id="bar">Bar</div>';
-      var foo = goog.dom.getElement('foo');
-      controlRenderer.setAriaRole(foo);
-      assertEquals('ControlRenderer must not set ARIA role', '',
-          goog.dom.a11y.getRole(foo));
-      var bar = goog.dom.getElement('bar');
-      testRenderer.setAriaRole(bar);
-      assertEquals('Element must have expected ARIA role',
-          goog.dom.a11y.Role.BUTTON, goog.dom.a11y.getRole(bar));
-    }
-    function testSetAllowTextSelection() {
-      sandbox.innerHTML = '<div id="foo"><span>Foo</span></div>';
-      var foo = goog.dom.getElement('foo');
-      controlRenderer.setAllowTextSelection(foo, false);
-      assertTrue('Parent element must be unselectable on all browsers',
-          goog.style.isUnselectable(foo));
-      if (goog.userAgent.IE || goog.userAgent.OPERA) {
-        assertTrue('On IE and Opera, child element must also be unselectable',
-            goog.style.isUnselectable(foo.firstChild));
-      } else {
-        assertFalse('On browsers other than IE and Opera, the child element ' +
-            'must not be unselectable',
-            goog.style.isUnselectable(foo.firstChild));
-      }
-      controlRenderer.setAllowTextSelection(foo, true);
-      assertFalse('Parent element must be selectable',
-          goog.style.isUnselectable(foo));
-      assertFalse('Child element must be unselectable',
-          goog.style.isUnselectable(foo.firstChild));
-    }
-    function testSetRightToLeft() {
-      sandbox.innerHTML = '<div id="foo">Foo</div><div id="bar">Bar</div>';
-      var foo = goog.dom.getElement('foo');
-      controlRenderer.setRightToLeft(foo, true);
-      assertSameElements('Element must have right-to-left class applied',
-          ['goog-control-rtl'], goog.dom.classes.get(foo));
-      controlRenderer.setRightToLeft(foo, false);
-      assertSameElements('Element must not have right-to-left class applied',
-          [], goog.dom.classes.get(foo));
-      var bar = goog.dom.getElement('bar');
-      testRenderer.setRightToLeft(bar, true);
-      assertSameElements('Element must have right-to-left class applied',
-          ['goog-base-rtl'], goog.dom.classes.get(bar));
-      testRenderer.setRightToLeft(bar, false);
-      assertSameElements('Element must not have right-to-left class applied',
-          [], goog.dom.classes.get(bar));
-    }
-    function testIsFocusable() {
-      control.render(sandbox);
-      // Expected to fail on Mac Safari 3, because it doesn't support tab index.
-      expectedFailures.expectFailureFor(isMacSafari3());
-      try {
-        assertTrue('Control\'s key event target must be focusable',
-            controlRenderer.isFocusable(control));
-      } catch (e) {
-        expectedFailures.handleException(e);
-      }
-    }
-    function testIsFocusableForNonFocusableControl() {
-      control.setSupportedState(goog.ui.Component.State.FOCUSED, false);
-      control.render(sandbox);
-      assertFalse('Non-focusable control\'s key event target must not be ' +
-          'focusable', controlRenderer.isFocusable(control));
-    }
-    function testIsFocusableForControlWithoutKeyEventTarget() {
-      // Unrendered control has no key event target.
-      assertNull('Unrendered control must not have key event target',
-          control.getKeyEventTarget());
-      assertFalse('isFocusable() must return null if no key event target',
-          controlRenderer.isFocusable(control));
-    }
-    function testSetFocusable() {
-      control.render(sandbox);
-      controlRenderer.setFocusable(control, false);
-      assertFalse('Control\'s key event target must not have tab index',
-          goog.dom.isFocusableTabIndex(control.getKeyEventTarget()));
-      controlRenderer.setFocusable(control, true);
-      // Expected to fail on Mac Safari 3, because it doesn't support tab index.
-      expectedFailures.expectFailureFor(isMacSafari3());
-      try {
-        assertTrue('Control\'s key event target must have focusable tab index',
-            goog.dom.isFocusableTabIndex(control.getKeyEventTarget()));
-      } catch (e) {
-        expectedFailures.handleException(e);
-      }
-    }
-    function testSetFocusableForNonFocusableControl() {
-      control.setSupportedState(goog.ui.Component.State.FOCUSED, false);
-      control.render(sandbox);
-      assertFalse('Non-focusable control\'s key event target must not be ' +
-          'focusable',
-          goog.dom.isFocusableTabIndex(control.getKeyEventTarget()));
-      controlRenderer.setFocusable(control, true);
-      assertFalse('Non-focusable control\'s key event target must not be ' +
-          'focusable, even after calling setFocusable(true)',
-          goog.dom.isFocusableTabIndex(control.getKeyEventTarget()));
-    }
-    function testSetVisible() {
-      sandbox.innerHTML = '<div id="foo">Foo</div>';
-      var foo = goog.dom.getElement('foo');
-      assertTrue('Element must be visible', foo.style.display != 'none');
-      controlRenderer.setVisible(foo, true);
-      assertTrue('Element must still be visible', foo.style.display != 'none');
-      controlRenderer.setVisible(foo, false);
-      assertTrue('Element must be hidden', foo.style.display == 'none');
-    }
-    function testSetState() {
-      control.setRenderer(testRenderer);
-      control.createDom();
-      var element = control.getElement();
-      assertSameElements('Control must have expected class names',
-          ['goog-button', 'goog-base'], goog.dom.classes.get(element));
-      assertEquals('Control must not have disabled ARIA state', '',
-          goog.dom.a11y.getState(element, goog.dom.a11y.State.DISABLED));
-      testRenderer.setState(control, goog.ui.Component.State.DISABLED, true);
-      assertSameElements('Control must have disabled class name',
-          ['goog-button', 'goog-base', 'goog-base-disabled'],
-          goog.dom.classes.get(element));
-      assertEquals('Control must have disabled ARIA state', 'true',
-          goog.dom.a11y.getState(element, goog.dom.a11y.State.DISABLED));
-      testRenderer.setState(control, goog.ui.Component.State.DISABLED, false);
-      assertSameElements('Control must no longer have disabled class name',
-          ['goog-button', 'goog-base'], goog.dom.classes.get(element));
-      assertEquals('Control must not have disabled ARIA state',
-          'false',
-          goog.dom.a11y.getState(element, goog.dom.a11y.State.DISABLED));
-      testRenderer.setState(control, 0xFFFFFF, true);
-      assertSameElements('Class names must be unchanged for invalid state',
-          ['goog-button', 'goog-base'], goog.dom.classes.get(element));
-    }
-    function testUpdateAriaState() {
-      control.createDom();
-      var element = control.getElement();
-      controlRenderer.updateAriaState(element, goog.ui.Component.State.ACTIVE,
-          true);
-      assertEquals('Control must have pressed ARIA state', 'true',
-          goog.dom.a11y.getState(element, goog.dom.a11y.State.PRESSED));
-      controlRenderer.updateAriaState(element, goog.ui.Component.State.ACTIVE,
-          false);
-      assertEquals('Control must no longer have pressed ARIA state',
-          'false',
-          goog.dom.a11y.getState(element, goog.dom.a11y.State.PRESSED));
-  }
-    function testSetContent() {
-      sandbox.innerHTML = 'Hello, world!';
-      controlRenderer.setContent(sandbox, 'Not so fast!');
-      assertEquals('Element must contain expected text value', 'Not so fast!',
-          goog.dom.getTextContent(sandbox));
-    }
-    function testSetContentNull() {
-      sandbox.innerHTML = 'Hello, world!';
-      controlRenderer.setContent(sandbox, null);
-      assertEquals('Element must have no child nodes', 0,
-          sandbox.childNodes.length);
-      assertEquals('Element must contain expected text value', '',
-          goog.dom.getTextContent(sandbox));
-    }
-    function testSetContentEmpty() {
-      sandbox.innerHTML = 'Hello, world!';
-      controlRenderer.setContent(sandbox, '');
-      assertEquals('Element must not have children', 0,
-          sandbox.childNodes.length);
-      assertEquals('Element must contain expected text value', '',
-          goog.dom.getTextContent(sandbox));
-    }
-    function testSetContentWhitespace() {
-      sandbox.innerHTML = 'Hello, world!';
-      controlRenderer.setContent(sandbox, ' ');
-      assertEquals('Element must have one child', 1,
-          sandbox.childNodes.length);
-      assertEquals('Child must be a text node', goog.dom.NodeType.TEXT,
-          sandbox.firstChild.nodeType);
-      assertEquals('Element must contain expected text value', ' ',
-          goog.dom.getTextContent(sandbox));
-    }
-    function testSetContentTextNode() {
-      sandbox.innerHTML = 'Hello, world!';
-      controlRenderer.setContent(sandbox, document.createTextNode('Text'));
-      assertEquals('Element must have one child', 1,
-          sandbox.childNodes.length);
-      assertEquals('Child must be a text node', goog.dom.NodeType.TEXT,
-          sandbox.firstChild.nodeType);
-      assertEquals('Element must contain expected text value', 'Text',
-          goog.dom.getTextContent(sandbox));
-    }
-    function testSetContentElementNode() {
-      sandbox.innerHTML = 'Hello, world!';
-      controlRenderer.setContent(sandbox,
-          goog.dom.createDom('div', {id: 'foo'}, 'Foo'));
-      assertEquals('Element must have one child', 1,
-          sandbox.childNodes.length);
-      assertEquals('Child must be an element node', goog.dom.NodeType.ELEMENT,
-          sandbox.firstChild.nodeType);
-      assertHTMLEquals('Element must contain expected HTML',
-          '<div id="foo">Foo</div>', sandbox.innerHTML);
-    }
-    function testSetContentArray() {
-      sandbox.innerHTML = 'Hello, world!';
-      controlRenderer.setContent(sandbox,
-          ['Hello, ', goog.dom.createDom('b', null, 'world'), '!']);
-      assertEquals('Element must have three children', 3,
-          sandbox.childNodes.length);
-      assertEquals('1st child must be a text node', goog.dom.NodeType.TEXT,
-          sandbox.childNodes[0].nodeType);
-      assertEquals('2nd child must be an element', goog.dom.NodeType.ELEMENT,
-          sandbox.childNodes[1].nodeType);
-      assertEquals('3rd child must be a text node', goog.dom.NodeType.TEXT,
-          sandbox.childNodes[2].nodeType);
-      assertHTMLEquals('Element must contain expected HTML',
-          'Hello, <b>world</b>!', sandbox.innerHTML);
-    }
-    function testSetContentNodeList() {
-      sandbox.innerHTML = 'Hello, world!';
-      var div = goog.dom.createDom('div', null, 'Hello, ',
-          goog.dom.createDom('b', null, 'world'), '!');
-      controlRenderer.setContent(sandbox, div.childNodes);
-      assertEquals('Element must have three children', 3,
-          sandbox.childNodes.length);
-      assertEquals('1st child must be a text node', goog.dom.NodeType.TEXT,
-          sandbox.childNodes[0].nodeType);
-      assertEquals('2nd child must be an element', goog.dom.NodeType.ELEMENT,
-          sandbox.childNodes[1].nodeType);
-      assertEquals('3rd child must be a text node', goog.dom.NodeType.TEXT,
-          sandbox.childNodes[2].nodeType);
-      assertHTMLEquals('Element must contain expected HTML',
-          'Hello, <b>world</b>!', sandbox.innerHTML);
-    }
-    function testGetKeyEventTarget() {
-      assertNull('Key event target for unrendered control must be null',
-          controlRenderer.getKeyEventTarget(control));
-      control.createDom();
-      assertEquals('Key event target for rendered control must be its element',
-          control.getElement(), controlRenderer.getKeyEventTarget(control));
-    }
-    function testGetCssClass() {
-      assertEquals('ControlRenderer\'s CSS class must have expected value',
-          goog.ui.ControlRenderer.CSS_CLASS, controlRenderer.getCssClass());
-      assertEquals('TestRenderer\'s CSS class must have expected value',
-          TestRenderer.CSS_CLASS, testRenderer.getCssClass());
-    }
-    function testGetStructuralCssClass() {
-      assertEquals('ControlRenderer\'s structural class must be its CSS class',
-          controlRenderer.getCssClass(),
-          controlRenderer.getStructuralCssClass());
-      assertEquals('TestRenderer\'s structural class must have expected value',
-          'goog-base', testRenderer.getStructuralCssClass());
-    }
-    function testGetClassNames() {
-      // These tests use assertArrayEquals, because the order is significant.
-      assertArrayEquals('ControlRenderer must return expected class names ' +
-          'in the expected order',
-          ['goog-control'],
-          controlRenderer.getClassNames(control));
-      assertArrayEquals('TestRenderer must return expected class names ' +
-          'in the expected order',
-          ['goog-button', 'goog-base'],
-          testRenderer.getClassNames(control));
-    }
-    function testGetClassNamesForControlWithState() {
-      control.setStateInternal(goog.ui.Component.State.HOVER |
-          goog.ui.Component.State.ACTIVE);
-      // These tests use assertArrayEquals, because the order is significant.
-      assertArrayEquals('ControlRenderer must return expected class names ' +
-          'in the expected order',
-          ['goog-control', 'goog-control-hover', 'goog-control-active'],
-          controlRenderer.getClassNames(control));
-      assertArrayEquals('TestRenderer must return expected class names ' +
-          'in the expected order',
-          ['goog-button', 'goog-base', 'goog-base-hover', 'goog-base-active'],
-          testRenderer.getClassNames(control));
-    }
-    function testGetClassNamesForControlWithExtraClassNames() {
-      control.addClassName('foo');
-      control.addClassName('bar');
-      // These tests use assertArrayEquals, because the order is significant.
-      assertArrayEquals('ControlRenderer must return expected class names ' +
-          'in the expected order',
-          ['goog-control', 'foo', 'bar'],
-          controlRenderer.getClassNames(control));
-      assertArrayEquals('TestRenderer must return expected class names ' +
-          'in the expected order',
-          ['goog-button', 'goog-base', 'foo', 'bar'],
-          testRenderer.getClassNames(control));
-    }
-    function testGetClassNamesForControlWithStateAndExtraClassNames() {
-      control.setStateInternal(goog.ui.Component.State.HOVER |
-          goog.ui.Component.State.ACTIVE);
-      control.addClassName('foo');
-      control.addClassName('bar');
-      // These tests use assertArrayEquals, because the order is significant.
-      assertArrayEquals('ControlRenderer must return expected class names ' +
-          'in the expected order', [
-            'goog-control',
-            'goog-control-hover',
-            'goog-control-active',
-            'foo',
-            'bar'
-          ], controlRenderer.getClassNames(control));
-      assertArrayEquals('TestRenderer must return expected class names ' +
-          'in the expected order', [
-            'goog-button',
-            'goog-base',
-            'goog-base-hover',
-            'goog-base-active',
-            'foo',
-            'bar'
-          ], testRenderer.getClassNames(control));
-    }
-    function testGetClassNamesForState() {
-      // These tests use assertArrayEquals, because the order is significant.
-      assertArrayEquals('ControlRenderer must return expected class names ' +
-          'in the expected order',
-          ['goog-control-hover', 'goog-control-checked'],
-          controlRenderer.getClassNamesForState(goog.ui.Component.State.HOVER |
-              goog.ui.Component.State.CHECKED));
-      assertArrayEquals('TestRenderer must return expected class names ' +
-          'in the expected order',
-          ['goog-base-hover', 'goog-base-checked'],
-          testRenderer.getClassNamesForState(goog.ui.Component.State.HOVER |
-              goog.ui.Component.State.CHECKED));
-    }
-    function testGetClassForState() {
-      var renderer = new goog.ui.ControlRenderer();
-      assertUndefined('State-to-class map must not exist until first use',
-          renderer.classByState_);
-      assertEquals('Renderer must return expected class name for SELECTED',
-          'goog-control-selected',
-          renderer.getClassForState(goog.ui.Component.State.SELECTED));
-      assertUndefined('Renderer must return undefined for invalid state',
-          renderer.getClassForState('foo'));
-    }
-    function testGetStateFromClass() {
-      var renderer = new goog.ui.ControlRenderer();
-      assertUndefined('Class-to-state map must not exist until first use',
-          renderer.stateByClass_);
-      assertEquals('Renderer must return expected state',
-          goog.ui.Component.State.SELECTED,
-          renderer.getStateFromClass('goog-control-selected'));
-      assertEquals('Renderer must return 0x00 for unknown class',
-          0x00,
-          renderer.getStateFromClass('goog-control-annoyed'));
-    }
-    function testIe6ClassCombinationsCreateDom() {
-      control.setRenderer(testRenderer);
-      control.enableClassName('combined', true);
-      control.createDom();
-      var element = control.getElement();
-      testRenderer.setState(control, goog.ui.Component.State.DISABLED, true);
-      var expectedClasses = [
-        'combined',
-        'goog-base',
-        'goog-base-disabled',
-        'goog-button'
-      ];
-      if (isIe6()) {
-        assertSameElements('IE6 and lower should have one combined class',
-            expectedClasses.concat(['combined_goog-base-disabled_goog-button']),
-            goog.dom.classes.get(element));
-      } else {
-        assertSameElements('Non IE6 browsers should not have a combined class',
-            expectedClasses, goog.dom.classes.get(element));
-      }
-      testRenderer.setState(control, goog.ui.Component.State.DISABLED, false);
-      testRenderer.setState(control, goog.ui.Component.State.HOVER, true);
-      var expectedClasses = [
-        'combined',
-        'goog-base',
-        'goog-base-hover',
-        'goog-button'
-      ];
-      if (isIe6()) {
-        assertSameElements('IE6 and lower should have one combined class',
-            expectedClasses.concat(['combined_goog-base-hover_goog-button']),
-            goog.dom.classes.get(element));
-      } else {
-        assertSameElements('Non IE6 browsers should not have a combined class',
-            expectedClasses, goog.dom.classes.get(element));
-      }
-      testRenderer.setRightToLeft(element, true);
-      testRenderer.enableExtraClassName(control, 'combined2', true);
-      var expectedClasses = [
-        'combined',
-        'combined2',
-        'goog-base',
-        'goog-base-hover',
-        'goog-base-rtl',
-        'goog-button'
-      ];
-      if (isIe6()) {
-        assertSameElements('IE6 and lower should have two combined class',
-            expectedClasses.concat([
-              'combined_goog-base-hover_goog-button',
-              'combined_combined2_goog-base-hover_goog-base-rtl_goog-button'
-            ]), goog.dom.classes.get(element));
-      } else {
-        assertSameElements('Non IE6 browsers should not have a combined class',
-            expectedClasses, goog.dom.classes.get(element));
-      }
-    }
-    function testIe6ClassCombinationsDecorate() {
-      sandbox.innerHTML =
-          '<div id="foo" class="combined goog-base-hover"></div>';
-      var foo = goog.dom.getElement('foo');
-      var element = testRenderer.decorate(control, foo);
-      var expectedClasses = [
-        'combined',
-        'goog-base',
-        'goog-base-hover',
-        'goog-button'
-      ];
-      if (isIe6()) {
-        assertSameElements('IE6 and lower should have one combined class',
-            expectedClasses.concat(['combined_goog-base-hover_goog-button']),
-            goog.dom.classes.get(element));
-      } else {
-        assertSameElements('Non IE6 browsers should not have a combined class',
-            expectedClasses, goog.dom.classes.get(element));
-      }
-    }
-  </script>
-</body>
-</html>