test/test-api-content-screening-async.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-async.cpp
  18  * @author      Kyungwook Tak (k.tak@samsung.com)
  19  * @version     1.0
  20  * @brief       CSR Content screening async API test
  21  */
  22 #include <csr-content-screening.h>
  23
  24 #include <condition_variable>
  25 #include <thread>
  26 #include <chrono>
  27 #include <mutex>
  28 #include <vector>
  29 #include <boost/test/unit_test.hpp>
  30
  31 #include "test-common.h"
  32 #include "test-helper.h"
  33 #include "test-resource.h"
  34
  35 #define ASSERT_CALLBACK(actual, scan, detect, complete, cancel, error)                  \
  36         do {                                                                                \
  37                 std::unique_lock<std::mutex> l(actual.m);                                       \
  38                 if (!actual.isDone()) {                                                         \
  39                         actual.cv.wait(l);                                                          \
  40                         l.unlock();                                                                 \
  41                 }                                                                               \
  42                 if (complete >= 0)                                                              \
  43                         ASSERT_IF_MSG(actual.completedCnt, complete,                                \
  44                                                   "completed count mismatch! "                                  \
  45                                                   "Async isn't successfully completed!");                       \
  46                 if (cancel >= 0)                                                                \
  47                         ASSERT_IF_MSG(actual.cancelledCnt, cancel, "cancelled count mismatch.");    \
  48                 if (error >= 0)                                                                 \
  49                         ASSERT_IF_MSG(actual.errorCnt, error, "error count mismatch.");             \
  50                 if (detect >= 0)                                                                \
  51                         ASSERT_IF_MSG(actual.detectedCnt, detect, "detected count mismatch.");      \
  52                 if (scan >= 0)                                                                  \
  53                         ASSERT_IF_MSG(actual.scannedCnt, scan, "scanned count mismatch.");          \
  54                 break;                                                                          \
  55         } while (false)
  56
  57 namespace {
  58
  59 struct AsyncTestContext {
  60         std::mutex m;
  61         std::mutex m_vec;
  62         std::condition_variable cv;
  63         int scannedCnt;
  64         int detectedCnt;
  65         int completedCnt;
  66         int cancelledCnt;
  67         int errorCnt;
  68         std::vector<std::string> scannedList;
  69         std::vector<csr_cs_malware_h> detectedList;
  70         int errorCode;
  71         bool apiReturned;
  72
  73         AsyncTestContext(bool raceTest) :
  74                 scannedCnt(0),
  75                 detectedCnt(0),
  76                 completedCnt(0),
  77                 cancelledCnt(0),
  78                 errorCnt(0),
  79                 apiReturned(!raceTest) {}
  80
  81         AsyncTestContext() :
  82                 scannedCnt(0),
  83                 detectedCnt(0),
  84                 completedCnt(0),
  85                 cancelledCnt(0),
  86                 errorCnt(0),
  87                 apiReturned(true) {}
  88
  89         bool isDone(void) const {
  90                 return this->completedCnt != 0 || this->cancelledCnt != 0 || this->errorCnt != 0;
  91         }
  92 };
  93
  94 void on_scanned(const char *file, void *userdata)
  95 {
  96         auto ctx = reinterpret_cast<AsyncTestContext *>(userdata);
  97
  98         BOOST_REQUIRE_MESSAGE(ctx->apiReturned,
  99                 "API not returned yet but scanned callback called on file: " << file);
 100
 101         BOOST_MESSAGE("on_scanned. file[" << file << "] scanned!");
 102
 103         std::lock_guard<std::mutex> l(ctx->m_vec);
 104
 105         ctx->scannedCnt++;
 106         ctx->scannedList.push_back(file);
 107 }
 108
 109 void on_detected(csr_cs_malware_h detected, void *userdata)
 110 {
 111         auto ctx = reinterpret_cast<AsyncTestContext *>(userdata);
 112
 113         BOOST_REQUIRE_MESSAGE(ctx->apiReturned,
 114                 "API not returned yet but detected callback called");
 115
 116         Test::ScopedCstr file_name;
 117         ASSERT_SUCCESS(csr_cs_malware_get_file_name(detected, &file_name.ptr));
 118         BOOST_MESSAGE("on_detected. file[" << file_name.ptr << "] detected!");
 119
 120         std::lock_guard<std::mutex> l(ctx->m_vec);
 121
 122         ctx->detectedCnt++;
 123         ctx->detectedList.push_back(detected);
 124 }
 125
 126 void on_error(int ec, void *userdata)
 127 {
 128         auto ctx = reinterpret_cast<AsyncTestContext *>(userdata);
 129
 130         BOOST_REQUIRE_MESSAGE(ctx->apiReturned,
 131                 "API not returned yet but error callback called with error: " <<
 132                 Test::capi_ec_to_string(ec));
 133
 134         BOOST_MESSAGE("on_error. async request done with error: " <<
 135                                   Test::capi_ec_to_string(ec));
 136
 137         ctx->errorCnt++;
 138         ctx->errorCode = ec;
 139         ctx->cv.notify_one();
 140 }
 141
 142 void on_completed(void *userdata)
 143 {
 144         auto ctx = reinterpret_cast<AsyncTestContext *>(userdata);
 145
 146         BOOST_REQUIRE_MESSAGE(ctx->apiReturned,
 147                 "API not returned yet but completed callback called");
 148
 149         BOOST_MESSAGE("on_completed. async request completed succesfully.");
 150         ctx->completedCnt++;
 151         ctx->cv.notify_one();
 152 }
 153
 154 void on_cancelled(void *userdata)
 155 {
 156         auto ctx = reinterpret_cast<AsyncTestContext *>(userdata);
 157
 158         BOOST_REQUIRE_MESSAGE(ctx->apiReturned,
 159                 "API not returned yet but cancelled callback called");
 160
 161         BOOST_MESSAGE("on_cancelled. async request canceled!");
 162         ctx->cancelledCnt++;
 163         ctx->cv.notify_one();
 164 }
 165
 166 void set_default_callback(csr_cs_context_h context)
 167 {
 168         ASSERT_SUCCESS(csr_cs_set_detected_cb(context, on_detected));
 169         ASSERT_SUCCESS(csr_cs_set_completed_cb(context, on_completed));
 170         ASSERT_SUCCESS(csr_cs_set_cancelled_cb(context, on_cancelled));
 171         ASSERT_SUCCESS(csr_cs_set_error_cb(context, on_error));
 172         ASSERT_SUCCESS(csr_cs_set_file_scanned_cb(context, on_scanned));
 173 }
 174
 175 void install_test_files()
 176 {
 177         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
 178         Test::copy_file(TEST_FILE_HIGH, TEST_FILE_TMP);
 179
 180         Test::make_dir(TEST_FAKE_APP_ROOT());
 181         Test::copy_file(TEST_FILE_HIGH, TEST_FAKE_APP_FILE());
 182 }
 183
 184 void uninstall_test_files()
 185 {
 186         Test::remove_file(TEST_FILE_MEDIA());
 187         Test::remove_file(TEST_FILE_TMP);
 188         Test::remove_file(TEST_FAKE_APP_FILE());
 189         Test::remove_file(TEST_FAKE_APP_ROOT());
 190 }
 191
 192 void uninstall_test_apps()
 193 {
 194         Test::uninstall_app(TEST_WGT_PKG_ID);
 195         Test::uninstall_app(TEST_TPK_PKG_ID);
 196         Test::uninstall_app(TEST_SAFE_WGT_PKG_ID);
 197 }
 198
 199 void install_test_apps()
 200 {
 201         uninstall_test_apps();
 202
 203         ASSERT_INSTALL_APP(TEST_WGT_PATH, TEST_WGT_TYPE);
 204         ASSERT_INSTALL_APP(TEST_TPK_PATH, TEST_TPK_TYPE);
 205         ASSERT_INSTALL_APP(TEST_SAFE_WGT_PATH, TEST_SAFE_WGT_TYPE);
 206 }
 207
 208 } // end of namespace
 209
 210 BOOST_AUTO_TEST_SUITE(API_CONTENT_SCREENING_ASYNC)
 211
 212 BOOST_AUTO_TEST_CASE(set_callbacks_positive)
 213 {
 214         EXCEPTION_GUARD_START
 215
 216         auto c = Test::Context<csr_cs_context_h>();
 217         auto context = c.get();
 218
 219         set_default_callback(context);
 220
 221         EXCEPTION_GUARD_END
 222 }
 223
 224 BOOST_AUTO_TEST_CASE(set_callbacks_negative)
 225 {
 226         EXCEPTION_GUARD_START
 227
 228         auto c = Test::Context<csr_cs_context_h>();
 229         auto context = c.get();
 230
 231         ASSERT_IF(csr_cs_set_detected_cb(nullptr, on_detected), CSR_ERROR_INVALID_HANDLE);
 232         ASSERT_IF(csr_cs_set_detected_cb(context, nullptr), CSR_ERROR_INVALID_PARAMETER);
 233         ASSERT_IF(csr_cs_set_completed_cb(nullptr, on_completed), CSR_ERROR_INVALID_HANDLE);
 234         ASSERT_IF(csr_cs_set_completed_cb(context, nullptr), CSR_ERROR_INVALID_PARAMETER);
 235         ASSERT_IF(csr_cs_set_cancelled_cb(nullptr, on_cancelled), CSR_ERROR_INVALID_HANDLE);
 236         ASSERT_IF(csr_cs_set_cancelled_cb(context, nullptr), CSR_ERROR_INVALID_PARAMETER);
 237         ASSERT_IF(csr_cs_set_error_cb(nullptr, on_error), CSR_ERROR_INVALID_HANDLE);
 238         ASSERT_IF(csr_cs_set_error_cb(context, nullptr), CSR_ERROR_INVALID_PARAMETER);
 239         ASSERT_IF(csr_cs_set_file_scanned_cb(nullptr, on_scanned), CSR_ERROR_INVALID_HANDLE);
 240         ASSERT_IF(csr_cs_set_file_scanned_cb(context, nullptr), CSR_ERROR_INVALID_PARAMETER);
 241
 242         EXCEPTION_GUARD_END
 243 }
 244
 245 BOOST_AUTO_TEST_CASE(scan_files_async_positive)
 246 {
 247         EXCEPTION_GUARD_START
 248
 249         auto c = Test::Context<csr_cs_context_h>();
 250         auto context = c.get();
 251
 252         set_default_callback(context);
 253
 254         const char *files[4] = {
 255                 TEST_FILE_HIGH,
 256                 TEST_FILE_MEDIUM,
 257                 TEST_FILE_LOW,
 258                 TEST_FILE_NORMAL
 259         };
 260
 261         AsyncTestContext testCtx;
 262
 263         ASSERT_SUCCESS(csr_cs_scan_files_async(context, files, 4, &testCtx));
 264
 265         ASSERT_CALLBACK(testCtx, -1, 3, 1, 0, 0);
 266
 267         ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
 268                 TEST_FILE_HIGH, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
 269         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_HIGH, false, "");
 270
 271         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_MEDIUM, MALWARE_MEDIUM_NAME,
 272                                                         MALWARE_MEDIUM_SEVERITY, MALWARE_MEDIUM_DETAILED_URL);
 273         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_MEDIUM, false, "");
 274
 275         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_LOW, MALWARE_LOW_NAME,
 276                                                         MALWARE_LOW_SEVERITY, MALWARE_LOW_DETAILED_URL);
 277         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_LOW, false, "");
 278
 279         EXCEPTION_GUARD_END
 280 }
 281
 282 BOOST_AUTO_TEST_CASE(scan_files_async_negative)
 283 {
 284         EXCEPTION_GUARD_START
 285
 286         auto c = Test::Context<csr_cs_context_h>();
 287         auto context = c.get();
 288
 289         const char *files[3] = {
 290                 TEST_FILE_HIGH,
 291                 TEST_FILE_NORMAL,
 292                 TEST_FILE_MEDIUM
 293         };
 294
 295         AsyncTestContext testCtx;
 296
 297         ASSERT_IF(csr_cs_scan_files_async(nullptr, files, 3, nullptr), CSR_ERROR_INVALID_HANDLE);
 298         ASSERT_IF(csr_cs_scan_files_async(context, nullptr, 3, nullptr), CSR_ERROR_INVALID_PARAMETER);
 299
 300         EXCEPTION_GUARD_END
 301 }
 302
 303 BOOST_AUTO_TEST_CASE(scan_dir_positive)
 304 {
 305         EXCEPTION_GUARD_START
 306
 307         auto c = Test::Context<csr_cs_context_h>();
 308         auto context = c.get();
 309
 310         set_default_callback(context);
 311
 312         AsyncTestContext testCtx;
 313
 314         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_MALWARES, &testCtx));
 315
 316         //scanned, detected, completed, cancelled, error
 317         ASSERT_CALLBACK(testCtx, -1, -1, 1, 0, 0);
 318         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_UNREMOVABLE,
 319                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 320                                                         MALWARE_HIGH_DETAILED_URL);
 321         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_UNREMOVABLE, false, "");
 322
 323         EXCEPTION_GUARD_END
 324 }
 325
 326 BOOST_AUTO_TEST_CASE(scan_dir_negative)
 327 {
 328         EXCEPTION_GUARD_START
 329
 330         auto c = Test::Context<csr_cs_context_h>();
 331         auto context = c.get();
 332
 333         AsyncTestContext testCtx;
 334
 335         ASSERT_IF(csr_cs_scan_dir_async(nullptr, TEST_DIR_MALWARES, nullptr), CSR_ERROR_INVALID_HANDLE);
 336         ASSERT_IF(csr_cs_scan_dir_async(context, nullptr, nullptr), CSR_ERROR_INVALID_PARAMETER);
 337
 338         EXCEPTION_GUARD_END
 339 }
 340
 341 BOOST_AUTO_TEST_CASE(scan_dir_root)
 342 {
 343         EXCEPTION_GUARD_START
 344
 345         auto c = Test::Context<csr_cs_context_h>();
 346         auto context = c.get();
 347
 348         install_test_files();
 349         install_test_apps();
 350
 351         set_default_callback(context);
 352
 353         AsyncTestContext testCtx;
 354
 355         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_ROOT, &testCtx));
 356
 357         //scanned, detected, completed, cancelled, error
 358         ASSERT_CALLBACK(testCtx, -1, -1, 1, 0, 0);
 359
 360         Test::uninstall_app(TEST_WGT_PKG_ID);
 361         Test::uninstall_app(TEST_TPK_PKG_ID);
 362
 363         std::string homeDirPrefix;
 364 #ifdef PLATFORM_VERSION_3
 365         // "/home" is symlinked of "/opt/home" so in root directory scanning,
 366         // user directory prefix("/opt") is additionally needed to check file_name field
 367         // in malware handle
 368         homeDirPrefix = "/opt";
 369 #endif
 370
 371         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_HIGH, MALWARE_HIGH_NAME,
 372                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
 373         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_HIGH, false, "");
 374
 375         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, homeDirPrefix + TEST_FILE_MEDIA(),
 376                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 377                                                         MALWARE_HIGH_DETAILED_URL);
 378         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, homeDirPrefix + TEST_FILE_MEDIA(),
 379                                                                 false, "");
 380
 381         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_TMP, MALWARE_HIGH_NAME,
 382                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
 383         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_TMP, false, "");
 384
 385         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, homeDirPrefix + TEST_WGT_APP_ROOT(),
 386                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 387                                                         MALWARE_HIGH_DETAILED_URL);
 388         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, homeDirPrefix + TEST_WGT_APP_ROOT(),
 389                                                                 true, TEST_WGT_PKG_ID);
 390
 391         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, homeDirPrefix + TEST_TPK_APP_ROOT(),
 392                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 393                                                         MALWARE_HIGH_DETAILED_URL);
 394         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, homeDirPrefix + TEST_TPK_APP_ROOT(),
 395                                                                 true, TEST_TPK_PKG_ID);
 396
 397         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, homeDirPrefix + TEST_FAKE_APP_FILE(),
 398                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 399                                                         MALWARE_HIGH_DETAILED_URL);
 400         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, homeDirPrefix + TEST_FAKE_APP_FILE(),
 401                                                                 false, "");
 402
 403         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_MEDIUM, MALWARE_MEDIUM_NAME,
 404                                                         MALWARE_MEDIUM_SEVERITY, MALWARE_MEDIUM_DETAILED_URL);
 405         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_MEDIUM, false, "");
 406
 407         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_LOW, MALWARE_LOW_NAME,
 408                                                         MALWARE_LOW_SEVERITY, MALWARE_LOW_DETAILED_URL);
 409         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_LOW, false, "");
 410
 411         EXCEPTION_GUARD_END
 412 }
 413
 414 BOOST_AUTO_TEST_CASE(scan_dir_media)
 415 {
 416         EXCEPTION_GUARD_START
 417
 418         auto c = Test::Context<csr_cs_context_h>();
 419         auto context = c.get();
 420
 421         install_test_files();
 422
 423         set_default_callback(context);
 424
 425         AsyncTestContext testCtx;
 426
 427         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_MEDIA(), &testCtx));
 428
 429         // scanned, detected, completed, cancelled, error
 430         ASSERT_CALLBACK(testCtx, -1, 1, 1, 0, 0);
 431
 432         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_MEDIA(), MALWARE_HIGH_NAME,
 433                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
 434         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_MEDIA(), false, "");
 435
 436         EXCEPTION_GUARD_END
 437 }
 438
 439 BOOST_AUTO_TEST_CASE(scan_dir_tmp)
 440 {
 441         EXCEPTION_GUARD_START
 442
 443         auto c = Test::Context<csr_cs_context_h>();
 444         auto context = c.get();
 445
 446         install_test_files();
 447
 448         set_default_callback(context);
 449
 450         AsyncTestContext testCtx;
 451
 452         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_TMP, &testCtx));
 453
 454         //scanned, detected, completed, cancelled, error
 455         ASSERT_CALLBACK(testCtx, -1, 1, 1, 0, 0);
 456
 457         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_TMP, MALWARE_HIGH_NAME,
 458                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
 459         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_TMP, false, "");
 460
 461         EXCEPTION_GUARD_END
 462 }
 463
 464 BOOST_AUTO_TEST_CASE(scan_dir_apps)
 465 {
 466         EXCEPTION_GUARD_START
 467
 468         auto c = Test::Context<csr_cs_context_h>();
 469         auto context = c.get();
 470
 471         install_test_files();
 472         install_test_apps();
 473
 474         set_default_callback(context);
 475
 476         AsyncTestContext testCtx;
 477
 478         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testCtx));
 479
 480         //scanned, detected, completed, cancelled, error
 481         ASSERT_CALLBACK(testCtx, -1, 3, 1, 0, 0);
 482
 483         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_WGT_APP_ROOT(), MALWARE_HIGH_NAME,
 484                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
 485         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_WGT_APP_ROOT(), true,
 486                                                                 TEST_WGT_PKG_ID);
 487
 488         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_TPK_APP_ROOT(), MALWARE_HIGH_NAME,
 489                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
 490         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_TPK_APP_ROOT(), true,
 491                                                                 TEST_TPK_PKG_ID);
 492
 493         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FAKE_APP_FILE(), MALWARE_HIGH_NAME,
 494                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
 495         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FAKE_APP_FILE(), false, "");
 496
 497         uninstall_test_apps();
 498
 499         EXCEPTION_GUARD_END
 500 }
 501
 502 BOOST_AUTO_TEST_CASE(scan_dir_wgt)
 503 {
 504         EXCEPTION_GUARD_START
 505
 506         auto c = Test::Context<csr_cs_context_h>();
 507         auto context = c.get();
 508
 509         Test::uninstall_app(TEST_WGT_PKG_ID);
 510         ASSERT_INSTALL_APP(TEST_WGT_PATH, TEST_WGT_TYPE);
 511
 512         set_default_callback(context);
 513
 514         AsyncTestContext testCtx;
 515
 516         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_WGT_APP_ROOT(), &testCtx));
 517
 518         //scanned, detected, completed, cancelled, error
 519         ASSERT_CALLBACK(testCtx, -1, 1, 1, 0, 0);
 520
 521         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_WGT_APP_ROOT(), MALWARE_HIGH_NAME,
 522                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
 523         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_WGT_APP_ROOT(), true,
 524                                                                 TEST_WGT_PKG_ID);
 525
 526         Test::uninstall_app(TEST_WGT_PKG_ID);
 527
 528         EXCEPTION_GUARD_END
 529 }
 530
 531 BOOST_AUTO_TEST_CASE(scan_dir_tpk)
 532 {
 533         EXCEPTION_GUARD_START
 534
 535         auto c = Test::Context<csr_cs_context_h>();
 536         auto context = c.get();
 537
 538         Test::uninstall_app(TEST_TPK_PKG_ID);
 539         ASSERT_INSTALL_APP(TEST_TPK_PATH, TEST_TPK_TYPE);
 540
 541         set_default_callback(context);
 542
 543         AsyncTestContext testCtx;
 544
 545         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_TPK_APP_ROOT(), &testCtx));
 546
 547         //scanned, detected, completed, cancelled, error
 548         ASSERT_CALLBACK(testCtx, -1, 1, 1, 0, 0);
 549
 550         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_TPK_APP_ROOT(), MALWARE_HIGH_NAME,
 551                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
 552         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_TPK_APP_ROOT(), true,
 553                                                                 TEST_TPK_PKG_ID);
 554
 555         Test::uninstall_app(TEST_TPK_PKG_ID);
 556
 557         EXCEPTION_GUARD_END
 558 }
 559
 560 BOOST_AUTO_TEST_CASE(scan_dirs_positive)
 561 {
 562         EXCEPTION_GUARD_START
 563
 564         auto c = Test::Context<csr_cs_context_h>();
 565         auto context = c.get();
 566
 567         set_default_callback(context);
 568
 569         AsyncTestContext testCtx;
 570
 571         const char *dirs[1] = {
 572                 TEST_DIR_MALWARES
 573         };
 574
 575         ASSERT_SUCCESS(csr_cs_scan_dirs_async(context, dirs, 1, &testCtx));
 576
 577         //scanned, detected, completed, cancelled, error
 578         ASSERT_CALLBACK(testCtx, -1, -1, 1, 0, 0);
 579         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_UNREMOVABLE,
 580                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 581                                                         MALWARE_HIGH_DETAILED_URL);
 582         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_UNREMOVABLE, false, "");
 583
 584         EXCEPTION_GUARD_END
 585 }
 586
 587 BOOST_AUTO_TEST_CASE(scan_dirs_negative)
 588 {
 589         EXCEPTION_GUARD_START
 590
 591         auto c = Test::Context<csr_cs_context_h>();
 592         auto context = c.get();
 593
 594         const char *dirs[1] = {
 595                 TEST_DIR_MALWARES
 596         };
 597
 598         ASSERT_IF(csr_cs_scan_dirs_async(nullptr, dirs, 1, nullptr), CSR_ERROR_INVALID_HANDLE);
 599         ASSERT_IF(csr_cs_scan_dirs_async(context, nullptr, 1, nullptr), CSR_ERROR_INVALID_PARAMETER);
 600
 601         EXCEPTION_GUARD_END
 602 }
 603
 604 BOOST_AUTO_TEST_CASE(scan_cancel_positive)
 605 {
 606         EXCEPTION_GUARD_START
 607
 608         auto c = Test::Context<csr_cs_context_h>();
 609         auto context = c.get();
 610
 611         set_default_callback(context);
 612
 613         AsyncTestContext testCtx;
 614
 615         const char *dirs[1] = {
 616                 "/"
 617         };
 618
 619         // touch a file : in case of no target file to scan, we cannot cancel to scan.
 620         Test::touch_file(TEST_FILE_HIGH);
 621
 622         ASSERT_SUCCESS(csr_cs_scan_dirs_async(context, dirs, 1, &testCtx));
 623         ASSERT_SUCCESS(csr_cs_cancel_scanning(context));
 624
 625         //scanned, detected, completed, cancelled, error
 626         ASSERT_CALLBACK(testCtx, -1, -1, 0, 1, 0);
 627
 628         EXCEPTION_GUARD_END
 629 }
 630
 631 BOOST_AUTO_TEST_CASE(scan_cancel_positive_100)
 632 {
 633         EXCEPTION_GUARD_START
 634
 635         auto c = Test::Context<csr_cs_context_h>();
 636         auto context = c.get();
 637
 638         set_default_callback(context);
 639
 640         AsyncTestContext testCtx;
 641
 642         const char *dirs[1] = {
 643                 "/"
 644         };
 645
 646         // touch a file : in case of no target file to scan, we cannot cancel to scan.
 647         Test::touch_file(TEST_FILE_HIGH);
 648
 649         ASSERT_SUCCESS(csr_cs_scan_dirs_async(context, dirs, 1, &testCtx));
 650
 651         std::this_thread::sleep_for(std::chrono::milliseconds(100));
 652
 653         ASSERT_SUCCESS(csr_cs_cancel_scanning(context));
 654
 655         //scanned, detected, completed, cancelled, error
 656         ASSERT_CALLBACK(testCtx, -1, -1, 0, 1, 0);
 657
 658         EXCEPTION_GUARD_END
 659 }
 660
 661 BOOST_AUTO_TEST_CASE(scan_cancel_positive_500)
 662 {
 663         EXCEPTION_GUARD_START
 664
 665         auto c = Test::Context<csr_cs_context_h>();
 666         auto context = c.get();
 667
 668         set_default_callback(context);
 669
 670         AsyncTestContext testCtx;
 671
 672         const char *dirs[1] = {
 673                 "/"
 674         };
 675
 676         // touch a file : in case of no target file to scan, we cannot cancel to scan.
 677         Test::touch_file(TEST_FILE_HIGH);
 678
 679         ASSERT_SUCCESS(csr_cs_scan_dirs_async(context, dirs, 1, &testCtx));
 680
 681         std::this_thread::sleep_for(std::chrono::milliseconds(500));
 682
 683         ASSERT_SUCCESS(csr_cs_cancel_scanning(context));
 684
 685         //scanned, detected, completed, cancelled, error
 686         ASSERT_CALLBACK(testCtx, -1, -1, 0, 1, 0);
 687
 688         EXCEPTION_GUARD_END
 689 }
 690
 691 BOOST_AUTO_TEST_CASE(scan_cancel_negative)
 692 {
 693         EXCEPTION_GUARD_START
 694
 695         auto c = Test::Context<csr_cs_context_h>();
 696         auto context = c.get();
 697
 698         ASSERT_IF(csr_cs_cancel_scanning(nullptr), CSR_ERROR_INVALID_HANDLE);
 699         ASSERT_IF(csr_cs_cancel_scanning(context), CSR_ERROR_NO_TASK);
 700
 701         EXCEPTION_GUARD_END
 702 }
 703
 704 BOOST_AUTO_TEST_CASE(delta_scan_basic)
 705 {
 706         EXCEPTION_GUARD_START
 707
 708         Test::initialize_db();
 709
 710         auto c = Test::Context<csr_cs_context_h>();
 711         auto context = c.get();
 712
 713         install_test_files();
 714         install_test_apps();
 715
 716         set_default_callback(context);
 717
 718         // Base Scan
 719         AsyncTestContext testBaseCtx;
 720
 721         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testBaseCtx));
 722
 723         // scanned, detected, completed, cancelled, error
 724         ASSERT_CALLBACK(testBaseCtx, -1, -1, 1, 0, 0);
 725         BOOST_REQUIRE_MESSAGE(testBaseCtx.scannedCnt > 0,
 726                         "Base Scan count should not be zero");
 727
 728         ASSERT_DETECTED_IN_LIST(testBaseCtx.detectedList, TEST_WGT_APP_ROOT(),
 729                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 730                                                         MALWARE_HIGH_DETAILED_URL);
 731         ASSERT_DETECTED_IN_LIST_EXT(testBaseCtx.detectedList, TEST_WGT_APP_ROOT(), true,
 732                                                                 TEST_WGT_PKG_ID);
 733
 734         ASSERT_DETECTED_IN_LIST(testBaseCtx.detectedList, TEST_TPK_APP_ROOT(),
 735                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 736                                                         MALWARE_HIGH_DETAILED_URL);
 737         ASSERT_DETECTED_IN_LIST_EXT(testBaseCtx.detectedList, TEST_TPK_APP_ROOT(), true,
 738                                                                 TEST_TPK_PKG_ID);
 739
 740         ASSERT_DETECTED_IN_LIST(testBaseCtx.detectedList, TEST_FAKE_APP_FILE(),
 741                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 742                                                         MALWARE_HIGH_DETAILED_URL);
 743         ASSERT_DETECTED_IN_LIST_EXT(testBaseCtx.detectedList, TEST_FAKE_APP_FILE(), false, "");
 744
 745         // Rescan the same dir
 746         AsyncTestContext testRescanCtx;
 747
 748         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testRescanCtx));
 749
 750         // scanned, detected, completed, cancelled, error
 751         ASSERT_CALLBACK(testRescanCtx, -1, -1, 1, 0, 0);
 752         BOOST_REQUIRE_MESSAGE(testBaseCtx.scannedCnt > testRescanCtx.scannedCnt,
 753                         "Scan count of the base[" << testBaseCtx.scannedCnt <<
 754                         "] should be bigger than the delta-scan[" << testRescanCtx.scannedCnt << "]");
 755
 756         ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList, TEST_WGT_APP_ROOT(),
 757                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 758                                                         MALWARE_HIGH_DETAILED_URL);
 759         ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_WGT_APP_ROOT(), true,
 760                                                                 TEST_WGT_PKG_ID);
 761
 762         ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList, TEST_TPK_APP_ROOT(),
 763                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 764                                                         MALWARE_HIGH_DETAILED_URL);
 765         ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_TPK_APP_ROOT(), true,
 766                                                                 TEST_TPK_PKG_ID);
 767
 768         ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList, TEST_FAKE_APP_FILE(),
 769                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 770                                                         MALWARE_HIGH_DETAILED_URL);
 771         ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_FAKE_APP_FILE(), false,
 772                                                                 "");
 773
 774         // Rescan the sub dir
 775         AsyncTestContext testRescanSubCtx;
 776
 777         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_WGT_APP_ROOT(), &testRescanSubCtx));
 778
 779         // scanned, detected, completed, cancelled, error
 780         ASSERT_CALLBACK(testRescanSubCtx, 0, 1, 1, 0, 0);
 781
 782         ASSERT_DETECTED_IN_LIST(testRescanSubCtx.detectedList, TEST_WGT_APP_ROOT(),
 783                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 784                                                         MALWARE_HIGH_DETAILED_URL);
 785         ASSERT_DETECTED_IN_LIST_EXT(testRescanSubCtx.detectedList, TEST_WGT_APP_ROOT(), true,
 786                                                                 TEST_WGT_PKG_ID);
 787
 788         uninstall_test_apps();
 789
 790         EXCEPTION_GUARD_END
 791 }
 792
 793 BOOST_AUTO_TEST_CASE(delta_scan_changed_after_scan)
 794 {
 795         EXCEPTION_GUARD_START
 796
 797         Test::initialize_db();
 798
 799         auto c = Test::Context<csr_cs_context_h>();
 800         auto context = c.get();
 801
 802         install_test_files();
 803         install_test_apps();
 804
 805         set_default_callback(context);
 806
 807         // Base Scan
 808         AsyncTestContext testBaseCtx;
 809
 810         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testBaseCtx));
 811
 812         // scanned, detected, completed, cancelled, error
 813         ASSERT_CALLBACK(testBaseCtx, -1, 3, 1, 0, 0);
 814         BOOST_REQUIRE_MESSAGE(testBaseCtx.scannedCnt != 0,
 815                         "Base Scan count should not be zero");
 816
 817         // changed
 818         Test::uninstall_app(TEST_SAFE_WGT_PKG_ID);
 819         ASSERT_INSTALL_APP(TEST_SAFE_WGT_PATH, TEST_SAFE_WGT_TYPE);
 820
 821         // Rescan the same dir
 822         AsyncTestContext testRescanCtx;
 823
 824         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testRescanCtx));
 825
 826         // scanned, detected, completed, cancelled, error
 827         ASSERT_CALLBACK(testRescanCtx, -1, -1, 1, 0, 0);
 828         BOOST_REQUIRE_MESSAGE(testRescanCtx.scannedCnt >= 1,
 829                         "reinstalled app(non-malicious wgt) should be counted in scanned.");
 830
 831         ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList, TEST_WGT_APP_ROOT(),
 832                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 833                                                         MALWARE_HIGH_DETAILED_URL);
 834         ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_WGT_APP_ROOT(), true,
 835                                                                 TEST_WGT_PKG_ID);
 836
 837         ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList, TEST_TPK_APP_ROOT(),
 838                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 839                                                         MALWARE_HIGH_DETAILED_URL);
 840         ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_TPK_APP_ROOT(), true,
 841                                                                 TEST_TPK_PKG_ID);
 842
 843         ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList, TEST_FAKE_APP_FILE(),
 844                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
 845                                                         MALWARE_HIGH_DETAILED_URL);
 846         ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_FAKE_APP_FILE(), false,
 847                                                                 "");
 848
 849         uninstall_test_apps();
 850
 851         EXCEPTION_GUARD_END
 852 }
 853
 854 BOOST_AUTO_TEST_CASE(canonicalize_files_absolute_path)
 855 {
 856         EXCEPTION_GUARD_START
 857
 858         Test::initialize_db();
 859
 860         auto c = Test::Context<csr_cs_context_h>();
 861         auto context = c.get();
 862
 863         install_test_files();
 864
 865         set_default_callback(context);
 866
 867         // four files are all same as realpath.
 868         const char *files[4] = {
 869                 TEST_FILE_NORMAL,
 870                 TEST_DIR "/./test_normal_file",
 871                 TEST_DIR "/.././././csr-test/test_normal_file",
 872                 TEST_DIR "/././.././csr-test/test_normal_file"
 873         };
 874
 875         AsyncTestContext testCtx;
 876
 877         ASSERT_SUCCESS(csr_cs_scan_files_async(context, files, 4, &testCtx));
 878
 879         ASSERT_CALLBACK(testCtx, 1, 0, 1, 0, 0);
 880         ASSERT_IF(testCtx.scannedList.size(), static_cast<std::size_t>(1));
 881         ASSERT_IF(testCtx.scannedList.front(), static_cast<const char *>(TEST_FILE_NORMAL));
 882
 883         EXCEPTION_GUARD_END
 884 }
 885
 886 BOOST_AUTO_TEST_CASE(canonicalize_files_relative_path)
 887 {
 888         EXCEPTION_GUARD_START
 889
 890         Test::initialize_db();
 891
 892         auto c = Test::Context<csr_cs_context_h>();
 893         auto context = c.get();
 894
 895         install_test_files();
 896
 897         set_default_callback(context);
 898
 899         // four files are all same as realpath.
 900         const char *files[4] = {
 901                 "test_normal_file",
 902                 "./test_normal_file",
 903                 ".././././csr-test/test_normal_file",
 904                 "././.././csr-test/test_normal_file"
 905         };
 906
 907         AsyncTestContext testCtx;
 908
 909         Test::ScopedChDir scopedCd(TEST_DIR);
 910
 911         ASSERT_SUCCESS(csr_cs_scan_files_async(context, files, 4, &testCtx));
 912
 913         ASSERT_CALLBACK(testCtx, 1, 0, 1, 0, 0);
 914         ASSERT_IF(testCtx.scannedList.size(), static_cast<std::size_t>(1));
 915         ASSERT_IF(testCtx.scannedList.front(), static_cast<const char *>(TEST_FILE_NORMAL));
 916
 917         EXCEPTION_GUARD_END
 918 }
 919
 920 BOOST_AUTO_TEST_CASE(multiple_async_dispatch_negative)
 921 {
 922         EXCEPTION_GUARD_START
 923
 924         Test::initialize_db();
 925
 926         auto c = Test::Context<csr_cs_context_h>();
 927         auto context = c.get();
 928
 929         install_test_files();
 930         install_test_apps();
 931
 932         set_default_callback(context);
 933
 934         AsyncTestContext testCtx;
 935
 936         // first call. it'll running in background asynchronously.
 937         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testCtx));
 938
 939         AsyncTestContext testCtx2;
 940
 941         // second call while first call is running in background. It should blocked because
 942         // only one operation can be running asynchronously on one handle.
 943         ASSERT_IF(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testCtx2), CSR_ERROR_BUSY);
 944
 945         ASSERT_CALLBACK(testCtx, -1, 3, 1, 0, 0);
 946
 947         EXCEPTION_GUARD_END
 948 }
 949
 950 BOOST_AUTO_TEST_CASE(get_malware_after_async)
 951 {
 952         EXCEPTION_GUARD_START
 953
 954         auto c = Test::Context<csr_cs_context_h>();
 955         auto context = c.get();
 956
 957         set_default_callback(context);
 958
 959         const char *dirs[4] = {
 960                 "/opt/usr/media/",
 961                 "/opt/usr/apps/",
 962                 "/tmp/",
 963                 "/sdcard/"
 964         };
 965
 966         csr_cs_malware_list_h malwares = nullptr;
 967         csr_cs_malware_h malware = nullptr;
 968         size_t count = 0;
 969
 970         ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs, 4, &malwares, &count));
 971         BOOST_MESSAGE("detected malware exist count before scanning: " << count);
 972
 973         AsyncTestContext testCtx;
 974
 975         ASSERT_SUCCESS(csr_cs_scan_dirs_async(context, dirs, 4, &testCtx));
 976
 977         ASSERT_CALLBACK(testCtx, -1, -1, -1, -1, -1);
 978
 979         BOOST_MESSAGE("scanned count: " << testCtx.scannedCnt);
 980         BOOST_MESSAGE("detected count: " << testCtx.detectedCnt);
 981         BOOST_MESSAGE("completed count: " << testCtx.completedCnt);
 982         BOOST_MESSAGE("cancelled count: " << testCtx.cancelledCnt);
 983         BOOST_MESSAGE("error count: " << testCtx.errorCnt);
 984
 985         ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs, 4, &malwares, &count));
 986
 987         CHECK_IS_NOT_NULL(malwares);
 988
 989         for (size_t i = 0; i < count; ++i) {
 990                 malware = nullptr;
 991                 Test::ScopedCstr filepath;
 992                 ASSERT_SUCCESS(csr_cs_malware_list_get_malware(malwares, i, &malware));
 993                 CHECK_IS_NOT_NULL(malware);
 994                 ASSERT_SUCCESS(csr_cs_malware_get_file_name(malware, &filepath.ptr));
 995                 CHECK_IS_NOT_NULL(filepath.ptr);
 996                 BOOST_MESSAGE("detect malware from file: " << filepath.ptr);
 997         }
 998
 999         EXCEPTION_GUARD_END
