Support test app management on tizen v 3.0

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

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 2d5f48a..f6ef7ad 100755 (executable)
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -36,6 +36,7 @@ PKG_CHECK_MODULES(${TARGET_CSR_TEST_COMMON}_DEP
 
 SET(${TARGET_CSR_TEST_COMMON}_SRCS
        test-common.cpp
+       test-resource.cpp
        colour_log_formatter.cpp
 )
 

diff --git a/test/internals/test-file-system.cpp b/test/internals/test-file-system.cpp
index e77ad44..6baa676 100644 (file)
--- a/test/internals/test-file-system.cpp
+++ b/test/internals/test-file-system.cpp
@@ -155,7 +155,7 @@ BOOST_AUTO_TEST_CASE(remove_app)
        Test::uninstall_app(TEST_TPK_PKG_ID);
        ASSERT_INSTALL_APP(TEST_TPK_PATH, TEST_TPK_TYPE);
 
-       auto app = File::create(TEST_TPK_MAL_FILE);
+       auto app = File::create(TEST_TPK_MAL_FILE());
        CHECK_IS_NOT_NULL(app);
        app->remove();
 

diff --git a/test/test-api-content-screening-async.cpp b/test/test-api-content-screening-async.cpp
index e6ada81..2d44b00 100644 (file)
--- a/test/test-api-content-screening-async.cpp
+++ b/test/test-api-content-screening-async.cpp
@@ -365,14 +365,14 @@ BOOST_AUTO_TEST_CASE(scan_dir_root)
                TEST_FILE_TMP, false, nullptr);
 
        ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_WGT_APP_ROOT, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
+               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);
+               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);
+               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);
+               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);
@@ -466,14 +466,14 @@ BOOST_AUTO_TEST_CASE(scan_dir_apps)
        ASSERT_CALLBACK(testCtx, -1, 3, 1, 0, 0);
 
        ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_WGT_APP_ROOT, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
+               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);
+               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);
+               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);
+               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);
@@ -499,7 +499,7 @@ BOOST_AUTO_TEST_CASE(scan_dir_wgt)
 
        AsyncTestContext testCtx;
 
-       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_WGT_APP_ROOT, &testCtx), CSR_ERROR_NONE);
+       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_WGT_APP_ROOT().c_str(), &testCtx), CSR_ERROR_NONE);
 
        std::unique_lock<std::mutex> l(testCtx.m);
        testCtx.cv.wait(l);
@@ -509,9 +509,9 @@ BOOST_AUTO_TEST_CASE(scan_dir_wgt)
        ASSERT_CALLBACK(testCtx, -1, 1, 1, 0, 0);
 
        ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_WGT_APP_ROOT, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
+               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);
+               TEST_WGT_APP_ROOT(), true, TEST_WGT_PKG_ID);
 
        Test::uninstall_app(TEST_WGT_PKG_ID);
 
@@ -532,7 +532,7 @@ BOOST_AUTO_TEST_CASE(scan_dir_tpk)
 
        AsyncTestContext testCtx;
 
-       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_TPK_APP_ROOT, &testCtx), CSR_ERROR_NONE);
+       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_TPK_APP_ROOT().c_str(), &testCtx), CSR_ERROR_NONE);
 
        std::unique_lock<std::mutex> l(testCtx.m);
        testCtx.cv.wait(l);
@@ -542,9 +542,9 @@ BOOST_AUTO_TEST_CASE(scan_dir_tpk)
        ASSERT_CALLBACK(testCtx, -1, 1, 1, 0, 0);
 
        ASSERT_DETECTED_IN_LIST(testCtx.detectedList,
-               TEST_TPK_APP_ROOT, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
+               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);
+               TEST_TPK_APP_ROOT(), true, TEST_TPK_PKG_ID);
 
        Test::uninstall_app(TEST_TPK_PKG_ID);
 
@@ -672,7 +672,7 @@ BOOST_AUTO_TEST_CASE(delta_scan_basic)
        // Base Scan
        AsyncTestContext testBaseCtx;
 
-       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testBaseCtx), CSR_ERROR_NONE);
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testBaseCtx));
 
        std::unique_lock<std::mutex> lBase(testBaseCtx.m);
        testBaseCtx.cv.wait(lBase);
@@ -686,8 +686,7 @@ BOOST_AUTO_TEST_CASE(delta_scan_basic)
        // Rescan the same dir
        AsyncTestContext testRescanCtx;
 
