2016-03-02T18:53:01 LayoutPosition

third_party/WebKit/Source/core/editing/VisibleUnitsTest.cpp

 // Copyright 2015 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.
 
 #include "core/editing/VisibleUnits.h"
 
 #include "core/dom/Text.h"
 #include "core/editing/EditingTestBase.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/html/HTMLTextFormControlElement.h"
@@ skipping 141 matching lines @@
     Element* one = document().getElementById("one");
     Element* two = document().getElementById("two");
 
     EXPECT_EQ('2', characterAfter(createVisiblePositionInDOMTree(*one->firstChild(), 1)));
     EXPECT_EQ('5', characterAfter(createVisiblePositionInFlatTree(*one->firstChild(), 1)));
 
     EXPECT_EQ(0, characterAfter(createVisiblePositionInDOMTree(*two->firstChild(), 2)));
     EXPECT_EQ('1', characterAfter(createVisiblePositionInFlatTree(*two->firstChild(), 2)));
 }
 
+// Replacement of caret-in-empty-inline-1.html and caret-in-empty-inline-2.html
+TEST_F(VisibleUnitsTest, canonicalPositionWithEmptyInline)
+{
+    setBodyContent("<span id=sample contenteditable></span>");
+    updateAllLifecyclePhases();
+    Element* sample = document().getElementById("sample");
+
+    EXPECT_EQ(Position::firstPositionInNode(sample), canonicalPositionOf(Position(sample, 0)));
+    EXPECT_EQ(Position(sample, 0), mostBackwardCaretPosition(Position(sample, 0)));
+}
+
+TEST_F(VisibleUnitsTest, canonicalPositionWithEmptyInlineWithText)
+{
+    setBodyContent("foo<span id=sample contenteditable></span>bar");
+    updateAllLifecyclePhases();
+    Element* sample = document().getElementById("sample");
+
+    EXPECT_EQ(Position::firstPositionInNode(sample), canonicalPositionOf(Position(sample, 0)));
+    EXPECT_EQ(Position(sample, 0), mostBackwardCaretPosition(Position(sample, 0)));
+}
+
+TEST_F(VisibleUnitsTest, canonicalPositionWithEmptyLikeInline)
+{
+    setBodyContent("<span id=sample contenteditable><b></b></span>");
+    updateAllLifecyclePhases();
+    Element* sample = document().getElementById("sample");
+
+    EXPECT_EQ(Position::beforeNode(sample->firstChild()), canonicalPositionOf(Position(sample, 0)));
+    EXPECT_EQ(Position::beforeNode(sample->firstChild()), canonicalPositionOf(Position(sample, 1)));
+    EXPECT_EQ(Position(sample, 0), canonicalPositionOf(Position(sample->firstChild(), 0)));
+    EXPECT_EQ(Position(sample, 0), mostBackwardCaretPosition(Position(sample, 0)));
+    EXPECT_EQ(Position(sample, 0), mostBackwardCaretPosition(Position(sample, 1)));
+    EXPECT_EQ(Position(sample, 0), mostBackwardCaretPosition(Position(sample->firstChild(), 0)));
+}
+
 TEST_F(VisibleUnitsTest, canonicalPositionOfWithHTMLHtmlElement)
 {
     const char* bodyContent = "<html><div id=one contenteditable>1</div><span id=two contenteditable=false>22</span><span id=three contenteditable=false>333</span><span id=four contenteditable=false>333</span></html>";
     setBodyContent(bodyContent);
 
     Node* one = document().querySelector("#one", ASSERT_NO_EXCEPTION);
     Node* two = document().querySelector("#two", ASSERT_NO_EXCEPTION);
     Node* three = document().querySelector("#three", ASSERT_NO_EXCEPTION);
     Node* four = document().querySelector("#four", ASSERT_NO_EXCEPTION);
     Element* html = document().createElement("html", ASSERT_NO_EXCEPTION);
     // Move two, three and four into second html element.
+    // We have: <div id=one>1<html><span id=two>22</span><id=three>333</span><span id=four>333</span></div>
     html->appendChild(two);
     html->appendChild(three);
     html->appendChild(four);
     one->appendChild(html);
     updateAllLifecyclePhases();
 
-    EXPECT_EQ(Position(), canonicalPositionOf(Position(document().documentElement(), 0)));
+    EXPECT_EQ(Position::beforeNode(document().body()), canonicalPositionOf(Position(document().documentElement(), 0)))
+        << "Since we don't have HEAD, HTML@0 is equivalent to before(BODY)";
 
     EXPECT_EQ(Position(one->firstChild(), 0), canonicalPositionOf(Position(one, 0)));
+    // TODO(yosin): mbcp([one, 1)) should equal to mbcp(before(html))
+    EXPECT_EQ(Position(one->firstChild(), 1), mostBackwardCaretPosition(Position(one, 1)));
+    EXPECT_EQ(Position(html, 0), mostBackwardCaretPosition(Position::beforeNode(html)));
     EXPECT_EQ(Position(one->firstChild(), 1), canonicalPositionOf(Position(one, 1)));
+    EXPECT_EQ(Position(one->firstChild(), 1), canonicalPositionOf(Position::beforeNode(html)));
 
     EXPECT_EQ(Position(one->firstChild(), 0), canonicalPositionOf(Position(one->firstChild(), 0)));
     EXPECT_EQ(Position(one->firstChild(), 1), canonicalPositionOf(Position(one->firstChild(), 1)));
 
-    EXPECT_EQ(Position(html, 0), canonicalPositionOf(Position(html, 0)));
-    EXPECT_EQ(Position(html, 1), canonicalPositionOf(Position(html, 1)));
-    EXPECT_EQ(Position(html, 2), canonicalPositionOf(Position(html, 2)));
+    EXPECT_EQ(Position(html, 0), mostBackwardCaretPosition(Position(html, 0)));
+    EXPECT_EQ(Position(two, 0), mostBackwardCaretPosition(Position::beforeNode(two)));
+    EXPECT_EQ(Position(one->firstChild(), 1), canonicalPositionOf(Position(html, 0)));
+
+    EXPECT_EQ(Position(html, 1), mostBackwardCaretPosition(Position(html, 1)));
+    EXPECT_EQ(Position(three, 0), mostBackwardCaretPosition(Position::beforeNode(three)));
+    EXPECT_EQ(Position::beforeNode(three), canonicalPositionOf(Position(html, 1)));
+
+    EXPECT_EQ(Position(html, 2), mostBackwardCaretPosition(Position(html, 2)));
+    EXPECT_EQ(Position::beforeNode(four), canonicalPositionOf(Position(html, 2)));
 
     EXPECT_EQ(Position(two->firstChild(), 0), canonicalPositionOf(Position(two, 0)));
     EXPECT_EQ(Position(two->firstChild(), 2), canonicalPositionOf(Position(two, 1)));
 }
 
