selenium-webdriver 3.1.0 → 3.6.0

package/lib/capabilities.js

@@ -132,7 +132,7 @@ const Capability = {
    * Defines how the driver should handle unexpected alerts. The value should
    * be one of "accept", "dismiss", or "ignore".
    */
-  UNEXPECTED_ALERT_BEHAVIOR: 'unexpectedAlertBehavior',
+  UNEXPECTED_ALERT_BEHAVIOR: 'unexpectedAlertBehaviour',
 
   /** Defines the browser version. */
   VERSION: 'version'
@@ -204,16 +204,19 @@ function toMap(hash) {
 /**
  * Describes a set of capabilities for a WebDriver session.
  */
-class Capabilities extends Map {
+class Capabilities {
   /**
-   * @param {(Capabilities|Map<string, ?>|Object)=} opt_other Another set of
+   * @param {(Capabilities|Map<string, ?>|Object)=} other Another set of
    *     capabilities to initialize this instance from.
    */
-  constructor(opt_other) {
-    if (opt_other && !(opt_other instanceof Map)) {
-      opt_other = toMap(opt_other);
+  constructor(other = undefined) {
+    if (other instanceof Capabilities) {
+      other = other.map_;
+    } else if (other && !(other instanceof Map)) {
+      other = toMap(other);
     }
-    super(opt_other);
+    /** @private @const {!Map<string, ?>} */
+    this.map_ = new Map(other);
   }
 
   /**
@@ -221,8 +224,7 @@ class Capabilities extends Map {
    */
   static android() {
     return new Capabilities()
-        .set(Capability.BROWSER_NAME, Browser.ANDROID)
-        .set(Capability.PLATFORM, 'ANDROID');
+        .set(Capability.BROWSER_NAME, Browser.ANDROID);
   }
 
   /**
@@ -237,8 +239,7 @@ class Capabilities extends Map {
    */
   static edge() {
     return new Capabilities()
-        .set(Capability.BROWSER_NAME, Browser.EDGE)
-        .set(Capability.PLATFORM, 'WINDOWS');
+        .set(Capability.BROWSER_NAME, Browser.EDGE);
   }
 
   /**
@@ -253,8 +254,7 @@ class Capabilities extends Map {
    */
   static ie() {
     return new Capabilities().
-        set(Capability.BROWSER_NAME, Browser.INTERNET_EXPLORER).
-        set(Capability.PLATFORM, 'WINDOWS');
+        set(Capability.BROWSER_NAME, Browser.INTERNET_EXPLORER);
   }
 
   /**
@@ -262,8 +262,7 @@ class Capabilities extends Map {
    */
   static ipad() {
     return new Capabilities().
-        set(Capability.BROWSER_NAME, Browser.IPAD).
-        set(Capability.PLATFORM, 'MAC');
+        set(Capability.BROWSER_NAME, Browser.IPAD);
   }
 
   /**
@@ -271,8 +270,7 @@ class Capabilities extends Map {
    */
   static iphone() {
     return new Capabilities().
-        set(Capability.BROWSER_NAME, Browser.IPHONE).
-        set(Capability.PLATFORM, 'MAC');
+        set(Capability.BROWSER_NAME, Browser.IPHONE);
   }
 
   /**
@@ -296,8 +294,7 @@ class Capabilities extends Map {
    */
   static safari() {
     return new Capabilities().
-        set(Capability.BROWSER_NAME, Browser.SAFARI).
-        set(Capability.PLATFORM, 'MAC');
+        set(Capability.BROWSER_NAME, Browser.SAFARI);
   }
 
   /**
@@ -328,6 +325,35 @@ class Capabilities extends Map {
     return serialize(this);
   }
 
+  /**
+   * @param {string} key the parameter key to get.
+   * @return {T} the stored parameter value.
+   * @template T
+   */
+  get(key) {
+    return this.map_.get(key);
+  }
+
+  /**
+   * @param {string} key the key to test.
+   * @return {boolean} whether this capability set has the specified key.
+   */
+  has(key) {
+    return this.map_.has(key);
+  }
+
+  /**
+   * @return {!Iterator<string>} an iterator of the keys set.
+   */
+  keys() {
+    return this.map_.keys();
+  }
+
+  /** @return {number} The number of capabilities set. */
+  get size() {
+    return this.map_.size;
+  }
+
   /**
    * Merges another set of capabilities into this instance.
    * @param {!(Capabilities|Map<String, ?>|Object<string, ?>)} other The other
@@ -339,7 +365,12 @@ class Capabilities extends Map {
       throw new TypeError('no capabilities provided for merge');
     }
 
-    if (!(other instanceof Map)) {
+    let map;
+    if (other instanceof Capabilities) {
+      map = other.map_;
+    } else if (other instanceof Map) {
+      map = other;
+    } else {
       other = toMap(other);
     }
 
@@ -350,18 +381,26 @@ class Capabilities extends Map {
     return this;
   }
 
+  /**
+   * Deletes an entry from this set of capabilities.
+   *
+   * @param {string} key the capability key to delete.
+   */
+  delete(key) {
+    this.map_.delete(key);
+  }
+
   /**
    * @param {string} key The capability key.
    * @param {*} value The capability value.
    * @return {!Capabilities} A self reference.
    * @throws {TypeError} If the `key` is not a string.
-   * @override
    */
   set(key, value) {
     if (typeof key !== 'string') {
       throw new TypeError('Capability keys must be strings: ' + typeof key);
     }
-    super.set(key, value);
+    this.map_.set(key, value);
     return this;
   }
 

package/lib/command.js

@@ -150,6 +150,8 @@ const Name = {
   TAKE_ELEMENT_SCREENSHOT: 'takeElementScreenshot',
   IMPLICITLY_WAIT: 'implicitlyWait',
   SET_SCRIPT_TIMEOUT: 'setScriptTimeout',
+
+  GET_TIMEOUT: 'getTimeout',
   SET_TIMEOUT: 'setTimeout',
 
   ACCEPT_ALERT: 'acceptAlert',

package/lib/error.js

@@ -28,6 +28,14 @@ class WebDriverError extends Error {
 
     /** @override */
     this.name = this.constructor.name;
+
+    /**
+     * A stacktrace reported by the remote webdriver endpoint that initially
+     * reported this error. This property will be an empty string if the remote
+     * end did not provide a stacktrace.
+     * @type {string}
+     */
+    this.remoteStacktrace = '';
   }
 }
 
@@ -43,11 +51,27 @@ class ElementNotSelectableError extends WebDriverError {
 }
 
 
+/**
+ * Indicates a command could not be completed because the target element is
+ * not pointer or keyboard interactable. This will often occur if an element
+ * is present in the DOM, but not rendered (i.e. its CSS style has
+ * "display: none").
+ */
+class ElementNotInteractableError extends WebDriverError {
+  /** @param {string=} opt_error the error message, if any. */
+  constructor(opt_error) {
+    super(opt_error);
+  }
+}
+
+
 /**
  * An element command could not be completed because the element is not visible
  * on the page.
+ *
+ * @deprecated Use {@link ElementNotInteractable} instead.
  */
-class ElementNotVisibleError extends WebDriverError {
+class ElementNotVisibleError extends ElementNotInteractableError {
   /** @param {string=} opt_error the error message, if any. */
   constructor(opt_error) {
     super(opt_error);
@@ -392,6 +416,7 @@ const LEGACY_ERROR_CODE_TO_TYPE = new Map([
 
 const ERROR_CODE_TO_TYPE = new Map([
     ['unknown error', WebDriverError],
+    ['element not interactable', ElementNotInteractableError],
     ['element not selectable', ElementNotSelectableError],
     ['element not visible', ElementNotVisibleError],
     ['invalid argument', InvalidArgumentError],
@@ -486,7 +511,11 @@ function isErrorResponse(data) {
 function throwDecodedError(data) {
   if (isErrorResponse(data)) {
     let ctor = ERROR_CODE_TO_TYPE.get(data.error) || WebDriverError;
-    throw new ctor(data.message);
+    let err = new ctor(data.message);
+    if (typeof data.stacktrace === 'string') {
+      err.remoteStacktrace = data.stacktrace;
+    }
+    throw err;
   }
   throw new WebDriverError('Unknown error: ' + JSON.stringify(data));
 }
@@ -535,6 +564,7 @@ module.exports = {
   ErrorCode: ErrorCode,
 
   WebDriverError: WebDriverError,
+  ElementNotInteractableError: ElementNotInteractableError,
   ElementNotSelectableError: ElementNotSelectableError,
   ElementNotVisibleError: ElementNotVisibleError,
   InvalidArgumentError: InvalidArgumentError,

package/lib/http.js

@@ -32,10 +32,10 @@ const promise = require('./promise');
 const Session = require('./session').Session;
 const WebElement = require('./webdriver').WebElement;
 
-const {getAttribute, isDisplayed} = (function() {
+const {getAttribute, isDisplayed} = /** @suppress {undefinedVars|uselessCode} */(function() {
   try {
     return {
-      getAttribute: require('./atoms/getAttribute.js'),
+      getAttribute: require('./atoms/get-attribute.js'),
       isDisplayed: require('./atoms/is-displayed.js')
     };
   } catch (ex) {
@@ -225,6 +225,7 @@ const COMMAND_MAP = new Map([
     [cmd.Name.EXECUTE_SCRIPT, post('/session/:sessionId/execute')],
     [cmd.Name.EXECUTE_ASYNC_SCRIPT, post('/session/:sessionId/execute_async')],
     [cmd.Name.SCREENSHOT, get('/session/:sessionId/screenshot')],
+    [cmd.Name.GET_TIMEOUT, get('/session/:sessionId/timeouts')],
     [cmd.Name.SET_TIMEOUT, post('/session/:sessionId/timeouts')],
     [cmd.Name.MOVE_TO, post('/session/:sessionId/moveto')],
     [cmd.Name.CLICK, post('/session/:sessionId/click')],
@@ -256,6 +257,10 @@ const COMMAND_MAP = new Map([
 /** @const {!Map<string, (CommandSpec|CommandTransformer)>} */
 const W3C_COMMAND_MAP = new Map([
   [cmd.Name.GET_ACTIVE_ELEMENT, get('/session/:sessionId/element/active')],
+  [cmd.Name.GET_ALERT_TEXT, get('/session/:sessionId/alert/text')],
+  [cmd.Name.SET_ALERT_TEXT, post('/session/:sessionId/alert/text')],
+  [cmd.Name.ACCEPT_ALERT, post('/session/:sessionId/alert/accept')],
+  [cmd.Name.DISMISS_ALERT, post('/session/:sessionId/alert/dismiss')],
   [cmd.Name.GET_ELEMENT_ATTRIBUTE, (cmd) => {
     return toExecuteAtomCommand(cmd, Atom.GET_ATTRIBUTE, 'id', 'name');
   }],
@@ -264,11 +269,15 @@ const W3C_COMMAND_MAP = new Map([
   [cmd.Name.IS_ELEMENT_DISPLAYED, (cmd) => {
     return toExecuteAtomCommand(cmd, Atom.IS_DISPLAYED, 'id');
   }],
+  [cmd.Name.EXECUTE_SCRIPT, post('/session/:sessionId/execute/sync')],
+  [cmd.Name.EXECUTE_ASYNC_SCRIPT, post('/session/:sessionId/execute/async')],
   [cmd.Name.MAXIMIZE_WINDOW, post('/session/:sessionId/window/maximize')],
   [cmd.Name.GET_WINDOW_POSITION, get('/session/:sessionId/window/position')],
   [cmd.Name.SET_WINDOW_POSITION, post('/session/:sessionId/window/position')],
   [cmd.Name.GET_WINDOW_SIZE, get('/session/:sessionId/window/size')],
   [cmd.Name.SET_WINDOW_SIZE, post('/session/:sessionId/window/size')],
+  [cmd.Name.GET_CURRENT_WINDOW_HANDLE, get('/session/:sessionId/window')],
+  [cmd.Name.GET_WINDOW_HANDLES, get('/session/:sessionId/window/handles')],
 ]);
 
 
@@ -428,34 +437,29 @@ class Executor {
       return doSend(this, request).then(response => {
         this.log_.finer(() => `>>>\n${request}\n<<<\n${response}`);
 
-        let parsed =
-            parseHttpResponse(
-                command, /** @type {!Response} */ (response), this.w3c);
+        let httpResponse = /** @type {!Response} */(response);
+        let {isW3C, value} = parseHttpResponse(command, httpResponse);
 
         if (command.getName() === cmd.Name.NEW_SESSION
             || command.getName() === cmd.Name.DESCRIBE_SESSION) {
-          if (!parsed || !parsed['sessionId']) {
+          if (!value || !value.sessionId) {
             throw new error.WebDriverError(
-                'Unable to parse new session response: ' + response.body);
+                `Unable to parse new session response: ${response.body}`);
           }
 
           // The remote end is a W3C compliant server if there is no `status`
           // field in the response. This is not applicable for the DESCRIBE_SESSION
           // command, which is not defined in the W3C spec.
           if (command.getName() === cmd.Name.NEW_SESSION) {
-            this.w3c = this.w3c || !('status' in parsed);
+            this.w3c = this.w3c || isW3C;
           }
 
-          return new Session(parsed['sessionId'], parsed['value']);
+          // No implementations use the `capabilities` key yet...
+          let capabilities = value.capabilities || value.value;
+          return new Session(value.sessionId, capabilities);
         }
 
-        if (parsed
-            && typeof parsed === 'object'
-            && 'value' in parsed) {
-          let value = parsed['value'];
-          return typeof value === 'undefined' ? null : value;
-        }
-        return parsed;
+        return typeof value === 'undefined' ? null : value;
       });
     });
   }
@@ -481,40 +485,45 @@ function tryParse(str) {
  *
  * @param {!cmd.Command} command The command the response is for.
  * @param {!Response} httpResponse The HTTP response to parse.
- * @param {boolean} w3c Whether the response should be processed using the
- *     W3C wire protocol.
- * @return {?} The parsed response.
+ * @return {{isW3C: boolean, value: ?}} An object describing the parsed
+ *     response. This object will have two fields: `isW3C` indicates whether
+ *     the response looks like it came from a remote end that conforms with the
+ *     W3C WebDriver spec, and `value`, the actual response value.
  * @throws {WebDriverError} If the HTTP response is an error.
  */
-function parseHttpResponse(command, httpResponse, w3c) {
-  let parsed = tryParse(httpResponse.body);
-  if (parsed !== undefined) {
-    if (httpResponse.status < 200) {
-      // This should never happen, but throw the raw response so
-      // users report it.
-      throw new error.WebDriverError(
-          `Unexpected HTTP response:\n${httpResponse}`);
-    }
+function parseHttpResponse(command, httpResponse) {
+  if (httpResponse.status < 200) {
+    // This should never happen, but throw the raw response so users report it.
+    throw new error.WebDriverError(
+        `Unexpected HTTP response:\n${httpResponse}`);
+  }
 
-    if (w3c) {
-      if (httpResponse.status > 399) {
-        error.throwDecodedError(parsed);
+  let parsed = tryParse(httpResponse.body);
+  if (parsed && typeof parsed === 'object') {
+    let value = parsed.value;
+    let isW3C =
+        value !== null && typeof value === 'object'
+            && typeof parsed.status === 'undefined';
+
+    if (!isW3C) {
+      error.checkLegacyResponse(parsed);
+
+      // Adjust legacy new session responses to look like W3C to simplify
+      // later processing.
+      if (command.getName() === cmd.Name.NEW_SESSION
+          || command.getName() == cmd.Name.DESCRIBE_SESSION) {
+        value = parsed;
       }
-      return parsed;
-    }
 
-    // If this is a new session command, we need to check for a W3C compliant
-    // error object. This is necessary since a successful new session command
-    // is what puts the executor into W3C mode.
-    if (httpResponse.status > 399
-        && (command.getName() == cmd.Name.NEW_SESSION
-            || command.getName() === cmd.Name.DESCRIBE_SESSION)
-        && error.isErrorResponse(parsed)) {
-      error.throwDecodedError(parsed);
+    } else if (httpResponse.status > 399) {
+      error.throwDecodedError(value);
     }
 
-    error.checkLegacyResponse(parsed);
-    return parsed;
+    return {isW3C, value};
+  }
+
+  if (parsed !== undefined) {
+    return {isW3C: false, value: parsed};
   }
 
   let value = httpResponse.body.replace(/\r\n/g, '\n');
@@ -527,7 +536,7 @@ function parseHttpResponse(command, httpResponse, w3c) {
     throw new error.WebDriverError(value);
   }
 
-  return value || null;
+  return {isW3C: false, value: value || null};
 }
 
 

package/lib/promise.js

@@ -33,13 +33,12 @@
  * > style tests:
  * >
  * > ```js
- * > const {Builder, By, promise, until} = require('selenium-webdriver');
+ * > const {Builder, By, Key, promise, until} = require('selenium-webdriver');
  * >
  * > let result = promise.consume(function* doGoogleSearch() {
  * >   let driver = new Builder().forBrowser('firefox').build();
  * >   yield driver.get('http://www.google.com/ncr');
- * >   yield driver.findElement(By.name('q')).sendKeys('webdriver');
- * >   yield driver.findElement(By.name('btnG')).click();
+ * >   yield driver.findElement(By.name('q')).sendKeys('webdriver', Key.RETURN);
  * >   yield driver.wait(until.titleIs('webdriver - Google Search'), 1000);
  * >   yield driver.quit();
  * > });
@@ -63,8 +62,7 @@
  * control flow, allowing users to write
  *
  *     driver.get('http://www.google.com/ncr');
- *     driver.findElement({name: 'q'}).sendKeys('webdriver');
- *     driver.findElement({name: 'btnGn'}).click();
+ *     driver.findElement({name: 'q'}).sendKeys('webdriver', Key.RETURN);
  *
  * instead of
  *
@@ -73,13 +71,7 @@
  *       return driver.findElement({name: 'q'});
  *     })
  *     .then(function(q) {
- *       return q.sendKeys('webdriver');
- *     })
- *     .then(function() {
- *       return driver.findElement({name: 'btnG'});
- *     })
- *     .then(function(btnG) {
- *       return btnG.click();
+ *       return q.sendKeys('webdriver', Key.RETURN);
  *     });
  *
  * ## Tasks and Task Queues
@@ -1003,6 +995,9 @@ const PromiseState = {
  */
 const ON_CANCEL_HANDLER = new WeakMap;
 
+const SKIP_LOG = Symbol('skip-log');
+const FLOW_LOG = logging.getLogger('promise.ControlFlow');
+
 
 /**
  * Represents the eventual value of a completed operation. Each promise may be
@@ -1025,14 +1020,29 @@ class ManagedPromise {
    *     functions, one for fulfilling the promise and another for rejecting it.
    * @param {ControlFlow=} opt_flow The control flow
    *     this instance was created under. Defaults to the currently active flow.
+   * @param {?=} opt_skipLog An internal parameter used to skip logging the
+   *     creation of this promise. This parameter has no effect unless it is
+   *     strictly equal to an internal symbol. In other words, this parameter
+   *     is always ignored for external code.
    */
-  constructor(resolver, opt_flow) {
+  constructor(resolver, opt_flow, opt_skipLog) {
     if (!usePromiseManager()) {
       throw TypeError(
         'Unable to create a managed promise instance: the promise manager has'
             + ' been disabled by the SELENIUM_PROMISE_MANAGER environment'
             + ' variable: ' + process.env['SELENIUM_PROMISE_MANAGER']);
+    } else if (opt_skipLog !== SKIP_LOG) {
+      FLOW_LOG.warning(() => {
+        let e =
+            captureStackTrace(
+                'ManagedPromiseError',
+                'Creating a new managed Promise. This call will fail when the'
+                    + ' promise manager is disabled',
+            ManagedPromise)
+        return e.stack;
+      });
     }
+
     getUid(this);
 
     /** @private {!ControlFlow} */
@@ -1432,15 +1442,19 @@ class Deferred {
   /**
    * @param {ControlFlow=} opt_flow The control flow this instance was
    *     created under. This should only be provided during unit tests.
+   * @param {?=} opt_skipLog An internal parameter used to skip logging the
+   *     creation of this promise. This parameter has no effect unless it is
+   *     strictly equal to an internal symbol. In other words, this parameter
+   *     is always ignored for external code.
    */
-  constructor(opt_flow) {
+  constructor(opt_flow, opt_skipLog) {
     var fulfill, reject;
 
     /** @type {!ManagedPromise<T>} */
     this.promise = new ManagedPromise(function(f, r) {
       fulfill = f;
       reject = r;
-    }, opt_flow);
+    }, opt_flow, opt_skipLog);
 
     var self = this;
     var checkNotSelf = function(value) {
@@ -1563,9 +1577,17 @@ function defer() {
 function fulfilled(opt_value) {
   let ctor = usePromiseManager() ? ManagedPromise : NativePromise;
   if (opt_value instanceof ctor) {
-    return /** @type {!Thenable<T>} */(opt_value);
+    return /** @type {!Thenable} */(opt_value);
+  }
+
+  if (usePromiseManager()) {
+    // We can skip logging warnings about creating a managed promise because
+    // this function will automatically switch to use a native promise when
+    // the promise manager is disabled.
+    return new ManagedPromise(
+        resolve => resolve(opt_value), undefined, SKIP_LOG);
   }
-  return ctor.resolve(opt_value);
+  return NativePromise.resolve(opt_value);
 }
 
 
@@ -1582,7 +1604,11 @@ function fulfilled(opt_value) {
  */
 function rejected(opt_reason) {
   if (usePromiseManager()) {
-    return ManagedPromise.reject(opt_reason);
+    // We can skip logging warnings about creating a managed promise because
+    // this function will automatically switch to use a native promise when
+    // the promise manager is disabled.
+    return new ManagedPromise(
+        (_, reject) => reject(opt_reason), undefined, SKIP_LOG);
   }
   return NativePromise.reject(opt_reason);
 }
@@ -2444,15 +2470,31 @@ class ControlFlow extends events.EventEmitter {
     }
 
     if (!this.hold_) {
-      var holdIntervalMs = 2147483647;  // 2^31-1; max timer length for Node.js
+      let holdIntervalMs = 2147483647;  // 2^31-1; max timer length for Node.js
       this.hold_ = setInterval(function() {}, holdIntervalMs);
     }
 
-    var task = new Task(
+    let task = new Task(
         this, fn, opt_description || '<anonymous>',
-        {name: 'Task', top: ControlFlow.prototype.execute});
+        {name: 'Task', top: ControlFlow.prototype.execute},
+        true);
+
+    let q = this.getActiveQueue_();
+
+    for (let i = q.tasks_.length; i > 0; i--) {
+      let previousTask = q.tasks_[i - 1];
+      if (previousTask.userTask_) {
+        FLOW_LOG.warning(() => {
+          return `Detected scheduling of an unchained task.
+When the promise manager is disabled, unchained tasks will not wait for
+previously scheduled tasks to finish before starting to execute.
+New task: ${task.promise.stack_.stack}
+Previous task: ${previousTask.promise.stack_.stack}`.split(/\n/).join('\n    ');
+        });
+        break;
+      }
+    }
 
-    var q = this.getActiveQueue_();
     q.enqueue(task);
     this.emit(ControlFlow.EventType.SCHEDULE_TASK, task.description);
     return task.promise;
@@ -2460,7 +2502,7 @@ class ControlFlow extends events.EventEmitter {
 
   /** @override */
   promise(resolver) {
-    return new ManagedPromise(resolver, this);
+    return new ManagedPromise(resolver, this, SKIP_LOG);
   }
 
   /** @override */
@@ -2729,9 +2771,11 @@ class Task extends Deferred {
    * @param {string} description A description of the task for debugging.
    * @param {{name: string, top: !Function}=} opt_stackOptions Options to use
    *     when capturing the stacktrace for when this task was created.
+   * @param {boolean=} opt_isUserTask Whether this task was explicitly scheduled
+   *     by the use of the promise manager.
    */
-  constructor(flow, fn, description, opt_stackOptions) {
-    super(flow);
+  constructor(flow, fn, description, opt_stackOptions, opt_isUserTask) {
+    super(flow, SKIP_LOG);
     getUid(this);
 
     /** @type {function(): (T|!ManagedPromise<T>)} */
@@ -2743,6 +2787,9 @@ class Task extends Deferred {
     /** @type {TaskQueue} */
     this.queue = null;
 
+    /** @private @const {boolean} */
+    this.userTask_ = !!opt_isUserTask;
+
     /**
      * Whether this task is considered block. A blocked task may be registered
      * in a task queue, but will be dropped if it is still blocked when it

package/lib/test/data/click_tests/disabled_element.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Clicking on a disabled element</title>
+</head>
+<body>
+<h1>See below</h1>
+<form action="POST">
+  <input name="disabled" disabled="disabled" />
+</form>
+</body>
+</html>

package/lib/test/data/content-editable.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Testing content editable</title>
+</head>
+<body>
+  <div id="editable" contenteditable="true">
+    Why <span>hello</span></div>
+</body>
+</html>