-       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testRescanCtx),
-                         CSR_ERROR_NONE);
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testRescanCtx));
 
        std::unique_lock<std::mutex> lRescan(testRescanCtx.m);
        testRescanCtx.cv.wait(lRescan);
@@ -697,14 +696,14 @@ BOOST_AUTO_TEST_CASE(delta_scan_basic)
        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);
+               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);
+               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);
+               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);
+               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);
@@ -714,7 +713,7 @@ BOOST_AUTO_TEST_CASE(delta_scan_basic)
        // Rescan the sub dir
        AsyncTestContext testRescanSubCtx;
 
-       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_WGT_APP_ROOT, &testRescanSubCtx), CSR_ERROR_NONE);
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_WGT_APP_ROOT().c_str(), &testRescanSubCtx));
 
        std::unique_lock<std::mutex> lRescanSub(testRescanSubCtx.m);
        testRescanSubCtx.cv.wait(lRescanSub);
@@ -724,9 +723,9 @@ BOOST_AUTO_TEST_CASE(delta_scan_basic)
        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);
+               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);
+               TEST_WGT_APP_ROOT(), true, TEST_WGT_PKG_ID);
 
        uninstall_test_apps();
 
@@ -750,7 +749,7 @@ BOOST_AUTO_TEST_CASE(delta_scan_changed_after_scan)
        // Base Scan
        AsyncTestContext testBaseCtx;
 
-       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testBaseCtx), CSR_ERROR_NONE);
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testBaseCtx));
 
        std::unique_lock<std::mutex> lBase(testBaseCtx.m);
        testBaseCtx.cv.wait(lBase);
@@ -768,8 +767,7 @@ BOOST_AUTO_TEST_CASE(delta_scan_changed_after_scan)
        // Rescan the same dir
        AsyncTestContext testRescanCtx;
 
-       ASSERT_IF(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testRescanCtx),
-                         CSR_ERROR_NONE);
+       ASSERT_SUCCESS(csr_cs_scan_dir_async(context, TEST_DIR_APPS, &testRescanCtx));
 
        std::unique_lock<std::mutex> lRescan(testRescanCtx.m);
        testRescanCtx.cv.wait(lRescan);
@@ -779,14 +777,14 @@ BOOST_AUTO_TEST_CASE(delta_scan_changed_after_scan)
        ASSERT_CALLBACK(testRescanCtx, 1, 3, 1, 0, 0);
 
        ASSERT_DETECTED_IN_LIST(testRescanCtx.detectedList,
-               TEST_WGT_APP_ROOT, MALWARE_HIGH_NAME, MALWARE_HIGH_SEVERITY, MALWARE_HIGH_DETAILED_URL);
+               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);
+               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);
+               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);
+               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);
@@ -821,9 +819,8 @@ BOOST_AUTO_TEST_CASE(canonicalize_files_absolute_path)
 
        AsyncTestContext testCtx;
 
-       ASSERT_IF(csr_cs_scan_files_async(context, files, sizeof(files) / sizeof(const char *),
-                                                                         &testCtx),
-                         CSR_ERROR_NONE);
+       ASSERT_SUCCESS(csr_cs_scan_files_async(context, files, sizeof(files) / sizeof(const char *),
+                                                                                  &testCtx));
 
        std::unique_lock<std::mutex> l(testCtx.m);
        testCtx.cv.wait(l);
@@ -861,9 +858,8 @@ BOOST_AUTO_TEST_CASE(canonicalize_files_relative_path)
 
        Test::ScopedChDir scopedCd(TEST_DIR);
 
-       ASSERT_IF(csr_cs_scan_files_async(context, files, sizeof(files) / sizeof(const char *),
-                                                                         &testCtx),
-                         CSR_ERROR_NONE);
+       ASSERT_SUCCESS(csr_cs_scan_files_async(context, files, sizeof(files) / sizeof(const char *),
+                                                                                  &testCtx));
 
        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 3d9653f..a6e7faa 100644 (file)
--- a/test/test-api-content-screening.cpp
+++ b/test/test-api-content-screening.cpp
@@ -327,12 +327,12 @@ 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, &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_WGT_MAL_FILE().c_str(), &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_WGT_APP_ROOT, true, TEST_WGT_PKG_ID);
+       ASSERT_DETECTED_EXT(detected, start_time, TEST_WGT_APP_ROOT(), true, TEST_WGT_PKG_ID);
 
        ASSERT_UNINSTALL_APP(TEST_WGT_PKG_ID);
 
