CustomElementUpgradeSorter puts elements in shadow-including tree order.

third_party/WebKit/Source/core/dom/custom/CustomElementUpgradeSorterTest.cpp

+// 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.
+
+#include "core/dom/custom/CustomElementUpgradeSorter.h"
+
+#include "bindings/core/v8/ExceptionState.h"
+#include "core/HTMLNames.h"
+#include "core/dom/Document.h"
+#include "core/dom/Element.h"
+#include "core/dom/shadow/ShadowRoot.h"
+#include "core/dom/shadow/ShadowRootInit.h"
+#include "core/html/HTMLDocument.h"
+#include "core/testing/DummyPageHolder.h"
+#include "platform/heap/Handle.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "wtf/OwnPtr.h"
+#include "wtf/text/AtomicString.h"
+
+namespace blink {
+
+class CustomElementUpgradeSorterTest : public ::testing::Test {
+public:
+    Element* createElementWithId(const char* localName, const char* id)
+    {
+        NonThrowableExceptionState noExceptions;
+        Element* element =
+            document()->createElement(localName, AtomicString(), noExceptions);
+        element->setAttribute(HTMLNames::idAttr, id);
+        return element;
+    }
+
+    Document* document() { return &m_page->document(); }
+
+    ScriptState* scriptState()
+    {
+        return ScriptState::forMainWorld(&m_page->frame());
+    }
+
+    ShadowRoot* attachShadowTo(Element* element)
+    {
+        NonThrowableExceptionState noExceptions;
+        ShadowRootInit shadowRootInit;
+        return
+            element->attachShadow(scriptState(), shadowRootInit, noExceptions);
+    }
+
+protected:
+    void SetUp() override
+    {
+        m_page = DummyPageHolder::create(IntSize(1, 1));
+    }
+
+    void TearDown() override
+    {
+        m_page = nullptr;
+    }
+
+private:
+    OwnPtr<DummyPageHolder> m_page;
+};
+
+TEST_F(CustomElementUpgradeSorterTest, inOtherDocument_notInSet)
+{
+    NonThrowableExceptionState noExceptions;
+    Element* element =
+        document()->createElement("a-a", AtomicString(), noExceptions);
+
+    Document* otherDocument = HTMLDocument::create();
+    otherDocument->appendChild(element);
+    EXPECT_EQ(otherDocument, element->ownerDocument())
+        << "sanity: another document should have adopted an element on append";
+
+    CustomElementUpgradeSorter sorter;
+    sorter.add(element);
+
+    HeapVector<Member<Element>> elements;
+    sorter.sorted(&elements, document());
+    EXPECT_EQ(0u, elements.size())
+        << "the adopted-away candidate should not have been included";
+}
+
+TEST_F(CustomElementUpgradeSorterTest, oneCandidate)
+{
+    NonThrowableExceptionState noExceptions;
+    Element* element =
+        document()->createElement("a-a", AtomicString(), noExceptions);
+    document()->documentElement()->appendChild(element);
+
+    CustomElementUpgradeSorter sorter;
+    sorter.add(element);
+
+    HeapVector<Member<Element>> elements;
+    sorter.sorted(&elements, document());
+    EXPECT_EQ(1u, elements.size())
+        << "exactly one candidate should be in the result set";
+    EXPECT_TRUE(elements.contains(element))
+        << "the candidate should be the element that was added";
+}
+
+TEST_F(CustomElementUpgradeSorterTest, candidatesInDocumentOrder)
+{
+    Element* a = createElementWithId("a-a", "a");
+    Element* b = createElementWithId("a-a", "b");
+    Element* c = createElementWithId("a-a", "c");
+
+    document()->documentElement()->appendChild(a);
+    a->appendChild(b);
+    document()->documentElement()->appendChild(c);
+
+    CustomElementUpgradeSorter sorter;
+    sorter.add(b);
+    sorter.add(a);
+    sorter.add(c);
+
+    HeapVector<Member<Element>> elements;
+    sorter.sorted(&elements, document());
+    EXPECT_EQ(3u, elements.size());
+    EXPECT_EQ(a, elements[0].get());
+    EXPECT_EQ(b, elements[1].get());
+    EXPECT_EQ(c, elements[2].get());
+}
+
+TEST_F(CustomElementUpgradeSorterTest, sorter_ancestorInSet)
+{
+    // A*
+    // + B
+    //   + C*
+    Element* a = createElementWithId("a-a", "a");
+    Element* b = createElementWithId("a-a", "b");
+    Element* c = createElementWithId("a-a", "c");
+
+    document()->documentElement()->appendChild(a);
+    a->appendChild(b);
+    b->appendChild(c);
+
+    CustomElementUpgradeSorter sort;
+    sort.add(c);
+    sort.add(a);
+
+    HeapVector<Member<Element>> elements;
+    sort.sorted(&elements, document());
+    EXPECT_EQ(2u, elements.size());
+    EXPECT_EQ(a, elements[0].get());
+    EXPECT_EQ(c, elements[1].get());
+}
+
+TEST_F(CustomElementUpgradeSorterTest, sorter_deepShallow)
+{
+    // A
+    // + B*
+    // C*
+    Element* a = createElementWithId("a-a", "a");
+    Element* b = createElementWithId("a-a", "b");
+    Element* c = createElementWithId("a-a", "c");
+
+    document()->documentElement()->appendChild(a);
+    a->appendChild(b);
+    document()->documentElement()->appendChild(c);
+
+    CustomElementUpgradeSorter sort;
+    sort.add(b);
+    sort.add(c);
+
+    HeapVector<Member<Element>> elements;
+    sort.sorted(&elements, document());
+    EXPECT_EQ(2u, elements.size());
+    EXPECT_EQ(b, elements[0].get());
+    EXPECT_EQ(c, elements[1].get());
+}
+
+TEST_F(CustomElementUpgradeSorterTest, sorter_shallowDeep)
+{
+    // A*
+    // B
+    // + C*
+    Element* a = createElementWithId("a-a", "a");
+    Element* b = createElementWithId("a-a", "b");
+    Element* c = createElementWithId("a-a", "c");
+
+    document()->documentElement()->appendChild(a);
+    document()->documentElement()->appendChild(b);
+    b->appendChild(c);
+
+    CustomElementUpgradeSorter sort;
+    sort.add(a);
+    sort.add(c);
+
+    HeapVector<Member<Element>> elements;
+    sort.sorted(&elements, document());
+    EXPECT_EQ(2u, elements.size());
+    EXPECT_EQ(a, elements[0].get());
+    EXPECT_EQ(c, elements[1].get());
+}
+
+TEST_F(CustomElementUpgradeSorterTest, sorter_shadow)
+{
+    // A*
+    // + {ShadowRoot}
+    // | + B
+    // |   + C*
+    // + D*
+    Element* a = createElementWithId("a-a", "a");
+    Element* b = createElementWithId("a-a", "b");
+    Element* c = createElementWithId("a-a", "c");
+    Element* d = createElementWithId("a-a", "d");
+
+    document()->documentElement()->appendChild(a);
+    ShadowRoot* s = attachShadowTo(a);
+    a->appendChild(d);
+
+    s->appendChild(b);
+    b->appendChild(c);
+
+    CustomElementUpgradeSorter sort;
+    sort.add(a);
+    sort.add(c);
+    sort.add(d);
+
+    HeapVector<Member<Element>> elements;
+    sort.sorted(&elements, document());
+    EXPECT_EQ(3u, elements.size());
+    EXPECT_EQ(a, elements[0].get());
+    EXPECT_EQ(c, elements[1].get());
+    EXPECT_EQ(d, elements[2].get());
+}
+
+} // namespace blink