From f1d432892ce158490bb564ba3d01982772439a81 Mon Sep 17 00:00:00 2001 From: Benjamin Paassen Date: Mon, 26 Jan 2015 23:55:41 +0100 Subject: Renamed CSS to Style (finally) --- test/core/CSSTest.cpp | 270 ------------------------------------ test/core/model/StyleTest.cpp | 272 +++++++++++++++++++++++++++++++++++++ test/plugins/css/CSSParserTest.cpp | 72 +++++----- 3 files changed, 308 insertions(+), 306 deletions(-) delete mode 100644 test/core/CSSTest.cpp create mode 100644 test/core/model/StyleTest.cpp (limited to 'test') diff --git a/test/core/CSSTest.cpp b/test/core/CSSTest.cpp deleted file mode 100644 index 2d182a1..0000000 --- a/test/core/CSSTest.cpp +++ /dev/null @@ -1,270 +0,0 @@ -/* - Ousía - Copyright (C) 2014, 2015 Benjamin Paaßen, Andreas Stöckel - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -*/ - -#include - -#include - -namespace ousia { -TEST(Specificity, testOperators) -{ - Specificity s1{0, 0, 1}; - Specificity s2{0, 1, 1}; - Specificity s3{1, 1, 1}; - Specificity s4{0, 0, 2}; - Specificity s5{1, 0, 2}; - - // This should be s1 < s4 < s2 < s5 < s3 - - ASSERT_TRUE(s1 == s1); - ASSERT_FALSE(s1 < s1); - ASSERT_FALSE(s1 > s1); - ASSERT_FALSE(s1 == s2); - ASSERT_TRUE(s1 < s2); - ASSERT_FALSE(s1 > s2); - ASSERT_FALSE(s1 == s3); - ASSERT_TRUE(s1 < s3); - ASSERT_FALSE(s1 > s3); - ASSERT_FALSE(s1 == s4); - ASSERT_TRUE(s1 < s4); - ASSERT_FALSE(s1 > s4); - ASSERT_FALSE(s1 == s5); - ASSERT_TRUE(s1 < s5); - ASSERT_FALSE(s1 > s5); - - ASSERT_FALSE(s2 == s1); - ASSERT_FALSE(s2 < s1); - ASSERT_TRUE(s2 > s1); - ASSERT_TRUE(s2 == s2); - ASSERT_FALSE(s2 < s2); - ASSERT_FALSE(s2 > s2); - ASSERT_FALSE(s2 == s3); - ASSERT_TRUE(s2 < s3); - ASSERT_FALSE(s2 > s3); - ASSERT_FALSE(s2 == s4); - ASSERT_FALSE(s2 < s4); - ASSERT_TRUE(s2 > s4); - ASSERT_FALSE(s2 == s5); - ASSERT_TRUE(s2 < s5); - ASSERT_FALSE(s2 > s5); - - ASSERT_FALSE(s3 == s1); - ASSERT_FALSE(s3 < s1); - ASSERT_TRUE(s3 > s1); - ASSERT_FALSE(s3 == s2); - ASSERT_FALSE(s3 < s2); - ASSERT_TRUE(s3 > s2); - ASSERT_TRUE(s3 == s3); - ASSERT_FALSE(s3 < s3); - ASSERT_FALSE(s3 > s3); - ASSERT_FALSE(s3 == s4); - ASSERT_FALSE(s3 < s4); - ASSERT_TRUE(s3 > s4); - ASSERT_FALSE(s3 == s5); - ASSERT_FALSE(s3 < s5); - ASSERT_TRUE(s3 > s5); - - ASSERT_FALSE(s4 == s1); - ASSERT_FALSE(s4 < s1); - ASSERT_TRUE(s4 > s1); - ASSERT_FALSE(s4 == s2); - ASSERT_TRUE(s4 < s2); - ASSERT_FALSE(s4 > s2); - ASSERT_FALSE(s4 == s3); - ASSERT_TRUE(s4 < s3); - ASSERT_FALSE(s4 > s3); - ASSERT_TRUE(s4 == s4); - ASSERT_FALSE(s4 < s4); - ASSERT_FALSE(s4 > s4); - ASSERT_FALSE(s4 == s5); - ASSERT_TRUE(s4 < s5); - ASSERT_FALSE(s4 > s5); - - ASSERT_FALSE(s5 == s1); - ASSERT_FALSE(s5 < s1); - ASSERT_TRUE(s5 > s1); - ASSERT_FALSE(s5 == s2); - ASSERT_FALSE(s5 < s2); - ASSERT_TRUE(s5 > s2); - ASSERT_FALSE(s5 == s3); - ASSERT_TRUE(s5 < s3); - ASSERT_FALSE(s5 > s3); - ASSERT_FALSE(s5 == s4); - ASSERT_FALSE(s5 < s4); - ASSERT_TRUE(s5 > s4); - ASSERT_TRUE(s5 == s5); - ASSERT_FALSE(s5 < s5); - ASSERT_FALSE(s5 > s5); -} - -TEST(SelectorNode, testGetChildren) -{ - Manager mgr(1); - // build some children. - Rooted root{new SelectorNode{mgr, "root"}}; - Rooted A{new SelectorNode{mgr, "A"}}; - Rooted AMy_Select{ - new SelectorNode{mgr, "A", {"my_select", {"a", "b"}, false}}}; - Rooted B{new SelectorNode{mgr, "B"}}; - - std::vector> children = {A, AMy_Select, B}; - - for (auto &c : children) { - root->getEdges().push_back(new SelectorNode::SelectorEdge{mgr, c}); - } - root->getEdges().push_back(new SelectorNode::SelectorEdge{ - mgr, B, SelectionOperator::DIRECT_DESCENDANT}); - - // make some checks. - std::vector> expected = {A}; - std::vector> actual = - root->getChildren(SelectionOperator::DESCENDANT, "A", {"true", false}); - ASSERT_EQ(expected, actual); - - expected = {A, AMy_Select}; - actual = root->getChildren(SelectionOperator::DESCENDANT, "A"); - ASSERT_EQ(expected, actual); - actual = root->getChildren("A"); - ASSERT_EQ(expected, actual); - - expected = {A, AMy_Select, B}; - actual = root->getChildren(SelectionOperator::DESCENDANT); - ASSERT_EQ(expected, actual); - - expected = {B}; - actual = root->getChildren(SelectionOperator::DIRECT_DESCENDANT); - ASSERT_EQ(expected, actual); - - expected = {B, B}; - actual = root->getChildren("B"); - ASSERT_EQ(expected, actual); - - { - expected = {A, B, B}; - PseudoSelector select = {"true", false}; - actual = root->getChildren(select); - ASSERT_EQ(expected, actual); - } - - expected = {A, AMy_Select, B, B}; - actual = root->getChildren(); - ASSERT_EQ(expected, actual); -} - -TEST(SelectorNode, testAppend) -{ - Manager mgr(1); - // build the root. - Rooted root{new SelectorNode{mgr, "root"}}; - // append a child. - Rooted A{new SelectorNode{mgr, "A"}}; - // this should work without any unmerged leafs. - ASSERT_EQ(0U, (root->append(A)).size()); - /* - * check the result. We expect the SelectorTree - * - * root - * | - * A - */ - ASSERT_EQ(1U, (root->getEdges()).size()); - std::vector> children = root->getChildren("A"); - ASSERT_EQ(1U, children.size()); - ASSERT_EQ(A, children[0]); - - // append another child. - Rooted B{new SelectorNode{mgr, "B"}}; - ASSERT_EQ(0U, (root->append(B)).size()); - /* - * check the result. We expect the SelectorTree - * - * root - * | \ - * A B - */ - ASSERT_EQ(2U, (root->getEdges()).size()); - children = root->getChildren("B"); - ASSERT_EQ(1U, children.size()); - ASSERT_EQ(B, children[0]); - - // append a grandchild using a path. - Rooted C{new SelectorNode{mgr, "C"}}; - { - Rooted pathA{new SelectorNode{mgr, "A"}}; - pathA->append(C); - - ASSERT_EQ(0U, (root->append(pathA)).size()); - } - /* - * check the result. We expect the SelectorTree - * - * root - * | \ - * A B - * | - * C - */ - ASSERT_EQ(2U, (root->getEdges()).size()); - children = root->getChildren("A"); - ASSERT_EQ(1U, children.size()); - ASSERT_EQ(1U, (children[0]->getEdges()).size()); - children = children[0]->getChildren("C"); - ASSERT_EQ(1U, children.size()); - ASSERT_EQ(C, children[0]); - - // append a subtree that is partially contained. - Rooted D{new SelectorNode{mgr, "D"}}; - { - Rooted pathA{new SelectorNode{mgr, "A"}}; - Rooted pathC{new SelectorNode{mgr, "C"}}; - pathA->append(pathC); - pathA->append(D); - - // The C leaf can not be appended because it is already part of the - // tree. So we expect that as a return value. - std::vector> unmergedLeafs = root->append(pathA); - ASSERT_EQ(1U, unmergedLeafs.size()); - ASSERT_EQ(C.get(), unmergedLeafs[0].get()); - } - /* - * check the result. We expect the SelectorTree - * - * root - * | \ - * A B - * |\ - * C D - */ - ASSERT_EQ(2U, (root->getEdges()).size()); - children = root->getChildren("A"); - ASSERT_EQ(1U, children.size()); - ASSERT_EQ(2U, (children[0]->getEdges()).size()); - children = children[0]->getChildren("D"); - ASSERT_EQ(1U, children.size()); - ASSERT_EQ(D, children[0]); - - // append a child with a non-trivial PseudoSelector. - Rooted ASelect{ - new SelectorNode{mgr, "A", {"my_select", {"a", "b"}, false}}}; - ASSERT_EQ(0U, (root->append(ASelect)).size()); - ASSERT_EQ(3U, (root->getEdges()).size()); - children = root->getChildren("A"); - ASSERT_EQ(2U, children.size()); - ASSERT_EQ(ASelect, children[1]); -} -} diff --git a/test/core/model/StyleTest.cpp b/test/core/model/StyleTest.cpp new file mode 100644 index 0000000..4727f4d --- /dev/null +++ b/test/core/model/StyleTest.cpp @@ -0,0 +1,272 @@ +/* + Ousía + Copyright (C) 2014, 2015 Benjamin Paaßen, Andreas Stöckel + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include + +#include + +namespace ousia { +namespace model { +TEST(Specificity, testOperators) +{ + Specificity s1{0, 0, 1}; + Specificity s2{0, 1, 1}; + Specificity s3{1, 1, 1}; + Specificity s4{0, 0, 2}; + Specificity s5{1, 0, 2}; + + // This should be s1 < s4 < s2 < s5 < s3 + + ASSERT_TRUE(s1 == s1); + ASSERT_FALSE(s1 < s1); + ASSERT_FALSE(s1 > s1); + ASSERT_FALSE(s1 == s2); + ASSERT_TRUE(s1 < s2); + ASSERT_FALSE(s1 > s2); + ASSERT_FALSE(s1 == s3); + ASSERT_TRUE(s1 < s3); + ASSERT_FALSE(s1 > s3); + ASSERT_FALSE(s1 == s4); + ASSERT_TRUE(s1 < s4); + ASSERT_FALSE(s1 > s4); + ASSERT_FALSE(s1 == s5); + ASSERT_TRUE(s1 < s5); + ASSERT_FALSE(s1 > s5); + + ASSERT_FALSE(s2 == s1); + ASSERT_FALSE(s2 < s1); + ASSERT_TRUE(s2 > s1); + ASSERT_TRUE(s2 == s2); + ASSERT_FALSE(s2 < s2); + ASSERT_FALSE(s2 > s2); + ASSERT_FALSE(s2 == s3); + ASSERT_TRUE(s2 < s3); + ASSERT_FALSE(s2 > s3); + ASSERT_FALSE(s2 == s4); + ASSERT_FALSE(s2 < s4); + ASSERT_TRUE(s2 > s4); + ASSERT_FALSE(s2 == s5); + ASSERT_TRUE(s2 < s5); + ASSERT_FALSE(s2 > s5); + + ASSERT_FALSE(s3 == s1); + ASSERT_FALSE(s3 < s1); + ASSERT_TRUE(s3 > s1); + ASSERT_FALSE(s3 == s2); + ASSERT_FALSE(s3 < s2); + ASSERT_TRUE(s3 > s2); + ASSERT_TRUE(s3 == s3); + ASSERT_FALSE(s3 < s3); + ASSERT_FALSE(s3 > s3); + ASSERT_FALSE(s3 == s4); + ASSERT_FALSE(s3 < s4); + ASSERT_TRUE(s3 > s4); + ASSERT_FALSE(s3 == s5); + ASSERT_FALSE(s3 < s5); + ASSERT_TRUE(s3 > s5); + + ASSERT_FALSE(s4 == s1); + ASSERT_FALSE(s4 < s1); + ASSERT_TRUE(s4 > s1); + ASSERT_FALSE(s4 == s2); + ASSERT_TRUE(s4 < s2); + ASSERT_FALSE(s4 > s2); + ASSERT_FALSE(s4 == s3); + ASSERT_TRUE(s4 < s3); + ASSERT_FALSE(s4 > s3); + ASSERT_TRUE(s4 == s4); + ASSERT_FALSE(s4 < s4); + ASSERT_FALSE(s4 > s4); + ASSERT_FALSE(s4 == s5); + ASSERT_TRUE(s4 < s5); + ASSERT_FALSE(s4 > s5); + + ASSERT_FALSE(s5 == s1); + ASSERT_FALSE(s5 < s1); + ASSERT_TRUE(s5 > s1); + ASSERT_FALSE(s5 == s2); + ASSERT_FALSE(s5 < s2); + ASSERT_TRUE(s5 > s2); + ASSERT_FALSE(s5 == s3); + ASSERT_TRUE(s5 < s3); + ASSERT_FALSE(s5 > s3); + ASSERT_FALSE(s5 == s4); + ASSERT_FALSE(s5 < s4); + ASSERT_TRUE(s5 > s4); + ASSERT_TRUE(s5 == s5); + ASSERT_FALSE(s5 < s5); + ASSERT_FALSE(s5 > s5); +} + +TEST(SelectorNode, testGetChildren) +{ + Manager mgr(1); + // build some children. + Rooted root{new SelectorNode{mgr, "root"}}; + Rooted A{new SelectorNode{mgr, "A"}}; + Rooted AMy_Select{ + new SelectorNode{mgr, "A", {"my_select", {"a", "b"}, false}}}; + Rooted B{new SelectorNode{mgr, "B"}}; + + std::vector> children = {A, AMy_Select, B}; + + for (auto &c : children) { + root->getEdges().push_back(new SelectorNode::SelectorEdge{mgr, c}); + } + root->getEdges().push_back(new SelectorNode::SelectorEdge{ + mgr, B, SelectionOperator::DIRECT_DESCENDANT}); + + // make some checks. + std::vector> expected = {A}; + std::vector> actual = + root->getChildren(SelectionOperator::DESCENDANT, "A", {"true", false}); + ASSERT_EQ(expected, actual); + + expected = {A, AMy_Select}; + actual = root->getChildren(SelectionOperator::DESCENDANT, "A"); + ASSERT_EQ(expected, actual); + actual = root->getChildren("A"); + ASSERT_EQ(expected, actual); + + expected = {A, AMy_Select, B}; + actual = root->getChildren(SelectionOperator::DESCENDANT); + ASSERT_EQ(expected, actual); + + expected = {B}; + actual = root->getChildren(SelectionOperator::DIRECT_DESCENDANT); + ASSERT_EQ(expected, actual); + + expected = {B, B}; + actual = root->getChildren("B"); + ASSERT_EQ(expected, actual); + + { + expected = {A, B, B}; + PseudoSelector select = {"true", false}; + actual = root->getChildren(select); + ASSERT_EQ(expected, actual); + } + + expected = {A, AMy_Select, B, B}; + actual = root->getChildren(); + ASSERT_EQ(expected, actual); +} + +TEST(SelectorNode, testAppend) +{ + Manager mgr(1); + // build the root. + Rooted root{new SelectorNode{mgr, "root"}}; + // append a child. + Rooted A{new SelectorNode{mgr, "A"}}; + // this should work without any unmerged leafs. + ASSERT_EQ(0U, (root->append(A)).size()); + /* + * check the result. We expect the SelectorTree + * + * root + * | + * A + */ + ASSERT_EQ(1U, (root->getEdges()).size()); + std::vector> children = root->getChildren("A"); + ASSERT_EQ(1U, children.size()); + ASSERT_EQ(A, children[0]); + + // append another child. + Rooted B{new SelectorNode{mgr, "B"}}; + ASSERT_EQ(0U, (root->append(B)).size()); + /* + * check the result. We expect the SelectorTree + * + * root + * | \ + * A B + */ + ASSERT_EQ(2U, (root->getEdges()).size()); + children = root->getChildren("B"); + ASSERT_EQ(1U, children.size()); + ASSERT_EQ(B, children[0]); + + // append a grandchild using a path. + Rooted C{new SelectorNode{mgr, "C"}}; + { + Rooted pathA{new SelectorNode{mgr, "A"}}; + pathA->append(C); + + ASSERT_EQ(0U, (root->append(pathA)).size()); + } + /* + * check the result. We expect the SelectorTree + * + * root + * | \ + * A B + * | + * C + */ + ASSERT_EQ(2U, (root->getEdges()).size()); + children = root->getChildren("A"); + ASSERT_EQ(1U, children.size()); + ASSERT_EQ(1U, (children[0]->getEdges()).size()); + children = children[0]->getChildren("C"); + ASSERT_EQ(1U, children.size()); + ASSERT_EQ(C, children[0]); + + // append a subtree that is partially contained. + Rooted D{new SelectorNode{mgr, "D"}}; + { + Rooted pathA{new SelectorNode{mgr, "A"}}; + Rooted pathC{new SelectorNode{mgr, "C"}}; + pathA->append(pathC); + pathA->append(D); + + // The C leaf can not be appended because it is already part of the + // tree. So we expect that as a return value. + std::vector> unmergedLeafs = root->append(pathA); + ASSERT_EQ(1U, unmergedLeafs.size()); + ASSERT_EQ(C.get(), unmergedLeafs[0].get()); + } + /* + * check the result. We expect the SelectorTree + * + * root + * | \ + * A B + * |\ + * C D + */ + ASSERT_EQ(2U, (root->getEdges()).size()); + children = root->getChildren("A"); + ASSERT_EQ(1U, children.size()); + ASSERT_EQ(2U, (children[0]->getEdges()).size()); + children = children[0]->getChildren("D"); + ASSERT_EQ(1U, children.size()); + ASSERT_EQ(D, children[0]); + + // append a child with a non-trivial PseudoSelector. + Rooted ASelect{ + new SelectorNode{mgr, "A", {"my_select", {"a", "b"}, false}}}; + ASSERT_EQ(0U, (root->append(ASelect)).size()); + ASSERT_EQ(3U, (root->getEdges()).size()); + children = root->getChildren("A"); + ASSERT_EQ(2U, children.size()); + ASSERT_EQ(ASelect, children[1]); +} +} +} diff --git a/test/plugins/css/CSSParserTest.cpp b/test/plugins/css/CSSParserTest.cpp index 33b97af..815efa2 100644 --- a/test/plugins/css/CSSParserTest.cpp +++ b/test/plugins/css/CSSParserTest.cpp @@ -28,7 +28,6 @@ namespace ousia { static TerminalLogger logger(std::cerr, true); -//static ConcreteLogger logger; TEST(CSSParser, testParseSelectors) { @@ -47,19 +46,19 @@ TEST(CSSParser, testParseSelectors) // parse the data. CSSParser instance; - Rooted root = - instance.parse(data, env.context).cast(); + Rooted root = + instance.parse(data, env.context).cast(); // we expect three children of the root node overall. ASSERT_EQ(3U, root->getEdges().size()); // get all "A" children, which should be two. - std::vector> children = root->getChildren("A"); + std::vector> children = root->getChildren("A"); ASSERT_EQ(2U, children.size()); // assert A - Rooted A = children[0]; + Rooted A = children[0]; ASSERT_EQ("A", A->getName()); { - PseudoSelector select{"true", false}; + model::PseudoSelector select{"true", false}; ASSERT_EQ(select, A->getPseudoSelector()); } ASSERT_EQ(2U, A->getEdges().size()); @@ -67,25 +66,25 @@ TEST(CSSParser, testParseSelectors) ASSERT_EQ(0U, A->getRuleSet()->getRules().size()); { // assert A > B - std::vector> Achildren = - A->getChildren(SelectionOperator::DIRECT_DESCENDANT, "B"); + std::vector> Achildren = + A->getChildren(model::SelectionOperator::DIRECT_DESCENDANT, "B"); ASSERT_EQ(1U, Achildren.size()); - Rooted B = Achildren[0]; + Rooted B = Achildren[0]; ASSERT_EQ("B", B->getName()); { - PseudoSelector select{"true", false}; + model::PseudoSelector select{"true", false}; ASSERT_EQ(select, B->getPseudoSelector()); } ASSERT_EQ(0U, B->getEdges().size()); ASSERT_TRUE(B->isAccepting()); ASSERT_EQ(0U, B->getRuleSet()->getRules().size()); // assert A B:r - Achildren = A->getChildren(SelectionOperator::DESCENDANT, "B"); + Achildren = A->getChildren(model::SelectionOperator::DESCENDANT, "B"); ASSERT_EQ(1U, Achildren.size()); - Rooted Br = Achildren[0]; + Rooted Br = Achildren[0]; ASSERT_EQ("B", Br->getName()); { - PseudoSelector select{"r", false}; + model::PseudoSelector select{"r", false}; ASSERT_EQ(select, Br->getPseudoSelector()); } ASSERT_EQ(0U, Br->getEdges().size()); @@ -95,10 +94,10 @@ TEST(CSSParser, testParseSelectors) // assert C#a children = root->getChildren("C"); ASSERT_EQ(1U, children.size()); - Rooted C = children[0]; + Rooted C = children[0]; ASSERT_EQ("C", C->getName()); { - PseudoSelector select{"has_id", {"a"}, false}; + model::PseudoSelector select{"has_id", {"a"}, false}; ASSERT_EQ(select, C->getPseudoSelector()); } ASSERT_EQ(1U, C->getEdges().size()); @@ -106,13 +105,13 @@ TEST(CSSParser, testParseSelectors) ASSERT_EQ(0U, C->getRuleSet()->getRules().size()); { // assert C#a A[bla=\"blub\"] - std::vector> Cchildren = - C->getChildren(SelectionOperator::DESCENDANT, "A"); + std::vector> Cchildren = + C->getChildren(model::SelectionOperator::DESCENDANT, "A"); ASSERT_EQ(1U, Cchildren.size()); - Rooted A = Cchildren[0]; + Rooted A = Cchildren[0]; ASSERT_EQ("A", A->getName()); { - PseudoSelector select{"has_value", {"bla", "blub"}, false}; + model::PseudoSelector select{"has_value", {"bla", "blub"}, false}; ASSERT_EQ(select, A->getPseudoSelector()); } ASSERT_EQ(0U, A->getEdges().size()); @@ -122,10 +121,11 @@ TEST(CSSParser, testParseSelectors) // assert A::g(4,2,3) children = root->getChildren("A"); ASSERT_EQ(2U, children.size()); - Rooted Ag = children[1]; + Rooted Ag = children[1]; ASSERT_EQ("A", Ag->getName()); { - PseudoSelector select{"g", {Variant(4), Variant(2), Variant(3)}, true}; + model::PseudoSelector select{ + "g", {Variant(4), Variant(2), Variant(3)}, true}; ASSERT_EQ(select, Ag->getPseudoSelector()); } ASSERT_EQ(0U, Ag->getEdges().size()); @@ -158,13 +158,13 @@ TEST(CSSParser, testParseCSS) // parse the input. CSSParser instance; CharReader reader{input}; - Rooted root = - instance.parse(reader, env.context).cast(); + Rooted root = + instance.parse(reader, env.context).cast(); // we expect three children of the root node overall. ASSERT_EQ(3U, root->getEdges().size()); // get all "A" children, which should be two. - std::vector> children = root->getChildren("A"); + std::vector> children = root->getChildren("A"); ASSERT_EQ(2U, children.size()); // assert A /* @@ -181,16 +181,16 @@ TEST(CSSParser, testParseCSS) * * should be merged. */ - Rooted A = children[0]; + Rooted A = children[0]; ASSERT_EQ("A", A->getName()); { - PseudoSelector select{"true", false}; + model::PseudoSelector select{"true", false}; ASSERT_EQ(select, A->getPseudoSelector()); } ASSERT_EQ(0U, A->getEdges().size()); ASSERT_TRUE(A->isAccepting()); { - Rooted ruleSet = A->getRuleSet(); + Rooted ruleSet = A->getRuleSet(); ASSERT_EQ(2U, ruleSet->getRules().size()); Variant v = ruleSet->getRules()["ident1"]; ASSERT_TRUE(v.isString()); @@ -206,16 +206,16 @@ TEST(CSSParser, testParseCSS) * ident3 : val3; * } */ - Rooted Aselect = children[1]; + Rooted Aselect = children[1]; ASSERT_EQ("A", Aselect->getName()); { - PseudoSelector select{"select", {"a", "b"}, false}; + model::PseudoSelector select{"select", {"a", "b"}, false}; ASSERT_EQ(select, Aselect->getPseudoSelector()); } ASSERT_EQ(0U, Aselect->getEdges().size()); ASSERT_TRUE(Aselect->isAccepting()); { - Rooted ruleSet = Aselect->getRuleSet(); + Rooted ruleSet = Aselect->getRuleSet(); ASSERT_EQ(1U, ruleSet->getRules().size()); Variant v = ruleSet->getRules()["ident3"]; ASSERT_TRUE(v.isString()); @@ -232,10 +232,10 @@ TEST(CSSParser, testParseCSS) children = root->getChildren("B"); ASSERT_EQ(1U, children.size()); - Rooted B = children[0]; + Rooted B = children[0]; ASSERT_EQ("B", B->getName()); { - PseudoSelector select{"true", false}; + model::PseudoSelector select{"true", false}; ASSERT_EQ(select, B->getPseudoSelector()); } ASSERT_EQ(1U, B->getEdges().size()); @@ -245,16 +245,16 @@ TEST(CSSParser, testParseCSS) children = B->getChildren("A"); ASSERT_EQ(1U, children.size()); - Rooted BA = children[0]; + Rooted BA = children[0]; ASSERT_EQ("A", BA->getName()); { - PseudoSelector select{"true", false}; + model::PseudoSelector select{"true", false}; ASSERT_EQ(select, BA->getPseudoSelector()); } ASSERT_EQ(0U, BA->getEdges().size()); ASSERT_TRUE(BA->isAccepting()); { - Rooted ruleSet = BA->getRuleSet(); + Rooted ruleSet = BA->getRuleSet(); ASSERT_EQ(2U, ruleSet->getRules().size()); Variant v = ruleSet->getRules()["ident1"]; ASSERT_TRUE(v.isString()); @@ -274,7 +274,7 @@ void assertException(std::string css) logger.reset(); try { - instance.parse(reader, env.context).cast(); + instance.parse(reader, env.context).cast(); } catch (LoggableException ex) { logger.log(ex); -- cgit v1.2.3