@@ -352,12 +352,12 @@ 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, &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_TPK_MAL_FILE().c_str(), &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_TPK_APP_ROOT, true, TEST_TPK_PKG_ID);
+       ASSERT_DETECTED_EXT(detected, start_time, TEST_TPK_APP_ROOT(), true, TEST_TPK_PKG_ID);
 
        ASSERT_UNINSTALL_APP(TEST_TPK_PKG_ID);
 
@@ -915,7 +915,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, &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_WGT_MAL_FILE().c_str(), &detected));
        CHECK_IS_NOT_NULL(detected);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));
@@ -936,7 +936,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, &detected));
+       ASSERT_SUCCESS(csr_cs_scan_file(context, TEST_TPK_MAL_FILE().c_str(), &detected));
        CHECK_IS_NOT_NULL(detected);
 
        ASSERT_SUCCESS(csr_cs_judge_detected_malware(context, detected, CSR_CS_ACTION_REMOVE));

diff --git a/test/test-common.cpp b/test/test-common.cpp
index 569a9c9..38ff458 100644 (file)
--- a/test/test-common.cpp
+++ b/test/test-common.cpp
@@ -85,13 +85,15 @@ bool pkgmgr_request(const std::function<int(pkgmgr_client *, PkgEventData *)> &r
 
        PkgEventData data;
        auto ret = request(pkgmgr, &data);
-       if (ret <= PKGMGR_R_OK)
+       if (ret <= PKGMGR_R_OK) {
+               BOOST_MESSAGE("pkgmgr request failed with ret: " << ret);
                return false;
+       }
 
        auto id = g_timeout_add_seconds(10, __quit_loop_on_timeout_cb, &data);
        data.loop = g_main_loop_new(nullptr, false);
        g_main_loop_run(data.loop);
-       BOOST_REQUIRE_MESSAGE(g_source_remove(id),
+       BOOST_WARN_MESSAGE(g_source_remove(id),
                        "Failed to remove timeout event source from main loop.");
        g_main_loop_unref(data.loop);
        pkgmgr_client_free(pkgmgr);
@@ -303,22 +305,33 @@ bool is_file_exist(const char *file)
 bool uninstall_app(const char *pkg_id)
 {
        return pkgmgr_request([&](pkgmgr_client *pc, PkgEventData *data) {
-               return pkgmgr_client_uninstall(pc, nullptr, pkg_id, PM_QUIET,
-                                                                          __quit_loop_on_end_cb, data);
+#ifdef PLATFORM_VERSION_3
+               return ::pkgmgr_client_usr_uninstall(pc, nullptr, pkg_id, PM_QUIET,
+                                                                                __quit_loop_on_end_cb, data, ::getuid());
+#else
+               return ::pkgmgr_client_uninstall(pc, nullptr, pkg_id, PM_QUIET,
+                                                                                __quit_loop_on_end_cb, data);
+#endif
        });
 }
 
 bool install_app(const char *app_path, const char *pkg_type)
 {
        return pkgmgr_request([&](pkgmgr_client *pc, PkgEventData *data) {
-               return pkgmgr_client_install(pc, pkg_type, nullptr, app_path, nullptr, PM_QUIET,
-                                                                        __quit_loop_on_end_cb, data);
+#ifdef PLATFORM_VERSION_3
+               return ::pkgmgr_client_usr_install(pc, pkg_type, nullptr, app_path, nullptr,
+                                                                                  PM_QUIET, __quit_loop_on_end_cb, data,
+                                                                                  ::getuid());
+#else
+               return ::pkgmgr_client_install(pc, pkg_type, nullptr, app_path, nullptr, PM_QUIET,
+                                                                          __quit_loop_on_end_cb, data);
+#endif
        });
 }
 
 void initialize_db()
 {
-#ifdef PLATFORM_VERSION3
+#ifdef PLATFORM_VERSION_3
        remove_file(RW_DBSPACE ".csr.db");
        remove_file(RW_DBSPACE ".csr.db-journal");
 

diff --git a/test/test-helper.cpp b/test/test-helper.cpp
index 5af8c25..6e51c12 100644 (file)
--- a/test/test-helper.cpp
+++ b/test/test-helper.cpp
@@ -45,7 +45,7 @@ void ASSERT_DETECTED(csr_cs_malware_h detected, const char *e_malware_name,
 }
 
 void ASSERT_DETECTED_EXT(csr_cs_malware_h detected, time_t e_timestamp,
-                                                const char *e_file_name, bool e_is_app, const char *e_pkg_id)
+                                                const std::string &e_file_name, bool e_is_app, const char *e_pkg_id)
 {
        time_t a_timestamp;
        bool a_is_app;
@@ -102,7 +102,7 @@ void ASSERT_DETECTED_HANDLE(csr_cs_malware_h expected, csr_cs_malware_h actual)
 }
 
 void ASSERT_DETECTED_IN_LIST(const std::vector<csr_cs_malware_h> &detectedList,
-                                                        const char *file_name, const char *name,
+                                                        const std::string &file_name, const char *name,
                                                         csr_cs_severity_level_e severity, const char *detailed_url)
 {
        csr_cs_severity_level_e a_severity;
@@ -111,7 +111,7 @@ void ASSERT_DETECTED_IN_LIST(const std::vector<csr_cs_malware_h> &detectedList,
        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);
-               if (strcmp(file_name, a_file_name.ptr) != 0)
+               if (file_name != a_file_name.ptr)
                        continue;
 
                ASSERT_SUCCESS(csr_cs_malware_get_name(d, &a_name.ptr));
@@ -130,14 +130,15 @@ void ASSERT_DETECTED_IN_LIST(const std::vector<csr_cs_malware_h> &detectedList,
 }
 
 void ASSERT_DETECTED_IN_LIST_EXT(const std::vector<csr_cs_malware_h> &detectedList,
-                                                                const char *file_name, bool is_app, const char *pkg_id)
+                                                                const std::string &file_name, bool is_app,
+                                                                const char *pkg_id)
 {
        bool a_is_app;
        Test::ScopedCstr a_file_name, a_pkg_id;
 
        for (auto &d : detectedList) {
                ASSERT_SUCCESS(csr_cs_malware_get_file_name(d, &a_file_name.ptr));
-               if (strcmp(file_name, a_file_name.ptr) != 0)
+               if (file_name != a_file_name.ptr)
                        continue;
 
                ASSERT_SUCCESS(csr_cs_malware_is_app(d, &a_is_app));

diff --git a/test/test-helper.h b/test/test-helper.h
index 224fe64..2d2b742 100644 (file)
--- a/test/test-helper.h
+++ b/test/test-helper.h
@@ -21,17 +21,19 @@
  */
 #include <csr-content-screening.h>
 
+#include <string>
+
 void ASSERT_DETECTED(csr_cs_malware_h detected, const char *name,
                                         csr_cs_severity_level_e severity, const char *detailed_url);
 
-void ASSERT_DETECTED_EXT(csr_cs_malware_h detected, time_t time, const char *file_name,
+void ASSERT_DETECTED_EXT(csr_cs_malware_h detected, time_t time, const std::string &file_name,
                                                 bool is_app, const char *pkg_id);
 
 void ASSERT_DETECTED_HANDLE(csr_cs_malware_h expected, csr_cs_malware_h actual);
 
 void ASSERT_DETECTED_IN_LIST(const std::vector<csr_cs_malware_h> &detectedList,
-                                                        const char *file_name, const char *name,
+                                                        const std::string &file_name, const char *name,
                                                         csr_cs_severity_level_e severity, const char *detailed_url);
 
 void ASSERT_DETECTED_IN_LIST_EXT(const std::vector<csr_cs_malware_h> &detectedList,
-                                                                const char *file_name, bool is_app, const char *pkg_id);
+                                                                const std::string &file_name, bool is_app, const char *pkg_id);

diff --git a/test/test-resource.cpp b/test/test-resource.cpp
new file mode 100644 (file)
index 0000000..efc603f
--- /dev/null
+++ b/test/test-resource.cpp
@@ -0,0 +1,97 @@
+/*
+ *  Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License
+ */
+/*
+ * @file        test-resource.cpp
+ * @author      Kyungwook Tak (k.tak@samsung.com)
+ * @version     1.0
+ * @brief       Test resoure name and paths
+ */
+#include "test-resource.h"
+
+#include <vector>
+#include <unistd.h>
+#include <sys/types.h>
+#include <pwd.h>
+
+#include "test-common.h"
+
+namespace {
+
+std::string s_wgtAppRootCache;
+std::string s_wgtMalFileCache;
+std::string s_tpkAppRootCache;
+std::string s_tpkMalFileCache;
+
+#ifdef PLATFORM_VERSION_3
+std::string getUsername(void)
+{
+       struct passwd pwd;
+       struct passwd *result = nullptr;
+
+       auto bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
+       bufsize = (bufsize == -1) ? 16384 : bufsize;
+
+       std::vector<char> buf(bufsize, 0);
+
+       ::getpwuid_r(::getuid(), &pwd, buf.data(), buf.size(), &result);
+       if (result == nullptr)
+               throw std::logic_error("Failed to getpwuid_r with errno: " + errno);
+
+       return std::string(pwd.pw_name);
+}
+#endif
+
+} // namespace anonymous
+
+const std::string &TEST_WGT_APP_ROOT(void)
+{
+       if (s_wgtAppRootCache.empty())
+#ifdef PLATFORM_VERSION_3
+               s_wgtAppRootCache = "/home/" + ::getUsername() + "/apps_rw/" TEST_WGT_PKG_ID;
+#else
+               s_wgtAppRootCache = TEST_DIR_APPS "/" TEST_WGT_PKG_ID;
+#endif
+
+       return s_wgtAppRootCache;
+}
+
+const std::string &TEST_WGT_MAL_FILE(void)
+{
+       if (s_wgtMalFileCache.empty())
+               s_wgtMalFileCache = TEST_WGT_APP_ROOT() + "/res/wgt/data/malicious.txt";
+
+       return s_wgtMalFileCache;
+}
+
+const std::string &TEST_TPK_APP_ROOT(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
+
+       return s_tpkAppRootCache;
+}
+
+const std::string &TEST_TPK_MAL_FILE(void)
+{
+       if (s_tpkMalFileCache.empty())
+               s_tpkMalFileCache = TEST_TPK_APP_ROOT() + "/shared/res/malicious.txt";
+
+       return s_tpkMalFileCache;
+}

diff --git a/test/test-resource.h b/test/test-resource.h
index e129569..26e6a37 100644 (file)
--- a/test/test-resource.h
+++ b/test/test-resource.h
@@ -21,6 +21,8 @@
  */
 #pragma once
 
+#include <string>
+
 // Test data for content screening
 #define TEST_FILE_NORMAL   TEST_DIR "/test_normal_file"
 #define TEST_FILE_HIGH     TEST_DIR "/test_malware_file"
@@ -38,21 +40,20 @@
 #define TEST_FILE_NO_EXIST TEST_DIR_TMP "/not_existing_file"
 
 #define TEST_WGT_PKG_ID    "hFhcNcbE6K"
-#define TEST_WGT_APP_ROOT  TEST_DIR_APPS "/" TEST_WGT_PKG_ID
-#define TEST_WGT_MAL_FILE  TEST_WGT_APP_ROOT "/res/wgt/data/malicious.txt"
+#define TEST_WGT_TYPE      "wgt"
 #define TEST_WGT_PATH      TEST_RES_DIR "/" TEST_TARGET "/MaliciousWgt.wgt"
-#define TEST_WGT_TYPE      "WGT"
+const std::string &TEST_WGT_APP_ROOT();
+const std::string &TEST_WGT_MAL_FILE();
 
 #define TEST_SAFE_WGT_PKG_ID   "q3JfX6RA5q"
-#define TEST_SAFE_WGT_APP_ROOT TEST_DIR_APPS "/" TEST_SAFE_WGT_PKG_ID
+#define TEST_SAFE_WGT_TYPE     "wgt"
 #define TEST_SAFE_WGT_PATH     TEST_RES_DIR "/" TEST_TARGET "/non-malware.wgt"
-#define TEST_SAFE_WGT_TYPE     "WGT"
 
 #define TEST_TPK_PKG_ID    "org.example.malicioustpk"
-#define TEST_TPK_APP_ROOT  TEST_DIR_APPS "/" TEST_TPK_PKG_ID
-#define TEST_TPK_MAL_FILE  TEST_TPK_APP_ROOT "/shared/res/malicious.txt"
+#define TEST_TPK_TYPE      "tpk"
 #define TEST_TPK_PATH      TEST_RES_DIR "/" TEST_TARGET "/MaliciousTpk.tpk"
-#define TEST_TPK_TYPE      "TPK"
+const std::string &TEST_TPK_APP_ROOT();
+const std::string &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"