test/test-helper.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-helper.cpp
  18  * @author      Dongsun Lee (ds73.lee@samsung.com)
  19  * @version     1.0
  20  * @brief       CSR API test helper
  21  */
  22 #include <string>
  23
  24 #include <time.h>
  25 #include <utime.h>
  26 #include <unistd.h>
  27
  28 #include <boost/test/unit_test.hpp>
  29
  30 #include "test-common.h"
  31
  32 void ASSERT_DETECTED(csr_cs_malware_h detected, const std::string &e_malware_name,
  33                                          csr_cs_severity_level_e e_severity, const std::string &e_detailed_url)
  34 {
  35         csr_cs_severity_level_e a_severity;
  36         Test::ScopedCstr a_malware_name, a_detailed_url;
  37
  38         ASSERT_SUCCESS(csr_cs_malware_get_severity(detected, &a_severity));
  39         ASSERT_SUCCESS(csr_cs_malware_get_name(detected, &a_malware_name.ptr));
  40         ASSERT_SUCCESS(csr_cs_malware_get_detailed_url(detected, &a_detailed_url.ptr));
  41
  42         ASSERT_IF(a_severity, e_severity);
  43         ASSERT_IF(a_malware_name.ptr, e_malware_name);
  44         ASSERT_IF(a_detailed_url.ptr, e_detailed_url);
  45 }
  46
  47 void ASSERT_DETECTED_EXT(csr_cs_malware_h detected, time_t e_timestamp,
  48                                                  const std::string &e_file_name, bool e_is_app,
  49                                                  const std::string &e_pkg_id)
  50 {
  51         time_t a_timestamp;
  52         bool a_is_app;
  53         Test::ScopedCstr a_file_name, a_pkg_id;
  54
  55         ASSERT_SUCCESS(csr_cs_malware_get_timestamp(detected, &a_timestamp));
  56         ASSERT_SUCCESS(csr_cs_malware_get_file_name(detected, &a_file_name.ptr));
  57         ASSERT_SUCCESS(csr_cs_malware_is_app(detected, &a_is_app));
  58         ASSERT_SUCCESS(csr_cs_malware_get_pkg_id(detected, &a_pkg_id.ptr));
  59
  60         ASSERT_IF(a_file_name.ptr, e_file_name);
  61         ASSERT_IF(a_is_app, e_is_app);
  62         ASSERT_IF(a_pkg_id.ptr, e_pkg_id);
  63
  64         BOOST_WARN_MESSAGE(e_timestamp <= a_timestamp,
  65                                            "Actual detected item's time stamp is later than expected time "
  66                                            "stamp (which is start time before scan_file maybe..). this case "
  67                                            "should be the returned detected item comes from history which is "
  68                                            "scanned in the past. actual time: " << a_timestamp <<
  69                                            " expected(started) time: " << e_timestamp);
  70 }
  71
  72 void ASSERT_DETECTED_HANDLE(csr_cs_malware_h expected, csr_cs_malware_h actual)
  73 {
  74         csr_cs_severity_level_e e_severity, a_severity;
  75         Test::ScopedCstr e_malware_name, e_detailed_url, e_file_name, e_pkg_id;
  76         Test::ScopedCstr a_malware_name, a_detailed_url, a_file_name, a_pkg_id;
  77         time_t e_timestamp, a_timestamp;
  78         bool e_is_app, a_is_app;
  79
  80         ASSERT_SUCCESS(csr_cs_malware_get_severity(expected, &e_severity));
  81         ASSERT_SUCCESS(csr_cs_malware_get_name(expected, &e_malware_name.ptr));
  82         ASSERT_SUCCESS(csr_cs_malware_get_detailed_url(expected, &e_detailed_url.ptr));
  83         ASSERT_SUCCESS(csr_cs_malware_get_timestamp(expected, &e_timestamp));
  84         ASSERT_SUCCESS(csr_cs_malware_get_file_name(expected, &e_file_name.ptr));
  85         ASSERT_SUCCESS(csr_cs_malware_is_app(expected, &e_is_app));
  86         ASSERT_SUCCESS(csr_cs_malware_get_pkg_id(expected, &e_pkg_id.ptr));
  87
  88         ASSERT_SUCCESS(csr_cs_malware_get_severity(actual, &a_severity));
  89         ASSERT_SUCCESS(csr_cs_malware_get_name(actual, &a_malware_name.ptr));
  90         ASSERT_SUCCESS(csr_cs_malware_get_detailed_url(actual, &a_detailed_url.ptr));
  91         ASSERT_SUCCESS(csr_cs_malware_get_timestamp(actual, &a_timestamp));
  92         ASSERT_SUCCESS(csr_cs_malware_get_file_name(actual, &a_file_name.ptr));
  93         ASSERT_SUCCESS(csr_cs_malware_is_app(actual, &a_is_app));
  94         ASSERT_SUCCESS(csr_cs_malware_get_pkg_id(actual, &a_pkg_id.ptr));
  95
  96         ASSERT_IF(a_severity, e_severity);
  97         ASSERT_IF(a_malware_name.ptr, e_malware_name.ptr);
  98         ASSERT_IF(a_detailed_url.ptr, e_detailed_url.ptr);
  99         ASSERT_IF(a_file_name.ptr, e_file_name.ptr);
 100         ASSERT_IF(a_is_app, e_is_app);
 101         ASSERT_IF(a_pkg_id.ptr, e_pkg_id.ptr);
 102         ASSERT_IF(a_timestamp, e_timestamp);
 103 }
 104
 105 void ASSERT_DETECTED_IN_LIST(const std::vector<csr_cs_malware_h> &detectedList,
 106                                                          const std::string &file_name, const std::string &name,
 107                                                          csr_cs_severity_level_e severity, const std::string &detailed_url)
 108 {
 109         csr_cs_severity_level_e a_severity;
 110         Test::ScopedCstr a_file_name, a_name, a_detailed_url;
 111
 112         std::vector<csr_cs_malware_h>::iterator iter;
 113         for (auto &d : detectedList) {
 114                 ASSERT_IF(csr_cs_malware_get_file_name(d, &a_file_name.ptr), CSR_ERROR_NONE);
 115                 if (file_name != a_file_name.ptr)
 116                         continue;
 117
 118                 ASSERT_SUCCESS(csr_cs_malware_get_name(d, &a_name.ptr));
 119                 ASSERT_SUCCESS(csr_cs_malware_get_severity(d, &a_severity));
 120                 ASSERT_SUCCESS(csr_cs_malware_get_detailed_url(d, &a_detailed_url.ptr));
 121
 122                 ASSERT_IF(a_name.ptr, name);
 123                 ASSERT_IF(a_severity, severity);
 124                 ASSERT_IF(a_detailed_url.ptr, detailed_url);
 125
 126                 return;
 127         }
 128
 129         BOOST_REQUIRE_MESSAGE(false,
 130                         "Cannot find the file[" << file_name << "] in detected list.");
 131 }
 132
 133 void ASSERT_DETECTED_IN_LIST_EXT(const std::vector<csr_cs_malware_h> &detectedList,
 134                                                                  const std::string &file_name, bool is_app,
 135                                                                  const std::string &pkg_id)
 136 {
 137         bool a_is_app;
 138         Test::ScopedCstr a_file_name, a_pkg_id;
 139
 140         for (auto &d : detectedList) {
 141                 ASSERT_SUCCESS(csr_cs_malware_get_file_name(d, &a_file_name.ptr));
 142                 if (file_name != a_file_name.ptr)
 143                         continue;
 144
 145                 ASSERT_SUCCESS(csr_cs_malware_is_app(d, &a_is_app));
 146                 ASSERT_SUCCESS(csr_cs_malware_get_pkg_id(d, &a_pkg_id.ptr));
 147
 148                 ASSERT_IF(a_is_app, is_app);
 149                 ASSERT_IF(a_pkg_id.ptr, pkg_id);
 150
 151                 return;
 152         }
 153
 154         BOOST_REQUIRE_MESSAGE(false,
 155                         "Cannot find the file[" << file_name << "] in detected list.");
 156 }