Fix test-resource and permissions on platform v3.0

Change-Id: Ifc41778f138b7cebf981cda662279434878daf28
Signed-off-by: Kyungwook Tak <k.tak@samsung.com>

diff --git a/packaging/csr-framework.spec b/packaging/csr-framework.spec
index 3a2dec6..a226df5 100644 (file)
--- a/packaging/csr-framework.spec
+++ b/packaging/csr-framework.spec
@@ -66,12 +66,14 @@ file contents and checking url to prevent malicious items.
 %if "%{?tizen_version}" == "3.0"
 %global service_user                 security_fw
 %global service_group                security_fw
+%global test_user                    owner
 %global popup_service_env_file_path  /run/tizen-system-env
 %global smack_domain_name            System
 %global popup_unitdir                %{_unitdir_user}
 %else
 %global service_user                 system
 %global service_group                system
+%global test_user                    system
 %global smack_domain_name            %{service_name}
 %global popup_service_env_file_path  /run/tizen-mobile-env
 %global popup_unitdir                %{_unitdir}
@@ -316,17 +318,17 @@ fi
 %{ro_data_dir}/license/%{name}-test
 %{ro_data_dir}/license/%{name}-test.BSL-1.0
 %{_libdir}/lib%{service_name}-test-common.so
-%attr(-, %{service_user}, %{service_group}) %{bin_dir}/%{service_name}-test
-%attr(-, %{service_user}, %{service_group}) %{bin_dir}/%{service_name}-internal-test
-%attr(-, %{service_user}, %{service_group}) %{bin_dir}/%{service_name}-popup-test
-%attr(-, %{service_user}, %{service_group}) %{bin_dir}/%{service_name}-threadpool-test
+%attr(-, %{test_user}, %{service_group}) %{bin_dir}/%{service_name}-test
+%attr(-, %{test_user}, %{service_group}) %{bin_dir}/%{service_name}-internal-test
+%attr(-, %{test_user}, %{service_group}) %{bin_dir}/%{service_name}-popup-test
+%attr(-, %{test_user}, %{service_group}) %{bin_dir}/%{service_name}-threadpool-test
 
 # test resources
