test/test-api-content-screening.cpp

   1 /*
   2  *  Copyright (c) 2016 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-api-content-screening.cpp
  18  * @author      Kyungwook Tak (k.tak@samsung.com)
  19  * @version     1.0
  20  * @brief       CSR Content screening API test
  21  */
  22 #include <csr-content-screening.h>
  23
  24 #include <string>
  25 #include <memory>
  26 #include <new>
  27 #include <iostream>
  28 #include <fstream>
  29 #include <chrono>
  30 #include <thread>
  31
  32 #include <boost/test/unit_test.hpp>
  33
  34 #include "test-common.h"
  35 #include "test-helper.h"
  36 #include "test-resource.h"
  37
  38 BOOST_AUTO_TEST_SUITE(API_CONTENT_SCREENING)
  39
  40 BOOST_AUTO_TEST_CASE(context_create_destroy)
  41 {
  42         EXCEPTION_GUARD_START
  43
  44         Test::Context<csr_cs_context_h>();
  45
  46         EXCEPTION_GUARD_END
  47 }
  48
  49 BOOST_AUTO_TEST_CASE(set_values_to_context_positive)
  50 {
  51         EXCEPTION_GUARD_START
  52
  53         auto c = Test::Context<csr_cs_context_h>();
  54         auto context = c.get();
  55
  56         ASSERT_SUCCESS(csr_cs_set_ask_user(context, CSR_CS_ASK_USER_NO));
  57         ASSERT_SUCCESS(csr_cs_set_ask_user(context, CSR_CS_ASK_USER_YES));
  58
  59         ASSERT_SUCCESS(csr_cs_set_popup_message(context, "Test popup message"));
  60
  61         ASSERT_SUCCESS(csr_cs_set_core_usage(context, CSR_CS_CORE_USAGE_DEFAULT));
  62         ASSERT_SUCCESS(csr_cs_set_core_usage(context, CSR_CS_CORE_USAGE_ALL));
  63         ASSERT_SUCCESS(csr_cs_set_core_usage(context, CSR_CS_CORE_USAGE_HALF));
  64         ASSERT_SUCCESS(csr_cs_set_core_usage(context, CSR_CS_CORE_USAGE_SINGLE));
  65
  66         ASSERT_SUCCESS(csr_cs_set_scan_on_cloud(context, true));
  67         ASSERT_SUCCESS(csr_cs_set_scan_on_cloud(context, false));
  68
  69         EXCEPTION_GUARD_END
  70 }
  71
  72 BOOST_AUTO_TEST_CASE(set_values_to_context_negative)
  73 {
  74         EXCEPTION_GUARD_START
  75
  76         auto c = Test::Context<csr_cs_context_h>();
  77         auto context = c.get();
  78
  79         ASSERT_IF(csr_cs_set_ask_user(context, static_cast<csr_cs_ask_user_e>(0x926ce)),
  80                           CSR_ERROR_INVALID_PARAMETER);
  81
  82         ASSERT_IF(csr_cs_set_popup_message(context, nullptr), CSR_ERROR_INVALID_PARAMETER);
  83         ASSERT_IF(csr_cs_set_popup_message(context, ""), CSR_ERROR_INVALID_PARAMETER);
  84
  85         ASSERT_IF(csr_cs_set_core_usage(context,
  86                                                                         static_cast<csr_cs_core_usage_e>(0x882a2)),
  87                           CSR_ERROR_INVALID_PARAMETER);
  88
  89         EXCEPTION_GUARD_END
  90 }
  91
  92 BOOST_AUTO_TEST_CASE(scan_data_normal)
  93 {
  94         EXCEPTION_GUARD_START
  95
  96         auto c = Test::Context<csr_cs_context_h>();
  97         auto context = c.get();
  98         csr_cs_malware_h detected;
  99         unsigned char data[100] = {0, };
 100
 101         // no malware detected
 102         ASSERT_SUCCESS(csr_cs_scan_data(context, data, sizeof(data), &detected));
 103
 104         CHECK_IS_NULL(detected);
 105
 106         EXCEPTION_GUARD_END
 107 }
 108
 109 BOOST_AUTO_TEST_CASE(scan_data_high)
 110 {
 111         EXCEPTION_GUARD_START
 112
 113         auto c = Test::Context<csr_cs_context_h>();
 114         auto context = c.get();
 115         csr_cs_malware_h detected;
 116         unsigned char data[100] = {0, };
 117         time_t start_time = time(nullptr);
 118
 119         // severity high detected
 120         memcpy(data, MALWARE_HIGH_SIGNATURE, strlen(MALWARE_HIGH_SIGNATURE));
 121         ASSERT_SUCCESS(csr_cs_scan_data(context, data, sizeof(data), &detected));
 122
 123         CHECK_IS_NOT_NULL(detected);
 124         ASSERT_DETECTED(detected, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 125                                         MALWARE_HIGH_DETAILED_URL);
 126         ASSERT_DETECTED_EXT(detected, start_time, nullptr, false, nullptr);
 127
 128         EXCEPTION_GUARD_END
 129 }
 130
 131 BOOST_AUTO_TEST_CASE(scan_data_medium)
 132 {
 133         EXCEPTION_GUARD_START
 134
 135         auto c = Test::Context<csr_cs_context_h>();
 136         auto context = c.get();
 137         csr_cs_malware_h detected;
 138         unsigned char data[100] = {0, };
 139         time_t start_time = time(nullptr);
 140
 141         // severity medium detected
 142         memcpy(data, MALWARE_MEDIUM_SIGNATURE, strlen(MALWARE_MEDIUM_SIGNATURE));
 143         ASSERT_SUCCESS(csr_cs_scan_data(context, data, sizeof(data), &detected));
 144
 145         CHECK_IS_NOT_NULL(detected);
 146         ASSERT_DETECTED(detected, MALWARE_MEDIUM_NAME, MALWARE_MEDIUM_SEVERITY,
 147                                         MALWARE_MEDIUM_DETAILED_URL);
 148         ASSERT_DETECTED_EXT(detected, start_time, nullptr, false, nullptr);
 149
 150         EXCEPTION_GUARD_END
 151 }
 152
 153 BOOST_AUTO_TEST_CASE(scan_data_low)
 154 {
 155         EXCEPTION_GUARD_START
 156
 157         auto c = Test::Context<csr_cs_context_h>();
 158         auto context = c.get();
 159         csr_cs_malware_h detected;
 160         unsigned char data[100] = {0, };
 161         time_t start_time = time(nullptr);
 162
 163         // severity low detected
 164         memcpy(data, MALWARE_LOW_SIGNATURE, strlen(MALWARE_LOW_SIGNATURE));
 165         ASSERT_SUCCESS(csr_cs_scan_data(context, data, sizeof(data), &detected));
 166
 167         CHECK_IS_NOT_NULL(detected);
 168         ASSERT_DETECTED(detected, MALWARE_LOW_NAME, MALWARE_LOW_SEVERITY,
 169                                         MALWARE_LOW_DETAILED_URL);
 170         ASSERT_DETECTED_EXT(detected, start_time, nullptr, false, nullptr);
 171
 172         EXCEPTION_GUARD_END
 173 }
 174
 175 BOOST_AUTO_TEST_CASE(scan_data_negative)
 176 {
 177         EXCEPTION_GUARD_START
 178
 179         auto c = Test::Context<csr_cs_context_h>();
 180         auto context = c.get();
 181         csr_cs_malware_h detected;
 182         unsigned char data[100] = {0, };
 183
 184         ASSERT_IF(csr_cs_scan_data(nullptr, data, sizeof(data), &detected),
 185                           CSR_ERROR_INVALID_HANDLE);
 186
 187         ASSERT_IF(csr_cs_scan_data(context, nullptr, sizeof(data), &detected),
 188                           CSR_ERROR_INVALID_PARAMETER);
 189
 190         ASSERT_IF(csr_cs_scan_data(context, data, sizeof(data), nullptr),
 191                           CSR_ERROR_INVALID_PARAMETER);
 192
 193         EXCEPTION_GUARD_END
 194 }
 195
 196 BOOST_AUTO_TEST_CASE(scan_file_normal)
 197 {
 198         EXCEPTION_GUARD_START
 199
 200         auto c = Test::Context<csr_cs_context_h>();
 201         auto context = c.get();
 202         csr_cs_malware_h detected;
 203
 204         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_NORMAL, &detected));
 205
 206         // no malware detected
 207         CHECK_IS_NULL(detected);
 208
 209         EXCEPTION_GUARD_END
 210 }
 211
 212 BOOST_AUTO_TEST_CASE(scan_file_high)
 213 {
 214         EXCEPTION_GUARD_START
 215
 216         auto c = Test::Context<csr_cs_context_h>();
 217         auto context = c.get();
 218         csr_cs_malware_h detected;
 219         time_t start_time = time(nullptr);
 220
 221         Test::touch_file(TEST_FILE_HIGH);
 222
 223         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_HIGH, &detected));
 224
 225         CHECK_IS_NOT_NULL(detected);
 226         ASSERT_DETECTED(detected, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 227                                         MALWARE_HIGH_DETAILED_URL);
 228         ASSERT_DETECTED_EXT(detected, start_time, TEST_FILE_HIGH, false, nullptr);
 229
 230         EXCEPTION_GUARD_END
 231 }
 232
 233 BOOST_AUTO_TEST_CASE(scan_file_medium)
 234 {
 235         EXCEPTION_GUARD_START
 236
 237         auto c = Test::Context<csr_cs_context_h>();
 238         auto context = c.get();
 239         csr_cs_malware_h detected;
 240         time_t start_time = time(nullptr);
 241
 242         Test::touch_file(TEST_FILE_MEDIUM);
 243
 244         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIUM, &detected));
 245
 246         CHECK_IS_NOT_NULL(detected);
 247         ASSERT_DETECTED(detected, MALWARE_MEDIUM_NAME, MALWARE_MEDIUM_SEVERITY,
 248                                         MALWARE_MEDIUM_DETAILED_URL);
 249         ASSERT_DETECTED_EXT(detected, start_time, TEST_FILE_MEDIUM, false, nullptr);
 250
 251         EXCEPTION_GUARD_END
 252 }
 253
 254 BOOST_AUTO_TEST_CASE(scan_file_low)
 255 {
 256         EXCEPTION_GUARD_START
 257
 258         auto c = Test::Context<csr_cs_context_h>();
 259         auto context = c.get();
 260         csr_cs_malware_h detected;
 261         time_t start_time = time(nullptr);
 262
 263         Test::touch_file(TEST_FILE_LOW);
 264
 265         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_LOW, &detected));
 266
 267         CHECK_IS_NOT_NULL(detected);
 268         ASSERT_DETECTED(detected, MALWARE_LOW_NAME, MALWARE_LOW_SEVERITY,
 269                                         MALWARE_LOW_DETAILED_URL);
 270         ASSERT_DETECTED_EXT(detected, start_time, TEST_FILE_LOW, false, nullptr);
 271
 272         EXCEPTION_GUARD_END
 273 }
 274
 275 BOOST_AUTO_TEST_CASE(scan_file_media_dir)
 276 {
 277         EXCEPTION_GUARD_START
 278
 279         auto c = Test::Context<csr_cs_context_h>();
 280         auto context = c.get();
 281         csr_cs_malware_h detected;
 282         time_t start_time = time(nullptr);
 283
 284         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
 285
 286         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 287
 288         CHECK_IS_NOT_NULL(detected);
 289         ASSERT_DETECTED(detected, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 290                                         MALWARE_HIGH_DETAILED_URL);
 291         ASSERT_DETECTED_EXT(detected, start_time, TEST_FILE_MEDIA, false, nullptr);
 292
 293         EXCEPTION_GUARD_END
 294 }
 295
 296 BOOST_AUTO_TEST_CASE(scan_file_tmp_dir)
 297 {
 298         EXCEPTION_GUARD_START
 299
 300         auto c = Test::Context<csr_cs_context_h>();
 301         auto context = c.get();
 302         csr_cs_malware_h detected;
 303         time_t start_time = time(nullptr);
 304
 305         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_TMP);
 306
 307         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP, &detected));
 308
 309         CHECK_IS_NOT_NULL(detected);
 310         ASSERT_DETECTED(detected, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 311                                         MALWARE_HIGH_DETAILED_URL);
 312         ASSERT_DETECTED_EXT(detected, start_time, TEST_FILE_TMP, false, nullptr);
 313
 314         EXCEPTION_GUARD_END
 315 }
 316
 317 // TODO : Add TC for different directories
 318 BOOST_AUTO_TEST_CASE(scan_file_wgt_dir)
 319 {
 320         EXCEPTION_GUARD_START
 321
 322         auto c = Test::Context<csr_cs_context_h>();
 323         auto context = c.get();
 324         csr_cs_malware_h detected;
 325         time_t start_time = time(nullptr);
 326
 327         Test::uninstall_app(TEST_WGT_PKG_ID);
 328         ASSERT_INSTALL_APP(TEST_WGT_PATH, TEST_WGT_TYPE);
 329
 330         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_WGT_MAL_FILE, &detected));
 331
 332         CHECK_IS_NOT_NULL(detected);
 333         ASSERT_DETECTED(detected, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 334                                         MALWARE_HIGH_DETAILED_URL);
 335         ASSERT_DETECTED_EXT(detected, start_time, TEST_WGT_APP_ROOT, true, TEST_WGT_PKG_ID);
 336
 337         ASSERT_UNINSTALL_APP(TEST_WGT_PKG_ID);
 338
 339         EXCEPTION_GUARD_END
 340 }
 341
 342 // TODO : Add TC for different directories
 343 BOOST_AUTO_TEST_CASE(scan_file_tpk_dir)
 344 {
 345         EXCEPTION_GUARD_START
 346
 347         auto c = Test::Context<csr_cs_context_h>();
 348         auto context = c.get();
 349         csr_cs_malware_h detected;
 350         time_t start_time = time(nullptr);
 351
 352         Test::uninstall_app(TEST_TPK_PKG_ID);
 353         ASSERT_INSTALL_APP(TEST_TPK_PATH, TEST_TPK_TYPE);
 354
 355         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_TPK_MAL_FILE, &detected));
 356
 357         CHECK_IS_NOT_NULL(detected);
 358         ASSERT_DETECTED(detected, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 359                                         MALWARE_HIGH_DETAILED_URL);
 360         ASSERT_DETECTED_EXT(detected, start_time, TEST_TPK_APP_ROOT, true, TEST_TPK_PKG_ID);
 361
 362         ASSERT_UNINSTALL_APP(TEST_TPK_PKG_ID);
 363
 364         EXCEPTION_GUARD_END
 365 }
 366
 367 BOOST_AUTO_TEST_CASE(scan_file_invalid_params)
 368 {
 369
 370         EXCEPTION_GUARD_START
 371
 372         auto c = Test::Context<csr_cs_context_h>();
 373         auto context = c.get();
 374         csr_cs_malware_h detected;
 375
 376         ASSERT_IF(csr_cs_scan_file(nullptr, TEST_FILE_NORMAL, &detected),
 377                           CSR_ERROR_INVALID_HANDLE);
 378         ASSERT_IF(csr_cs_scan_file(context, nullptr, &detected), CSR_ERROR_INVALID_PARAMETER);
 379         ASSERT_IF(csr_cs_scan_file(context, TEST_FILE_NORMAL, nullptr),
 380                           CSR_ERROR_INVALID_PARAMETER);
 381
 382         EXCEPTION_GUARD_END
 383 }
 384
 385 BOOST_AUTO_TEST_CASE(scan_file_not_existing_file)
 386 {
 387         EXCEPTION_GUARD_START
 388
 389         auto c = Test::Context<csr_cs_context_h>();
 390         auto context = c.get();
 391         csr_cs_malware_h detected;
 392
 393         ASSERT_IF(csr_cs_scan_file(context, TEST_FILE_NO_EXIST, &detected),
 394                           CSR_ERROR_FILE_DO_NOT_EXIST);
 395
 396         EXCEPTION_GUARD_END
 397 }
 398
 399 BOOST_AUTO_TEST_CASE(get_detected_malware)
 400 {
 401         EXCEPTION_GUARD_START
 402
 403         auto c = Test::Context<csr_cs_context_h>();
 404         auto context = c.get();
 405         csr_cs_malware_h detected;
 406         csr_cs_malware_h stored;
 407
 408         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIUM, &detected));
 409         CHECK_IS_NOT_NULL(detected);
 410
 411         ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIUM, &stored));
 412         CHECK_IS_NOT_NULL(stored);
 413
 414         ASSERT_DETECTED_HANDLE(detected, stored);
 415
 416         EXCEPTION_GUARD_END
 417 }
 418
 419 BOOST_AUTO_TEST_CASE(get_detected_malware_invalid_param)
 420 {
 421         EXCEPTION_GUARD_START
 422
 423         auto c = Test::Context<csr_cs_context_h>();
 424         auto context = c.get();
 425         csr_cs_malware_h stored;
 426
 427         ASSERT_IF(csr_cs_get_detected_malware(nullptr, TEST_FILE_MEDIUM, &stored),
 428                           CSR_ERROR_INVALID_HANDLE);
 429         ASSERT_IF(csr_cs_get_detected_malware(context, nullptr, &stored),
 430                           CSR_ERROR_INVALID_PARAMETER);
 431         ASSERT_IF(csr_cs_get_detected_malware(context, TEST_FILE_MEDIUM, nullptr),
 432                           CSR_ERROR_INVALID_PARAMETER);
 433
 434         EXCEPTION_GUARD_END;
 435 }
 436
 437 BOOST_AUTO_TEST_CASE(get_detected_malware_not_existing_file)
 438 {
 439         EXCEPTION_GUARD_START
 440
 441         auto c = Test::Context<csr_cs_context_h>();
 442         auto context = c.get();
 443         csr_cs_malware_h stored;
 444
 445         ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_NO_EXIST, &stored));
 446         CHECK_IS_NULL(stored);
 447
 448         EXCEPTION_GUARD_END
 449 }
 450
 451 BOOST_AUTO_TEST_CASE(get_detected_malwares)
 452 {
 453         EXCEPTION_GUARD_START
 454
 455         auto c = Test::Context<csr_cs_context_h>();
 456         auto context = c.get();
 457         csr_cs_malware_list_h detected_list;
 458         csr_cs_malware_h detected_high, detected_medium;
 459         csr_cs_malware_h stored;
 460         Test::ScopedCstr file_path_actual;
 461         size_t cnt = 0;
 462         size_t idx = 0;
 463         size_t compared_cnt = 0;
 464
 465         const char *dirs[1] = {
 466                 TEST_DIR
 467         };
 468
 469         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_HIGH, &detected_high));
 470         CHECK_IS_NOT_NULL(detected_high);
 471         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIUM, &detected_medium));
 472         CHECK_IS_NOT_NULL(detected_medium);
 473
 474         ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs,
 475                                                                                                 sizeof(dirs) / sizeof(const char *),
 476                                                                                                 &detected_list, &cnt));
 477         CHECK_IS_NOT_NULL(detected_list);
 478
 479         for (idx = 0; idx < cnt; idx++) {
 480                 ASSERT_SUCCESS(csr_cs_malware_list_get_malware(detected_list, idx, &stored));
 481                 CHECK_IS_NOT_NULL(stored);
 482                 ASSERT_SUCCESS(csr_cs_malware_get_file_name(stored, &file_path_actual.ptr));
 483                 if (strcmp(TEST_FILE_HIGH, file_path_actual.ptr) == 0) {
 484                         ASSERT_DETECTED_HANDLE(detected_high, stored);
 485                         compared_cnt++;
 486                 } else if (strcmp(TEST_FILE_MEDIUM, file_path_actual.ptr) == 0) {
 487                         ASSERT_DETECTED_HANDLE(detected_medium, stored);
 488                         compared_cnt++;
 489                 } else {
 490                         continue;
 491                 }
 492         }
 493
 494         BOOST_REQUIRE_MESSAGE(compared_cnt == 2, "Detected malware count is invalid. "
 495                                                   "expected: == 2, cnt: " << compared_cnt);
 496
 497         EXCEPTION_GUARD_END
 498 }
 499
 500 BOOST_AUTO_TEST_CASE(get_detected_malwares_invalid_params)
 501 {
 502         EXCEPTION_GUARD_START
 503
 504         auto c = Test::Context<csr_cs_context_h>();
 505         auto context = c.get();
 506         csr_cs_malware_list_h detected_list;
 507         size_t cnt = 0;
 508
 509         const char *dirs[1] = {
 510                 TEST_DIR
 511         };
 512
 513         ASSERT_IF(csr_cs_get_detected_malwares(nullptr, dirs,
 514                                                                                    sizeof(dirs) / sizeof(const char *),
 515                                                                                    &detected_list, &cnt),
 516                           CSR_ERROR_INVALID_HANDLE);
 517
 518         ASSERT_IF(csr_cs_get_detected_malwares(context, nullptr,
 519                                                                                    sizeof(dirs) / sizeof(const char *),
 520                                                                                    &detected_list, &cnt),
 521                           CSR_ERROR_INVALID_PARAMETER);
 522         ASSERT_IF(csr_cs_get_detected_malwares(context, dirs,
 523                                                                                    sizeof(dirs) / sizeof(const char *),
 524                                                                                    nullptr, &cnt),
 525                           CSR_ERROR_INVALID_PARAMETER);
 526         ASSERT_IF(csr_cs_get_detected_malwares(context, dirs,
 527                                                                                    sizeof(dirs) / sizeof(const char *),
 528                                                                                    &detected_list, nullptr),
 529                           CSR_ERROR_INVALID_PARAMETER);
 530
 531         EXCEPTION_GUARD_END
 532 }
 533
 534 BOOST_AUTO_TEST_CASE(get_detected_malwares_not_existing_dir)
 535 {
 536         EXCEPTION_GUARD_START
 537
 538         auto c = Test::Context<csr_cs_context_h>();
 539         auto context = c.get();
 540         csr_cs_malware_list_h detected_list;
 541         size_t cnt = 0;
 542
 543         const char *dirs[1] = {
 544                 TEST_FILE_NO_EXIST
 545         };
 546
 547         ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs,
 548                                                                                                 sizeof(dirs) / sizeof(const char *),
 549                                                                                                 &detected_list, &cnt));
 550
 551         ASSERT_IF(cnt, static_cast<size_t>(0));
 552
 553         EXCEPTION_GUARD_END
 554 }
 555
 556 BOOST_AUTO_TEST_CASE(get_ignored_malware)
 557 {
 558         EXCEPTION_GUARD_START
 559
 560         auto c = Test::Context<csr_cs_context_h>();
 561         auto context = c.get();
 562         csr_cs_malware_h detected, stored;
 563
 564         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_HIGH, &detected));
 565         CHECK_IS_NOT_NULL(detected);
 566
 567         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_IGNORE));
 568
 569         ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_HIGH, &stored));
 570
 571         CHECK_IS_NOT_NULL(stored);
 572
 573         ASSERT_DETECTED_HANDLE(detected, stored);
 574
 575         // rollback to unignore
 576         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_UNIGNORE));
 577
 578         EXCEPTION_GUARD_END
 579 }
 580
 581 BOOST_AUTO_TEST_CASE(get_ignored_malware_invalid_param)
 582 {
 583         EXCEPTION_GUARD_START
 584
 585         auto c = Test::Context<csr_cs_context_h>();
 586         auto context = c.get();
 587         csr_cs_malware_h stored;
 588
 589         ASSERT_IF(csr_cs_get_ignored_malware(nullptr, TEST_FILE_MEDIUM, &stored),
 590                           CSR_ERROR_INVALID_HANDLE);
 591         ASSERT_IF(csr_cs_get_ignored_malware(context, nullptr, &stored),
 592                           CSR_ERROR_INVALID_PARAMETER);
 593         ASSERT_IF(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIUM, nullptr),
 594                           CSR_ERROR_INVALID_PARAMETER);
 595
 596         EXCEPTION_GUARD_END
 597 }
 598
 599 BOOST_AUTO_TEST_CASE(get_ignored_malware_not_existing_file)
 600 {
 601         EXCEPTION_GUARD_START
 602
 603         auto c = Test::Context<csr_cs_context_h>();
 604         auto context = c.get();
 605         csr_cs_malware_h stored;
 606
 607         ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_NO_EXIST, &stored));
 608         CHECK_IS_NULL(stored);
 609
 610         EXCEPTION_GUARD_END
 611 }
 612
 613 BOOST_AUTO_TEST_CASE(get_ignored_malwares)
 614 {
 615         EXCEPTION_GUARD_START
 616
 617         auto c = Test::Context<csr_cs_context_h>();
 618         auto context = c.get();
 619         csr_cs_malware_list_h ignored_list;
 620         csr_cs_malware_h detected_high, detected_medium, stored;
 621         size_t cnt = 0;
 622         size_t idx = 0;
 623         size_t compared_cnt = 0;
 624         Test::ScopedCstr file_path_actual;
 625
 626         const char *dirs[1] = {
 627                 TEST_DIR
 628         };
 629
 630         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_HIGH, &detected_high));
 631         CHECK_IS_NOT_NULL(detected_high);
 632         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected_high,
 633                                                                                                  CSR_CS_ACTION_IGNORE));
 634
 635         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIUM, &detected_medium));
 636         CHECK_IS_NOT_NULL(detected_medium);
 637         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected_medium,
 638                                                                                                  CSR_CS_ACTION_IGNORE));
 639
 640         ASSERT_SUCCESS(csr_cs_get_ignored_malwares(context, dirs,
 641                                                                                                 sizeof(dirs) / sizeof(const char *),
 642                                                                                                 &ignored_list, &cnt));
 643         CHECK_IS_NOT_NULL(ignored_list);
 644
 645         for (idx = 0; idx < cnt; idx++) {
 646                 ASSERT_SUCCESS(csr_cs_malware_list_get_malware(ignored_list, idx, &stored));
 647                 CHECK_IS_NOT_NULL(stored);
 648                 ASSERT_SUCCESS(csr_cs_malware_get_file_name(stored, &file_path_actual.ptr));
 649                 if (strcmp(TEST_FILE_HIGH, file_path_actual.ptr) == 0) {
 650                         ASSERT_DETECTED_HANDLE(detected_high, stored);
 651                         compared_cnt++;
 652                 } else if (strcmp(TEST_FILE_MEDIUM, file_path_actual.ptr) == 0) {
 653                         ASSERT_DETECTED_HANDLE(detected_medium, stored);
 654                         compared_cnt++;
 655                 } else {
 656                         continue;
 657                 }
 658         }
 659
 660         ASSERT_IF(compared_cnt, static_cast<size_t>(2));
 661
 662         // rollback to unignore
 663         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected_high,
 664                                                                                                  CSR_CS_ACTION_UNIGNORE));
 665         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected_medium,
 666                                                                                                  CSR_CS_ACTION_UNIGNORE));
 667
 668         EXCEPTION_GUARD_END
 669 }
 670
 671 BOOST_AUTO_TEST_CASE(get_ignored_malwares_invalid_params)
 672 {
 673         EXCEPTION_GUARD_START
 674
 675         auto c = Test::Context<csr_cs_context_h>();
 676         auto context = c.get();
 677         csr_cs_malware_list_h ignored_list;
 678         size_t cnt = 0;
 679
 680         const char *dirs[1] = {
 681                 TEST_DIR
 682         };
 683
 684         ASSERT_IF(csr_cs_get_ignored_malwares(nullptr, dirs,
 685                                                                                   sizeof(dirs) / sizeof(const char *),
 686                                                                                   &ignored_list, &cnt),
 687                           CSR_ERROR_INVALID_HANDLE);
 688         ASSERT_IF(csr_cs_get_ignored_malwares(context, nullptr,
 689                                                                                   sizeof(dirs) / sizeof(const char *),
 690                                                                                   &ignored_list, &cnt),
 691                           CSR_ERROR_INVALID_PARAMETER);
 692         ASSERT_IF(csr_cs_get_ignored_malwares(context, dirs,
 693                                                                                   sizeof(dirs) / sizeof(const char *),
 694                                                                                   nullptr, &cnt),
 695                           CSR_ERROR_INVALID_PARAMETER);
 696         ASSERT_IF(csr_cs_get_ignored_malwares(context, dirs,
 697                                                                                   sizeof(dirs) / sizeof(const char *),
 698                                                                                   &ignored_list, nullptr),
 699                           CSR_ERROR_INVALID_PARAMETER);
 700
 701         EXCEPTION_GUARD_END
 702 }
 703
 704 BOOST_AUTO_TEST_CASE(get_ignored_malwares_not_existing_dir)
 705 {
 706         EXCEPTION_GUARD_START
 707
 708         auto c = Test::Context<csr_cs_context_h>();
 709         auto context = c.get();
 710         csr_cs_malware_list_h ignored_list;
 711         size_t cnt = 0;
 712
 713         const char *dirs[1] = {
 714                 TEST_FILE_NO_EXIST
 715         };
 716
 717         ASSERT_SUCCESS(csr_cs_get_ignored_malwares(context, dirs,
 718                                                                                            sizeof(dirs) / sizeof(const char *),
 719                                                                                            &ignored_list, &cnt));
 720
 721         ASSERT_IF(cnt, static_cast<size_t>(0));
 722
 723         EXCEPTION_GUARD_END
 724 }
 725
 726 BOOST_AUTO_TEST_CASE(judge_detected_malware)
 727 {
 728         EXCEPTION_GUARD_START
 729
 730         auto c = Test::Context<csr_cs_context_h>();
 731         auto context = c.get();
 732         csr_cs_malware_h detected, stored;
 733
 734         // remove earlier test results
 735         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
 736         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 737         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 738         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
 739
 740         // store detected malware
 741         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 742         CHECK_IS_NOT_NULL(detected);
 743
 744         ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
 745         CHECK_IS_NOT_NULL(stored);
 746
 747         ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
 748         CHECK_IS_NULL(stored);
 749
 750         // IGNORE
 751         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_IGNORE));
 752
 753         ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
 754         CHECK_IS_NULL(stored);
 755
 756         ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
 757         CHECK_IS_NOT_NULL(stored);
 758
 759         // UNIGNORE
 760         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_UNIGNORE));
 761
 762         ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
 763         CHECK_IS_NOT_NULL(stored);
 764
 765         ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
 766         CHECK_IS_NULL(stored);
 767
 768         // REMOVE
 769         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 770
 771         ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
 772         CHECK_IS_NULL(stored);
 773
 774         ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
 775         CHECK_IS_NULL(stored);
 776
 777         EXCEPTION_GUARD_END
 778 }
 779
 780 BOOST_AUTO_TEST_CASE(judge_detected_malware_after_changed_file)
 781 {
 782         EXCEPTION_GUARD_START
 783
 784         auto c = Test::Context<csr_cs_context_h>();
 785         auto context = c.get();
 786         csr_cs_malware_h detected;
 787
 788         // scan and judge after touch
 789         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
 790         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 791         CHECK_IS_NOT_NULL(detected);
 792
 793         std::this_thread::sleep_for(std::chrono::seconds(1));
 794
 795         Test::touch_file(TEST_FILE_MEDIA);
 796
 797         std::this_thread::sleep_for(std::chrono::seconds(1));
 798
 799         ASSERT_IF(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE),
 800                           CSR_ERROR_FILE_CHANGED);
 801
 802         // rescan and judge again without touch
 803         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 804         CHECK_IS_NOT_NULL(detected);
 805         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 806
 807         EXCEPTION_GUARD_END
 808 }
 809
 810 BOOST_AUTO_TEST_CASE(judge_detected_malware_ignored_rescan)
 811 {
 812         EXCEPTION_GUARD_START
 813
 814         auto c = Test::Context<csr_cs_context_h>();
 815         auto context = c.get();
 816         csr_cs_malware_h detected, stored;
 817
 818         // remove earlier test results
 819         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
 820         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 821         csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE);
 822         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
 823
 824         // store detected malware
 825         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 826         CHECK_IS_NOT_NULL(detected);
 827
 828         // ignore
 829         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_IGNORE));
 830
 831         // rescan
 832         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 833         CHECK_IS_NULL(detected);
 834
 835         ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
 836         CHECK_IS_NULL(stored);
 837
 838         ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
 839         CHECK_IS_NOT_NULL(stored);
 840
 841         // rollback to unignore
 842         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, stored, CSR_CS_ACTION_UNIGNORE));
 843
 844         EXCEPTION_GUARD_END
 845 }
 846
 847 BOOST_AUTO_TEST_CASE(judge_detected_malware_remove_file)
 848 {
 849         EXCEPTION_GUARD_START
 850
 851         auto c = Test::Context<csr_cs_context_h>();
 852         auto context = c.get();
 853         csr_cs_malware_h detected, stored;
 854
 855         // remove earlier test results
 856         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
 857         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 858         csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE);
 859         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
 860
 861         // store detected malware
 862         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 863         CHECK_IS_NOT_NULL(detected);
 864
 865         // remove detected malware file
 866         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 867
 868         ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
 869         CHECK_IS_NULL(stored);
 870
 871         ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
 872         CHECK_IS_NULL(stored);
 873
 874         ASSERT_IF(Test::is_file_exist(TEST_FILE_MEDIA), false);
 875
 876         // make ignored
 877         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
 878         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 879         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_IGNORE));
 880
 881         // remove ignored malware file
 882         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 883
 884         ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
 885         CHECK_IS_NULL(stored);
 886
 887         ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
 888         CHECK_IS_NULL(stored);
 889
 890         ASSERT_IF(Test::is_file_exist(TEST_FILE_MEDIA), false);
 891
 892         // remove not existing file
 893         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
 894         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
 895         CHECK_IS_NOT_NULL(detected);
 896
 897         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 898
 899         ASSERT_IF(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE),
 900                           CSR_ERROR_FILE_DO_NOT_EXIST);
 901
 902         EXCEPTION_GUARD_END
 903 }
 904
 905 BOOST_AUTO_TEST_CASE(judge_detected_malware_remove_wgt)
 906 {
 907         EXCEPTION_GUARD_START
 908
 909         auto c = Test::Context<csr_cs_context_h>();
 910         auto context = c.get();
 911         csr_cs_malware_h detected;
 912
 913         // remove old test data
 914         Test::uninstall_app(TEST_WGT_PKG_ID);
 915
 916         ASSERT_INSTALL_APP(TEST_WGT_PATH, TEST_WGT_TYPE);
 917
 918         // remove detected malware file
 919         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_WGT_MAL_FILE, &detected));
 920         CHECK_IS_NOT_NULL(detected);
 921
 922         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 923
 924         EXCEPTION_GUARD_END
 925 }
 926
 927 BOOST_AUTO_TEST_CASE(judge_detected_malware_remove_tpk)
 928 {
 929         EXCEPTION_GUARD_START
 930
 931         auto c = Test::Context<csr_cs_context_h>();
 932         auto context = c.get();
 933         csr_cs_malware_h detected;
 934
 935         // remove old test data
 936         Test::uninstall_app(TEST_TPK_PKG_ID);
 937         ASSERT_INSTALL_APP(TEST_TPK_PATH, TEST_TPK_TYPE);
 938
 939         // remove detected malware file
 940         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_TPK_MAL_FILE, &detected));
 941         CHECK_IS_NOT_NULL(detected);
 942
 943         ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 944
 945         EXCEPTION_GUARD_END
 946 }
 947
 948 BOOST_AUTO_TEST_CASE(judge_detected_malware_invalid_params)
 949 {
 950         EXCEPTION_GUARD_START
 951
 952         auto c = Test::Context<csr_cs_context_h>();
 953         auto context = c.get();
 954         csr_cs_malware_h detected;
 955
 956         ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_HIGH, &detected));
 957         CHECK_IS_NOT_NULL(detected);
 958
 959         ASSERT_IF(csr_cs_judge_detected_malware(nullptr, detected, CSR_CS_ACTION_REMOVE),
 960                           CSR_ERROR_INVALID_HANDLE);
 961         ASSERT_IF(csr_cs_judge_detected_malware(context, nullptr, CSR_CS_ACTION_REMOVE),
 962                           CSR_ERROR_INVALID_PARAMETER);
 963         ASSERT_IF(csr_cs_judge_detected_malware(context, detected,
 964                                                                                         static_cast<csr_cs_action_e>(-1)),
 965                           CSR_ERROR_INVALID_PARAMETER);
 966
 967         EXCEPTION_GUARD_END
 968 }
 969
 970 BOOST_AUTO_TEST_SUITE_END()