Sibling invalidation sets

Source/core/css/RuleFeatureSetTest.cpp

Index: Source/core/css/RuleFeatureSetTest.cpp
diff --git a/Source/core/css/RuleFeatureSetTest.cpp b/Source/core/css/RuleFeatureSetTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d1c4f7a00a67bdb7906d8a7d5474082e5dfd1ec8
--- /dev/null
+++ b/Source/core/css/RuleFeatureSetTest.cpp
@@ -0,0 +1,225 @@
+// 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 "config.h"
+#include "core/css/RuleFeature.h"
+
+#include "core/css/CSSSelectorList.h"
+#include "core/css/RuleSet.h"
+#include "core/css/StylePropertySet.h"
+#include "core/css/StyleRule.h"
+#include "core/css/invalidation/InvalidationSet.h"
+#include "core/css/parser/CSSParser.h"
+#include "core/dom/ElementTraversal.h"
+#include "core/html/HTMLBodyElement.h"
+#include "core/html/HTMLDocument.h"
+#include "core/html/HTMLElement.h"
+#include "core/html/HTMLHtmlElement.h"
+#include <gtest/gtest.h>
+
+namespace blink {
+
+class RuleFeatureSetTest : public ::testing::Test {
+public:
+    RuleFeatureSetTest()
+    {
+    }
+
+    void SetUp()
+    {
+        m_document = HTMLDocument::create();
+        RefPtrWillBeRawPtr<HTMLHtmlElement> html = HTMLHtmlElement::create(*m_document);
+        html->appendChild(HTMLBodyElement::create(*m_document));
+        m_document->appendChild(html.release());
+
+        m_document->body()->setInnerHTML("<b><i></i></b>", ASSERT_NO_EXCEPTION);
+    }
+
+    void updateInvalidationSets(const String& selectorText)
+    {
+        CSSSelectorList selectorList;
+        CSSParser::parseSelector(strictCSSParserContext(), selectorText, selectorList);
+
+        RefPtrWillBeRawPtr<StyleRule> styleRule = StyleRule::create(selectorList, MutableStylePropertySet::create(HTMLStandardMode));
+        RuleData ruleData(styleRule.get(), 0, 0, RuleHasNoSpecialState);
+        m_ruleFeatureSet.updateInvalidationSets(ruleData);
+    }
+
+    void collectInvalidationSetsForClass(InvalidationLists& invalidationLists, const AtomicString& className) const
+    {
+        Element* element = Traversal<HTMLElement>::firstChild(*Traversal<HTMLElement>::firstChild(*m_document->body()));
+        m_ruleFeatureSet.collectInvalidationSetsForClass(invalidationLists, *element, className);
+    }
+
+    WillBeHeapHashSet<AtomicString>& classSet(InvalidationSet& invalidationSet)
+    {
+        ASSERT(invalidationSet.m_classes);
+        return *invalidationSet.m_classes;
+    }
+
+    void expectNoInvalidation(InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(0u, invalidationSets.size());
+    }
+
+    void expectSelfInvalidation(InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        EXPECT_TRUE(invalidationSets[0]->invalidatesSelf());
+    }
+
+    void expectClassInvalidation(const AtomicString& className, InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        WillBeHeapHashSet<AtomicString> classes = classSet(*invalidationSets[0]);
+        EXPECT_EQ(1u, classes.size());
+        EXPECT_TRUE(classes.contains(className));
+    }
+
+    void expectSiblingInvalidation(unsigned maxDirectAdjacentSelectors, const AtomicString& siblingName, InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        WillBeHeapHashSet<AtomicString> classes = classSet(*invalidationSets[0]);
+        EXPECT_EQ(1u, classes.size());
+        EXPECT_TRUE(classes.contains(siblingName));
+        EXPECT_EQ(maxDirectAdjacentSelectors, invalidationSets[0]->maxDirectAdjacentSelectors());
+    }
+
+    void expectSiblingDescendantInvalidation(unsigned maxDirectAdjacentSelectors, const AtomicString& siblingName, const AtomicString& descendantName, InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        WillBeHeapHashSet<AtomicString> classes = classSet(*invalidationSets[0]);
+        EXPECT_EQ(1u, classes.size());
+        EXPECT_TRUE(classes.contains(siblingName));
+        EXPECT_EQ(maxDirectAdjacentSelectors, invalidationSets[0]->maxDirectAdjacentSelectors());
+
+        WillBeHeapHashSet<AtomicString> descendantClasses = classSet(invalidationSets[0]->ensureDescendantInvalidationSet());
+        EXPECT_EQ(1u, descendantClasses.size());
+        EXPECT_TRUE(descendantClasses.contains(descendantName));
+    }
+
+    void expectClassesInvalidation(const AtomicString& firstClassName, const AtomicString& secondClassName, InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        WillBeHeapHashSet<AtomicString> classes = classSet(*invalidationSets[0]);
+        EXPECT_EQ(2u, classes.size());
+        EXPECT_TRUE(classes.contains(firstClassName));
+        EXPECT_TRUE(classes.contains(secondClassName));
+    }
+
+    DEFINE_INLINE_TRACE()
+    {
+#if ENABLE(OILPAN)
+        visitor->trace(m_ruleFeatureSet);
+        visitor->trace(m_document);
+#endif
+    }
+
+private:
+    RuleFeatureSet m_ruleFeatureSet;
+    RefPtrWillBePersistent<Document> m_document;
+};
+
+TEST_F(RuleFeatureSetTest, interleavedDescendantSibling1)
+{
+    updateInvalidationSets(".p");
+
+    InvalidationLists invalidationLists;
+    collectInvalidationSetsForClass(invalidationLists, "p");
+    expectSelfInvalidation(invalidationLists.descendants);
+    expectNoInvalidation(invalidationLists.siblings);
+}
+
+TEST_F(RuleFeatureSetTest, interleavedDescendantSibling2)
+{
+    updateInvalidationSets(".o + .p");
+
+    InvalidationLists invalidationLists;
+    collectInvalidationSetsForClass(invalidationLists, "o");
+    expectNoInvalidation(invalidationLists.descendants);
+    expectSiblingInvalidation(1, "p", invalidationLists.siblings);
+}
+
+TEST_F(RuleFeatureSetTest, interleavedDescendantSibling3)
+{
+    updateInvalidationSets(".n .o + .p");
+
+    InvalidationLists invalidationLists;
+    collectInvalidationSetsForClass(invalidationLists, "n");
+    expectClassInvalidation("p", invalidationLists.descendants);
+    expectNoInvalidation(invalidationLists.siblings);
+}
+
+TEST_F(RuleFeatureSetTest, interleavedDescendantSibling4)
+{
+    updateInvalidationSets(".m + .n .o + .p");
+
+    InvalidationLists invalidationLists;
+    collectInvalidationSetsForClass(invalidationLists, "m");
+    expectNoInvalidation(invalidationLists.descendants);
+    expectSiblingDescendantInvalidation(1, "n", "p", invalidationLists.siblings);
+}
+
+TEST_F(RuleFeatureSetTest, interleavedDescendantSibling5)
+{
+    updateInvalidationSets(".l ~ .m + .n .o + .p");
+
+    InvalidationLists invalidationLists;
+    collectInvalidationSetsForClass(invalidationLists, "l");
+    expectNoInvalidation(invalidationLists.descendants);
+    expectSiblingDescendantInvalidation(std::numeric_limits<unsigned>::max(), "n", "p", invalidationLists.siblings);
+}
+
+TEST_F(RuleFeatureSetTest, interleavedDescendantSibling6)
+{
+    updateInvalidationSets(".k > .l ~ .m + .n .o + .p");
+
+    InvalidationLists invalidationLists;
+    collectInvalidationSetsForClass(invalidationLists, "k");
+    expectClassInvalidation("p", invalidationLists.descendants);
+    expectNoInvalidation(invalidationLists.siblings);
+}
+
+
+TEST_F(RuleFeatureSetTest, anySibling)
+{
+    updateInvalidationSets(":-webkit-any(.q, .r) ~ .s .t");
+
+    InvalidationLists invalidationLists;
+    collectInvalidationSetsForClass(invalidationLists, "q");
+    expectNoInvalidation(invalidationLists.descendants);
+    expectSiblingDescendantInvalidation(std::numeric_limits<unsigned>::max(), "s", "t", invalidationLists.siblings);
+}
+
+TEST_F(RuleFeatureSetTest, any)
+{
+    updateInvalidationSets(":-webkit-any(.w, .x)");
+
+    InvalidationLists invalidationLists;
+    collectInvalidationSetsForClass(invalidationLists, "w");
+    expectSelfInvalidation(invalidationLists.descendants);
+    expectNoInvalidation(invalidationLists.siblings);
+}
+
+TEST_F(RuleFeatureSetTest, siblingAny)
+{
+    updateInvalidationSets(".v ~ :-webkit-any(.w, .x)");
+
+    InvalidationLists invalidationLists;
+    collectInvalidationSetsForClass(invalidationLists, "v");
+    expectNoInvalidation(invalidationLists.descendants);
+    expectClassesInvalidation("w", "x", invalidationLists.siblings);
+}
+
+TEST_F(RuleFeatureSetTest, descendantSiblingAny)
+{
+    updateInvalidationSets(".u .v ~ :-webkit-any(.w, .x)");
+
+    InvalidationLists invalidationLists;
+    collectInvalidationSetsForClass(invalidationLists, "u");
+    expectClassesInvalidation("w", "x", invalidationLists.descendants);
+    expectNoInvalidation(invalidationLists.siblings);
+}
+
+} // namespace blink