-%dir %attr(-, %{service_user}, %{service_group}) %{test_dir}
-%attr(-, %{service_user}, %{service_group}) %{test_dir}/*
+%dir %attr(777, %{test_user}, %{service_group}) %{test_dir}
+%attr(777, %{test_user}, %{service_group}) %{test_dir}/*
 
-%dir %attr(-, %{service_user}, %{service_group}) %{test_res_dir}
-%attr(-, %{service_user}, %{service_group}) %{test_res_dir}/*
+%dir %attr(777, %{test_user}, %{service_group}) %{test_res_dir}
+%attr(777, %{test_user}, %{service_group}) %{test_res_dir}/*
 
 # sample engine related files
 %if 0%{?with_sample_engine}

diff --git a/test/test-api-content-screening-async.cpp b/test/test-api-content-screening-async.cpp
index b7de434..6bd0997 100644 (file)
--- a/test/test-api-content-screening-async.cpp
+++ b/test/test-api-content-screening-async.cpp
@@ -154,19 +154,19 @@ void set_default_callback(csr_cs_context_h context)
 
 void install_test_files()
 {
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
+       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
        Test::copy_file(TEST_FILE_HIGH, TEST_FILE_TMP);
 
-       Test::make_dir(TEST_FAKE_APP_ROOT);
-       Test::copy_file(TEST_FILE_HIGH, TEST_FAKE_APP_FILE);
+       Test::make_dir(TEST_FAKE_APP_ROOT());
+       Test::copy_file(TEST_FILE_HIGH, TEST_FAKE_APP_FILE());
 }
 
 void uninstall_test_files()
 {
-       Test::remove_file(TEST_FILE_MEDIA);
+       Test::remove_file(TEST_FILE_MEDIA());
        Test::remove_file(TEST_FILE_TMP);
-       Test::remove_file(TEST_FAKE_APP_FILE);
-       Test::remove_file(TEST_FAKE_APP_ROOT);
+       Test::remove_file(TEST_FAKE_APP_FILE());
+       Test::remove_file(TEST_FAKE_APP_ROOT());
 }
 
 void uninstall_test_apps()
@@ -346,39 +346,55 @@ BOOST_AUTO_TEST_CASE(scan_dir_root)
        Test::uninstall_app(TEST_TPK_PKG_ID);
 
        //scanned, detected, completed, cancelled, error
-       ASSERT_CALLBACK(testCtx, -1, 12, 1, 0, 0);
-
-       ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_FILE_HIGH, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
+       ASSERT_CALLBACK(testCtx, -1, -1, 1, 0, 0);
+
+       std::string homeDirPrefix;
+#ifdef PLATFORM_VERSION_3
+       // "/home" is symlinked of "/opt/home" so in root directory scanning,
+       // user directory prefix("/opt") is additionally needed to check file_name field
+       // in malware handle
+       homeDirPrefix = "/opt";
+#endif
+
+       ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_HIGH, MALWARE_HIGH_NAME,
+                                                       MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
        ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_HIGH, false, "");
 
-       ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_FILE_MEDIUM, MALWARE_MEDIUM_NAME, MALWARE_MEDIUM_SEVERITY, MALWARE_MEDIUM_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_MEDIUM, false, "");
-
-       ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_FILE_LOW, MALWARE_LOW_NAME, MALWARE_LOW_SEVERITY, MALWARE_LOW_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_LOW, false, "");
-
-       ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_FILE_MEDIA, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_MEDIA, false, "");
+       ASSERT_DETECTED_IN_LIST(testCtx.detectedList, homeDirPrefix + TEST_FILE_MEDIA(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, homeDirPrefix + TEST_FILE_MEDIA(),
+                                                               false, "");
 
-       ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_FILE_TMP, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_TMP, MALWARE_HIGH_NAME,
+                                                       MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
        ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_TMP, false, "");
 
-       ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_WGT_APP_ROOT(), MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_WGT_APP_ROOT(), true, TEST_WGT_PKG_ID);
-
-       ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_TPK_APP_ROOT(), MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_TPK_APP_ROOT(), true, TEST_TPK_PKG_ID);
+       ASSERT_DETECTED_IN_LIST(testCtx.detectedList, homeDirPrefix + TEST_WGT_APP_ROOT(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, homeDirPrefix + TEST_WGT_APP_ROOT(),
+                                                               true, TEST_WGT_PKG_ID);
+
+       ASSERT_DETECTED_IN_LIST(testCtx.detectedList, homeDirPrefix + TEST_TPK_APP_ROOT(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, homeDirPrefix + TEST_TPK_APP_ROOT(),
+                                                               true, TEST_TPK_PKG_ID);
+
+       ASSERT_DETECTED_IN_LIST(testCtx.detectedList, homeDirPrefix + TEST_FAKE_APP_FILE(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, homeDirPrefix + TEST_FAKE_APP_FILE(),
+                                                               false, "");
+
+       ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_MEDIUM, MALWARE_MEDIUM_NAME,
+                                                       MALWARE_MEDIUM_SEVERITY, MALWARE_MEDIUM_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_MEDIUM, false, "");
 
-       ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_FAKE_APP_FILE, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FAKE_APP_FILE, false, "");
+       ASSERT_DETECTED_IN_LIST(testCtx.detectedList, TEST_FILE_LOW, MALWARE_LOW_NAME,
+                                                       MALWARE_LOW_SEVERITY, MALWARE_LOW_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_LOW, false, "");
 
        EXCEPTION_GUARD_END
 }
@@ -396,7 +412,7 @@ BOOST_AUTO_TEST_CASE(scan_dir_media)
 
        AsyncTestContext testCtx;
 
-       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_MEDIA, &testCtx));
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_MEDIA(), &testCtx));
 
        std::unique_lock<std::mutex> l(testCtx.m);
        testCtx.cv.wait(l);
@@ -406,8 +422,8 @@ BOOST_AUTO_TEST_CASE(scan_dir_media)
        ASSERT_CALLBACK(testCtx, -1, 1, 1, 0, 0);
 
        ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_FILE_MEDIA, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_MEDIA, false, "");
+               TEST_FILE_MEDIA(), MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FILE_MEDIA(), false, "");
 
        EXCEPTION_GUARD_END
 }
@@ -455,7 +471,7 @@ BOOST_AUTO_TEST_CASE(scan_dir_apps)
 
        AsyncTestContext testCtx;
 
-       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testCtx));
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testCtx));
 
        std::unique_lock<std::mutex> l(testCtx.m);
        testCtx.cv.wait(l);
@@ -473,8 +489,8 @@ BOOST_AUTO_TEST_CASE(scan_dir_apps)
        ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_TPK_APP_ROOT(), true, TEST_TPK_PKG_ID);
 
        ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_FAKE_APP_FILE, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FAKE_APP_FILE, false, "");
+               TEST_FAKE_APP_FILE(), MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testCtx.detectedList, TEST_FAKE_APP_FILE(), false, "");
 
        uninstall_test_apps();
 
@@ -495,7 +511,7 @@ BOOST_AUTO_TEST_CASE(scan_dir_wgt)
 
        AsyncTestContext testCtx;
 
-       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_WGT_APP_ROOT().c_str(), &testCtx));
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_WGT_APP_ROOT(), &testCtx));
 
        std::unique_lock<std::mutex> l(testCtx.m);
        testCtx.cv.wait(l);
@@ -527,7 +543,7 @@ BOOST_AUTO_TEST_CASE(scan_dir_tpk)
 
        AsyncTestContext testCtx;
 
-       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_TPK_APP_ROOT().c_str(), &testCtx));
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_TPK_APP_ROOT(), &testCtx));
 
        std::unique_lock<std::mutex> l(testCtx.m);
        testCtx.cv.wait(l);
@@ -647,56 +663,81 @@ BOOST_AUTO_TEST_CASE(delta_scan_basic)
        // Base Scan
        AsyncTestContext testBaseCtx;
 
-       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testBaseCtx));
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testBaseCtx));
 
        std::unique_lock<std::mutex> lBase(testBaseCtx.m);
        testBaseCtx.cv.wait(lBase);
        lBase.unlock();
 
        // scanned, detected, completed, cancelled, error
-       ASSERT_CALLBACK(testBaseCtx, -1, 3, 1, 0, 0);
+       ASSERT_CALLBACK(testBaseCtx, -1, -1, 1, 0, 0);
        BOOST_REQUIRE_MESSAGE(testBaseCtx.scannedCnt != 0,
                        "Base Scan count should not be zero");
 
+       ASSERT_DETECTED_IN_LIST(testBaseCtx.detectedList, TEST_WGT_APP_ROOT(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testBaseCtx.detectedList, TEST_WGT_APP_ROOT(), true,
+                                                               TEST_WGT_PKG_ID);
+
+       ASSERT_DETECTED_IN_LIST(testBaseCtx.detectedList, TEST_TPK_APP_ROOT(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testBaseCtx.detectedList, TEST_TPK_APP_ROOT(), true,
+                                                               TEST_TPK_PKG_ID);
+
+       ASSERT_DETECTED_IN_LIST(testBaseCtx.detectedList, TEST_FAKE_APP_FILE(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testBaseCtx.detectedList, TEST_FAKE_APP_FILE(), false, "");
+
        // Rescan the same dir
        AsyncTestContext testRescanCtx;
 
-       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testRescanCtx));
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testRescanCtx));
 
        std::unique_lock<std::mutex> lRescan(testRescanCtx.m);
        testRescanCtx.cv.wait(lRescan);
        lRescan.unlock();
 
        // scanned, detected, completed, cancelled, error
-       ASSERT_CALLBACK(testRescanCtx, 0, 3, 1, 0, 0);
-
-       ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList,
-               TEST_WGT_APP_ROOT(), MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_WGT_APP_ROOT(), true, TEST_WGT_PKG_ID);
-
-       ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList,
-               TEST_TPK_APP_ROOT(), MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_TPK_APP_ROOT(), true, TEST_TPK_PKG_ID);
-
-       ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList,
-               TEST_FAKE_APP_FILE, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_FAKE_APP_FILE, false, "");
+       ASSERT_CALLBACK(testRescanCtx, 0, -1, 1, 0, 0);
+
+       ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList, TEST_WGT_APP_ROOT(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_WGT_APP_ROOT(), true,
+                                                               TEST_WGT_PKG_ID);
+
+       ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList, TEST_TPK_APP_ROOT(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_TPK_APP_ROOT(), true,
+                                                               TEST_TPK_PKG_ID);
+
+       ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList, TEST_FAKE_APP_FILE(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_FAKE_APP_FILE(), false,
+                                                               "");
 
        // Rescan the sub dir
        AsyncTestContext testRescanSubCtx;
 
-       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_WGT_APP_ROOT().c_str(), &testRescanSubCtx));
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_WGT_APP_ROOT(), &testRescanSubCtx));
 
        std::unique_lock<std::mutex> lRescanSub(testRescanSubCtx.m);
        testRescanSubCtx.cv.wait(lRescanSub);
        lRescanSub.unlock();
 
        // scanned, detected, completed, cancelled, error
-       ASSERT_CALLBACK(testRescanSubCtx, 0, 1, 1, 0, 0);
+       ASSERT_CALLBACK(testRescanSubCtx, 0, -1, 1, 0, 0);
 
-       ASSERT_DETECTED_IN_LIST(testRescanSubCtx.detectedList,
-               TEST_WGT_APP_ROOT(), MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testRescanSubCtx.detectedList, TEST_WGT_APP_ROOT(), true, TEST_WGT_PKG_ID);
+       ASSERT_DETECTED_IN_LIST(testRescanSubCtx.detectedList, TEST_WGT_APP_ROOT(),
+                                                       MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
+                                                       MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testRescanSubCtx.detectedList, TEST_WGT_APP_ROOT(), true,
+                                                               TEST_WGT_PKG_ID);
 
        uninstall_test_apps();
 
@@ -720,7 +761,7 @@ BOOST_AUTO_TEST_CASE(delta_scan_changed_after_scan)
        // Base Scan
        AsyncTestContext testBaseCtx;
 
-       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testBaseCtx));
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testBaseCtx));
 
        std::unique_lock<std::mutex> lBase(testBaseCtx.m);
        testBaseCtx.cv.wait(lBase);
@@ -738,14 +779,14 @@ BOOST_AUTO_TEST_CASE(delta_scan_changed_after_scan)
        // Rescan the same dir
        AsyncTestContext testRescanCtx;
 
-       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testRescanCtx));
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testRescanCtx));
 
        std::unique_lock<std::mutex> lRescan(testRescanCtx.m);
        testRescanCtx.cv.wait(lRescan);
        lRescan.unlock();
 
        // scanned, detected, completed, cancelled, error
-       ASSERT_CALLBACK(testRescanCtx, 1, 3, 1, 0, 0);
+       ASSERT_CALLBACK(testRescanCtx, -1, -1, 1, 0, 0);
 
        ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList,
                TEST_WGT_APP_ROOT(), MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
@@ -756,8 +797,8 @@ BOOST_AUTO_TEST_CASE(delta_scan_changed_after_scan)
        ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_TPK_APP_ROOT(), true, TEST_TPK_PKG_ID);
 
        ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList,
-               TEST_FAKE_APP_FILE, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_FAKE_APP_FILE, false, "");
+               TEST_FAKE_APP_FILE(), MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
+       ASSERT_DETECTED_IN_LIST_EXT(testRescanCtx.detectedList, TEST_FAKE_APP_FILE(), false, "");
 
        uninstall_test_apps();
 
@@ -855,13 +896,13 @@ BOOST_AUTO_TEST_CASE(multiple_async_dispatch_negative)
        AsyncTestContext testCtx;
 
        // first call. it'll running in background asynchronously.
-       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testCtx));
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testCtx));
 
        AsyncTestContext testCtx2;
 
        // second call while first call is running in background. It should blocked because
        // only one operation can be running asynchronously on one handle.
-       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testCtx2), CSR_ERROR_BUSY);
+       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_DIR_APPS(), &testCtx2), CSR_ERROR_BUSY);
 
        std::unique_lock<std::mutex> l(testCtx.m);
        testCtx.cv.wait(l);

diff --git a/test/test-api-content-screening.cpp b/test/test-api-content-screening.cpp
index 67599f1..2bd9a3a 100644 (file)
--- a/test/test-api-content-screening.cpp
+++ b/test/test-api-content-screening.cpp
@@ -255,7 +255,7 @@ BOOST_AUTO_TEST_CASE(scan_file_high)
        csr_cs_malware_h detected;
        auto start_time = ::time(nullptr);
 
-       Test::touch_file(TEST_FILE_HIGH);
+       Test::touch_file_assert(TEST_FILE_HIGH);
 
        ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_HIGH, &detected));
 
@@ -276,7 +276,7 @@ BOOST_AUTO_TEST_CASE(scan_file_medium)
        csr_cs_malware_h detected;
        auto start_time = ::time(nullptr);
 
-       Test::touch_file(TEST_FILE_MEDIUM);
+       Test::touch_file_assert(TEST_FILE_MEDIUM);
 
        ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIUM, &detected));
 
@@ -297,7 +297,7 @@ BOOST_AUTO_TEST_CASE(scan_file_low)
        csr_cs_malware_h detected;
        auto start_time = ::time(nullptr);
 
-       Test::touch_file(TEST_FILE_LOW);
+       Test::touch_file_assert(TEST_FILE_LOW);
 
        ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_LOW, &detected));
 
@@ -318,14 +318,15 @@ BOOST_AUTO_TEST_CASE(scan_file_media_dir)
        csr_cs_malware_h detected;
        auto start_time = ::time(nullptr);
 
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
+       Test::remove_file(TEST_FILE_MEDIA());
+       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_MEDIA());
 
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
 
        CHECK_IS_NOT_NULL(detected);
        ASSERT_DETECTED(detected, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
                                        MALWARE_HIGH_DETAILED_URL);
-       ASSERT_DETECTED_EXT(detected, start_time, TEST_FILE_MEDIA, false, "");
+       ASSERT_DETECTED_EXT(detected, start_time, TEST_FILE_MEDIA(), false, "");
 
        EXCEPTION_GUARD_END
 }
@@ -339,7 +340,8 @@ BOOST_AUTO_TEST_CASE(scan_file_tmp_dir)
        csr_cs_malware_h detected;
        auto start_time = ::time(nullptr);
 
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_TMP);
+       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP);
 
        ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP, &detected));
 
@@ -364,7 +366,7 @@ BOOST_AUTO_TEST_CASE(scan_file_wgt_dir)
        Test::uninstall_app(TEST_WGT_PKG_ID);
        ASSERT_INSTALL_APP(TEST_WGT_PATH, TEST_WGT_TYPE);
 
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_WGT_MAL_FILE().c_str(), &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_WGT_MAL_FILE(), &detected));
 
        CHECK_IS_NOT_NULL(detected);
        ASSERT_DETECTED(detected, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
@@ -389,7 +391,7 @@ BOOST_AUTO_TEST_CASE(scan_file_tpk_dir)
        Test::uninstall_app(TEST_TPK_PKG_ID);
        ASSERT_INSTALL_APP(TEST_TPK_PATH, TEST_TPK_TYPE);
 
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_TPK_MAL_FILE().c_str(), &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_TPK_MAL_FILE(), &detected));
 
        CHECK_IS_NOT_NULL(detected);
        ASSERT_DETECTED(detected, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY,
@@ -768,46 +770,46 @@ BOOST_AUTO_TEST_CASE(judge_detected_malware)
        csr_cs_malware_h detected, stored;
 
        // remove earlier test results
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
+       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
 
        // store detected malware
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        CHECK_IS_NOT_NULL(detected);
 
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NOT_NULL(stored);
 
-       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NULL(stored);
 
        // IGNORE
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_IGNORE));
 
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NULL(stored);
 
-       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NOT_NULL(stored);
 
        // UNIGNORE
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_UNIGNORE));
 
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NOT_NULL(stored);
 
-       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NULL(stored);
 
        // REMOVE
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NULL(stored);
 
-       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NULL(stored);
 
        EXCEPTION_GUARD_END
@@ -822,13 +824,13 @@ BOOST_AUTO_TEST_CASE(judge_detected_malware_after_changed_file)
        csr_cs_malware_h detected;
 
        // scan and judge after touch
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        CHECK_IS_NOT_NULL(detected);
 
        std::this_thread::sleep_for(std::chrono::seconds(1));
 
-       Test::touch_file(TEST_FILE_MEDIA);
+       Test::touch_file(TEST_FILE_MEDIA());
 
        std::this_thread::sleep_for(std::chrono::seconds(1));
 
@@ -836,7 +838,7 @@ BOOST_AUTO_TEST_CASE(judge_detected_malware_after_changed_file)
                          CSR_ERROR_FILE_CHANGED);
 
        // rescan and judge again without touch
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        CHECK_IS_NOT_NULL(detected);
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 
@@ -852,26 +854,26 @@ BOOST_AUTO_TEST_CASE(judge_detected_malware_ignored_rescan)
        csr_cs_malware_h detected, stored;
 
        // remove earlier test results
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE);
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
+       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
 
        // store detected malware
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        CHECK_IS_NOT_NULL(detected);
 
        // ignore
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_IGNORE));
 
        // rescan
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        CHECK_IS_NULL(detected);
 
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NULL(stored);
 
-       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NOT_NULL(stored);
 
        // rollback to unignore
@@ -889,45 +891,45 @@ BOOST_AUTO_TEST_CASE(judge_detected_malware_remove_file)
        csr_cs_malware_h detected, stored;
 
        // remove earlier test results
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE);
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
+       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
 
        // store detected malware
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        CHECK_IS_NOT_NULL(detected);
 
        // remove detected malware file
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NULL(stored);
 
-       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NULL(stored);
 
-       ASSERT_IF(Test::is_file_exist(TEST_FILE_MEDIA), false);
+       ASSERT_IF(Test::is_file_exist(TEST_FILE_MEDIA()), false);
 
        // make ignored
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_IGNORE));
 
        // remove ignored malware file
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
 
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NULL(stored);
 
-       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA, &stored));
+       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA(), &stored));
        CHECK_IS_NULL(stored);
 
-       ASSERT_IF(Test::is_file_exist(TEST_FILE_MEDIA), false);
+       ASSERT_IF(Test::is_file_exist(TEST_FILE_MEDIA()), false);
 
        // remove not existing file
-       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA);
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA, &detected));
+       Test::copy_file(TEST_FILE_HIGH, TEST_FILE_MEDIA());
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &detected));
        CHECK_IS_NOT_NULL(detected);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
@@ -952,7 +954,7 @@ BOOST_AUTO_TEST_CASE(judge_detected_malware_remove_wgt)
        ASSERT_INSTALL_APP(TEST_WGT_PATH, TEST_WGT_TYPE);
 
        // remove detected malware file
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_WGT_MAL_FILE().c_str(), &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_WGT_MAL_FILE(), &detected));
        CHECK_IS_NOT_NULL(detected);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
@@ -973,7 +975,7 @@ BOOST_AUTO_TEST_CASE(judge_detected_malware_remove_tpk)
        ASSERT_INSTALL_APP(TEST_TPK_PATH, TEST_TPK_TYPE);
 
        // remove detected malware file
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_TPK_MAL_FILE().c_str(), &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_TPK_MAL_FILE(), &detected));
        CHECK_IS_NOT_NULL(detected);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
@@ -1011,19 +1013,19 @@ BOOST_AUTO_TEST_CASE(get_malware_after_file_removed)
        auto context = c.get();
        csr_cs_malware_h malware;
 
-       Test::remove_file(TEST_FILE_TMP);
-       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
+       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_MEDIA());
 
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP, &malware));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &malware));
        CHECK_IS_NOT_NULL(malware);
 
        csr_cs_malware_h malware_stored;
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_TMP, &malware_stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &malware_stored));
        CHECK_IS_NOT_NULL(malware_stored);
 
-       Test::remove_file_assert(TEST_FILE_TMP);
+       Test::remove_file_assert(TEST_FILE_MEDIA());
 
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_TMP, &malware_stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &malware_stored));
        CHECK_IS_NULL(malware_stored);
 
        EXCEPTION_GUARD_END
@@ -1037,32 +1039,32 @@ BOOST_AUTO_TEST_CASE(get_malwares_after_file_removed)
        auto context = c.get();
        csr_cs_malware_h malware;
 
-       Test::remove_file(TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
        Test::remove_file(TEST_FILE_TMP_IN_DIR_MALWARES);
-       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP);
+       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_MEDIA());
        Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP_IN_DIR_MALWARES);
 
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP, &malware));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &malware));
        CHECK_IS_NOT_NULL(malware);
        ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP_IN_DIR_MALWARES, &malware));
        CHECK_IS_NOT_NULL(malware);
 
        const char *dirs[2] = {
-               TEST_DIR_TMP,
+               TEST_DIR_MEDIA(),
                TEST_DIR_MALWARES
        };
 
        csr_cs_malware_list_h malware_list;
        size_t list_count;
        ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs, 2, &malware_list, &list_count));
-       ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP);
+       ::assertMalwareInList(malware_list, list_count, TEST_FILE_MEDIA());
        ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP_IN_DIR_MALWARES);
 
-       Test::remove_file_assert(TEST_FILE_TMP);
+       Test::remove_file_assert(TEST_FILE_MEDIA());
        Test::remove_file_assert(TEST_FILE_TMP_IN_DIR_MALWARES);
 
        ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs, 2, &malware_list, &list_count));
-       ::assertMalwareNotInList(malware_list, list_count, TEST_FILE_TMP);
+       ::assertMalwareNotInList(malware_list, list_count, TEST_FILE_MEDIA());
        ::assertMalwareNotInList(malware_list, list_count, TEST_FILE_TMP_IN_DIR_MALWARES);
 
        EXCEPTION_GUARD_END
@@ -1076,23 +1078,23 @@ BOOST_AUTO_TEST_CASE(get_malware_after_file_changed)
        auto context = c.get();
        csr_cs_malware_h malware;
 
-       Test::remove_file(TEST_FILE_TMP);
-       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
+       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_MEDIA());
 
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP, &malware));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &malware));
        CHECK_IS_NOT_NULL(malware);
 
        csr_cs_malware_h malware_stored;
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_TMP, &malware_stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &malware_stored));
        CHECK_IS_NOT_NULL(malware_stored);
 
-       Test::touch_file_assert(TEST_FILE_TMP);
+       Test::touch_file_assert(TEST_FILE_MEDIA());
 
        malware_stored = nullptr;
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_TMP, &malware_stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &malware_stored));
        CHECK_IS_NOT_NULL(malware_stored);
 
-       Test::remove_file(TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
 
        EXCEPTION_GUARD_END
 }
@@ -1105,18 +1107,18 @@ BOOST_AUTO_TEST_CASE(get_malwares_after_file_changed)
        auto context = c.get();
        csr_cs_malware_h malware;
 
-       Test::remove_file(TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
        Test::remove_file(TEST_FILE_TMP_IN_DIR_MALWARES);
-       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP);
+       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_MEDIA());
        Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP_IN_DIR_MALWARES);
 
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP, &malware));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &malware));
        CHECK_IS_NOT_NULL(malware);
        ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP_IN_DIR_MALWARES, &malware));
        CHECK_IS_NOT_NULL(malware);
 
        const char *dirs[2] = {
-               TEST_DIR_TMP,
+               TEST_DIR_MEDIA(),
                TEST_DIR_MALWARES
        };
 
@@ -1124,19 +1126,19 @@ BOOST_AUTO_TEST_CASE(get_malwares_after_file_changed)
        size_t list_count;
        ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs, 2, &malware_list, &list_count));
 
-       ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP);
+       ::assertMalwareInList(malware_list, list_count, TEST_FILE_MEDIA());
        ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP_IN_DIR_MALWARES);
 
-       Test::touch_file_assert(TEST_FILE_TMP);
+       Test::touch_file_assert(TEST_FILE_MEDIA());
        Test::touch_file_assert(TEST_FILE_TMP_IN_DIR_MALWARES);
 
        ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs, 2, &malware_list, &list_count));
 
-       ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP);
+       ::assertMalwareInList(malware_list, list_count, TEST_FILE_MEDIA());
        ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP_IN_DIR_MALWARES);
 
+       Test::remove_file(TEST_FILE_MEDIA());
        Test::remove_file(TEST_FILE_TMP_IN_DIR_MALWARES);
-       Test::remove_file(TEST_FILE_TMP);
 
        EXCEPTION_GUARD_END
 }
@@ -1149,21 +1151,21 @@ BOOST_AUTO_TEST_CASE(get_ignored_malware_after_file_removed)
        auto context = c.get();
        csr_cs_malware_h malware;
 
-       Test::remove_file(TEST_FILE_TMP);
-       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
+       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_MEDIA());
 
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP, &malware));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &malware));
        CHECK_IS_NOT_NULL(malware);
 
        csr_cs_malware_h malware_stored;
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_TMP, &malware_stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &malware_stored));
        CHECK_IS_NOT_NULL(malware_stored);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, malware_stored, CSR_CS_ACTION_IGNORE));
 
-       Test::remove_file_assert(TEST_FILE_TMP);
+       Test::remove_file_assert(TEST_FILE_MEDIA());
 
-       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_TMP, &malware_stored));
+       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA(), &malware_stored));
        CHECK_IS_NULL(malware_stored);
 
        EXCEPTION_GUARD_END
@@ -1176,36 +1178,36 @@ BOOST_AUTO_TEST_CASE(get_ignored_malwares_after_file_removed)
        auto c = Test::Context<csr_cs_context_h>();
        auto context = c.get();
 
-       Test::remove_file(TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
        Test::remove_file(TEST_FILE_TMP_IN_DIR_MALWARES);
-       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP);
+       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_MEDIA());
        Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP_IN_DIR_MALWARES);
 
        csr_cs_malware_h malware_tmp[2];
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP, &malware_tmp[0]));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &malware_tmp[0]));
        CHECK_IS_NOT_NULL(malware_tmp[0]);
        ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP_IN_DIR_MALWARES, &malware_tmp[1]));
        CHECK_IS_NOT_NULL(malware_tmp[1]);
 
        const char *dirs[2] = {
-               TEST_DIR_TMP,
+               TEST_DIR_MEDIA(),
                TEST_DIR_MALWARES
        };
 
        csr_cs_malware_list_h malware_list;
        size_t list_count;
        ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs, 2, &malware_list, &list_count));
-       ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP);
+       ::assertMalwareInList(malware_list, list_count, TEST_FILE_MEDIA());
        ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP_IN_DIR_MALWARES);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, malware_tmp[0], CSR_CS_ACTION_IGNORE));
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, malware_tmp[1], CSR_CS_ACTION_IGNORE));
 
-       Test::remove_file_assert(TEST_FILE_TMP);
+       Test::remove_file_assert(TEST_FILE_MEDIA());
        Test::remove_file_assert(TEST_FILE_TMP_IN_DIR_MALWARES);
 
        ASSERT_SUCCESS(csr_cs_get_ignored_malwares(context, dirs, 2, &malware_list, &list_count));
-       ::assertMalwareNotInList(malware_list, list_count, TEST_FILE_TMP);
+       ::assertMalwareNotInList(malware_list, list_count, TEST_FILE_MEDIA());
        ::assertMalwareNotInList(malware_list, list_count, TEST_FILE_TMP_IN_DIR_MALWARES);
 
        EXCEPTION_GUARD_END
@@ -1219,27 +1221,27 @@ BOOST_AUTO_TEST_CASE(get_ignored_malware_after_file_changed)
        auto context = c.get();
        csr_cs_malware_h malware;
 
-       Test::remove_file(TEST_FILE_TMP);
-       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
+       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_MEDIA());
 
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP, &malware));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &malware));
        CHECK_IS_NOT_NULL(malware);
 
        csr_cs_malware_h malware_stored;
-       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_TMP, &malware_stored));
+       ASSERT_SUCCESS(csr_cs_get_detected_malware(context, TEST_FILE_MEDIA(), &malware_stored));
        CHECK_IS_NOT_NULL(malware_stored);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, malware_stored, CSR_CS_ACTION_IGNORE));
 
-       Test::touch_file_assert(TEST_FILE_TMP);
+       Test::touch_file_assert(TEST_FILE_MEDIA());
 
        malware_stored = nullptr;
-       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_TMP, &malware_stored));
+       ASSERT_SUCCESS(csr_cs_get_ignored_malware(context, TEST_FILE_MEDIA(), &malware_stored));
        CHECK_IS_NOT_NULL(malware_stored);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, malware_stored, CSR_CS_ACTION_UNIGNORE));
 
-       Test::remove_file(TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
 
        EXCEPTION_GUARD_END
 }
@@ -1251,42 +1253,42 @@ BOOST_AUTO_TEST_CASE(get_ignored_malwares_after_file_changed)
        auto c = Test::Context<csr_cs_context_h>();
        auto context = c.get();
 
-       Test::remove_file(TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
        Test::remove_file(TEST_FILE_TMP_IN_DIR_MALWARES);
-       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP);
+       Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_MEDIA());
        Test::copy_file_assert(TEST_FILE_HIGH, TEST_FILE_TMP_IN_DIR_MALWARES);
 
        csr_cs_malware_h malware_tmp[2];
-       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP, &malware_tmp[0]));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_MEDIA(), &malware_tmp[0]));
        CHECK_IS_NOT_NULL(malware_tmp[0]);
        ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_FILE_TMP_IN_DIR_MALWARES, &malware_tmp[1]));
        CHECK_IS_NOT_NULL(malware_tmp[1]);
 
        const char *dirs[2] = {
-               TEST_DIR_TMP,
+               TEST_DIR_MEDIA(),
                TEST_DIR_MALWARES
        };
 
        csr_cs_malware_list_h malware_list;
        size_t list_count;
        ASSERT_SUCCESS(csr_cs_get_detected_malwares(context, dirs, 2, &malware_list, &list_count));
-       ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP);
+       ::assertMalwareInList(malware_list, list_count, TEST_FILE_MEDIA());
        ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP_IN_DIR_MALWARES);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, malware_tmp[0], CSR_CS_ACTION_IGNORE));
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, malware_tmp[1], CSR_CS_ACTION_IGNORE));
 
-       Test::touch_file_assert(TEST_FILE_TMP);
+       Test::touch_file_assert(TEST_FILE_MEDIA());
        Test::touch_file_assert(TEST_FILE_TMP_IN_DIR_MALWARES);
 
        ASSERT_SUCCESS(csr_cs_get_ignored_malwares(context, dirs, 2, &malware_list, &list_count));
-       ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP);
+       ::assertMalwareInList(malware_list, list_count, TEST_FILE_MEDIA());
        ::assertMalwareInList(malware_list, list_count, TEST_FILE_TMP_IN_DIR_MALWARES);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, malware_tmp[0], CSR_CS_ACTION_UNIGNORE));
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, malware_tmp[1], CSR_CS_ACTION_UNIGNORE));
 
-       Test::remove_file(TEST_FILE_TMP);
+       Test::remove_file(TEST_FILE_MEDIA());
        Test::remove_file(TEST_FILE_TMP_IN_DIR_MALWARES);
 
        EXCEPTION_GUARD_END

diff --git a/test/test-common.cpp b/test/test-common.cpp
index 44e49d9..5b3c70f 100644 (file)
--- a/test/test-common.cpp
+++ b/test/test-common.cpp
@@ -313,29 +313,43 @@ void exceptionGuard(const std::function<void()> &f)
        }
 }
 
-void copy_file_assert(const char *src_file, const char *dest_file)
+void copy_file_assert(const char *src_file, const char *dst_file)
 {
        try {
-               std::ifstream srce(src_file, std::ios::binary);
-               std::ofstream dest(dest_file, std::ios::binary);
-               dest << srce.rdbuf();
+               std::ifstream src;
+               std::ofstream dst;
+
+               src.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+               dst.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+
+               src.open(src_file, std::ios::binary);
+               dst.open(dst_file, std::ios::binary);
+
+               dst << src.rdbuf();
        } catch (const std::exception &e) {
                BOOST_REQUIRE_MESSAGE(false,
                        "Failed to copy file from src[" << src_file <<
-                       "] to dst[" << dest_file << "]: " << e.what());
+                       "] to dst[" << dst_file << "]: " << e.what());
        }
 }
 
-void copy_file(const char *src_file, const char *dest_file)
+void copy_file(const char *src_file, const char *dst_file)
 {
        try {
-               std::ifstream srce(src_file, std::ios::binary);
-               std::ofstream dest(dest_file, std::ios::binary);
-               dest << srce.rdbuf();
+               std::ifstream src;
+               std::ofstream dst;
+
+               src.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+               dst.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+
+               src.open(src_file, std::ios::binary);
+               dst.open(dst_file, std::ios::binary);
+
+               dst << src.rdbuf();
        } catch (const std::exception &e) {
                BOOST_WARN_MESSAGE(false,
                        "Failed to copy file from src[" << src_file <<
-                       "] to dst[" << dest_file << "]: " << e.what());
+                       "] to dst[" << dst_file << "]: " << e.what());
        }
 }
 

diff --git a/test/test-common.h b/test/test-common.h
index 6d86c39..7ea1c01 100644 (file)
--- a/test/test-common.h
+++ b/test/test-common.h
@@ -187,8 +187,8 @@ std::string capi_ec_to_string(int ec);
 
 void make_dir(const char *dir);
 void make_dir_assert(const char *dir);
-void copy_file(const char *src_file, const char *dest_file);
-void copy_file_assert(const char *src_file, const char *dest_file);
+void copy_file(const char *src_file, const char *dst_file);
+void copy_file_assert(const char *src_file, const char *dst_file);
 void touch_file(const char *file);
 void touch_file_assert(const char *file);
 void remove_file(const char *file);

diff --git a/test/test-helper.cpp b/test/test-helper.cpp
index 4a9b677..7e92de3 100644 (file)
--- a/test/test-helper.cpp
+++ b/test/test-helper.cpp
@@ -109,9 +109,8 @@ void ASSERT_DETECTED_IN_LIST(const std::vector<csr_cs_malware_h> &detectedList,
        csr_cs_severity_level_e a_severity;
        Test::ScopedCstr a_file_name, a_name, a_detailed_url;
 
-       std::vector<csr_cs_malware_h>::iterator iter;
        for (auto &d : detectedList) {
-               ASSERT_IF(csr_cs_malware_get_file_name(d, &a_file_name.ptr), CSR_ERROR_NONE);
+               ASSERT_SUCCESS(csr_cs_malware_get_file_name(d, &a_file_name.ptr));
                if (file_name != a_file_name.ptr)
                        continue;
 

diff --git a/test/test-resource.cpp b/test/test-resource.cpp
index efc603f..3b2f801 100644 (file)
--- a/test/test-resource.cpp
+++ b/test/test-resource.cpp
@@ -30,10 +30,18 @@
 
 namespace {
 
-std::string s_wgtAppRootCache;
-std::string s_wgtMalFileCache;
-std::string s_tpkAppRootCache;
-std::string s_tpkMalFileCache;
+std::string s_testDirMedia;
+std::string s_testDirApps;
+
+std::string s_testFileMedia;
+std::string s_testFileInDirMalwares;
+
+std::string s_wgtAppRoot;
+std::string s_wgtMalFile;
+std::string s_tpkAppRoot;
+std::string s_tpkMalFile;
+std::string s_fakeAppRoot;
+std::string s_fakeAppFile;
 
 #ifdef PLATFORM_VERSION_3
 std::string getUsername(void)
@@ -56,42 +64,82 @@ std::string getUsername(void)
 
 } // namespace anonymous
 
-const std::string &TEST_WGT_APP_ROOT(void)
+const char *TEST_DIR_MEDIA(void)
 {
-       if (s_wgtAppRootCache.empty())
+       if (s_testDirMedia.empty())
 #ifdef PLATFORM_VERSION_3
-               s_wgtAppRootCache = "/home/" + ::getUsername() + "/apps_rw/" TEST_WGT_PKG_ID;
+               s_testDirMedia = "/home/" + ::getUsername() + "/content";
 #else
-               s_wgtAppRootCache = TEST_DIR_APPS "/" TEST_WGT_PKG_ID;
+               s_testDirMedia = "/opt/usr/media";
 #endif
 
-       return s_wgtAppRootCache;
+       return s_testDirMedia.c_str();
 }
 
-const std::string &TEST_WGT_MAL_FILE(void)
+const char *TEST_DIR_APPS(void)
 {
-       if (s_wgtMalFileCache.empty())
-               s_wgtMalFileCache = TEST_WGT_APP_ROOT() + "/res/wgt/data/malicious.txt";
+       if (s_testDirApps.empty())
+#ifdef PLATFORM_VERSION_3
+               s_testDirApps = "/home/" + ::getUsername() + "/apps_rw";
+#else
+               s_testDirApps = "/opt/usr/apps";
+#endif
 
-       return s_wgtMalFileCache;
+       return s_testDirApps.c_str();
 }
 
-const std::string &TEST_TPK_APP_ROOT(void)
+const char *TEST_FILE_MEDIA(void)
 {
-       if (s_tpkAppRootCache.empty())
-#ifdef PLATFORM_VERSION_3
-               s_tpkAppRootCache = "/home/" + ::getUsername() + "/apps_rw/" TEST_TPK_PKG_ID;
-#else
-               s_tpkAppRootCache = TEST_DIR_APPS "/" TEST_TPK_PKG_ID;
-#endif
+       if (s_testFileMedia.empty())
+               s_testFileMedia = std::string(TEST_DIR_MEDIA()) + "/test_malware_file";
+
+       return s_testFileMedia.c_str();
+}
+
+const char *TEST_WGT_APP_ROOT(void)
+{
+       if (s_wgtAppRoot.empty())
+               s_wgtAppRoot = std::string(TEST_DIR_APPS()) + "/" TEST_WGT_PKG_ID;
+
+       return s_wgtAppRoot.c_str();
+}
+
+const char *TEST_WGT_MAL_FILE(void)
+{
+       if (s_wgtMalFile.empty())
+               s_wgtMalFile = std::string(TEST_WGT_APP_ROOT()) + "/res/wgt/data/eicar.txt";
+
+       return s_wgtMalFile.c_str();
+}
+
+const char *TEST_TPK_APP_ROOT(void)
+{
+       if (s_tpkAppRoot.empty())
+               s_tpkAppRoot = std::string(TEST_DIR_APPS()) + "/" TEST_TPK_PKG_ID;
+
+       return s_tpkAppRoot.c_str();
+}
+
+const char *TEST_TPK_MAL_FILE(void)
+{
+       if (s_tpkMalFile.empty())
+               s_tpkMalFile = std::string(TEST_TPK_APP_ROOT()) + "/shared/res/eicar.txt";
+
+       return s_tpkMalFile.c_str();
+}
+
+const char *TEST_FAKE_APP_ROOT(void)
+{
+       if (s_fakeAppRoot.empty())
+               s_fakeAppRoot = std::string(TEST_DIR_APPS()) + "/fake_app";
 
-       return s_tpkAppRootCache;
+       return s_fakeAppRoot.c_str();
 }
 
-const std::string &TEST_TPK_MAL_FILE(void)
+const char *TEST_FAKE_APP_FILE(void)
 {
-       if (s_tpkMalFileCache.empty())
-               s_tpkMalFileCache = TEST_TPK_APP_ROOT() + "/shared/res/malicious.txt";
+       if (s_fakeAppFile.empty())
+               s_fakeAppFile = std::string(TEST_FAKE_APP_ROOT()) + "/malicious.txt";
 
-       return s_tpkMalFileCache;
+       return s_fakeAppFile.c_str();
 }

diff --git a/test/test-resource.h b/test/test-resource.h
index 4583bc4..38b9710 100644 (file)
--- a/test/test-resource.h
+++ b/test/test-resource.h
@@ -31,11 +31,11 @@
 
 #define TEST_DIR_MALWARES  TEST_DIR "/test_dir"
 #define TEST_DIR_ROOT      "/"
-#define TEST_DIR_MEDIA     "/opt/usr/media"
 #define TEST_DIR_TMP       "/tmp"
-#define TEST_DIR_APPS      "/opt/usr/apps"
+const char *TEST_DIR_MEDIA();
+const char *TEST_DIR_APPS();
 
-#define TEST_FILE_MEDIA               TEST_DIR_MEDIA "/test_malware_file"
+const char *TEST_FILE_MEDIA();
 #define TEST_FILE_TMP_IN_DIR_MALWARES TEST_DIR_MALWARES "/tmp_malware_file"
 #define TEST_FILE_TMP                 TEST_DIR_TMP "/test_malware_file"
 #define TEST_FILE_NO_EXIST            TEST_DIR_TMP "/not_existing_file"
@@ -43,8 +43,8 @@
 #define TEST_WGT_PKG_ID    "hFhcNcbE6K"
 #define TEST_WGT_TYPE      "wgt"
 #define TEST_WGT_PATH      TEST_RES_DIR "/" TEST_TARGET "/MaliciousWgt.wgt"
-const std::string &TEST_WGT_APP_ROOT();
-const std::string &TEST_WGT_MAL_FILE();
+const char *TEST_WGT_APP_ROOT();
+const char *TEST_WGT_MAL_FILE();
 
 #define TEST_SAFE_WGT_PKG_ID   "q3JfX6RA5q"
 #define TEST_SAFE_WGT_TYPE     "wgt"
@@ -53,11 +53,11 @@ const std::string &TEST_WGT_MAL_FILE();
 #define TEST_TPK_PKG_ID    "org.example.malicioustpk"
 #define TEST_TPK_TYPE      "tpk"
 #define TEST_TPK_PATH      TEST_RES_DIR "/" TEST_TARGET "/MaliciousTpk.tpk"
-const std::string &TEST_TPK_APP_ROOT();
-const std::string &TEST_TPK_MAL_FILE();
+const char *TEST_TPK_APP_ROOT();
+const char *TEST_TPK_MAL_FILE();
 
-#define TEST_FAKE_APP_ROOT TEST_DIR_APPS "/fake_app"
-#define TEST_FAKE_APP_FILE TEST_FAKE_APP_ROOT "/malicious.txt"
+const char *TEST_FAKE_APP_ROOT();
+const char *TEST_FAKE_APP_FILE();
 
 #define MALWARE_HIGH_NAME            "test_malware"
 #define MALWARE_HIGH_SEVERITY        CSR_CS_SEVERITY_HIGH