tests/test_xml-parser.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License
  15  *
  16  *
  17  * @file        test_xml-parser.cpp
  18  * @author      Maciej Karpiuk (m.karpiuk2@samsung.com)
  19  * @version     1.0
  20  * @brief       XML parser tests.
  21  */
  22
  23 #include <vector>
  24 #include <boost/test/unit_test.hpp>
  25 #include <parser.h>
  26
  27 using namespace XML;
  28
  29 namespace
  30 {
  31 const char *XML_1_okay          = "XML_1_okay.xml";
  32 const char *XSD_1_okay          = "XML_1_okay.xsd";
  33 const char *XML_1_wrong         = "XML_1_wrong.xml";
  34 const char *XSD_1_wrong         = "XML_1_wrong.xsd";
  35 const char *XML_2_structure     = "XML_2_structure.xml";
  36 const char *XML_3_structure     = "XML_3_structure.xml";
  37
  38 std::string format_test_path(const char *file)
  39 {
  40     return std::string("/usr/share/ckm-db-test/") + std::string(file);
  41 }
  42
  43 bool startCallbackFlag = false;
  44 XML::Parser::ElementHandlerPtr dummyStartCallback()
  45 {
  46     startCallbackFlag = true;
  47     // return empty pointer
  48     return XML::Parser::ElementHandlerPtr();
  49 }
  50 bool endCallbackFlag = false;
  51 void dummyEndCallback(const XML::Parser::ElementHandlerPtr &)
  52 {
  53     endCallbackFlag = true;
  54 }
  55 }
  56
  57 BOOST_AUTO_TEST_SUITE(XML_PARSER_TEST)
  58
  59 BOOST_AUTO_TEST_CASE(XmlParserTest_wrong_argument)
  60 {
  61     XML::Parser parser(0);
  62     BOOST_REQUIRE(Parser::ErrorCode::ERROR_INVALID_ARGUMENT == parser.Validate(0));
  63
  64     // no listeners
  65     BOOST_REQUIRE(Parser::ErrorCode::ERROR_INVALID_ARGUMENT == parser.Parse());
  66
  67     BOOST_REQUIRE(Parser::ErrorCode::SUCCESS == parser.RegisterElementCb("Key", dummyStartCallback, dummyEndCallback));
  68     BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_PARSE_FAILED == parser.Parse());
  69 }
  70
  71 BOOST_AUTO_TEST_CASE(XmlParserTest_no_XML_file)
  72 {
  73     XML::Parser parser(format_test_path("i-am-not-here").c_str());
  74     BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_VALIDATION_FAILED == parser.Validate(format_test_path(XSD_1_okay).c_str()));
  75 }
  76
  77 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_correct_verify)
  78 {
  79     XML::Parser parser(format_test_path(XML_1_okay).c_str());
  80     BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
  81 }
  82
  83 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_wrong_verify)
  84 {
  85     XML::Parser parser(format_test_path(XML_1_wrong).c_str());
  86     BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_VALIDATION_FAILED == parser.Validate(format_test_path(XSD_1_okay).c_str()));
  87 }
  88
  89 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_wrong_schema)
  90 {
  91     XML::Parser parser(format_test_path(XML_1_okay).c_str());
  92     BOOST_REQUIRE(Parser::ErrorCode::ERROR_XSD_PARSE_FAILED == parser.Validate(format_test_path(XSD_1_wrong).c_str()));
  93 }
  94
  95 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_correct_parse_incorrect_callbacks)
  96 {
  97     XML::Parser parser(format_test_path(XML_1_okay).c_str());
  98     BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
  99
 100     BOOST_REQUIRE(Parser::ErrorCode::SUCCESS == parser.RegisterElementCb("Data", NULL, NULL));
 101     BOOST_REQUIRE(Parser::ErrorCode::SUCCESS == parser.Parse());
 102 }
 103
 104 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_correct_parse)
 105 {
 106     XML::Parser parser(format_test_path(XML_1_okay).c_str());
 107     BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
 108
 109     BOOST_REQUIRE(Parser::ErrorCode::SUCCESS == parser.RegisterElementCb("Key", dummyStartCallback, NULL));
 110     BOOST_REQUIRE(Parser::ErrorCode::SUCCESS == parser.RegisterElementCb("Cert", NULL, dummyEndCallback));
 111     startCallbackFlag = false;
 112     endCallbackFlag = false;
 113     BOOST_REQUIRE(Parser::ErrorCode::SUCCESS == parser.Parse());
 114     BOOST_REQUIRE(startCallbackFlag == true);
 115     BOOST_REQUIRE(endCallbackFlag == true);
 116 }
 117
 118
 119 class StructureTest
 120 {
 121 public:
 122     class ExpectedSumHandler : public XML::Parser::ElementHandler
 123     {
 124         public:
 125             ExpectedSumHandler() : m_value(0) {}
 126
 127             virtual void Start(const XML::Parser::Attributes &) {}
 128             virtual void Characters(const std::string &data) {
 129                 m_value = atoi(data.c_str());
 130             }
 131             virtual void End() {}
 132
 133             int getSum() const {
 134                 return m_value;
 135             }
 136
 137         protected:
 138             int m_value;
 139     };
 140
 141     class MathHandler : public XML::Parser::ElementHandler
 142     {
 143         public:
 144             MathHandler() : m_valueSet(false), m_powerFactor(1) {}
 145
 146             virtual void Start(const XML::Parser::Attributes &attr) {
 147                 const auto & it = attr.find("powerFactor");
 148                 if(it != attr.end())
 149                     m_powerFactor = atoi(it->second.c_str());
 150             }
 151             virtual void Characters(const std::string &data) {
 152                 m_value = pow(atoi(data.c_str()), m_powerFactor);
 153                 m_valueSet = true;
 154             }
 155             virtual void End() {}
 156
 157             virtual int compute(int prevVal) = 0;
 158
 159         protected:
 160             bool m_valueSet;
 161             int m_value;
 162             int m_powerFactor;
 163     };
 164     class AddHandler : public MathHandler
 165     {
 166         public:
 167             virtual int compute(int prevVal) {
 168                 if( !m_valueSet )
 169                     return prevVal;
 170
 171                 return prevVal + m_value;
 172             }
 173     };
 174
 175     class MultiplyHandler : public MathHandler
 176     {
 177         public:
 178             virtual int compute(int prevVal) {
 179                 if( !m_valueSet )
 180                     return prevVal;
 181
 182                 return prevVal * m_value;
 183             }
 184     };
 185
 186     class DivHandler : public MathHandler
 187     {
 188         public:
 189             virtual int compute(int prevVal) {
 190                 if( !m_valueSet )
 191                     return prevVal;
 192
 193                 if(m_value == 0)
 194                     return prevVal;
 195                 return prevVal / m_value;
 196             }
 197     };
 198
 199     StructureTest(const char *filename) : m_parser(filename), m_sum(0), m_expectedSum(0)
 200     {
 201         m_parser.RegisterErrorCb(StructureTest::Error);
 202         m_parser.RegisterElementCb("Add",
 203                 [this]() -> XML::Parser::ElementHandlerPtr
 204                 {
 205                     return std::make_shared<AddHandler>();
 206                 },
 207                 [this](const XML::Parser::ElementHandlerPtr & element)
 208                 {
 209                     // add computation
 210                     if(element)
 211                     {
 212                         MathHandler *mathElement = reinterpret_cast<MathHandler*>(element.get());
 213                         m_sum = mathElement->compute(m_sum);
 214                     }
 215                 });
 216         m_parser.RegisterElementCb("Multiply",
 217                 [this]() -> XML::Parser::ElementHandlerPtr
 218                 {
 219                     return std::make_shared<MultiplyHandler>();
 220                 },
 221                 [this](const XML::Parser::ElementHandlerPtr &element)
 222                 {
 223                     // multiply computation
 224                     if(element)
 225                     {
 226                         MathHandler *mathElement = reinterpret_cast<MathHandler*>(element.get());
 227                         m_sum = mathElement->compute(m_sum);
 228                     }
 229                 });
 230         m_parser.RegisterElementCb("Div",
 231                 [this]() -> XML::Parser::ElementHandlerPtr
 232                 {
 233                     return std::make_shared<DivHandler>();
 234                 },
 235                 [this](const XML::Parser::ElementHandlerPtr &element)
 236                 {
 237                     // division computation
 238                     if(element)
 239                     {
 240                         MathHandler *mathElement = reinterpret_cast<MathHandler*>(element.get());
 241                         m_sum = mathElement->compute(m_sum);
 242                     }
 243                 });
 244         m_parser.RegisterElementCb("ExpectedSum",
 245                 [this]() -> XML::Parser::ElementHandlerPtr
 246                 {
 247                     return std::make_shared<ExpectedSumHandler>();
 248                 },
 249                 [this](const XML::Parser::ElementHandlerPtr &element)
 250                 {
 251                     if(element)
 252                     {
 253                         ExpectedSumHandler *sumElement = reinterpret_cast<ExpectedSumHandler*>(element.get());
 254                         m_expectedSum = sumElement->getSum();
 255                     }
 256                 });
 257     }
 258
 259     static void Error(const Parser::ErrorType /*errorType*/,
 260                       const std::string & log_msg)
 261     {
 262         BOOST_FAIL(log_msg);
 263     }
 264
 265     int Parse()
 266     {
 267         return m_parser.Parse();
 268     }
 269
 270     int getSum() const {
 271         return m_sum;
 272     }
 273     int getExpectedSum() const {
 274         return m_expectedSum;
 275     }
 276 private:
 277     XML::Parser m_parser;
 278     int m_sum;
 279     int m_expectedSum;
 280 };
 281
 282 BOOST_AUTO_TEST_CASE(XmlParserTest_XML2_structure)
 283 {
 284     StructureTest parser(format_test_path(XML_2_structure).c_str());
 285     BOOST_REQUIRE(0 == parser.Parse());
 286     BOOST_REQUIRE_MESSAGE(parser.getSum() == parser.getExpectedSum(),
 287                           "got sum: " << parser.getSum() << " while expected: " << parser.getExpectedSum());
 288 }
 289
 290 BOOST_AUTO_TEST_SUITE_END()