Successfully (hopefully) implemented CSS Parsing and the respective test.

1 files changed, 109 insertions, 3 deletions

diff --git a/test/plugins/css/CSSParserTest.cpp b/test/plugins/css/CSSParserTest.cpp
index 8880fc5..8873673 100644
--- a/test/plugins/css/CSSParserTest.cpp
+++ b/test/plugins/css/CSSParserTest.cpp
@@ -59,6 +59,7 @@ TEST(CSSParser, testParseSelectors)
 	}
 	ASSERT_EQ(2, A->getEdges().size());
 	ASSERT_FALSE(A->isAccepting());
+	ASSERT_EQ(0, A->getRuleSet()->getRules().size());
 	{
 		// assert A > B
 		std::vector<Rooted<SelectorNode>> Achildren =
@@ -72,6 +73,7 @@ TEST(CSSParser, testParseSelectors)
 		}
 		ASSERT_EQ(0, B->getEdges().size());
 		ASSERT_TRUE(B->isAccepting());
+		ASSERT_EQ(0, B->getRuleSet()->getRules().size());
 		// assert A B:r
 		Achildren = A->getChildren(SelectionOperator::DESCENDANT, "B");
 		ASSERT_EQ(1, Achildren.size());
@@ -83,6 +85,7 @@ TEST(CSSParser, testParseSelectors)
 		}
 		ASSERT_EQ(0, Br->getEdges().size());
 		ASSERT_TRUE(Br->isAccepting());
+		ASSERT_EQ(0, Br->getRuleSet()->getRules().size());
 	}
 	// assert C#a
 	children = root->getChildren("C");
@@ -95,6 +98,7 @@ TEST(CSSParser, testParseSelectors)
 	}
 	ASSERT_EQ(1, C->getEdges().size());
 	ASSERT_FALSE(C->isAccepting());
+	ASSERT_EQ(0, C->getRuleSet()->getRules().size());
 	{
 		// assert C#a A[bla=\"blub\"]
 		std::vector<Rooted<SelectorNode>> Cchildren =
@@ -108,6 +112,7 @@ TEST(CSSParser, testParseSelectors)
 		}
 		ASSERT_EQ(0, A->getEdges().size());
 		ASSERT_TRUE(A->isAccepting());
+		ASSERT_EQ(0, A->getRuleSet()->getRules().size());
 	}
 	// assert A::g(4,2,3)
 	children = root->getChildren("A");
@@ -120,10 +125,12 @@ TEST(CSSParser, testParseSelectors)
 	}
 	ASSERT_EQ(0, Ag->getEdges().size());
 	ASSERT_TRUE(Ag->isAccepting());
+	ASSERT_EQ(0, Ag->getRuleSet()->getRules().size());
 }
 
 TEST(CSSParser, testParseCSS)
 {
+
 	// create the CSS input
 	std::stringstream input;
 	input << "A, B A {\n";
@@ -140,18 +147,117 @@ TEST(CSSParser, testParseCSS)
 	input << "A {\n";
 	input << "\t ident1 : \"val4\";\n";
 	input << "}\n";
-	
-	
+
 	// initialize an empty parser context.
 	StandaloneParserContext ctx;
 
 	// parse the input.
 	CSSParser instance;
 	Rooted<SelectorNode> root = instance.parse(input, ctx).cast<SelectorNode>();
+
+	// we expect three children of the root node overall.
+	ASSERT_EQ(3, root->getEdges().size());
+	// get all "A" children, which should be two.
+	std::vector<Rooted<SelectorNode>> children = root->getChildren("A");
+	ASSERT_EQ(2, children.size());
+	// assert A
+	/*
+	 * A {
+	 * ident1 : "val1";
+	 * ident2 : "val2";
+	 * }
+	 *
+	 * and
+	 *
+	 * A {
+	 * ident1 : "val4";
+	 * }
+	 *
+	 * should be merged.
+	 */
+	Rooted<SelectorNode> A = children[0];
+	ASSERT_EQ("A", A->getName());
+	{
+		PseudoSelector select{"true", false};
+		ASSERT_EQ(select, A->getPseudoSelector());
+	}
+	ASSERT_EQ(0, A->getEdges().size());
+	ASSERT_TRUE(A->isAccepting());
+	{
+		Rooted<RuleSet> ruleSet = A->getRuleSet();
+		ASSERT_EQ(2, ruleSet->getRules().size());
+		variant::Variant v = ruleSet->getRules()["ident1"];
+		ASSERT_EQ(variant::Variant::Type::STRING, v.getType());
+		ASSERT_EQ("val4", v.asString());
+		v = ruleSet->getRules()["ident2"];
+		ASSERT_EQ(variant::Variant::Type::STRING, v.getType());
+		ASSERT_EQ("val2", v.asString());
+	}
+	/*
+	 * For this part of the SelectorTree we only have
+	 *
+	 * A:select(a,b) {
+	 * ident3 : val3;
+	 * }
+	 */
+	Rooted<SelectorNode> Aselect = children[1];
+	ASSERT_EQ("A", Aselect->getName());
+	{
+		PseudoSelector select{"select",{"a","b"}, false};
+		ASSERT_EQ(select, Aselect->getPseudoSelector());
+	}
+	ASSERT_EQ(0, Aselect->getEdges().size());
+	ASSERT_TRUE(Aselect->isAccepting());
+	{
+		Rooted<RuleSet> ruleSet = Aselect->getRuleSet();
+		ASSERT_EQ(1, ruleSet->getRules().size());
+		variant::Variant v = ruleSet->getRules()["ident3"];
+		ASSERT_EQ(variant::Variant::Type::STRING, v.getType());
+		ASSERT_EQ("val3", v.asString());
+	}
+	/*
+	 * The remaining part of the SelectorTree is
+	 *
+	 * B A {
+	 * ident1 : val1;
+	 * ident2 : val2;
+	 * }
+	 */
+	children = root->getChildren("B");
+	ASSERT_EQ(1, children.size());
 	
+	Rooted<SelectorNode> B = children[0];
+	ASSERT_EQ("B", B->getName());
+	{
+		PseudoSelector select{"true", false};
+		ASSERT_EQ(select, B->getPseudoSelector());
+	}
+	ASSERT_EQ(1, B->getEdges().size());
+	ASSERT_FALSE(B->isAccepting());
+	ASSERT_EQ(0, B->getRuleSet()->getRules().size());
+	
+	children = B->getChildren("A");
+	ASSERT_EQ(1, children.size());
 	
+	Rooted<SelectorNode> BA = children[0];
+	ASSERT_EQ("A", BA->getName());
+	{
+		PseudoSelector select{"true", false};
+		ASSERT_EQ(select, BA->getPseudoSelector());
+	}
+	ASSERT_EQ(0, BA->getEdges().size());
+	ASSERT_TRUE(BA->isAccepting());
+	{
+		Rooted<RuleSet> ruleSet = BA->getRuleSet();
+		ASSERT_EQ(2, ruleSet->getRules().size());
+		variant::Variant v = ruleSet->getRules()["ident1"];
+		ASSERT_EQ(variant::Variant::Type::STRING, v.getType());
+		ASSERT_EQ("val1", v.asString());
+		v = ruleSet->getRules()["ident2"];
+		ASSERT_EQ(variant::Variant::Type::STRING, v.getType());
+		ASSERT_EQ("val2", v.asString());
+	}
 }
-
 }
 }
 }