1000 }
1001
1002 BOOST_AUTO_TEST_CASE(async_api_returning_and_callback_race)
1003 {
1004         EXCEPTION_GUARD_START
1005
1006         auto c = Test::Context<csr_cs_context_h>();
1007         auto context = c.get();
1008
1009         install_test_files();
1010
1011         set_default_callback(context);
1012
1013         const char *files[2] = {
1014                 TEST_FILE_NORMAL,
1015                 TEST_FILE_HIGH
1016         };
1017
1018         AsyncTestContext testCtx(true);
1019
1020         ASSERT_SUCCESS(csr_cs_scan_files_async(context, files, 2, &testCtx));
1021         testCtx.apiReturned = true;
1022
1023         ASSERT_CALLBACK(testCtx, -1, -1, -1, -1, -1);
1024
1025         EXCEPTION_GUARD_END
1026 }
1027
1028 BOOST_AUTO_TEST_CASE(scan_app_on_cloud)
1029 {
1030         EXCEPTION_GUARD_START
1031
1032         BOOST_MESSAGE("Only valid for engines which supports scan on cloud feature");
1033
1034         auto c = Test::Context<csr_cs_context_h>();
1035         auto context = c.get();
1036
1037         install_test_files();
1038         install_test_apps();
1039
1040         set_default_callback(context);
1041         ASSERT_SUCCESS(csr_cs_set_scan_on_cloud(context, true));
1042
1043         AsyncTestContext testCtx;
1044
1045         ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testCtx));
1046
1047         ASSERT_CALLBACK(testCtx, -1, -1, 1, 0, 0);
1048
1049         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_WGT_APP_ROOT(),
1050                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
1051                                                         MALWARE_HIGH_DETAILED_URL);
1052         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_WGT_APP_ROOT(), true,
1053                                                                 TEST_WGT_PKG_ID);
1054
1055         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_TPK_APP_ROOT(),
1056                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
1057                                                         MALWARE_HIGH_DETAILED_URL);
1058         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_TPK_APP_ROOT(), true,
1059                                                                 TEST_TPK_PKG_ID);
1060
1061         ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FAKE_APP_FILE(),
1062                                                         MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
1063                                                         MALWARE_HIGH_DETAILED_URL);
1064         ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FAKE_APP_FILE(), false, "");
1065
1066         const char *dirs[1] = {
1067                 TEST_DIR_APPS()
1068         };
1069         csr_cs_malware_list_h malwares = nullptr;
1070         size_t count = 0;
1071
1072         ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs, 1, &malwares, &count));
1073         CHECK_IS_NOT_NULL(malwares);
1074
1075         std::vector<csr_cs_malware_h> malware_vec;
1076         for (size_t i = 0; i < count; ++i) {
1077                 csr_cs_malware_h malware = nullptr;
1078                 ASSERT_SUCCESS(csr_cs_malware_list_get_malware(malwares, i, &malware));
1079
1080                 malware_vec.push_back(malware);
1081         }
1082
1083         ASSERT_DETECTED_IN_LIST(malware_vec, TEST_WGT_APP_ROOT(), MALWARE_HIGH_NAME,
1084                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
1085         ASSERT_DETECTED_IN_LIST_EXT(malware_vec, TEST_WGT_APP_ROOT(), true, TEST_WGT_PKG_ID);
1086
1087         ASSERT_DETECTED_IN_LIST(malware_vec, TEST_TPK_APP_ROOT(), MALWARE_HIGH_NAME,
1088                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
1089         ASSERT_DETECTED_IN_LIST_EXT(malware_vec, TEST_TPK_APP_ROOT(), true, TEST_TPK_PKG_ID);
1090
1091         ASSERT_DETECTED_IN_LIST(malware_vec, TEST_FAKE_APP_FILE(), MALWARE_HIGH_NAME,
1092                                                         MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
1093         ASSERT_DETECTED_IN_LIST_EXT(malware_vec, TEST_FAKE_APP_FILE(), false, "");
1094
1095         EXCEPTION_GUARD_END
1096 }
1097
1098 BOOST_AUTO_TEST_CASE(scan_async_multiple)
1099 {
1100         EXCEPTION_GUARD_START
1101
1102         constexpr size_t NUM = 3;
1103
1104         install_test_files();
1105         install_test_apps();
1106
1107         std::vector<Test::Context<csr_cs_context_h>> cs(NUM);
1108         std::vector<csr_cs_context_h> contexts(NUM);
1109         std::vector<AsyncTestContext> testCtxs(NUM);
1110
1111         for (size_t i = 0; i < NUM; ++i) {
1112                 contexts[i] = cs[i].get();
1113
1114                 set_default_callback(contexts[i]);
1115
1116                 ASSERT_SUCCESS(csr_cs_scan_dir_async(contexts[i], TEST_DIR_ROOT, &testCtxs[i]));
1117         }
1118
1119         for (size_t i = 0; i < NUM; ++i)
1120                 ASSERT_CALLBACK(testCtxs[i], -1, -1, 1, 0, 0);
1121
1122         std::string homeDirPrefix;
1123 #ifdef PLATFORM_VERSION_3
1124         // "/home" is symlinked of "/opt/home" so in root directory scanning,
1125         // user directory prefix("/opt") is additionally needed to check file_name field
1126         // in malware handle
1127         homeDirPrefix = "/opt";
1128 #endif
1129
1130         for (size_t i = 0; i < NUM; ++i) {
1131                 ASSERT_DETECTED_IN_LIST(testCtxs[i].detectedList, TEST_FILE_HIGH, MALWARE_HIGH_NAME,
1132                                                                 MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
1133                 ASSERT_DETECTED_IN_LIST_EXT(testCtxs[i].detectedList, TEST_FILE_HIGH, false, "");
1134
1135                 ASSERT_DETECTED_IN_LIST(testCtxs[i].detectedList, homeDirPrefix + TEST_FILE_MEDIA(),
1136                                                                 MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
1137                                                                 MALWARE_HIGH_DETAILED_URL);
1138                 ASSERT_DETECTED_IN_LIST_EXT(testCtxs[i].detectedList, homeDirPrefix + TEST_FILE_MEDIA(),
1139                                                                         false, "");
1140
1141                 ASSERT_DETECTED_IN_LIST(testCtxs[i].detectedList, TEST_FILE_TMP, MALWARE_HIGH_NAME,
1142                                                                 MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
1143                 ASSERT_DETECTED_IN_LIST_EXT(testCtxs[i].detectedList, TEST_FILE_TMP, false, "");
1144
1145                 ASSERT_DETECTED_IN_LIST(testCtxs[i].detectedList, homeDirPrefix + TEST_WGT_APP_ROOT(),
1146                                                                 MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
1147                                                                 MALWARE_HIGH_DETAILED_URL);
1148                 ASSERT_DETECTED_IN_LIST_EXT(testCtxs[i].detectedList, homeDirPrefix + TEST_WGT_APP_ROOT(),
1149                                                                         true, TEST_WGT_PKG_ID);
1150
1151                 ASSERT_DETECTED_IN_LIST(testCtxs[i].detectedList, homeDirPrefix + TEST_TPK_APP_ROOT(),
1152                                                                 MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
1153                                                                 MALWARE_HIGH_DETAILED_URL);
1154                 ASSERT_DETECTED_IN_LIST_EXT(testCtxs[i].detectedList, homeDirPrefix + TEST_TPK_APP_ROOT(),
1155                                                                         true, TEST_TPK_PKG_ID);
1156
1157                 ASSERT_DETECTED_IN_LIST(testCtxs[i].detectedList, homeDirPrefix + TEST_FAKE_APP_FILE(),
1158                                                                 MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
1159                                                                 MALWARE_HIGH_DETAILED_URL);
1160                 ASSERT_DETECTED_IN_LIST_EXT(testCtxs[i].detectedList, homeDirPrefix + TEST_FAKE_APP_FILE(),
1161                                                                         false, "");
1162
1163                 ASSERT_DETECTED_IN_LIST(testCtxs[i].detectedList, TEST_FILE_MEDIUM, MALWARE_MEDIUM_NAME,
1164                                                                 MALWARE_MEDIUM_SEVERITY, MALWARE_MEDIUM_DETAILED_URL);
1165                 ASSERT_DETECTED_IN_LIST_EXT(testCtxs[i].detectedList, TEST_FILE_MEDIUM, false, "");
1166
1167                 ASSERT_DETECTED_IN_LIST(testCtxs[i].detectedList, TEST_FILE_LOW, MALWARE_LOW_NAME,
1168                                                                 MALWARE_LOW_SEVERITY, MALWARE_LOW_DETAILED_URL);
1169                 ASSERT_DETECTED_IN_LIST_EXT(testCtxs[i].detectedList, TEST_FILE_LOW, false, "");
1170
1171         }
1172
1173         EXCEPTION_GUARD_END
1174 }
1175
1176 BOOST_AUTO_TEST_SUITE_END()