+TEST_F(VisibleUnitsTest, canonicalPositionOfWithSelect)
+{
+    // From "collapse_before_select.html"
+    const char* bodyContent = "<div id=one contenteditable><select><option>one</select></select>blah</div>";
+    setBodyContent(bodyContent);
+    updateAllLifecyclePhases();
+
+    Element* select = document().querySelector("select", ASSERT_NO_EXCEPTION);
+
+    EXPECT_EQ(Position::beforeNode(select), createVisiblePositionInDOMTree(*select, 0).deepEquivalent());
+}
+
 TEST_F(VisibleUnitsTest, characterBefore)
 {
     const char* bodyContent = "<p id=host><b id=one>1</b><b id=two>22</b></p><b id=three>333</b>";
     const char* shadowContent = "<b id=four>4444</b><content select=#two></content><content select=#one></content><b id=five>5555</b>";
     setBodyContent(bodyContent);
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
     Node* one = document().getElementById("one")->firstChild();
     Node* two = document().getElementById("two")->firstChild();
     Node* five = shadowRoot->getElementById("five")->firstChild();
 
-    EXPECT_EQ(0, characterBefore(createVisiblePositionInDOMTree(*one, 0)));
+    EXPECT_EQ('2', characterBefore(createVisiblePositionInDOMTree(*one, 0)))
+        << "VisiblePosition uses layout tree.";
     EXPECT_EQ('2', characterBefore(createVisiblePositionInFlatTree(*one, 0)));
 
     EXPECT_EQ('1', characterBefore(createVisiblePositionInDOMTree(*one, 1)));
     EXPECT_EQ('1', characterBefore(createVisiblePositionInFlatTree(*one, 1)));
 
-    EXPECT_EQ('1', characterBefore(createVisiblePositionInDOMTree(*two, 0)));
+    EXPECT_EQ('4', characterBefore(createVisiblePositionInDOMTree(*two, 0)))
+        << "VisiblePosition uses layout tree.";
     EXPECT_EQ('4', characterBefore(createVisiblePositionInFlatTree(*two, 0)));
 
-    EXPECT_EQ('4', characterBefore(createVisiblePositionInDOMTree(*five, 0)));
+    EXPECT_EQ('1', characterBefore(createVisiblePositionInDOMTree(*five, 0)))
+        << "VisiblePosition uses layout tree.";
     EXPECT_EQ('1', characterBefore(createVisiblePositionInFlatTree(*five, 0)));
 }
 
 TEST_F(VisibleUnitsTest, computeInlineBoxPosition)
 {
     const char* bodyContent = "<p id=host><b id=one>1</b><b id=two>22</b></p><b id=three>333</b>";
     const char* shadowContent = "<b id=four>4444</b><content select=#two></content><content select=#one></content><b id=five>5555</b>";
     setBodyContent(bodyContent);
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
@@ skipping 23 matching lines @@
 TEST_F(VisibleUnitsTest, endOfDocument)
 {
     const char* bodyContent = "<a id=host><b id=one>1</b><b id=two>22</b></a>";
     const char* shadowContent = "<p><content select=#two></content></p><p><content select=#one></content></p>";
     setBodyContent(bodyContent);
     setShadowContent(shadowContent, "host");
 
     Element* one = document().getElementById("one");
     Element* two = document().getElementById("two");
 
-    EXPECT_EQ(Position(two->firstChild(), 2), endOfDocument(createVisiblePositionInDOMTree(*one->firstChild(), 0)).deepEquivalent());
+    EXPECT_EQ(Position(one->firstChild(), 1), endOfDocument(createVisiblePositionInDOMTree(*one->firstChild(), 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(one->firstChild(), 1), endOfDocument(createVisiblePositionInFlatTree(*one->firstChild(), 0)).deepEquivalent());
 
-    EXPECT_EQ(Position(two->firstChild(), 2), endOfDocument(createVisiblePositionInDOMTree(*two->firstChild(), 1)).deepEquivalent());
+    EXPECT_EQ(Position(one->firstChild(), 1), endOfDocument(createVisiblePositionInDOMTree(*two->firstChild(), 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(one->firstChild(), 1), endOfDocument(createVisiblePositionInFlatTree(*two->firstChild(), 1)).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, endOfLine)
 {
     const char* bodyContent = "<a id=host><b id=one>11</b><b id=two>22</b></a><i id=three>333</i><i id=four>4444</i><br>";
     const char* shadowContent = "<div><u id=five>55555</u><content select=#two></content><br><u id=six>666666</u><br><content select=#one></content><u id=seven>7777777</u></div>";
     setBodyContent(bodyContent);
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
     Node* one = document().getElementById("one")->firstChild();
     Node* two = document().getElementById("two")->firstChild();
     Node* three = document().getElementById("three")->firstChild();
     Node* four = document().getElementById("four")->firstChild();
     Node* five = shadowRoot->getElementById("five")->firstChild();
     Node* six = shadowRoot->getElementById("six")->firstChild();
     Node* seven = shadowRoot->getElementById("seven")->firstChild();
 
     EXPECT_EQ(Position(seven, 7), endOfLine(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(seven, 7), endOfLine(createVisiblePositionInFlatTree(*one, 0)).deepEquivalent());
 
     EXPECT_EQ(Position(seven, 7), endOfLine(createVisiblePositionInDOMTree(*one, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(seven, 7), endOfLine(createVisiblePositionInFlatTree(*one, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(seven, 7), endOfLine(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent());
+    EXPECT_EQ(Position(two, 2), endOfLine(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 2), endOfLine(createVisiblePositionInFlatTree(*two, 0)).deepEquivalent());
 
     // TODO(yosin) endOfLine(two, 1) -> (five, 5) is a broken result. We keep
     // it as a marker for future change.
-    EXPECT_EQ(Position(five, 5), endOfLine(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent());
+    EXPECT_EQ(Position(two, 2), endOfLine(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 2), endOfLine(createVisiblePositionInFlatTree(*two, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(five, 5), endOfLine(createVisiblePositionInDOMTree(*three, 0)).deepEquivalent());
+    EXPECT_EQ(Position(four, 4), endOfLine(createVisiblePositionInDOMTree(*three, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(four, 4), endOfLine(createVisiblePositionInFlatTree(*three, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(four, 4), endOfLine(createVisiblePositionInDOMTree(*four, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(four, 4), endOfLine(createVisiblePositionInFlatTree(*four, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(five, 5), endOfLine(createVisiblePositionInDOMTree(*five, 1)).deepEquivalent());
+    EXPECT_EQ(Position(two, 2), endOfLine(createVisiblePositionInDOMTree(*five, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 2), endOfLine(createVisiblePositionInFlatTree(*five, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(six, 6), endOfLine(createVisiblePositionInDOMTree(*six, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(six, 6), endOfLine(createVisiblePositionInFlatTree(*six, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(seven, 7), endOfLine(createVisiblePositionInDOMTree(*seven, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(seven, 7), endOfLine(createVisiblePositionInFlatTree(*seven, 1)).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, endOfParagraphFirstLetter)
@@ skipping 84 matching lines @@
     const char* shadowContent = "<p><i id=three>333</i> <content select=#two></content> <content select=#one></content> <i id=four>4444</i></p>";
     setBodyContent(bodyContent);
     setShadowContent(shadowContent, "host");
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
     Node* one = document().getElementById("one")->firstChild();
     Node* two = document().getElementById("two")->firstChild();
     Node* three = shadowRoot->getElementById("three")->firstChild();
     Node* four = shadowRoot->getElementById("four")->firstChild();
 
-    EXPECT_EQ(Position(two, 2), endOfSentence(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent());
+    EXPECT_EQ(Position(four, 4), endOfSentence(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(four, 4), endOfSentence(createVisiblePositionInFlatTree(*one, 0)).deepEquivalent());
 
-    EXPECT_EQ(Position(two, 2), endOfSentence(createVisiblePositionInDOMTree(*one, 1)).deepEquivalent());
+    EXPECT_EQ(Position(four, 4), endOfSentence(createVisiblePositionInDOMTree(*one, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(four, 4), endOfSentence(createVisiblePositionInFlatTree(*one, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(two, 2), endOfSentence(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent());
+    EXPECT_EQ(Position(four, 4), endOfSentence(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(four, 4), endOfSentence(createVisiblePositionInFlatTree(*two, 0)).deepEquivalent());
 
-    EXPECT_EQ(Position(two, 2), endOfSentence(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent());
+    EXPECT_EQ(Position(four, 4), endOfSentence(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(four, 4), endOfSentence(createVisiblePositionInFlatTree(*two, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(four, 4), endOfSentence(createVisiblePositionInDOMTree(*three, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(four, 4), endOfSentence(createVisiblePositionInFlatTree(*three, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(four, 4), endOfSentence(createVisiblePositionInDOMTree(*four, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(four, 4), endOfSentence(createVisiblePositionInFlatTree(*four, 1)).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, endOfWord)
@@ skipping 34 matching lines @@
 TEST_F(VisibleUnitsTest, isEndOfEditableOrNonEditableContent)
 {
     const char* bodyContent = "<a id=host><b id=one contenteditable>1</b><b id=two>22</b></a>";
     const char* shadowContent = "<content select=#two></content></p><p><content select=#one></content>";
     setBodyContent(bodyContent);
     setShadowContent(shadowContent, "host");
 
     Element* one = document().getElementById("one");
     Element* two = document().getElementById("two");
 
-    EXPECT_FALSE(isEndOfEditableOrNonEditableContent(createVisiblePositionInDOMTree(*one->firstChild(), 1)));
+    EXPECT_TRUE(isEndOfEditableOrNonEditableContent(createVisiblePositionInDOMTree(*one->firstChild(), 1))) << "walk in layout tree";
     EXPECT_TRUE(isEndOfEditableOrNonEditableContent(createVisiblePositionInFlatTree(*one->firstChild(), 1)));
 
-    EXPECT_TRUE(isEndOfEditableOrNonEditableContent(createVisiblePositionInDOMTree(*two->firstChild(), 2)));
+    EXPECT_FALSE(isEndOfEditableOrNonEditableContent(createVisiblePositionInDOMTree(*two->firstChild(), 2))) << "walk in layout tree";
     EXPECT_FALSE(isEndOfEditableOrNonEditableContent(createVisiblePositionInFlatTree(*two->firstChild(), 2)));
 }
 
 TEST_F(VisibleUnitsTest, isEndOfEditableOrNonEditableContentWithInput)
 {
     const char* bodyContent = "<input id=sample value=ab>cde";
     setBodyContent(bodyContent);
 
     Node* text = toHTMLTextFormControlElement(document().getElementById("sample"))->innerEditorElement()->firstChild();
 
@@ skipping 21 matching lines @@
     Node* five = shadowRoot->getElementById("five")->firstChild();
     Node* six = shadowRoot->getElementById("six")->firstChild();
     Node* seven = shadowRoot->getElementById("seven")->firstChild();
 
     EXPECT_FALSE(isEndOfLine(createVisiblePositionInDOMTree(*one, 0)));
     EXPECT_FALSE(isEndOfLine(createVisiblePositionInFlatTree(*one, 0)));
 
     EXPECT_FALSE(isEndOfLine(createVisiblePositionInDOMTree(*one, 1)));
     EXPECT_FALSE(isEndOfLine(createVisiblePositionInFlatTree(*one, 1)));
 
-    EXPECT_FALSE(isEndOfLine(createVisiblePositionInDOMTree(*two, 2)));
+    EXPECT_TRUE(isEndOfLine(createVisiblePositionInDOMTree(*two, 2))) << "walk in layout tree";
     EXPECT_TRUE(isEndOfLine(createVisiblePositionInFlatTree(*two, 2)));
 
     EXPECT_FALSE(isEndOfLine(createVisiblePositionInDOMTree(*three, 3)));
     EXPECT_FALSE(isEndOfLine(createVisiblePositionInFlatTree(*three, 3)));
 
     EXPECT_TRUE(isEndOfLine(createVisiblePositionInDOMTree(*four, 4)));
     EXPECT_TRUE(isEndOfLine(createVisiblePositionInFlatTree(*four, 4)));
 
-    EXPECT_TRUE(isEndOfLine(createVisiblePositionInDOMTree(*five, 5)));
+    EXPECT_FALSE(isEndOfLine(createVisiblePositionInDOMTree(*five, 5))) << "walk in layout tree";
     EXPECT_FALSE(isEndOfLine(createVisiblePositionInFlatTree(*five, 5)));
 
     EXPECT_TRUE(isEndOfLine(createVisiblePositionInDOMTree(*six, 6)));
     EXPECT_TRUE(isEndOfLine(createVisiblePositionInFlatTree(*six, 6)));
 
     EXPECT_TRUE(isEndOfLine(createVisiblePositionInDOMTree(*seven, 7)));
     EXPECT_TRUE(isEndOfLine(createVisiblePositionInFlatTree(*seven, 7)));
 }
 
 TEST_F(VisibleUnitsTest, isLogicalEndOfLine)
@@ skipping 10 matching lines @@
     Node* five = shadowRoot->getElementById("five")->firstChild();
     Node* six = shadowRoot->getElementById("six")->firstChild();
     Node* seven = shadowRoot->getElementById("seven")->firstChild();
 
     EXPECT_FALSE(isLogicalEndOfLine(createVisiblePositionInDOMTree(*one, 0)));
     EXPECT_FALSE(isLogicalEndOfLine(createVisiblePositionInFlatTree(*one, 0)));
 
     EXPECT_FALSE(isLogicalEndOfLine(createVisiblePositionInDOMTree(*one, 1)));
     EXPECT_FALSE(isLogicalEndOfLine(createVisiblePositionInFlatTree(*one, 1)));
 
-    EXPECT_FALSE(isLogicalEndOfLine(createVisiblePositionInDOMTree(*two, 2)));
+    EXPECT_TRUE(isLogicalEndOfLine(createVisiblePositionInDOMTree(*two, 2))) << "walk in layout tree";
     EXPECT_TRUE(isLogicalEndOfLine(createVisiblePositionInFlatTree(*two, 2)));
 
     EXPECT_FALSE(isLogicalEndOfLine(createVisiblePositionInDOMTree(*three, 3)));
     EXPECT_FALSE(isLogicalEndOfLine(createVisiblePositionInFlatTree(*three, 3)));
 
     EXPECT_TRUE(isLogicalEndOfLine(createVisiblePositionInDOMTree(*four, 4)));
     EXPECT_TRUE(isLogicalEndOfLine(createVisiblePositionInFlatTree(*four, 4)));
 
-    EXPECT_TRUE(isLogicalEndOfLine(createVisiblePositionInDOMTree(*five, 5)));
+    EXPECT_FALSE(isLogicalEndOfLine(createVisiblePositionInDOMTree(*five, 5))) << "walk in layout tree";
     EXPECT_FALSE(isLogicalEndOfLine(createVisiblePositionInFlatTree(*five, 5)));
 
     EXPECT_TRUE(isLogicalEndOfLine(createVisiblePositionInDOMTree(*six, 6)));
     EXPECT_TRUE(isLogicalEndOfLine(createVisiblePositionInFlatTree(*six, 6)));
 
     EXPECT_TRUE(isLogicalEndOfLine(createVisiblePositionInDOMTree(*seven, 7)));
     EXPECT_TRUE(isLogicalEndOfLine(createVisiblePositionInFlatTree(*seven, 7)));
 }
 
 TEST_F(VisibleUnitsTest, inSameLine)
 {
     const char* bodyContent = "<p id='host'>00<b id='one'>11</b><b id='two'>22</b>33</p>";
     const char* shadowContent = "<div><span id='s4'>44</span><content select=#two></content><br><span id='s5'>55</span><br><content select=#one></content><span id='s6'>66</span></div>";
     setBodyContent(bodyContent);
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
     Element* body = document().body();
     Element* one = body->querySelector("#one", ASSERT_NO_EXCEPTION);
     Element* two = body->querySelector("#two", ASSERT_NO_EXCEPTION);
     Element* four = shadowRoot->querySelector("#s4", ASSERT_NO_EXCEPTION);
     Element* five = shadowRoot->querySelector("#s5", ASSERT_NO_EXCEPTION);
 
-    EXPECT_TRUE(inSameLine(positionWithAffinityInDOMTree(*one, 0), positionWithAffinityInDOMTree(*two, 0)));
-    EXPECT_TRUE(inSameLine(positionWithAffinityInDOMTree(*one->firstChild(), 0), positionWithAffinityInDOMTree(*two->firstChild(), 0)));
+    EXPECT_FALSE(inSameLine(positionWithAffinityInDOMTree(*one, 0), positionWithAffinityInDOMTree(*two, 0))) << "walk in layout tree";
+    EXPECT_FALSE(inSameLine(positionWithAffinityInDOMTree(*one->firstChild(), 0), positionWithAffinityInDOMTree(*two->firstChild(), 0)));
     EXPECT_FALSE(inSameLine(positionWithAffinityInDOMTree(*one->firstChild(), 0), positionWithAffinityInDOMTree(*five->firstChild(), 0)));
-    EXPECT_FALSE(inSameLine(positionWithAffinityInDOMTree(*two->firstChild(), 0), positionWithAffinityInDOMTree(*four->firstChild(), 0)));
+    EXPECT_TRUE(inSameLine(positionWithAffinityInDOMTree(*two->firstChild(), 0), positionWithAffinityInDOMTree(*four->firstChild(), 0))) << "walk in layout tree";
 
-    EXPECT_TRUE(inSameLine(createVisiblePositionInDOMTree(*one, 0), createVisiblePositionInDOMTree(*two, 0)));
-    EXPECT_TRUE(inSameLine(createVisiblePositionInDOMTree(*one->firstChild(), 0), createVisiblePositionInDOMTree(*two->firstChild(), 0)));
+    EXPECT_FALSE(inSameLine(createVisiblePositionInDOMTree(*one, 0), createVisiblePositionInDOMTree(*two, 0))) << "walk in layout tree";
+    EXPECT_FALSE(inSameLine(createVisiblePositionInDOMTree(*one->firstChild(), 0), createVisiblePositionInDOMTree(*two->firstChild(), 0))) << "walk in layout tree";
     EXPECT_FALSE(inSameLine(createVisiblePositionInDOMTree(*one->firstChild(), 0), createVisiblePositionInDOMTree(*five->firstChild(), 0)));
-    EXPECT_FALSE(inSameLine(createVisiblePositionInDOMTree(*two->firstChild(), 0), createVisiblePositionInDOMTree(*four->firstChild(), 0)));
+    EXPECT_TRUE(inSameLine(createVisiblePositionInDOMTree(*two->firstChild(), 0), createVisiblePositionInDOMTree(*four->firstChild(), 0))) << "walk in layout tree";
 
     EXPECT_FALSE(inSameLine(positionWithAffinityInFlatTree(*one, 0), positionWithAffinityInFlatTree(*two, 0)));
     EXPECT_FALSE(inSameLine(positionWithAffinityInFlatTree(*one->firstChild(), 0), positionWithAffinityInFlatTree(*two->firstChild(), 0)));
     EXPECT_FALSE(inSameLine(positionWithAffinityInFlatTree(*one->firstChild(), 0), positionWithAffinityInFlatTree(*five->firstChild(), 0)));
     EXPECT_TRUE(inSameLine(positionWithAffinityInFlatTree(*two->firstChild(), 0), positionWithAffinityInFlatTree(*four->firstChild(), 0)));
 
     EXPECT_FALSE(inSameLine(createVisiblePositionInFlatTree(*one, 0), createVisiblePositionInFlatTree(*two, 0)));
     EXPECT_FALSE(inSameLine(createVisiblePositionInFlatTree(*one->firstChild(), 0), createVisiblePositionInFlatTree(*two->firstChild(), 0)));
     EXPECT_FALSE(inSameLine(createVisiblePositionInFlatTree(*one->firstChild(), 0), createVisiblePositionInFlatTree(*five->firstChild(), 0)));
     EXPECT_TRUE(inSameLine(createVisiblePositionInFlatTree(*two->firstChild(), 0), createVisiblePositionInFlatTree(*four->firstChild(), 0)));
@@ skipping 43 matching lines @@
 
     EXPECT_TRUE(isStartOfLine(createVisiblePositionInDOMTree(*one, 0)));
     EXPECT_TRUE(isStartOfLine(createVisiblePositionInFlatTree(*one, 0)));
 
     EXPECT_FALSE(isStartOfLine(createVisiblePositionInDOMTree(*one, 1)));
     EXPECT_FALSE(isStartOfLine(createVisiblePositionInFlatTree(*one, 1)));
 
     EXPECT_FALSE(isStartOfLine(createVisiblePositionInDOMTree(*two, 0)));
     EXPECT_FALSE(isStartOfLine(createVisiblePositionInFlatTree(*two, 0)));
 
-    EXPECT_FALSE(isStartOfLine(createVisiblePositionInDOMTree(*three, 0)));
+    EXPECT_TRUE(isStartOfLine(createVisiblePositionInDOMTree(*three, 0))) << "walk in layout tree";
     EXPECT_TRUE(isStartOfLine(createVisiblePositionInFlatTree(*three, 0)));
 
     EXPECT_FALSE(isStartOfLine(createVisiblePositionInDOMTree(*four, 0)));
     EXPECT_FALSE(isStartOfLine(createVisiblePositionInFlatTree(*four, 0)));
 
     EXPECT_TRUE(isStartOfLine(createVisiblePositionInDOMTree(*five, 0)));
     EXPECT_TRUE(isStartOfLine(createVisiblePositionInFlatTree(*five, 0)));
 
     EXPECT_TRUE(isStartOfLine(createVisiblePositionInDOMTree(*six, 0)));
     EXPECT_TRUE(isStartOfLine(createVisiblePositionInFlatTree(*six, 0)));
@@ skipping 79 matching lines @@
 
     Element* one = document().getElementById("one");
     Element* two = document().getElementById("two");
     Element* three = document().getElementById("three");
     Element* four = shadowRoot->getElementById("four");
     Element* five = shadowRoot->getElementById("five");
 
     EXPECT_EQ(Position(two->firstChild(), 1), leftPositionOf(createVisiblePosition(Position(one, 0))).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(two->firstChild(), 1), leftPositionOf(createVisiblePosition(PositionInFlatTree(one, 0))).deepEquivalent());
 
-    EXPECT_EQ(Position(one->firstChild(), 0), leftPositionOf(createVisiblePosition(Position(two, 0))).deepEquivalent());
+    EXPECT_EQ(Position(four->firstChild(), 3), leftPositionOf(createVisiblePosition(Position(two, 0))).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(four->firstChild(), 3), leftPositionOf(createVisiblePosition(PositionInFlatTree(two, 0))).deepEquivalent());
 
-    EXPECT_EQ(Position(two->firstChild(), 2), leftPositionOf(createVisiblePosition(Position(three, 0))).deepEquivalent());
+    EXPECT_EQ(Position(five->firstChild(), 5), leftPositionOf(createVisiblePosition(Position(three, 0))).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(five->firstChild(), 5), leftPositionOf(createVisiblePosition(PositionInFlatTree(three, 0))).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, localCaretRectOfPosition)
 {
     const char* bodyContent = "<p id='host'><b id='one'>1</b></p><b id='two'>22</b>";
     const char* shadowContent = "<b id='two'>22</b><content select=#one></content><b id='three'>333</b>";
     setBodyContent(bodyContent);
     setShadowContent(shadowContent, "host");
 
@@ skipping 25 matching lines @@
     Node* five = shadowRoot->getElementById("five")->firstChild();
     Node* six = shadowRoot->getElementById("six")->firstChild();
     Node* seven = shadowRoot->getElementById("seven")->firstChild();
 
     EXPECT_EQ(Position(seven, 7), logicalEndOfLine(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(seven, 7), logicalEndOfLine(createVisiblePositionInFlatTree(*one, 0)).deepEquivalent());
 
     EXPECT_EQ(Position(seven, 7), logicalEndOfLine(createVisiblePositionInDOMTree(*one, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(seven, 7), logicalEndOfLine(createVisiblePositionInFlatTree(*one, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(seven, 7), logicalEndOfLine(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent());
+    EXPECT_EQ(Position(two, 2), logicalEndOfLine(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 2), logicalEndOfLine(createVisiblePositionInFlatTree(*two, 0)).deepEquivalent());
 
     // TODO(yosin) logicalEndOfLine(two, 1) -> (five, 5) is a broken result. We keep
     // it as a marker for future change.
-    EXPECT_EQ(Position(five, 5), logicalEndOfLine(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent());
+    EXPECT_EQ(Position(two, 2), logicalEndOfLine(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 2), logicalEndOfLine(createVisiblePositionInFlatTree(*two, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(five, 5), logicalEndOfLine(createVisiblePositionInDOMTree(*three, 0)).deepEquivalent());
+    EXPECT_EQ(Position(four, 4), logicalEndOfLine(createVisiblePositionInDOMTree(*three, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(four, 4), logicalEndOfLine(createVisiblePositionInFlatTree(*three, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(four, 4), logicalEndOfLine(createVisiblePositionInDOMTree(*four, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(four, 4), logicalEndOfLine(createVisiblePositionInFlatTree(*four, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(five, 5), logicalEndOfLine(createVisiblePositionInDOMTree(*five, 1)).deepEquivalent());
+    EXPECT_EQ(Position(two, 2), logicalEndOfLine(createVisiblePositionInDOMTree(*five, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 2), logicalEndOfLine(createVisiblePositionInFlatTree(*five, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(six, 6), logicalEndOfLine(createVisiblePositionInDOMTree(*six, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(six, 6), logicalEndOfLine(createVisiblePositionInFlatTree(*six, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(seven, 7), logicalEndOfLine(createVisiblePositionInDOMTree(*seven, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(seven, 7), logicalEndOfLine(createVisiblePositionInFlatTree(*seven, 1)).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, logicalStartOfLine)
@@ skipping 10 matching lines @@
     Node* five = shadowRoot->getElementById("five")->firstChild();
     Node* six = shadowRoot->getElementById("six")->firstChild();
     Node* seven = shadowRoot->getElementById("seven")->firstChild();
 
     EXPECT_EQ(Position(one, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(one, 0), logicalStartOfLine(createVisiblePositionInFlatTree(*one, 0)).deepEquivalent());
 
     EXPECT_EQ(Position(one, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*one, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(one, 0), logicalStartOfLine(createVisiblePositionInFlatTree(*one, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent());
+    EXPECT_EQ(Position(five, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(five, 0), logicalStartOfLine(createVisiblePositionInFlatTree(*two, 0)).deepEquivalent());
 
     EXPECT_EQ(Position(five, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(five, 0), logicalStartOfLine(createVisiblePositionInFlatTree(*two, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(five, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*three, 0)).deepEquivalent());
+    EXPECT_EQ(Position(three, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*three, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(three, 0), logicalStartOfLine(createVisiblePositionInFlatTree(*three, 1)).deepEquivalent());
 
     // TODO(yosin) logicalStartOfLine(four, 1) -> (two, 2) is a broken result.
     // We keep it as a marker for future change.
-    EXPECT_EQ(Position(two, 2), logicalStartOfLine(createVisiblePositionInDOMTree(*four, 1)).deepEquivalent());
+    EXPECT_EQ(Position(three, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*four, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(three, 0), logicalStartOfLine(createVisiblePositionInFlatTree(*four, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(five, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*five, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(five, 0), logicalStartOfLine(createVisiblePositionInFlatTree(*five, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(six, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*six, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(six, 0), logicalStartOfLine(createVisiblePositionInFlatTree(*six, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(one, 0), logicalStartOfLine(createVisiblePositionInDOMTree(*seven, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(one, 0), logicalStartOfLine(createVisiblePositionInFlatTree(*seven, 1)).deepEquivalent());
@@ skipping 93 matching lines @@
 TEST_F(VisibleUnitsTest, nextPositionOf)
 {
     const char* bodyContent = "<b id=zero>0</b><p id=host><b id=one>1</b><b id=two>22</b></p><b id=three>333</b>";
     const char* shadowContent = "<b id=four>4444</b><content select=#two></content><content select=#one></content><b id=five>55555</b>";
     setBodyContent(bodyContent);
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
     Element* zero = document().getElementById("zero");
     Element* one = document().getElementById("one");
     Element* two = document().getElementById("two");
-    Element* three = document().getElementById("three");
+    // Element* three = document().getElementById("three");
     Element* four = shadowRoot->getElementById("four");
     Element* five = shadowRoot->getElementById("five");
 
-    EXPECT_EQ(Position(one->firstChild(), 0), nextPositionOf(createVisiblePosition(Position(zero, 1))).deepEquivalent());
+    EXPECT_EQ(Position(four->firstChild(), 0), nextPositionOf(createVisiblePosition(Position(zero, 1))).deepEquivalent())
+        << "visible position walks layout tree";
     EXPECT_EQ(PositionInFlatTree(four->firstChild(), 0), nextPositionOf(createVisiblePosition(PositionInFlatTree(zero, 1))).deepEquivalent());
 
-    EXPECT_EQ(Position(one->firstChild(), 1), nextPositionOf(createVisiblePosition(Position(one, 0))).deepEquivalent());
+    EXPECT_EQ(Position(one->firstChild(), 1), nextPositionOf(createVisiblePosition(Position(one, 0))).deepEquivalent())
+        << "visible position walks layout tree";
     EXPECT_EQ(PositionInFlatTree(one->firstChild(), 1), nextPositionOf(createVisiblePosition(PositionInFlatTree(one, 0))).deepEquivalent());
 
-    EXPECT_EQ(Position(two->firstChild(), 1), nextPositionOf(createVisiblePosition(Position(one, 1))).deepEquivalent());
+    EXPECT_EQ(Position(five->firstChild(), 1), nextPositionOf(createVisiblePosition(Position(one, 1))).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(five->firstChild(), 1), nextPositionOf(createVisiblePosition(PositionInFlatTree(one, 1))).deepEquivalent());
 
-    EXPECT_EQ(Position(three->firstChild(), 0), nextPositionOf(createVisiblePosition(Position(two, 2))).deepEquivalent());
+    EXPECT_EQ(Position(one->firstChild(), 1), nextPositionOf(createVisiblePosition(Position(two, 2))).deepEquivalent())
+        << "visible position walks layout tree";
     EXPECT_EQ(PositionInFlatTree(one->firstChild(), 1), nextPositionOf(createVisiblePosition(PositionInFlatTree(two, 2))).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, previousPositionOf)
 {
     const char* bodyContent = "<b id=zero>0</b><p id=host><b id=one>1</b><b id=two>22</b></p><b id=three>333</b>";
     const char* shadowContent = "<b id=four>4444</b><content select=#two></content><content select=#one></content><b id=five>55555</b>";
     setBodyContent(bodyContent);
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
     Node* zero = document().getElementById("zero")->firstChild();
     Node* one = document().getElementById("one")->firstChild();
     Node* two = document().getElementById("two")->firstChild();
     Node* three = document().getElementById("three")->firstChild();
     Node* four = shadowRoot->getElementById("four")->firstChild();
     Node* five = shadowRoot->getElementById("five")->firstChild();
 
     EXPECT_EQ(Position(zero, 0), previousPositionOf(createVisiblePosition(Position(zero, 1))).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(zero, 0), previousPositionOf(createVisiblePosition(PositionInFlatTree(zero, 1))).deepEquivalent());
 
-    EXPECT_EQ(Position(zero, 1), previousPositionOf(createVisiblePosition(Position(one, 0))).deepEquivalent());
+    EXPECT_EQ(Position(two, 1), previousPositionOf(createVisiblePosition(Position(one, 0))).deepEquivalent())
+        << "visible position walks layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 1), previousPositionOf(createVisiblePosition(PositionInFlatTree(one, 0))).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), previousPositionOf(createVisiblePosition(Position(one, 1))).deepEquivalent());
+    EXPECT_EQ(Position(two, 2), previousPositionOf(createVisiblePosition(Position(one, 1))).deepEquivalent())
+        << "visible position walks layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 2), previousPositionOf(createVisiblePosition(PositionInFlatTree(one, 1))).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), previousPositionOf(createVisiblePosition(Position(two, 0))).deepEquivalent());
+    EXPECT_EQ(Position(four, 3), previousPositionOf(createVisiblePosition(Position(two, 0))).deepEquivalent())
+        << "visible position walks layout tree";
     EXPECT_EQ(PositionInFlatTree(four, 3), previousPositionOf(createVisiblePosition(PositionInFlatTree(two, 0))).deepEquivalent());
 
     // DOM tree to shadow tree
-    EXPECT_EQ(Position(two, 2), previousPositionOf(createVisiblePosition(Position(three, 0))).deepEquivalent());
+    EXPECT_EQ(Position(five, 5), previousPositionOf(createVisiblePosition(Position(three, 0))).deepEquivalent())
+        << "visible position walks layout tree";
     EXPECT_EQ(PositionInFlatTree(five, 5), previousPositionOf(createVisiblePosition(PositionInFlatTree(three, 0))).deepEquivalent());
 
     // Shadow tree to DOM tree
-    EXPECT_EQ(Position(), previousPositionOf(createVisiblePosition(Position(four, 0))).deepEquivalent());
+    EXPECT_EQ(Position(zero, 1), previousPositionOf(createVisiblePosition(Position(four, 0))).deepEquivalent())
+        << "visible position walks layout tree";
     EXPECT_EQ(PositionInFlatTree(zero, 1), previousPositionOf(createVisiblePosition(PositionInFlatTree(four, 0))).deepEquivalent());
 
     // Note: Canonicalization maps (five, 0) to (four, 4) in DOM tree and
     // (one, 1) in flat tree.
-    EXPECT_EQ(Position(four, 4), previousPositionOf(createVisiblePosition(Position(five, 1))).deepEquivalent());
+    EXPECT_EQ(Position(one, 1), previousPositionOf(createVisiblePosition(Position(five, 1))).deepEquivalent())
+        << "visible position walks layout tree";
     EXPECT_EQ(PositionInFlatTree(one, 1), previousPositionOf(createVisiblePosition(PositionInFlatTree(five, 1))).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, previousPositionOfOneCharPerLine)
 {
     const char* bodyContent = "<div id=sample style='font-size: 500px'>A&#x714a;&#xfa67;</div>";
     setBodyContent(bodyContent);
 
     Node* sample = document().getElementById("sample")->firstChild();
 
@@ skipping 59 matching lines @@
     const char* shadowContent = "<p id=four>4444</p><content select=#two></content><content select=#one></content><p id=five>55555</p>";
     setBodyContent(bodyContent);
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
     Node* one = document().getElementById("one")->firstChild();
     Node* two = document().getElementById("two")->firstChild();
     Node* three = document().getElementById("three")->firstChild();
     Node* four = shadowRoot->getElementById("four")->firstChild();
     Node* five = shadowRoot->getElementById("five")->firstChild();
 
-    EXPECT_EQ(Position(), rightPositionOf(createVisiblePosition(Position(one, 1))).deepEquivalent());
+    EXPECT_EQ(Position(five, 0), rightPositionOf(createVisiblePosition(Position(one, 1))).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(five, 0), rightPositionOf(createVisiblePosition(PositionInFlatTree(one, 1))).deepEquivalent());
 
     EXPECT_EQ(Position(one, 1), rightPositionOf(createVisiblePosition(Position(two, 2))).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(one, 1), rightPositionOf(createVisiblePosition(PositionInFlatTree(two, 2))).deepEquivalent());
 
-    EXPECT_EQ(Position(five, 0), rightPositionOf(createVisiblePosition(Position(four, 4))).deepEquivalent());
+    EXPECT_EQ(Position(two, 0), rightPositionOf(createVisiblePosition(Position(four, 4))).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 0), rightPositionOf(createVisiblePosition(PositionInFlatTree(four, 4))).deepEquivalent());
 
-    EXPECT_EQ(Position(), rightPositionOf(createVisiblePosition(Position(five, 5))).deepEquivalent());
+    EXPECT_EQ(Position(three, 0), rightPositionOf(createVisiblePosition(Position(five, 5))).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(three, 0), rightPositionOf(createVisiblePosition(PositionInFlatTree(five, 5))).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, startOfDocument)
 {
     const char* bodyContent = "<a id=host><b id=one>1</b><b id=two>22</b></a>";
     const char* shadowContent = "<p><content select=#two></content></p><p><content select=#one></content></p>";
     setBodyContent(bodyContent);
     setShadowContent(shadowContent, "host");
 
     Node* one = document().getElementById("one")->firstChild();
     Node* two = document().getElementById("two")->firstChild();
 
-    EXPECT_EQ(Position(one, 0), startOfDocument(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent());
+    EXPECT_EQ(Position(two, 0), startOfDocument(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 0), startOfDocument(createVisiblePositionInFlatTree(*one, 0)).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), startOfDocument(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent());
+    EXPECT_EQ(Position(two, 0), startOfDocument(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(two, 0), startOfDocument(createVisiblePositionInFlatTree(*two, 1)).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, startOfLine)
 {
     const char* bodyContent = "<a id=host><b id=one>11</b><b id=two>22</b></a><i id=three>333</i><i id=four>4444</i><br>";
     const char* shadowContent = "<div><u id=five>55555</u><content select=#two></content><br><u id=six>666666</u><br><content select=#one></content><u id=seven>7777777</u></div>";
     setBodyContent(bodyContent);
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
     Node* one = document().getElementById("one")->firstChild();
     Node* two = document().getElementById("two")->firstChild();
     Node* three = document().getElementById("three")->firstChild();
     Node* four = document().getElementById("four")->firstChild();
     Node* five = shadowRoot->getElementById("five")->firstChild();
     Node* six = shadowRoot->getElementById("six")->firstChild();
     Node* seven = shadowRoot->getElementById("seven")->firstChild();
 
     EXPECT_EQ(Position(one, 0), startOfLine(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(one, 0), startOfLine(createVisiblePositionInFlatTree(*one, 0)).deepEquivalent());
 
     EXPECT_EQ(Position(one, 0), startOfLine(createVisiblePositionInDOMTree(*one, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(one, 0), startOfLine(createVisiblePositionInFlatTree(*one, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), startOfLine(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent());
+    EXPECT_EQ(Position(five, 0), startOfLine(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(five, 0), startOfLine(createVisiblePositionInFlatTree(*two, 0)).deepEquivalent());
 
     EXPECT_EQ(Position(five, 0), startOfLine(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(five, 0), startOfLine(createVisiblePositionInFlatTree(*two, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(five, 0), startOfLine(createVisiblePositionInDOMTree(*three, 0)).deepEquivalent());
+    EXPECT_EQ(Position(three, 0), startOfLine(createVisiblePositionInDOMTree(*three, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(three, 0), startOfLine(createVisiblePositionInFlatTree(*three, 1)).deepEquivalent());
 
     // TODO(yosin) startOfLine(four, 1) -> (two, 2) is a broken result. We keep
     // it as a marker for future change.
-    EXPECT_EQ(Position(two, 2), startOfLine(createVisiblePositionInDOMTree(*four, 1)).deepEquivalent());
+    EXPECT_EQ(Position(three, 0), startOfLine(createVisiblePositionInDOMTree(*four, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(three, 0), startOfLine(createVisiblePositionInFlatTree(*four, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(five, 0), startOfLine(createVisiblePositionInDOMTree(*five, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(five, 0), startOfLine(createVisiblePositionInFlatTree(*five, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(six, 0), startOfLine(createVisiblePositionInDOMTree(*six, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(six, 0), startOfLine(createVisiblePositionInFlatTree(*six, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(one, 0), startOfLine(createVisiblePositionInDOMTree(*seven, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(one, 0), startOfLine(createVisiblePositionInFlatTree(*seven, 1)).deepEquivalent());
@@ skipping 43 matching lines @@
     const char* bodyContent = "<a id=host><b id=one>1</b><b id=two>22</b></a>";
     const char* shadowContent = "<p><i id=three>333</i> <content select=#two></content> <content select=#one></content> <i id=four>4444</i></p>";
     setBodyContent(bodyContent);
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
     Node* one = document().getElementById("one")->firstChild();
     Node* two = document().getElementById("two")->firstChild();
     Node* three = shadowRoot->getElementById("three")->firstChild();
     Node* four = shadowRoot->getElementById("four")->firstChild();
 
-    EXPECT_EQ(Position(one, 0), startOfSentence(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent());
+    EXPECT_EQ(Position(three, 0), startOfSentence(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(three, 0), startOfSentence(createVisiblePositionInFlatTree(*one, 0)).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), startOfSentence(createVisiblePositionInDOMTree(*one, 1)).deepEquivalent());
+    EXPECT_EQ(Position(three, 0), startOfSentence(createVisiblePositionInDOMTree(*one, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(three, 0), startOfSentence(createVisiblePositionInFlatTree(*one, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), startOfSentence(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent());
+    EXPECT_EQ(Position(three, 0), startOfSentence(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(three, 0), startOfSentence(createVisiblePositionInFlatTree(*two, 0)).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), startOfSentence(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent());
+    EXPECT_EQ(Position(three, 0), startOfSentence(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent()) << "walk in layout tree";
     EXPECT_EQ(PositionInFlatTree(three, 0), startOfSentence(createVisiblePositionInFlatTree(*two, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(three, 0), startOfSentence(createVisiblePositionInDOMTree(*three, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(three, 0), startOfSentence(createVisiblePositionInFlatTree(*three, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(three, 0), startOfSentence(createVisiblePositionInDOMTree(*four, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(three, 0), startOfSentence(createVisiblePositionInFlatTree(*four, 1)).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, startOfWord)
 {
     const char* bodyContent = "<a id=host><b id=one>1</b> <b id=two>22</b></a><i id=three>333</i>";
     const char* shadowContent = "<p><u id=four>44444</u><content select=#two></content><span id=space> </span><content select=#one></content><u id=five>55555</u></p>";
     setBodyContent(bodyContent);
     ShadowRoot* shadowRoot = setShadowContent(shadowContent, "host");
 
     Node* one = document().getElementById("one")->firstChild();
     Node* two = document().getElementById("two")->firstChild();
     Node* three = document().getElementById("three")->firstChild();
     Node* four = shadowRoot->getElementById("four")->firstChild();
     Node* five = shadowRoot->getElementById("five")->firstChild();
     Node* space = shadowRoot->getElementById("space")->firstChild();
 
-    EXPECT_EQ(Position(one, 0), startOfWord(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent());
+    EXPECT_EQ(Position(four, 0), startOfWord(createVisiblePositionInDOMTree(*one, 0)).deepEquivalent()) << "can't handle flat tree correctly";
     EXPECT_EQ(PositionInFlatTree(space, 1), startOfWord(createVisiblePositionInFlatTree(*one, 0)).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), startOfWord(createVisiblePositionInDOMTree(*one, 1)).deepEquivalent());
+    EXPECT_EQ(Position(space, 1), startOfWord(createVisiblePositionInDOMTree(*one, 1)).deepEquivalent()) << "walk on layout tree";
     EXPECT_EQ(PositionInFlatTree(space, 1), startOfWord(createVisiblePositionInFlatTree(*one, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), startOfWord(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent());
+    EXPECT_EQ(Position(four, 0), startOfWord(createVisiblePositionInDOMTree(*two, 0)).deepEquivalent()) << "walk on layout tree";
     EXPECT_EQ(PositionInFlatTree(four, 0), startOfWord(createVisiblePositionInFlatTree(*two, 0)).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), startOfWord(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent());
+    EXPECT_EQ(Position(four, 0), startOfWord(createVisiblePositionInDOMTree(*two, 1)).deepEquivalent()) << "walk on layout tree";
     EXPECT_EQ(PositionInFlatTree(four, 0), startOfWord(createVisiblePositionInFlatTree(*two, 1)).deepEquivalent());
 
-    EXPECT_EQ(Position(one, 0), startOfWord(createVisiblePositionInDOMTree(*three, 1)).deepEquivalent());
+    EXPECT_EQ(Position(four, 0), startOfWord(createVisiblePositionInDOMTree(*three, 1)).deepEquivalent()) << "can't handle flat tree correctly";
     EXPECT_EQ(PositionInFlatTree(space, 1), startOfWord(createVisiblePositionInFlatTree(*three, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(four, 0), startOfWord(createVisiblePositionInDOMTree(*four, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(four, 0), startOfWord(createVisiblePositionInFlatTree(*four, 1)).deepEquivalent());
 
     EXPECT_EQ(Position(space, 1), startOfWord(createVisiblePositionInDOMTree(*five, 1)).deepEquivalent());
     EXPECT_EQ(PositionInFlatTree(space, 1), startOfWord(createVisiblePositionInFlatTree(*five, 1)).deepEquivalent());
 }
 
 TEST_F(VisibleUnitsTest, endsOfNodeAreVisuallyDistinctPositionsWithInvisibleChild)
@@ skipping 10 matching lines @@
 {
     // Repro case of crbug.com/584030
     const char* bodyContent = "<button><rt><script>document.designMode = 'on'</script></rt></button>";
     setBodyContent(bodyContent);
 
     Node* button = document().querySelector("button", ASSERT_NO_EXCEPTION);
     EXPECT_TRUE(endsOfNodeAreVisuallyDistinctPositions(button));
 }
 
 } // namespace blink