Convert execCommand/unlink.html to use w3c test harness

third_party/WebKit/LayoutTests/editing/assert_selection.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 'use strict';
 
 // This file provides |assert_selection(sample, tester, expectedText)| assertion
 // to W3C test harness to write editing test cases easier.
 //
 // |sample| is an HTML fragment text which is inserted as |innerHTML|. It should
@@ skipping 328 matching lines @@
 // import "imported/wpt/html/resources/common.js", since |HTML5_VOID_ELEMENTS|
 // is defined in there.
 /**
  * @const @type {!Set<string>}
  * only void (without end tag) HTML5 elements
  */
 const HTML5_VOID_ELEMENTS = new Set([
   'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input',
   'keygen', 'link', 'meta', 'param', 'source','track', 'wbr' ]);
 
 class Serializer {

[yoichio, 2016/05/30 02:08:36]

Add comment describing simple example of 
sample = new Serializer(selection);
sample.serialize(element).

   /**
    * @public
    * @param {!SampleSelection} selection
    */
   constructor(selection) {
     /** @type {!SampleSelection} */
     this.selection_ = selection;
     /** @type {!Array<strings>} */
     this.strings_ = [];
   }
@@ skipping 52 matching lines @@
     }
     this.emit(text);
   }
 
   /**
    * @private
    * @param {!HTMLElement} element
    * @param {number} nodeIndex
    */
   handleElementNode(element, nodeIndex) {
-    if (element.parenNode === this.selection_.focusNode &&

[yoichio, 2016/05/30 02:08:36]

The strict mode can't check this? Sad,,,

+    if (element.parentNode === this.selection_.focusNode &&
         nodeIndex === this.selection_.focusOffset) {
       this.emit('|');
-    } else if (
-        element === this.selection_.anchorNode &&
-        nodeIndex === this.selection_.anchorOffset) {
+    } else if (element.parentNode === this.selection_.anchorNode &&
+               nodeIndex === this.selection_.anchorOffset) {
       this.emit('^');
     }
     /** @type {string} */
     const tagName = element.tagName.toLowerCase();
     this.emit(`<${tagName}`);
     Array.from(element.attributes)
         .sort((attr1, attr2) => attr1.name.localeCompare(attr2.name))
         .forEach(attr => {
           if (attr.value === '')
             return this.emit(` ${attr.name}`);
           const value = attr.value.replace(/&/g, '&amp;')
                             .replace(/\u0022/g, '&quot;')
                             .replace(/\u0027/g, '&apos;');
           this.emit(` ${attr.name}="${value}"`);
         });
     this.emit('>');
     if (element.childNodes.length === 0 &&
         HTML5_VOID_ELEMENTS.has(tagName)) {
       return;
     }
     /** @type {number} */
     let childIndex = 0;
     for (const child of Array.from(element.childNodes)) {
       this.serializeInternal(child, childIndex);
       ++childIndex;
     }
+    if (element === this.selection_.focusNode &&
+        childIndex === this.selection_.focusOffset) {
+      this.emit('|');
+    } else if (element === this.selection_.anchorNode &&
+               childIndex === this.selection_.anchorOffset) {
+      this.emit('^');
+    }
     this.emit(`</${tagName}>`);
   }
 
   /**
    * @public
    * @param {!HTMLElement} element
    */
   serialize(element) {
     if (this.selection_.isNone)
       return node.outerHTML;
     this.serializeInternal(element, 0);
     return this.strings_.join('');
   }
 
   /**
    * @private
    * @param {!Node} node
    * @param {number} nodeIndex
    */
   serializeInternal(node, nodeIndex) {
     if (isElement(node))
       return this.handleElementNode(node, nodeIndex);
     if (isCharacterData(node))
       return this.handleCharacterData(node);
     throw new Error(`Unexpected node ${node}`);
   }
 }
 
 class Sample {

[yoichio, 2016/05/30 02:08:36]

Add comment describing simple example of 
sample = new Sample(text);
sample.serialize().

   /**
    * @public
    * @param {string} sampleText
    */
   constructor(sampleText) {
     /** @const @type {!HTMLIFame} */
     this.iframe_ = document.createElement('iframe');
     document.body.appendChild(this.iframe_);
     /** @const @type {!HTMLDocument} */
     this.document_ = this.iframe_.contentDocument;
@@ skipping 70 matching lines @@
   for (const line of getStack()) {
     const match = RE_TEST_FUNCTION.exec(line);
     if (!match)
       continue;
     return `${match[1]}(${match[2]})`;
   }
   return '';
 }
 
 /**
+ * @param {string} expectedText
+ */
+function checkExpectedText(expectedText) {

[yoichio, 2016/05/30 02:08:36]

Could you extract sanity check functions from this and |Sample.load|
 like "shouldHaveAtMostOneAnchor(text)" ?

+  /** @type {number} */
+  const anchorOffset = expectedText.indexOf('^');
+  /** @type {number} */
+  const focusOffset = expectedText.indexOf('|');
+  if (anchorOffset != expectedText.lastIndexOf('^')) {
+      throw new Error(
+        `You should have at most one anchor marker "^" in "${expectedText}".`);
+  }
+  if (focusOffset != expectedText.lastIndexOf('|')) {
+      throw new Error(
+        `You should have at most one focus marker "|" in "${expectedText}".`);
+  }
+  if (anchorOffset >= 0 && focusOffset < 0) {
+    throw new Error(
+        `You should have both anchor marker "^" and focus marker "|" in ${expectedText}`);
+  }
+}
+
+/**
  * @param {string} inputText
  * @param {function(!Selection)|string}
  * @param {string} expectedText
  * @param {string=} opt_description
  */
 function assertSelection(
     inputText, tester, expectedText, opt_description = '') {
   /** @type {string} */
   const description =
       opt_description === '' ? assembleDescription() : opt_description;
-  if (expectedText.indexOf('^') != expectedText.lastIndexOf('^')) {
-      throw new Error(
-          `You should have at most one anchor marker "^" in "${expectedText}".`);
-  }
-  if (expectedText.indexOf('|') != expectedText.lastIndexOf('|')) {
-      throw new Error(
-          `You should have at most one focus marker "|" in "${expectedText}".`);
-  }
+  checkExpectedText(expectedText);
   const sample = new Sample(inputText);
   if (typeof(tester) === 'function') {
     tester.call(window, sample.selection);
   } else if (typeof(tester) === 'string') {
     const strings = tester.split(' ');
     sample.document.execCommand(strings[0], false, strings[1]);
   } else {
     throw new Error(`Invalid tester: ${tester}`);
   }
   /** @type {string} */
   const actualText = sample.serialize();
   // We keep sample HTML when assertion is false for ease of debugging test
   // case.
   if (actualText == expectedText)
     sample.remove();
   assert_equals(actualText, expectedText, description);
 }
 
 // Export symbols
 window.Sample = Sample;
 window.assert_selection = assertSelection;
 })();