Don't throw exception in dtor

[platform/upstream/csr-framework.git] / test / test-common.h

diff --git a/test/test-common.h b/test/test-common.h
index 481e5ab..cdec29a 100644 (file)
--- a/test/test-common.h
+++ b/test/test-common.h
@@ -28,6 +28,9 @@
 #include <typeinfo>
 #include <string>
 #include <cstring>
+#include <cerrno>
+#include <system_error>
+#include <unistd.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -37,9 +40,6 @@
 #include <csre-content-screening.h>
 #include <csre-web-protection.h>
 
-#include <csre-content-screening-engine-info.h>
-#include <csre-web-protection-engine-info.h>
-
 #ifndef __FILENAME__
 #define __FILENAME__ (::strrchr(__FILE__, '/') ? ::strrchr(__FILE__, '/') + 1 : __FILE__)
 #endif
@@ -49,13 +49,22 @@
                                                                                0, std::ios_base::cur) << ITEMS)).str()
 
 #define ASSERT_IF_MSG(value, expected, msg) \
-       Test::_assert(value, expected, __FILENAME__, __func__, __LINE__, TOSTRING(msg))
+       Test::_assert(value, expected, __FILENAME__, __func__, __LINE__, true, TOSTRING(msg))
+
+#define WARN_IF_MSG(value, expected, msg) \
+       Test::_assert(value, expected, __FILENAME__, __func__, __LINE__, false, TOSTRING(msg))
 
 #define ASSERT_IF(value, expected) \
-       Test::_assert(value, expected, __FILENAME__, __func__, __LINE__, "")
+       Test::_assert(value, expected, __FILENAME__, __func__, __LINE__, true, "")
+
+#define WARN_IF(value, expected) \
+       Test::_assert(value, expected, __FILENAME__, __func__, __LINE__, false, "")
 
 #define ASSERT_SUCCESS(value) \
-       Test::_assert(value, CSR_ERROR_NONE, __FILENAME__, __func__, __LINE__, "")
+       Test::_assert(value, CSR_ERROR_NONE, __FILENAME__, __func__, __LINE__, true, "")
+
+#define WARN_SUCCESS(value) \
+       Test::_assert(value, CSR_ERROR_NONE, __FILENAME__, __func__, __LINE__, false, "")
 
 #define ASSERT_INSTALL_APP(path, type)                       \
        BOOST_REQUIRE_MESSAGE(Test::install_app(path, type),     \
@@ -75,12 +84,19 @@ namespace Test {
 
 template <typename T, typename U>
 void _assert(const T &value, const U &expected, const std::string &filename,
-                        const std::string &funcname, unsigned int line, const std::string &msg)
+                        const std::string &funcname, unsigned int line, bool isAssert,
+                        const std::string &msg)
 {
-       BOOST_REQUIRE_MESSAGE(value == expected,
-                                                 "[" << filename << " > " << funcname << " : " << line << "]" <<
-                                                 " returned[" << value << "] expected[" << expected <<
-                                                 "] " << msg);
+       if (isAssert)
+               BOOST_REQUIRE_MESSAGE(value == expected,
+                                                         "[" << filename << " > " << funcname << " : " << line <<
+                                                         "]" << " returned[" << value << "] expected[" << expected <<
+                                                         "] " << msg);
+       else
+               BOOST_WARN_MESSAGE(value == expected,
+                                                         "[" << filename << " > " << funcname << " : " << line <<
+                                                         "]" << " returned[" << value << "] expected[" << expected <<
+                                                         "] " << msg);
 }
 
 template <>
@@ -89,6 +105,7 @@ void _assert<csr_error_e, csr_error_e>(const csr_error_e &value,
                                                                           const std::string &filename,
                                                                           const std::string &funcname,
                                                                           unsigned int line,
+                                                                          bool isAssert,
                                                                           const std::string &msg);
 
 template <>
@@ -97,6 +114,7 @@ void _assert<csr_error_e, int>(const csr_error_e &value,
                                                           const std::string &filename,
                                                           const std::string &funcname,
                                                           unsigned int line,
+                                                          bool isAssert,
                                                           const std::string &msg);
 
 template <>
@@ -105,6 +123,7 @@ void _assert<int, csr_error_e>(const int &value,
                                                           const std::string &filename,
                                                           const std::string &funcname,
                                                           unsigned int line,
+                                                          bool isAssert,
                                                           const std::string &msg);
 
 template <>
@@ -113,6 +132,7 @@ void _assert<const char *, const char *>(const char * const &value,
                                                                                 const std::string &filename,
                                                                                 const std::string &funcname,
                                                                                 unsigned int line,
+                                                                                bool isAssert,
                                                                                 const std::string &msg);
 
 template <>
@@ -121,6 +141,7 @@ void _assert<char *, const char *>(char * const &value,
                                                                   const std::string &filename,
                                                                   const std::string &funcname,
                                                                   unsigned int line,
+                                                                  bool isAssert,
                                                                   const std::string &msg);
 
 template <>
@@ -129,6 +150,7 @@ void _assert<const char *, char *>(const char * const &value,
                                                                   const std::string &filename,
                                                                   const std::string &funcname,
                                                                   unsigned int line,
+                                                                  bool isAssert,
                                                                   const std::string &msg);
 
 template <>
@@ -137,6 +159,7 @@ void _assert<char *, char *>(char * const &value,
                                                         const std::string &filename,
                                                         const std::string &funcname,
                                                         unsigned int line,
+                                                        bool isAssert,
                                                         const std::string &msg);
 
 template <>
@@ -145,6 +168,7 @@ void _assert<const char *, std::string>(const char * const &value,
                                                                                const std::string &filename,
                                                                                const std::string &funcname,
                                                                                unsigned int line,
+                                                                               bool isAssert,
                                                                                const std::string &msg);
 
 template <>
@@ -153,14 +177,22 @@ void _assert<char *, std::string>(char * const &value,
                                                                  const std::string &filename,
                                                                  const std::string &funcname,
                                                                  unsigned int line,
+                                                                 bool isAssert,
                                                                  const std::string &msg);
 
 void exceptionGuard(const std::function<void()> &);
 
+std::string capi_ec_to_string(csr_error_e ec);
+std::string capi_ec_to_string(int ec);
+
 void make_dir(const char *dir);
-void copy_file(const char *src_file, const char *dest_file);
+void make_dir_assert(const char *dir);
+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);
+void remove_file_assert(const char *file);
 bool is_file_exist(const char *file);
 bool install_app(const char *app_path, const char *app_type);
 bool uninstall_app(const char *pkg_id);
