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 CKM;
  28 using namespace XML;
  29
  30 namespace
  31 {
  32 const char *XML_1_okay          = "XML_1_okay.xml";
  33 const char *XSD_1_okay          = "XML_1_okay.xsd";
  34 const char *XML_1_wrong         = "XML_1_wrong.xml";
  35 const char *XSD_1_wrong         = "XML_1_wrong.xsd";
  36 const char *XML_2_structure     = "XML_2_structure.xml";
  37 const char *XML_3_structure     = "XML_3_structure.xml";
  38
  39 std::string format_test_path(const char *file)
  40 {
  41     return std::string("/usr/share/ckm-db-test/") + std::string(file);
  42 }
  43
  44 bool startCallbackFlag = false;
  45 XML::Parser::ElementHandlerPtr dummyStartCallback()
  46 {
  47     startCallbackFlag = true;
  48     // return empty pointer
  49     return XML::Parser::ElementHandlerPtr();
  50 }
  51 bool endCallbackFlag = false;
  52 void dummyEndCallback(const XML::Parser::ElementHandlerPtr &)
  53 {
  54     endCallbackFlag = true;
  55 }
  56 }
  57
  58 BOOST_AUTO_TEST_SUITE(XML_PARSER_TEST)
  59
  60 BOOST_AUTO_TEST_CASE(XmlParserTest_wrong_argument)
  61 {
  62     std::string emptyPath;
  63     XML::Parser parser(emptyPath);
  64     BOOST_REQUIRE(Parser::ErrorCode::ERROR_INVALID_ARGUMENT == parser.Validate(emptyPath));
  65
  66     // no listeners
  67     BOOST_REQUIRE(Parser::ErrorCode::ERROR_INVALID_ARGUMENT == parser.Parse());
  68
  69     BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("Key", dummyStartCallback, dummyEndCallback));
  70     BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_PARSE_FAILED == parser.Parse());
  71 }
  72
  73 BOOST_AUTO_TEST_CASE(XmlParserTest_no_XML_file)
  74 {
  75     XML::Parser parser(format_test_path("i-am-not-here").c_str());
  76     BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_VALIDATION_FAILED == parser.Validate(format_test_path(XSD_1_okay).c_str()));
  77 }
  78
  79 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_correct_verify)
  80 {
  81     XML::Parser parser(format_test_path(XML_1_okay).c_str());
  82     BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
  83 }
  84
  85 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_wrong_verify)
  86 {
  87     XML::Parser parser(format_test_path(XML_1_wrong).c_str());
  88     BOOST_REQUIRE(Parser::ErrorCode::ERROR_XML_VALIDATION_FAILED == parser.Validate(format_test_path(XSD_1_okay).c_str()));
  89 }
  90
  91 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_wrong_schema)
  92 {
  93     XML::Parser parser(format_test_path(XML_1_okay).c_str());
  94     BOOST_REQUIRE(Parser::ErrorCode::ERROR_XSD_PARSE_FAILED == parser.Validate(format_test_path(XSD_1_wrong).c_str()));
  95 }
  96
  97 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_correct_parse_incorrect_callbacks)
  98 {
  99     XML::Parser parser(format_test_path(XML_1_okay).c_str());
 100     BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
 101
 102     BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("Data", NULL, NULL));
 103     BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.Parse());
 104 }
 105
 106 BOOST_AUTO_TEST_CASE(XmlParserTest_XML1_correct_parse)
 107 {
 108     XML::Parser parser(format_test_path(XML_1_okay).c_str());
 109     BOOST_REQUIRE(0 == parser.Validate(format_test_path(XSD_1_okay).c_str()));
 110
 111     BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("Key", dummyStartCallback, NULL));
 112     BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.RegisterElementCb("Cert", NULL, dummyEndCallback));
 113     startCallbackFlag = false;
 114     endCallbackFlag = false;
 115     BOOST_REQUIRE(Parser::ErrorCode::PARSE_SUCCESS == parser.Parse());
 116     BOOST_REQUIRE(startCallbackFlag == true);
 117     BOOST_REQUIRE(endCallbackFlag == true);
 118 }
 119
 120
 121 class StructureTest
 122 {
 123 public:
 124     class ExpectedSumHandler : public XML::Parser::ElementHandler
 125     {
 126         public:
 127             ExpectedSumHandler() : m_value(0) {}
 128
 129             virtual void Start(const XML::Parser::Attributes &) {}
 130             virtual void Characters(const std::string &data) {
 131                 m_value = atoi(data.c_str());
 132             }
 133             virtual void End() {}
 134
 135             int getSum() const {
 136                 return m_value;
 137             }
 138
 139         protected:
 140             int m_value;
 141     };
 142
 143     class MathHandler : public XML::Parser::ElementHandler
 144     {
 145         public:
 146             MathHandler() : m_valueSet(false), m_value(0), m_powerFactor(1) {}
 147
 148             virtual void Start(const XML::Parser::Attributes &attr) {
 149                 const auto & it = attr.find("powerFactor");
 150                 if(it != attr.end())
 151                     m_powerFactor = atoi(it->second.c_str());
 152             }
 153             virtual void Characters(const std::string &data) {
 154                 m_value = pow(atoi(data.c_str()), m_powerFactor);
 155                 m_valueSet = true;
 156             }
 157             virtual void End() {}
 158
 159             virtual int compute(int prevVal) = 0;
 160
 161         protected:
 162             bool m_valueSet;
 163             int m_value;
 164             int m_powerFactor;
 165     };
 166     class AddHandler : public MathHandler
 167     {
 168         public:
 169             virtual int compute(int prevVal) {
 170                 if( !m_valueSet )
 171                     return prevVal;
 172
 173                 return prevVal + m_value;
 174             }
 175     };
 176
 177     class MultiplyHandler : public MathHandler
 178     {
 179         public:
 180             virtual int compute(int prevVal) {
 181                 if( !m_valueSet )
 182                     return prevVal;
 183
 184                 return prevVal * m_value;
 185             }
 186     };
 187
 188     class DivHandler : public MathHandler
 189     {
 190         public:
 191             virtual int compute(int prevVal) {
 192                 if( !m_valueSet )
 193                     return prevVal;
 194
 195                 if(m_value == 0)
 196                     return prevVal;
 197                 return prevVal / m_value;
 198             }
 199     };
 200
 201     StructureTest(const char *filename) : m_parser(filename), m_sum(0), m_expectedSum(0)
 202     {
 203         m_parser.RegisterErrorCb(StructureTest::Error);
 204         m_parser.RegisterElementCb("Add",
 205                 [this]() -> XML::Parser::ElementHandlerPtr
 206                 {
 207                     return std::make_shared<AddHandler>();
 208                 },
 209                 [this](const XML::Parser::ElementHandlerPtr & element)
 210                 {
 211                     // add computation
 212                     if(element)
 213                     {
 214                         MathHandler *mathElement = reinterpret_cast<MathHandler*>(element.get());
 215                         m_sum = mathElement->compute(m_sum);
 216                     }
 217                 });
 218         m_parser.RegisterElementCb("Multiply",
 219                 [this]() -> XML::Parser::ElementHandlerPtr
 220                 {
 221                     return std::make_shared<MultiplyHandler>();
 222                 },
 223                 [this](const XML::Parser::ElementHandlerPtr &element)
 224                 {
 225                     // multiply computation
 226                     if(element)
 227                     {
 228                         MathHandler *mathElement = reinterpret_cast<MathHandler*>(element.get());
 229                         m_sum = mathElement->compute(m_sum);
 230                     }
 231                 });
 232         m_parser.RegisterElementCb("Div",
 233                 [this]() -> XML::Parser::ElementHandlerPtr
 234                 {
 235                     return std::make_shared<DivHandler>();
 236                 },
 237                 [this](const XML::Parser::ElementHandlerPtr &element)
 238                 {
 239                     // division computation
 240                     if(element)
 241                     {
 242                         MathHandler *mathElement = reinterpret_cast<MathHandler*>(element.get());
 243                         m_sum = mathElement->compute(m_sum);
 244                     }
 245                 });
 246         m_parser.RegisterElementCb("ExpectedSum",
 247                 [this]() -> XML::Parser::ElementHandlerPtr
 248                 {
 249                     return std::make_shared<ExpectedSumHandler>();
 250                 },
 251                 [this](const XML::Parser::ElementHandlerPtr &element)
 252                 {
 253                     if(element)
 254                     {
 255                         ExpectedSumHandler *sumElement = reinterpret_cast<ExpectedSumHandler*>(element.get());
 256                         m_expectedSum = sumElement->getSum();
 257                     }
 258                 });
 259     }
 260
 261     static void Error(const Parser::ErrorType /*errorType*/,
 262                       const std::string & log_msg)
 263     {
 264         BOOST_FAIL(log_msg);
 265     }
 266
 267     int Parse()
 268     {
 269         return m_parser.Parse();
 270     }
 271
 272     int getSum() const {
 273         return m_sum;
 274     }
 275     int getExpectedSum() const {
 276         return m_expectedSum;
 277     }
 278 private:
 279     XML::Parser m_parser;
 280     int m_sum;
 281     int m_expectedSum;
 282 };
 283
 284 BOOST_AUTO_TEST_CASE(XmlParserTest_XML2_structure)
 285 {
 286     StructureTest parser(format_test_path(XML_2_structure).c_str());
 287     BOOST_REQUIRE(0 == parser.Parse());
 288     BOOST_REQUIRE_MESSAGE(parser.getSum() == parser.getExpectedSum(),
 289                           "got sum: " << parser.getSum() << " while expected: " << parser.getExpectedSum());
 290 }
 291
 292 BOOST_AUTO_TEST_SUITE_END()