l7vsd/unit_tests/parameter_test/parameter_test.cpp

   1 #define    __STDC_LIMIT_MACROS
   2 #include <stdint.h>
   3 #include <fstream>
   4 #include <unistd.h>
   5 #include <boost/test/included/unit_test.hpp>
   6 #include "../../src/parameter.cpp"
   7 #include "../../src/parameter_impl.cpp"
   8
   9 // すべての試験関数を含んだ実行ファイルにて試験を実行すると
  10 // 先頭試験関数でparameterインスタンスが作成されてしまうため、
  11 // 試験対象関数毎に実行ファイルを作成すること
  12
  13 using namespace boost::unit_test;
  14
  15 class parameter_test : public l7vs::Parameter
  16 {
  17
  18 };
  19
  20 // Parameter::Parameter() test
  21 void parameter_constructor_test()
  22 {
  23
  24         l7vs::error_code  err;
  25         int               zero_value = 0;
  26
  27         // unit_test [1] parameter constructor check init NG
  28         unlink(PARAMETER_FILE);
  29 //    parameter_test    param_test1;
  30         // check log "Parameter initialize failure"
  31
  32         std::ofstream ofs(PARAMETER_FILE);
  33         ofs << "[l7vsd]\n";
  34         ofs << "zero_value =" << zero_value << "\n";
  35         ofs.close();
  36
  37         // unit_test [2] parameter constructor check
  38 //    parameter_test param_test2;
  39 //    int ret = param_test2.get_int( l7vs::PARAM_COMP_L7VSD, "zero_value", err );
  40 //    BOOST_CHECK_EQUAL( ret, zero_value );
  41
  42         // unit_test[0] parameter constructor re check
  43         parameter_test param_test0;
  44         // check log "It's initialized already."
  45
  46         unlink(PARAMETER_FILE);
  47
  48 }
  49
  50 // Parameter::init() test
  51 void parameter_init_test()
  52 {
  53
  54         std::ofstream ofs(PARAMETER_FILE);
  55         ofs << "[l7vsd]\n";
  56         ofs << "zero_value = 0\n";
  57         ofs.close();
  58
  59         parameter_test param_test1;
  60         parameter_test param_test2;
  61
  62         // unit_test [3] parameter init() check
  63         BOOST_CHECK_EQUAL(param_test1.init(l7vs::PARAM_COMP_L7VSD,
  64                                            PARAMETER_FILE), true);
  65
  66         // uint_test [4] parameter init() false check
  67         BOOST_CHECK_EQUAL(param_test2.init(l7vs::PARAM_COMP_SSL, "./hoge.cf"),
  68                           false);
  69         // check FATAL LOG
  70
  71         unlink(PARAMETER_FILE);
  72 }
  73
  74 // Parameter::read_file() test
  75 void parameter_read_file_test()
  76 {
  77
  78         std::ofstream ofs(PARAMETER_FILE);
  79         ofs << "[l7vsd]\n";
  80         ofs << "zero_value = 0\n";
  81         ofs.close();
  82
  83         std::ofstream ofs2("./add.cf");
  84         ofs2 << "[ssl]\n";
  85         ofs2 << "zero_value = 0" << "\n";
  86         ofs2.close();
  87
  88         parameter_test param_test;
  89
  90         // unit_test [5] read_file(default file) check
  91         BOOST_CHECK_EQUAL(param_test.read_file(l7vs::PARAM_COMP_L7VSD), true);
  92
  93         // unit_test [6] read_file(filename) check
  94         BOOST_CHECK_EQUAL(
  95                 param_test.read_file(l7vs::PARAM_COMP_SSL, "./add.cf"),
  96                 true);
  97
  98         // unit_test [7] read_file ( no file ) check
  99         BOOST_CHECK_EQUAL(
 100                 param_test.read_file(l7vs::PARAM_COMP_L7VSD, "./hoge.cf"),
 101                 false);
 102
 103         unlink(PARAMETER_FILE);
 104         unlink("./add.cf");
 105 }
 106
 107 // Parameter::get_int() test
 108 void parameter_get_int_test()
 109 {
 110
 111         l7vs::error_code  err;
 112         int               zero_value = 0;
 113         int               ret = 99;
 114
 115         std::ofstream ofs(PARAMETER_FILE);
 116         ofs << "[l7vsd]\n";
 117         ofs << "zero_value = " << zero_value << "\n";
 118         ofs.close();
 119
 120         parameter_test         param_test;
 121
 122         // unit_test [8] get_int call check
 123         ret = param_test.get_int(l7vs::PARAM_COMP_L7VSD, "zero_value", err);
 124         BOOST_CHECK_EQUAL(ret, zero_value);
 125
 126         unlink(PARAMETER_FILE);
 127 }
 128
 129 // Parameter::get_string() test
 130 void parameter_get_string_test()
 131 {
 132
 133         l7vs::error_code  err;
 134         std::string       str_value = "\"strings\"";
 135         std::string       ret_str = "ZZZZ";
 136
 137         std::ofstream     ofs(PARAMETER_FILE);
 138         ofs << "[l7vsd]\n";
 139         ofs << "string_value = " << str_value << "\n";
 140         ofs.close();
 141
 142         parameter_test    param_test;
 143
 144         // unit_test [9] get_string call check
 145         ret_str = param_test.get_string(l7vs::PARAM_COMP_L7VSD,
 146                                         "string_value", err);
 147         BOOST_CHECK_EQUAL(err, false);
 148         BOOST_CHECK_EQUAL(ret_str, "strings");
 149
 150         unlink(PARAMETER_FILE);
 151 }
 152
 153 // Parameter::get_multistring() test
 154 void parameter_get_multistring_test()
 155 {
 156
 157         l7vs::error_code         err;
 158         std::string              str_value_1 = "\"strings_1\"";
 159         std::string              str_value_2 = "\"strings_2\"";
 160         std::vector<std::string> ret_vec;
 161
 162         std::ofstream     ofs(PARAMETER_FILE);
 163         ofs << "[ssl]\n";
 164         ofs << "string_value = " << str_value_1 << "\n";
 165         ofs << "string_value = " << str_value_2 << "\n";
 166         ofs.close();
 167
 168         parameter_test    param_test;
 169
 170         // unit_test [10] get_multistring call check
 171         param_test.get_multistring(l7vs::PARAM_COMP_SSL,
 172                                    "string_value", ret_vec, err);
 173         BOOST_CHECK_EQUAL(ret_vec.size(), (unsigned int)2);
 174         BOOST_CHECK_EQUAL(ret_vec[0], "strings_1");
 175         BOOST_CHECK_EQUAL(ret_vec[1], "strings_2");
 176
 177         unlink(PARAMETER_FILE);
 178
 179 }
 180
 181
 182 // read pattern test
 183 void parameter_read_pattern0()
 184 {
 185
 186         l7vs::PARAMETER_COMPONENT_TAG comp_tag[10] = {
 187                 l7vs::PARAM_COMP_L7VSD,          //!< parameter category l7vsd
 188                 l7vs::PARAM_COMP_COMMAND,        //!< parameter category command
 189                 l7vs::PARAM_COMP_SESSION,        //!< parameter category session
 190                 l7vs::PARAM_COMP_VIRTUALSERVICE, //!< parameter category virtualservice
 191                 l7vs::PARAM_COMP_MODULE,         //!< parameter category module control
 192                 l7vs::PARAM_COMP_REPLICATION,    //!< parameter category replication
 193                 l7vs::PARAM_COMP_LOGGER,         //!< parameter category logger
 194                 l7vs::PARAM_COMP_L7VSADM,        //!< parameter category l7vsadm
 195                 l7vs::PARAM_COMP_SNMPAGENT,      //!< parameter category snmpagent
 196                 l7vs::PARAM_COMP_SSL
 197         };           //!< parameter category ssl
 198         l7vs::error_code err;
 199         // create init files.
 200         std::string sectionstrings[10];
 201         sectionstrings[0] = "l7vsd";
 202         sectionstrings[1] = "command";
 203         sectionstrings[2] = "session";
 204         sectionstrings[3] = "virtualservice";
 205         sectionstrings[4] = "module";
 206         sectionstrings[5] = "replication";
 207         sectionstrings[6] = "logger";
 208         sectionstrings[7] = "l7vsadm";
 209         sectionstrings[8] = "snmpagent";
 210         std::string keystr[2];
 211         keystr[0] = "key1";
 212         keystr[1] = "key2";
 213         std::string valuestr[2];
 214         valuestr[0] = "1";
 215         valuestr[1] = "\"strings\"";
 216         valuestr[2] = "2";
 217         valuestr[3] = "\"strings2\"";
 218         std::ofstream ofs(PARAMETER_FILE);
 219         for (int i = 0 ; i < 9; ++i) {
 220                 ofs << "[" << sectionstrings[i] << "]\n";
 221                 ofs << keystr[0] << "=" << valuestr[0] << "\n";
 222                 ofs << keystr[1] << " = " << valuestr[1] << "\n";
 223         }
 224         ofs << "[" << sectionstrings[0] << "]\n";
 225         ofs << keystr[0] << "=" << valuestr[2] << std::endl;   // overwrite check
 226         ofs << keystr[1] << " = " << valuestr[3] << std::endl; // overwrite check
 227         ofs.close();
 228
 229         // unit_test[a1] default file read
 230         parameter_test param;
 231
 232         for (int i = 0; i < 9; ++i) {
 233                 if (i == 0) {
 234                         BOOST_CHECK_EQUAL(param.get_int(comp_tag[i],
 235                                                         keystr[0], err, PARAMETER_FILE), 2);
 236                         BOOST_CHECK_EQUAL(param.get_string(comp_tag[i],
 237                                                            keystr[1], err, PARAMETER_FILE), "strings2");
 238                 } else {
 239                         BOOST_CHECK_EQUAL(param.get_int(comp_tag[i],
 240                                                         keystr[0], err, PARAMETER_FILE), 1);
 241                         BOOST_CHECK_EQUAL(param.get_string(comp_tag[i],
 242                                                            keystr[1], err, PARAMETER_FILE), "strings");
 243                 }
 244         }
 245         unlink(PARAMETER_FILE);
 246 }
 247
 248 // read file pattern1
 249 void parameter_read_pattern1()
 250 {
 251
 252         // ssl1.cf read
 253         // ssl1.cf update
 254         // ssl1.cf read
 255
 256         // ssl file create
 257         l7vs::error_code         err;
 258         std::vector<std::string> strvec;
 259
 260         {
 261                 std::ofstream ofs("./ssl1.cf");
 262                 ofs << "[ssl]\n";
 263                 ofs << "string_value0 = \"ssl_10\"\n";
 264                 ofs << "mstring_value = \"ssl_11\"\n";
 265                 ofs << "mstring_value = \"ssl_12\"\n";
 266                 ofs << "int_value = 10\n";
 267                 ofs.close();
 268         }
 269         // default file read
 270         parameter_read_pattern0();
 271
 272         parameter_test param;
 273         // read ssl file
 274         param.init(l7vs::PARAM_COMP_SSL, "./ssl1.cf");
 275
 276         BOOST_CHECK_EQUAL(param.get_int(l7vs::PARAM_COMP_SSL,
 277                                         "int_value", err, "./ssl1.cf"), 10);
 278         BOOST_CHECK_EQUAL(param.get_string(l7vs::PARAM_COMP_SSL,
 279                                            "string_value0", err, "./ssl1.cf"), "ssl_10");
 280         param.get_multistring(l7vs::PARAM_COMP_SSL, "mstring_value",
 281                               strvec, err, "./ssl1.cf");
 282         BOOST_CHECK_EQUAL(strvec[0], "ssl_11");
 283         BOOST_CHECK_EQUAL(strvec[1], "ssl_12");
 284
 285         unlink("./ssl1cf");
 286
 287         {
 288                 std::ofstream ofs("./ssl1.cf");
 289                 ofs << "[ssl]\n";
 290                 ofs << "string_value0 = \"ssl_20\"\n";
 291                 ofs << "m2string_value = \"ssl_21\"\n";
 292                 ofs << "m2string_value = \"ssl_22\"\n";
 293                 ofs << "int_value = 20\n";
 294                 ofs.close();
 295         }
 296         // re-read ssl file
 297         param.init(l7vs::PARAM_COMP_SSL, "./ssl1.cf");
 298
 299         BOOST_CHECK_EQUAL(param.get_int(l7vs::PARAM_COMP_SSL,
 300                                         "int_value", err, "./ssl1.cf"), 20);
 301         BOOST_CHECK_EQUAL(param.get_string(l7vs::PARAM_COMP_SSL,
 302                                            "string_value0", err, "./ssl1.cf"), "ssl_20");
 303         param.get_multistring(l7vs::PARAM_COMP_SSL, "mstring_value",
 304                               strvec, err, "./ssl1.cf");
 305         BOOST_CHECK_EQUAL(err, true);
 306         param.get_multistring(l7vs::PARAM_COMP_SSL, "m2string_value",
 307                               strvec, err, "./ssl1.cf");
 308         BOOST_CHECK_EQUAL(strvec[0], "ssl_21");
 309         BOOST_CHECK_EQUAL(strvec[1], "ssl_22");
 310
 311         unlink("./ssl1cf");
 312
 313 }
 314
 315 // read file pattern2
 316 void parameter_read_pattern2()
 317 {
 318
 319         // ssl1.cf read
 320         // ssl1.cf read
 321
 322         // ssl file create
 323         l7vs::error_code         err;
 324         std::vector<std::string> strvec;
 325
 326         {
 327                 std::ofstream ofs("./ssl1.cf");
 328                 ofs << "[ssl]\n";
 329                 ofs << "string_value0 = \"ssl_10\"\n";
 330                 ofs << "mstring_value = \"ssl_11\"\n";
 331                 ofs << "mstring_value = \"ssl_12\"\n";
 332                 ofs << "int_value = 10\n";
 333                 ofs.close();
 334         }
 335         // default file read
 336         parameter_read_pattern0();
 337
 338         parameter_test param;
 339         // read ssl file
 340         param.init(l7vs::PARAM_COMP_SSL, "./ssl1.cf");
 341
 342         BOOST_CHECK_EQUAL(param.get_int(l7vs::PARAM_COMP_SSL,
 343                                         "int_value", err, "./ssl1.cf"), 10);
 344         BOOST_CHECK_EQUAL(param.get_string(l7vs::PARAM_COMP_SSL,
 345                                            "string_value0", err, "./ssl1.cf"), "ssl_10");
 346         param.get_multistring(l7vs::PARAM_COMP_SSL, "mstring_value",
 347                               strvec, err, "./ssl1.cf");
 348         BOOST_CHECK_EQUAL(strvec[0], "ssl_11");
 349         BOOST_CHECK_EQUAL(strvec[1], "ssl_12");
 350
 351         // read ssl file
 352         param.init(l7vs::PARAM_COMP_SSL, "./ssl1.cf");
 353
 354         BOOST_CHECK_EQUAL(param.get_int(l7vs::PARAM_COMP_SSL,
 355                                         "int_value", err, "./ssl1.cf"), 10);
 356         BOOST_CHECK_EQUAL(param.get_string(l7vs::PARAM_COMP_SSL,
 357                                            "string_value0", err, "./ssl1.cf"), "ssl_10");
 358         param.get_multistring(l7vs::PARAM_COMP_SSL, "mstring_value",
 359                               strvec, err, "./ssl1.cf");
 360         BOOST_CHECK_EQUAL(strvec[0], "ssl_11");
 361         BOOST_CHECK_EQUAL(strvec[1], "ssl_12");
 362
 363         unlink("./ssl1cf");
 364 }
 365
 366 // read file pattern3
 367 void parameter_read_pattern3()
 368 {
 369
 370         // ssl1.cf read
 371         // ssl2.cf read
 372
 373         // ssl file create
 374         l7vs::error_code         err;
 375         std::vector<std::string> strvec;
 376
 377         {
 378                 std::ofstream ofs("./ssl1.cf");
 379                 ofs << "[ssl]\n";
 380                 ofs << "string_value0 = \"ssl_10\"\n";
 381                 ofs << "mstring_value = \"ssl_11\"\n";
 382                 ofs << "mstring_value = \"ssl_12\"\n";
 383                 ofs << "int_value = 10\n";
 384                 ofs.close();
 385         }
 386         // default file read
 387         parameter_read_pattern0();
 388
 389         parameter_test param;
 390         // read ssl file
 391         param.init(l7vs::PARAM_COMP_SSL, "./ssl1.cf");
 392
 393         BOOST_CHECK_EQUAL(param.get_int(l7vs::PARAM_COMP_SSL,
 394                                         "int_value", err, "./ssl1.cf"), 10);
 395         BOOST_CHECK_EQUAL(param.get_string(l7vs::PARAM_COMP_SSL,
 396                                            "string_value0", err, "./ssl1.cf"), "ssl_10");
 397         param.get_multistring(l7vs::PARAM_COMP_SSL, "mstring_value",
 398                               strvec, err, "./ssl1.cf");
 399         BOOST_CHECK_EQUAL(strvec[0], "ssl_11");
 400         BOOST_CHECK_EQUAL(strvec[1], "ssl_12");
 401
 402
 403         {
 404                 std::ofstream ofs("./ssl2.cf");
 405                 ofs << "[ssl]\n";
 406                 ofs << "string_value0 = \"ssl_20\"\n";
 407                 ofs << "m2string_value = \"ssl_21\"\n";
 408                 ofs << "m2string_value = \"ssl_22\"\n";
 409                 ofs << "int_value = 20\n";
 410                 ofs.close();
 411         }
 412         // re-read ssl file
 413         param.init(l7vs::PARAM_COMP_SSL, "./ssl2.cf");
 414
 415         BOOST_CHECK_EQUAL(param.get_int(l7vs::PARAM_COMP_SSL,
 416                                         "int_value", err, "./ssl1.cf"), 10);
 417         BOOST_CHECK_EQUAL(param.get_string(l7vs::PARAM_COMP_SSL,
 418                                            "string_value0", err, "./ssl1.cf"), "ssl_10");
 419         param.get_multistring(l7vs::PARAM_COMP_SSL, "mstring_value",
 420                               strvec, err, "./ssl1.cf");
 421         BOOST_CHECK_EQUAL(strvec[0], "ssl_11");
 422         BOOST_CHECK_EQUAL(strvec[1], "ssl_12");
 423         param.get_multistring(l7vs::PARAM_COMP_SSL, "m2string_value",
 424                               strvec, err, "./ssl1.cf");
 425         BOOST_CHECK_EQUAL(err, true);
 426
 427         BOOST_CHECK_EQUAL(param.get_int(l7vs::PARAM_COMP_SSL,
 428                                         "int_value", err, "./ssl2.cf"), 20);
 429         BOOST_CHECK_EQUAL(param.get_string(l7vs::PARAM_COMP_SSL,
 430                                            "string_value0", err, "./ssl2.cf"), "ssl_20");
 431         param.get_multistring(l7vs::PARAM_COMP_SSL, "mstring_value",
 432                               strvec, err, "./ssl2.cf");
 433         BOOST_CHECK_EQUAL(err, true);
 434         param.get_multistring(l7vs::PARAM_COMP_SSL, "m2string_value",
 435                               strvec, err, "./ssl2.cf");
 436         BOOST_CHECK_EQUAL(strvec[0], "ssl_21");
 437         BOOST_CHECK_EQUAL(strvec[1], "ssl_22");
 438
 439         unlink("./ssl1.cf");
 440         unlink("./ssl2.cf");
 441
 442 }
 443
 444
 445 test_suite    *init_unit_test_suite(int argc, char *argv[])
 446 {
 447
 448         // Logger initialize
 449         l7vs::Logger        logger_instance;
 450         logger_instance.loadConf();
 451
 452         // create unit test suite
 453         // !!!! target test case is only one
 454         test_suite *ts = BOOST_TEST_SUITE("parameter");
 455 //    ts->add( BOOST_TEST_CASE( &parameter_constructor_test ) );
 456 //    ts->add( BOOST_TEST_CASE( &parameter_init_test ) );
 457 //    ts->add( BOOST_TEST_CASE( &parameter_read_file_test ) );
 458 //    ts->add( BOOST_TEST_CASE( &parameter_get_int_test ) );
 459 //    ts->add( BOOST_TEST_CASE( &parameter_get_string_test ) );
 460 //    ts->add( BOOST_TEST_CASE( &parameter_get_multistring_test ) );
 461 //    ts->add( BOOST_TEST_CASE( &parameter_read_pattern1 ) );
 462 //    ts->add( BOOST_TEST_CASE( &parameter_read_pattern2 ) );
 463         ts->add(BOOST_TEST_CASE(&parameter_read_pattern3));
 464
 465         framework::master_test_suite().add(ts);
 466
 467         return 0;
 468 }
 469