@@ -177,6 +209,27 @@ struct ScopedCstr {
        }
 };
 
+class ScopedChDir {
+public:
+       ScopedChDir(const std::string &dirpath)
+       {
+               if (::getcwd(cdbuf, PATH_MAX + 1) == nullptr)
+                       throw std::system_error(errno, std::system_category(), "getcwd failed");
+
+               if (::chdir(dirpath.c_str()) == -1)
+                       throw std::system_error(errno, std::system_category(),
+                                                                       dirpath + " chdir failed");
+       }
+
+       ~ScopedChDir()
+       {
+               ::chdir(cdbuf);
+       }
+
+private:
+       char cdbuf[PATH_MAX + 1];
+};
+
 template <typename T>
 class Context {
 public:
@@ -209,13 +262,13 @@ class Context<csr_cs_context_h> {
 public:
        Context() : m_context(nullptr)
        {
-               ASSERT_IF(csr_cs_context_create(&m_context), CSR_ERROR_NONE);
+               ASSERT_SUCCESS(csr_cs_context_create(&m_context));
                BOOST_REQUIRE(m_context != nullptr);
        }
 
        virtual ~Context()
        {
-               ASSERT_IF(csr_cs_context_destroy(m_context), CSR_ERROR_NONE);
+               ASSERT_SUCCESS(csr_cs_context_destroy(m_context));
        }
 
        csr_cs_context_h get(void) const
@@ -232,13 +285,13 @@ class Context<csr_wp_context_h> {
 public:
        Context() : m_context(nullptr)
        {
-               ASSERT_IF(csr_wp_context_create(&m_context), CSR_ERROR_NONE);
+               ASSERT_SUCCESS(csr_wp_context_create(&m_context));
                BOOST_REQUIRE(m_context != nullptr);
        }
 
        virtual ~Context()
        {
-               ASSERT_IF(csr_wp_context_destroy(m_context), CSR_ERROR_NONE);
+               ASSERT_SUCCESS(csr_wp_context_destroy(m_context));
        }
 
        csr_wp_context_h get(void) const
@@ -255,13 +308,13 @@ class Context<csre_cs_context_h> {
 public:
        Context() : m_context(nullptr)
        {
-               ASSERT_IF(csre_cs_context_create(&m_context), CSRE_ERROR_NONE);
+               ASSERT_SUCCESS(csre_cs_context_create(&m_context));
                BOOST_REQUIRE(m_context != nullptr);
        }
 
        virtual ~Context()
        {
-               ASSERT_IF(csre_cs_context_destroy(m_context), CSRE_ERROR_NONE);
+               ASSERT_SUCCESS(csre_cs_context_destroy(m_context));
        }
 
        csre_cs_context_h get(void) const
@@ -278,13 +331,13 @@ class Context<csre_wp_context_h> {
 public:
        Context() : m_context(nullptr)
        {
-               ASSERT_IF(csre_wp_context_create(&m_context), CSRE_ERROR_NONE);
+               ASSERT_SUCCESS(csre_wp_context_create(&m_context));
                BOOST_REQUIRE(m_context != nullptr);
        }
 
        virtual ~Context()
        {
-               ASSERT_IF(csre_wp_context_destroy(m_context), CSRE_ERROR_NONE);
+               ASSERT_SUCCESS(csre_wp_context_destroy(m_context));
        }
 
        csre_wp_context_h get(void) const
@@ -296,50 +349,4 @@ private:
        csre_wp_context_h m_context;
 };
 
-template <>
-class Context<csre_cs_engine_h> {
-public:
-       Context() : m_context(nullptr)
-       {
-               ASSERT_IF(csre_cs_engine_get_info(&m_context), CSRE_ERROR_NONE);
-               BOOST_REQUIRE(m_context != nullptr);
-       }
-
-       virtual ~Context()
-       {
-               ASSERT_IF(csre_cs_engine_destroy(m_context), CSRE_ERROR_NONE);
-       }
-
-       csre_cs_engine_h get(void) const
-       {
-               return m_context;
-       }
-
-private:
-       csre_cs_engine_h m_context;
-};
-
-template <>
-class Context<csre_wp_engine_h> {
-public:
-       Context() : m_context(nullptr)
-       {
-               ASSERT_IF(csre_wp_engine_get_info(&m_context), CSRE_ERROR_NONE);
-               BOOST_REQUIRE(m_context != nullptr);
-       }
-
-       virtual ~Context()
-       {
-               ASSERT_IF(csre_wp_engine_destroy(m_context), CSRE_ERROR_NONE);
-       }
-
-       csre_wp_engine_h get(void) const
-       {
-               return m_context;
-       }
-
-private:
-       csre_wp_engine_h m_context;
-};
-
 } // namespace Test