Replace std::string with Privilege class

New privileges (LICENSED/UNTRUSTED) needs to store
addtional information. Using pair of privilege and
license started to be confusing and requires a lot
of conversions. Privilege hides additional information
inside class that makes test more readable.

Change-Id: Ie5fd90e1a8077b7de1521ab1702905d7c7281eb2

diff --git a/src/security-manager-tests/common/app_def_privilege.h b/src/security-manager-tests/common/app_def_privilege.h
index db25a03..6d00972 100644 (file)
--- a/src/security-manager-tests/common/app_def_privilege.h
+++ b/src/security-manager-tests/common/app_def_privilege.h
@@ -21,6 +21,54 @@
 #include <tuple>
 
 #include <security-manager-types.h>
+#include <dpl/test/test_runner.h>
+
+class Privilege {
+public:
+    enum Type {
+        UNSET,
+        UNTRUSTED,
+        LICENSED,
+    };
+
+    Privilege(std::string systemPrivilege, Type type = UNSET, std::string license = std::string())
+      : m_name(std::move(systemPrivilege))
+      , m_type(type)
+      , m_license(std::move(license))
+    {}
+
+    Privilege(std::string licensedPrivilege, std::string license)
+      : m_name(std::move(licensedPrivilege))
+      , m_type(LICENSED)
+      , m_license(std::move(license))
+    {}
+
+    bool isUnset() const { return m_type == UNSET; }
+    bool isUntrusted() const { return m_type == UNTRUSTED; }
+    bool isLicensed() const { return m_type == LICENSED; }
+
+    int getType() const { return m_type; }
+    app_defined_privilege_type getSMType () const {
+        RUNNER_ASSERT(m_type != UNSET);
+        if (isLicensed()) return SM_APP_DEFINED_PRIVILEGE_TYPE_LICENSED;
+        return SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED;
+    }
+
+    const std::string& getName() const { return m_name; }
+    const std::string& getLicense() const { return m_license; }
+
+    const char *getNameC() const { return m_name.c_str(); }
+    const char *getLicenseC() const { return m_license.c_str(); }
+
+    operator const char *() const { return m_name.c_str(); }
+
+    operator std::string() const { return m_name; }
+
+private:
+    std::string m_name;
+    Type m_type;
+    std::string m_license;
+};
+
+typedef std::vector<Privilege> PrivilegeVector;
 
-typedef std::tuple<std::string, app_defined_privilege_type, std::string> AppDefinedPrivilege;
-typedef std::vector<AppDefinedPrivilege> AppDefinedPrivilegesVector;

diff --git a/src/security-manager-tests/common/app_install_helper.cpp b/src/security-manager-tests/common/app_install_helper.cpp
index 767be06..f1865fe 100644 (file)
--- a/src/security-manager-tests/common/app_install_helper.cpp
+++ b/src/security-manager-tests/common/app_install_helper.cpp
@@ -36,8 +36,11 @@ AppInstallHelper::AppInstallHelper(AppInstallHelper &&other)
       m_isLocal(other.m_isLocal), m_uidGid(other.m_uidGid),
       m_version(std::move(other.m_version)), m_installType(other.m_installType),
       m_isHybrid(other.m_isHybrid), m_installDir(std::move(other.m_installDir)),
-      m_dirTypeMap(std::move(other.m_dirTypeMap)), m_fileTypeMap(std::move(other.m_fileTypeMap)),
-      m_privileges(std::move(other.m_privileges)), m_author(std::move(other.m_author)),
+      m_dirTypeMap(std::move(other.m_dirTypeMap)),
+      m_fileTypeMap(std::move(other.m_fileTypeMap)),
+      m_privileges(std::move(other.m_privileges)),
+      m_appDefinedPrivileges(std::move(other.m_appDefinedPrivileges)),
+      m_author(std::move(other.m_author)),
       m_creatorPid(other.m_creatorPid)
 {
     other.m_creatorPid = -1;
@@ -141,37 +144,37 @@ bool AppInstallHelper::getIsHybrid() const {
     return m_isHybrid;
 }
 
-void AppInstallHelper::addPrivilege(const std::string &privilege) {
-    m_privileges.push_back(std::make_pair(privilege, std::string()));
-}
-
 void AppInstallHelper::addPrivileges(const std::vector<std::string> &privileges) {
-    for (auto &p : privileges)  {
-        m_privileges.push_back(std::make_pair(p, std::string()));
+    for (auto &p : privileges) {
+        addPrivilege(Privilege(p));
     }
 }
 
-std::vector<std::string> AppInstallHelper::getPrivileges() const {
+std::vector<std::string> AppInstallHelper::getPrivilegesNames() const {
     std::vector<std::string> privileges;
     for (auto &p : m_privileges) {
-        privileges.push_back(p.first);
+        privileges.push_back(p.getName());
     }
     return privileges;
 }
 
-void AppInstallHelper::addClientPrivilege(const std::pair<std::string, std::string> &privilege) {
-    m_privileges.push_back(privilege);
+void AppInstallHelper::addPrivilege(Privilege privilege) {
+    m_privileges.push_back(std::move(privilege));
+}
+
+void AppInstallHelper::addPrivileges(const PrivilegeVector &privileges) {
+    std::copy(privileges.begin(), privileges.end(), std::back_inserter(m_privileges));
 }
 
-std::vector<std::pair<std::string, std::string>> AppInstallHelper::getClientPrivileges() const {
+const PrivilegeVector& AppInstallHelper::getPrivileges() const {
     return m_privileges;
 }
 
-void AppInstallHelper::addAppDefinedPrivilege(const AppDefinedPrivilege &privilege) {
-    m_appDefinedPrivileges.push_back(privilege);
+void AppInstallHelper::addAppDefinedPrivilege(Privilege privilege) {
+    m_appDefinedPrivileges.push_back(std::move(privilege));
 }
 
-AppDefinedPrivilegesVector AppInstallHelper::getAppDefinedPrivileges() const {
+const PrivilegeVector& AppInstallHelper::getAppDefinedPrivileges() const {
     return m_appDefinedPrivileges;
 }
 

diff --git a/src/security-manager-tests/common/app_install_helper.h b/src/security-manager-tests/common/app_install_helper.h
index f59a49e..a514238 100644 (file)
--- a/src/security-manager-tests/common/app_install_helper.h
+++ b/src/security-manager-tests/common/app_install_helper.h
@@ -109,15 +109,14 @@ struct AppInstallHelper {
     const TypePathsMap& getFilesMap() const;
 
     // Privileges
-    void addPrivilege(const std::string &privilege);
-    void addPrivileges(const std::vector<std::string> &privileges);
-    std::vector<std::string> getPrivileges() const;
+    std::vector<std::string> getPrivilegesNames() const;             // deprecated
+    void addPrivileges(const std::vector<std::string> &privileges);  // deprecated
+    void addPrivilege(Privilege privilege);
+    void addPrivileges(const PrivilegeVector &privileges);
+    const PrivilegeVector& getPrivileges() const;
 
-    void addClientPrivilege(const std::pair<std::string, std::string> &privilege);
-    std::vector<std::pair<std::string, std::string>> getClientPrivileges() const;
-
-    void addAppDefinedPrivilege(const AppDefinedPrivilege &privilege);
-    AppDefinedPrivilegesVector getAppDefinedPrivileges() const;
+    void addAppDefinedPrivilege(Privilege privilege);
+    const PrivilegeVector& getAppDefinedPrivileges() const;
 
     // Smack
     std::string generateAppLabel() const;
@@ -142,8 +141,8 @@ protected:
     bool m_isInstallDirCreated;
     TypePathsMap m_dirTypeMap;
     TypePathsMap m_fileTypeMap;
-    std::vector<std::pair<std::string, std::string>> m_privileges;
-    AppDefinedPrivilegesVector m_appDefinedPrivileges;
+    PrivilegeVector m_privileges;
+    PrivilegeVector m_appDefinedPrivileges;
     std::string m_author;
 
     pid_t m_creatorPid;

diff --git a/src/security-manager-tests/common/scoped_installer.h b/src/security-manager-tests/common/scoped_installer.h
index b7a4e0c..4a0ff06 100644 (file)
--- a/src/security-manager-tests/common/scoped_installer.h
+++ b/src/security-manager-tests/common/scoped_installer.h
@@ -63,9 +63,7 @@ public:
             for (const auto& path : typePaths.second)
                 instReq.addPath(path, typePaths.first);
         for (const auto &priv : app.getPrivileges())
-            instReq.addPrivilege(priv.c_str());
-        for (const auto &priv : app.getClientPrivileges())
-            instReq.addClientPrivilege(priv);
+            instReq.addPrivilege(priv);
         for (const auto &priv : app.getAppDefinedPrivileges())
             instReq.addAppDefinedPrivilege(priv);
 

diff --git a/src/security-manager-tests/common/sm_request.cpp b/src/security-manager-tests/common/sm_request.cpp
index 2acce12..6e06150 100644 (file)
--- a/src/security-manager-tests/common/sm_request.cpp
+++ b/src/security-manager-tests/common/sm_request.cpp
@@ -84,42 +84,33 @@ void InstallRequest::setPkgId(std::string pkgId, lib_retcode expectedResult)
     m_pkgId = std::move(pkgId);
 }
 
-void InstallRequest::addPrivilege(const std::string &privilege, lib_retcode expectedResult)
-{
-    int result = security_manager_app_inst_req_add_privilege(m_req, privilege.c_str());
-    RUNNER_ASSERT_MSG((lib_retcode)result == expectedResult,
-                      "adding privilege returned wrong value."
-                          << " Privilege: " << privilege << ";"
-                          << " Result: " << result << ";"
-                          << " Expected result: " << expectedResult);
-    m_privileges.push_back(std::make_pair(privilege, std::string()));
-}
-
-void InstallRequest::addClientPrivilege(const std::pair<std::string, std::string> &privilege, lib_retcode expectedResult)
+void InstallRequest::addPrivilege(Privilege privilege, lib_retcode expectedResult)
 {
     int result = security_manager_app_inst_req_add_client_privilege(m_req,
-                                                                    privilege.first.c_str(),
-                                                                    privilege.second.c_str());
+                                                                    privilege,
+                                                                    privilege.getLicenseC());
     RUNNER_ASSERT_MSG((lib_retcode)result == expectedResult,
                       "adding privilege returned wrong value."
-                          << " Privilege: " << privilege.first << ";"
+                          << " Privilege: " << privilege.getName() << ";"
                           << " Result: " << result << ";"
                           << " Expected result: " << expectedResult);
-    m_privileges.push_back(privilege);
+    m_privileges.push_back(std::move(privilege));
 }
 
-void InstallRequest::addAppDefinedPrivilege(const AppDefinedPrivilege &privilege, lib_retcode expectedResult)
+void InstallRequest::addAppDefinedPrivilege(Privilege privilege, lib_retcode expectedResult)
 {
-    int result = security_manager_app_inst_req_add_app_defined_privilege(m_req,
-                                                                         std::get<0>(privilege).c_str(),
-                                                                         static_cast<app_defined_privilege_type>(std::get<1>(privilege)),
-                                                                         std::get<2>(privilege).c_str());
+    int result = security_manager_app_inst_req_add_app_defined_privilege(
+                    m_req,
+                    privilege,
+                    privilege.getSMType(),
+                    privilege.getLicenseC());
+
     RUNNER_ASSERT_MSG((lib_retcode)result == expectedResult,
                       "adding app defined privilege returned wrong value."
-                          << " Privilege: " << std::get<0>(privilege) << ";"
+                          << " Privilege: " << privilege.getName() << ";"
                           << " Result: " << result << ";"
                           << " Expected result: " << expectedResult);
-    m_appDefinedPrivileges.push_back(privilege);
+    m_appDefinedPrivileges.push_back(std::move(privilege));
 }
 
 void InstallRequest::addPath(std::string path, app_install_path_type pathType, lib_retcode expectedResult)
@@ -183,22 +174,24 @@ std::ostream& operator<<(std::ostream &os, const InstallRequest &request)
     if (!request.m_pkgId.empty())
         os << "pkg id: " << request.m_pkgId << "; ";
     if (!request.m_privileges.empty()) {
-        os << "privileges: [ "  << "< " << request.m_privileges[0].first << "; "
-                                        << request.m_privileges[0].second << " >";
+        os << "privileges: [ "  << "< " << request.m_privileges[0].getName() << "; "
+                                        << request.m_privileges[0].getLicense() << " >";
         for (size_t i = 1; i < request.m_privileges.size(); ++i) {
-            os << "; <" << request.m_privileges[i].first << "; "
-                        << request.m_privileges[i].second << " >";
+            os << "; <" << request.m_privileges[i].getName() << "; "
+                        << request.m_privileges[i].getLicense() << " >";
         }
         os << " ]";
     }
     if (!request.m_appDefinedPrivileges.empty()) {
-        os << "app defined privileges: [ "  << "< " << std::get<0>(request.m_appDefinedPrivileges[0]) << "; "
-                                                    << std::get<1>(request.m_appDefinedPrivileges[0]) << "; "
-                                                    << std::get<2>(request.m_appDefinedPrivileges[0]) << " >";
+        os << "app defined privileges: [ "  << "< "
+           << request.m_appDefinedPrivileges[0].getName() << "; "
+           << request.m_appDefinedPrivileges[0].getType() << "; "
+           << request.m_appDefinedPrivileges[0].getLicense() << " >";
+
         for (size_t i = 1; i < request.m_appDefinedPrivileges.size(); ++i) {
-            os << "; <" << std::get<0>(request.m_appDefinedPrivileges[i]) << "; "
-                        << std::get<1>(request.m_appDefinedPrivileges[i]) << "; "
-                        << std::get<2>(request.m_appDefinedPrivileges[i]) << " >";
+            os << "; <" << request.m_appDefinedPrivileges[i].getName() << "; "
+                        << request.m_appDefinedPrivileges[i].getType() << "; "
+                        << request.m_appDefinedPrivileges[i].getLicense() << " >";
         }
         os << " ]";
     }

diff --git a/src/security-manager-tests/common/sm_request.h b/src/security-manager-tests/common/sm_request.h
index 260fa11..7d74f64 100644 (file)
--- a/src/security-manager-tests/common/sm_request.h
+++ b/src/security-manager-tests/common/sm_request.h
@@ -59,9 +59,8 @@ public:
             lib_retcode expectedresult = SECURITY_MANAGER_SUCCESS);
     void setAppId(std::string appId, lib_retcode expectedresult = SECURITY_MANAGER_SUCCESS);
     void setPkgId(std::string pkgId, lib_retcode expectedresult = SECURITY_MANAGER_SUCCESS);
-    void addPrivilege(const std::string &privilege, lib_retcode expectedresult = SECURITY_MANAGER_SUCCESS);
-    void addClientPrivilege(const std::pair<std::string, std::string> &privilege, lib_retcode expectedresult = SECURITY_MANAGER_SUCCESS);
-    void addAppDefinedPrivilege(const AppDefinedPrivilege &privilege, lib_retcode expectedResult = SECURITY_MANAGER_SUCCESS);
+    void addPrivilege(Privilege privilege, lib_retcode expectedresult = SECURITY_MANAGER_SUCCESS);
+    void addAppDefinedPrivilege(Privilege privilege, lib_retcode expectedResult = SECURITY_MANAGER_SUCCESS);
     void addPath(std::string path, app_install_path_type pathType,
                  lib_retcode expectedResult = SECURITY_MANAGER_SUCCESS);
     void setUid(const uid_t uid, lib_retcode expectedresult = SECURITY_MANAGER_SUCCESS);
@@ -80,8 +79,8 @@ private:
     std::string m_appId;
     std::string m_pkgId;
     std::string m_authorId;
-    std::vector<std::pair<std::string, std::string>> m_privileges;
-    AppDefinedPrivilegesVector m_appDefinedPrivileges;
+    PrivilegeVector m_privileges;
+    PrivilegeVector m_appDefinedPrivileges;
     std::vector<std::pair<std::string, app_install_path_type> > m_paths;
     std::pair<bool, uid_t> m_uid;
 };

diff --git a/src/security-manager-tests/test_cases.cpp b/src/security-manager-tests/test_cases.cpp
index 54dfc93..7ecdfd2 100644 (file)
--- a/src/security-manager-tests/test_cases.cpp
+++ b/src/security-manager-tests/test_cases.cpp
@@ -172,7 +172,7 @@ RUNNER_TEST(security_manager_02_app_install_uninstall_full)
         ScopedInstaller appInstall(app);
 
         check_app_after_install(app.getAppId(), app.getPkgId(),
-                                app.getPrivileges(), someDeniedPrivs);
+                                app.getPrivilegesNames(), someDeniedPrivs);
 
         check_path(app.getPrivateDir(), generatePathRWLabel(app.getPkgId()));
         check_path(app.getPrivateRODir(), generatePathROLabel(app.getPkgId()), false);
@@ -180,7 +180,7 @@ RUNNER_TEST(security_manager_02_app_install_uninstall_full)
         check_path(app.getSharedRODir(), generatePathSharedROLabel(app.getPkgId()));
     }
 
-    check_app_after_uninstall(app.getAppId(), app.getPkgId(), app.getPrivileges());
+    check_app_after_uninstall(app.getAppId(), app.getPkgId(), app.getPrivilegesNames());
 }
 
 RUNNER_CHILD_TEST_SMACK(security_manager_03_set_label_from_appid)

diff --git a/src/security-manager-tests/test_cases_app_defined_privilege.cpp b/src/security-manager-tests/test_cases_app_defined_privilege.cpp
index 7828f8b..1c6ec5d 100644 (file)
--- a/src/security-manager-tests/test_cases_app_defined_privilege.cpp
+++ b/src/security-manager-tests/test_cases_app_defined_privilege.cpp
@@ -36,8 +36,8 @@ using namespace SecurityManagerTest;
 
 RUNNER_CHILD_TEST(app_defined_01_global_install_untrusted)
 {
-    const std::string privilege = "http://tizen.org/applicationDefinedPrivilege/app_defined_01";
-    const app_defined_privilege_type type = SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED;
+    const Privilege privilege("http://tizen.org/applicationDefinedPrivilege/app_defined_01",
+                              Privilege::UNTRUSTED);
     const std::string providerAppId = "app_def_01_provider_appid";
     const std::string consumerAppId = "app_def_01_client_appid";
     const std::string ownerId = "5001";
@@ -48,8 +48,8 @@ RUNNER_CHILD_TEST(app_defined_01_global_install_untrusted)
 
     std::string consumerLabel = consumer.generateAppLabel();
 
-    provider.addAppDefinedPrivilege(std::make_tuple(privilege, type, ""));
-    consumer.addClientPrivilege(std::make_pair(privilege, ""));
+    provider.addAppDefinedPrivilege(privilege);
+    consumer.addPrivilege(privilege);
 
     ScopedInstaller req1(provider);
     ScopedInstaller req2(consumer);
@@ -65,9 +65,8 @@ RUNNER_CHILD_TEST(app_defined_01_global_install_untrusted)
 
 RUNNER_CHILD_TEST(app_defined_02_global_install_licensed)
 {
-    const std::string privilege = "http://tizen.org/licensedPrivilege/app_defined_02";
-    const app_defined_privilege_type type = SM_APP_DEFINED_PRIVILEGE_TYPE_LICENSED;
-    const std::string license = "/opt/data/app_defined_02/res/license";
+    const Privilege privilege("http://tizen.org/licensedPrivilege/app_defined_02",
+                              "/opt/data/app_defined_02/res/license");
     const std::string providerAppId = "app_def_02_provider_appid";
     const std::string consumerAppId = "app_def_02_client_appid";
     const std::string ownerId = "5001";
@@ -78,8 +77,8 @@ RUNNER_CHILD_TEST(app_defined_02_global_install_licensed)
 
     std::string consumerLabel = consumer.generateAppLabel();
 
-    provider.addAppDefinedPrivilege(std::make_tuple(privilege, type, license));
-    consumer.addClientPrivilege(std::make_pair(privilege, license));
+    provider.addAppDefinedPrivilege(privilege);
+    consumer.addPrivilege(privilege);
 
     ScopedInstaller req1(provider);
     ScopedInstaller req2(consumer);
@@ -98,11 +97,10 @@ RUNNER_CHILD_TEST(app_defined_03_database_update)
     // Because of a bug in implementation during installation of
     // providerB privileges of providerA were deleted from cynara
     // database. This test should check if bug was fixed.
-    const std::string privilegeA = "http://tizen.org/licensedPrivilege/app_defined_03a";
-    const std::string privilegeB = "http://tizen.org/licensedPrivilege/app_defined_03b";
-    const app_defined_privilege_type type = SM_APP_DEFINED_PRIVILEGE_TYPE_LICENSED;
-    const std::string licenseA = "/opt/data/app_defined_03a/res/license";
-    const std::string licenseB = "/opt/data/app_defined_03b/res/license";
+    Privilege privilegeA("http://tizen.org/licensedPrivilege/app_defined_03a",
+                         "/opt/data/app_defined_03a/res/license");
+    Privilege privilegeB("http://tizen.org/licensedPrivilege/app_defined_03b",
+                         "/opt/data/app_defined_03b/res/license");
     const std::string providerAppIdA = "app_def_03a_provider_appid";
     const std::string providerAppIdB = "app_def_03b_provider_appid";
     const std::string consumerAppId = "app_def_03_client_appid";
@@ -115,10 +113,10 @@ RUNNER_CHILD_TEST(app_defined_03_database_update)
 
     std::string consumerLabel = consumer.generateAppLabel();
 
-    providerA.addAppDefinedPrivilege(std::make_tuple(privilegeA, type, licenseA));
-    providerB.addAppDefinedPrivilege(std::make_tuple(privilegeB, type, licenseB));
-    consumer.addClientPrivilege(std::make_pair(privilegeA, licenseA));
-    consumer.addClientPrivilege(std::make_pair(privilegeB, licenseB));
+    providerA.addAppDefinedPrivilege(privilegeA);
+    providerB.addAppDefinedPrivilege(privilegeB);
+    consumer.addPrivilege(privilegeA);
+    consumer.addPrivilege(privilegeB);
 
     ScopedInstaller req1(providerA);
     ScopedInstaller req2(providerB);
@@ -143,11 +141,12 @@ RUNNER_CHILD_TEST(app_defined_03_database_update)
 
 RUNNER_CHILD_TEST(app_defined_04_app_update)
 {
-    const std::string privilegeA = "http://tizen.org/licensedPrivilege/app_defined_04a";
-    const std::string privilegeB = "http://tizen.org/applicationDefinedPrivilege/app_defined_04b";
-    const std::string privilegeC = "http://tizen.org/licensedPrivilege/app_defined_04c";
-    const std::string licenseA = "/opt/data/app_defined_04a/res/license";
-    const std::string licenseC = "/opt/data/app_defined_04c/res/license";
+    const Privilege privilegeA("http://tizen.org/licensedPrivilege/app_defined_04a",
+                               "/opt/data/app_defined_04a/res/license");
+    const Privilege privilegeB("http://tizen.org/applicationDefinedPrivilege/app_defined_04b",
+                               Privilege::UNTRUSTED);
+    const Privilege privilegeC("http://tizen.org/licensedPrivilege/app_defined_04c",
+                               "/opt/data/app_defined_04c/res/license");
     const std::string providerAppId = "app_def_04_provider_appid";
     const std::string consumerAppId = "app_def_04_client_appid";
     const std::string ownerId = "5001";
@@ -159,15 +158,11 @@ RUNNER_CHILD_TEST(app_defined_04_app_update)
 
     std::string consumerLabel = consumer.generateAppLabel();
 
-    providerV1.addAppDefinedPrivilege(std::make_tuple(privilegeA,
-                                                      SM_APP_DEFINED_PRIVILEGE_TYPE_LICENSED,
-                                                      licenseA));
-    providerV1.addAppDefinedPrivilege(std::make_tuple(privilegeB,
-                                                      SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED,
-                                                      ""));
-    consumer.addClientPrivilege(std::make_pair(privilegeA, licenseA));
-    consumer.addClientPrivilege(std::make_pair(privilegeB, ""));
-    consumer.addClientPrivilege(std::make_pair(privilegeC, licenseC));
+    providerV1.addAppDefinedPrivilege(privilegeA);
+    providerV1.addAppDefinedPrivilege(privilegeB);
+    consumer.addPrivilege(privilegeA);
+    consumer.addPrivilege(privilegeB);
+    consumer.addPrivilege(privilegeC);
 
     ScopedInstaller req1(providerV1);
     ScopedInstaller req2(consumer);
@@ -178,12 +173,9 @@ RUNNER_CHILD_TEST(app_defined_04_app_update)
     cynara.check(consumerLabel, session, ownerId, privilegeC, CYNARA_API_ACCESS_DENIED);
 
     // update provider version, remove privilegeA, add privilegeC
-    providerV2.addAppDefinedPrivilege(std::make_tuple(privilegeB,
-                                                      SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED,
-                                                      ""));
-    providerV2.addAppDefinedPrivilege(std::make_tuple(privilegeC,
-                                                      SM_APP_DEFINED_PRIVILEGE_TYPE_LICENSED,
-                                                      licenseC));
+    providerV2.addAppDefinedPrivilege(privilegeB);
+    providerV2.addAppDefinedPrivilege(privilegeC);
+
     ScopedInstaller req3(providerV2);
 
     cynara.check(consumerLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_DENIED);
@@ -193,10 +185,12 @@ RUNNER_CHILD_TEST(app_defined_04_app_update)
 
 RUNNER_CHILD_TEST(app_defined_05_global_local_install)
 {
-    const std::string privilegeA = "http://tizen.org/licensedPrivilege/app_defined_05a";
-    const std::string privilegeB = "http://tizen.org/applicationDefinedPrivilege/app_defined_05b";
-    const std::string privilegeC = "http://tizen.org/applicationDefinedPrivilege/app_defined_05c";
-    const std::string licenseB = "/opt/data/app_defined_05b/res/license";
+    const Privilege privilegeA("http://tizen.org/licensedPrivilege/app_defined_05a",
+                               Privilege::UNTRUSTED);
+    const Privilege privilegeB("http://tizen.org/applicationDefinedPrivilege/app_defined_05b",
+                               "/opt/data/app_defined_05b/res/license");
+    const Privilege privilegeC("http://tizen.org/applicationDefinedPrivilege/app_defined_05c",
+                               Privilege::UNTRUSTED);
     const std::string providerAppId = "app_def_05_provider_appid";
     const std::string consumerAppId = "app_def_05_client_appid";
     const std::string ownerId = "5001";
@@ -211,26 +205,17 @@ RUNNER_CHILD_TEST(app_defined_05_global_local_install)
     std::string consumerGlobalLabel = consumerGlobal.generateAppLabel();
     std::string consumerLocalLabel = consumerLocal.generateAppLabel();
 
-    providerGlobal.addAppDefinedPrivilege(std::make_tuple(privilegeA,
-                                                          SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED,
-                                                          ""));
-    providerGlobal.addAppDefinedPrivilege(std::make_tuple(privilegeC,
-                                                          SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED,
-                                                          ""));
-
-    providerLocal.addAppDefinedPrivilege(std::make_tuple(privilegeA,
-                                                         SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED,
-                                                         ""));
-    providerLocal.addAppDefinedPrivilege(std::make_tuple(privilegeB,
-                                                         SM_APP_DEFINED_PRIVILEGE_TYPE_LICENSED,
-                                                         licenseB));
+    providerGlobal.addAppDefinedPrivilege(privilegeA);
+    providerGlobal.addAppDefinedPrivilege(privilegeC);
+    providerLocal.addAppDefinedPrivilege(privilegeA);
+    providerLocal.addAppDefinedPrivilege(privilegeB);
 
-    consumerGlobal.addClientPrivilege(std::make_pair(privilegeA, ""));
-    consumerGlobal.addClientPrivilege(std::make_pair(privilegeB, licenseB));
-    consumerGlobal.addClientPrivilege(std::make_pair(privilegeC, ""));
+    consumerGlobal.addPrivilege(privilegeA);
+    consumerGlobal.addPrivilege(privilegeB);
+    consumerGlobal.addPrivilege(privilegeC);
 
-    consumerLocal.addClientPrivilege(std::make_pair(privilegeB, licenseB));
-    consumerLocal.addClientPrivilege(std::make_pair(privilegeC, ""));
+    consumerLocal.addPrivilege(privilegeB);
+    consumerLocal.addPrivilege(privilegeC);
 
     CynaraTestClient::Client cynara;
 
@@ -280,16 +265,17 @@ RUNNER_CHILD_TEST(app_defined_06_get_provider)
     int result;
     char *pkgId = nullptr;
     char *appId = nullptr;
-    const std::string privilegeA = "http://tizen.org/applicationDefinedPrivilege/app_defined_06a";
-    const std::string privilegeB = "http://tizen.org/applicationDefinedPrivilege/app_defined_06b";
-    const app_defined_privilege_type type = SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED;
+    const Privilege privilegeA("http://tizen.org/applicationDefinedPrivilege/app_defined_06a",
+                               Privilege::UNTRUSTED);
+    const Privilege privilegeB("http://tizen.org/applicationDefinedPrivilege/app_defined_06b",
+                               Privilege::UNTRUSTED);
     const std::string providerId = "app_def_06_provider";
     uid_t uid = 5001;
 
     AppInstallHelper providerGlobal(providerId);
     AppInstallHelper providerLocal(providerId, uid);
-    providerGlobal.addAppDefinedPrivilege(std::make_tuple(privilegeB, type, ""));
-    providerLocal.addAppDefinedPrivilege(std::make_tuple(privilegeA, type, ""));
+    providerGlobal.addAppDefinedPrivilege(privilegeB);
+    providerLocal.addAppDefinedPrivilege(privilegeA);
     ScopedInstaller req1(providerGlobal);
     ScopedInstaller req2(providerLocal);
 
@@ -299,31 +285,31 @@ RUNNER_CHILD_TEST(app_defined_06_get_provider)
     RUNNER_ASSERT(appId == nullptr);
     RUNNER_ASSERT(pkgId == nullptr);
 
-    result = security_manager_get_app_defined_privilege_provider(privilegeA.c_str(),
+    result = security_manager_get_app_defined_privilege_provider(privilegeA,
                                                                  uid+1, &pkgId, &appId);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
     RUNNER_ASSERT(appId == nullptr);
     RUNNER_ASSERT(pkgId == nullptr);
 
-    result = security_manager_get_app_defined_privilege_provider(privilegeA.c_str(),
+    result = security_manager_get_app_defined_privilege_provider(privilegeA,
                                                                  uid, nullptr, nullptr);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
 
-    result = security_manager_get_app_defined_privilege_provider(privilegeA.c_str(),
+    result = security_manager_get_app_defined_privilege_provider(privilegeA,
                                                                  uid, &pkgId, nullptr);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider failed");
     RUNNER_ASSERT(pkgId && std::string(pkgId) == providerLocal.getPkgId());
     free(pkgId);
     pkgId = nullptr;
 
-    result = security_manager_get_app_defined_privilege_provider(privilegeA.c_str(),
+    result = security_manager_get_app_defined_privilege_provider(privilegeA,
                                                                  uid, nullptr, &appId);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider failed");
     RUNNER_ASSERT(appId && std::string(appId) == providerLocal.getAppId());
     free(appId);
     appId = nullptr;
 
-    result = security_manager_get_app_defined_privilege_provider(privilegeA.c_str(),
+    result = security_manager_get_app_defined_privilege_provider(privilegeA,
                                                                  uid, &pkgId, &appId);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider failed");
     RUNNER_ASSERT(appId && std::string(appId) == providerLocal.getAppId());
@@ -333,7 +319,7 @@ RUNNER_CHILD_TEST(app_defined_06_get_provider)
     appId = nullptr;
     pkgId = nullptr;
 
-    result = security_manager_get_app_defined_privilege_provider(privilegeB.c_str(),
+    result = security_manager_get_app_defined_privilege_provider(privilegeB,
                                                                  uid, &pkgId, &appId);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider failed");
     RUNNER_ASSERT(appId && std::string(appId) == providerGlobal.getAppId());
@@ -348,23 +334,23 @@ RUNNER_CHILD_TEST(app_defined_07_get_provider_license)
 {
     int result;
     char *license = nullptr;
-    const std::string privilegeA = "http://tizen.org/applicationDefinedPrivilege/app_defined_07a";
-    const std::string privilegeB = "http://tizen.org/applicationDefinedPrivilege/app_defined_07b";
-    const std::string privilegeC = "http://tizen.org/applicationDefinedPrivilege/app_defined_07c";
-    const std::string licenseA = "/opt/data/app_defined_07a/res/license";
-    const std::string licenseB = "/opt/data/app_defined_07b/res/license";
-    const std::string licenseC = "/opt/data/app_defined_07c/res/license";
-    const app_defined_privilege_type licensed = SM_APP_DEFINED_PRIVILEGE_TYPE_LICENSED;
-    const app_defined_privilege_type untrusted = SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED;
+    const Privilege privilegeA("http://tizen.org/applicationDefinedPrivilege/app_defined_07a",
+                               "/opt/data/app_defined_07a/res/license");
+    const Privilege privilegeB("http://tizen.org/applicationDefinedPrivilege/app_defined_07b",
+                               "/opt/data/app_defined_07b/res/license");
+    const Privilege privilegeC("http://tizen.org/applicationDefinedPrivilege/app_defined_07c",
+                               "/opt/data/app_defined_07c/res/license");
+    const Privilege privilegeCuntrusted(privilegeC.getName(), Privilege::UNTRUSTED);
     const std::string providerId = "app_def_07_provider";
     uid_t uid = 5001;
 
     AppInstallHelper providerGlobal(providerId);
     AppInstallHelper providerLocal(providerId, uid);
-    providerGlobal.addAppDefinedPrivilege(std::make_tuple(privilegeB, licensed, licenseB));
-    providerGlobal.addAppDefinedPrivilege(std::make_tuple(privilegeC, licensed, licenseC));
-    providerLocal.addAppDefinedPrivilege(std::make_tuple(privilegeA, licensed, licenseA));
-    providerLocal.addAppDefinedPrivilege(std::make_tuple(privilegeC, untrusted, ""));
+    providerGlobal.addAppDefinedPrivilege(privilegeB);
+    providerGlobal.addAppDefinedPrivilege(privilegeC);
+    providerLocal.addAppDefinedPrivilege(privilegeA);
+    providerLocal.addAppDefinedPrivilege(privilegeCuntrusted);
+
     ScopedInstaller req1(providerGlobal);
     ScopedInstaller req2(providerLocal);
 
@@ -372,37 +358,37 @@ RUNNER_CHILD_TEST(app_defined_07_get_provider_license)
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
     RUNNER_ASSERT(license == nullptr);
 
-    result = security_manager_get_app_defined_privilege_license(privilegeA.c_str(), uid, nullptr);
+    result = security_manager_get_app_defined_privilege_license(privilegeA, uid, nullptr);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
 
     result = security_manager_get_app_defined_privilege_license("noExistingPrivilege", uid, &license);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
     RUNNER_ASSERT(license == nullptr);
 
-    result = security_manager_get_app_defined_privilege_license(privilegeC.c_str(), uid, &license);
+    result = security_manager_get_app_defined_privilege_license(privilegeC, uid, &license);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
     RUNNER_ASSERT(license == nullptr);
 
-    result = security_manager_get_app_defined_privilege_license(privilegeA.c_str(), uid+1, &license);
+    result = security_manager_get_app_defined_privilege_license(privilegeA, uid+1, &license);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
     RUNNER_ASSERT(license == nullptr);
 
-    result = security_manager_get_app_defined_privilege_license(privilegeB.c_str(), uid, &license);
+    result = security_manager_get_app_defined_privilege_license(privilegeB, uid, &license);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider license failed");
-    RUNNER_ASSERT(license && std::string(license) == licenseB);
+    RUNNER_ASSERT(license && privilegeB.getLicense() == license);
     free(license);
     license = nullptr;
 
-    result = security_manager_get_app_defined_privilege_license(privilegeA.c_str(), uid, &license);
+    result = security_manager_get_app_defined_privilege_license(privilegeA, uid, &license);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider license failed");
-    RUNNER_ASSERT(license && std::string(license) == licenseA);
+    RUNNER_ASSERT(license && privilegeA.getLicense() == license);
     free(license);
     license = nullptr;
 
     req2.uninstallApp();
-    result = security_manager_get_app_defined_privilege_license(privilegeC.c_str(), uid, &license);
+    result = security_manager_get_app_defined_privilege_license(privilegeC, uid, &license);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider license failed");
-    RUNNER_ASSERT(license && std::string(license) == licenseC);
+    RUNNER_ASSERT(license && privilegeC.getLicense() == license);
     free(license);
     license = nullptr;
 }
@@ -411,21 +397,24 @@ RUNNER_CHILD_TEST(app_defined_08_add_get_client_license)
 {
     int result;
     char *license = nullptr;
-    const std::string privilegeA = "http://tizen.org/applicationDefinedPrivilege/app_defined_08a";
-    const std::string privilegeB = "http://tizen.org/applicationDefinedPrivilege/app_defined_08b";
-    const std::string privilegeC = "http://tizen.org/applicationDefinedPrivilege/app_defined_08c";
-    const std::string licenseA = "/opt/data/app_defined_08a/res/license";
-    const std::string licenseB = "/opt/data/app_defined_08b/res/license";
-    const std::string licenseC = "/opt/data/app_defined_08c/res/license";
+
+    const Privilege privilegeA("http://tizen.org/applicationDefinedPrivilege/app_defined_08a",
+                               "/opt/data/app_defined_08a/res/license");
+    const Privilege privilegeB("http://tizen.org/applicationDefinedPrivilege/app_defined_08b",
+                               "/opt/data/app_defined_08b/res/license");
+    const Privilege privilegeC("http://tizen.org/applicationDefinedPrivilege/app_defined_08c",
+                               "/opt/data/app_defined_08c/res/license");
+    const Privilege privilegeCunset(privilegeC.getName(), Privilege::UNTRUSTED);
+
     const std::string clientId = "app_def_08_client";
     uid_t uid = 5001;
 
     AppInstallHelper clientGlobal(clientId);
     AppInstallHelper clientLocal(clientId, uid);
-    clientGlobal.addClientPrivilege(std::make_pair(privilegeB, licenseB));
-    clientGlobal.addClientPrivilege(std::make_pair(privilegeC, licenseC));
-    clientLocal.addClientPrivilege(std::make_pair(privilegeA, licenseA));
-    clientLocal.addClientPrivilege(std::make_pair(privilegeC, ""));
+    clientGlobal.addPrivilege(privilegeB);
+    clientGlobal.addPrivilege(privilegeC);
+    clientLocal.addPrivilege(privilegeA);
+    clientLocal.addPrivilege(privilegeCunset);
     ScopedInstaller req1(clientGlobal);
     ScopedInstaller req2(clientLocal);
 
@@ -435,12 +424,12 @@ RUNNER_CHILD_TEST(app_defined_08_add_get_client_license)
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
     RUNNER_ASSERT(license == nullptr);
 
-    result = security_manager_get_client_privilege_license(privilegeA.c_str(), nullptr,
+    result = security_manager_get_client_privilege_license(privilegeA, nullptr,
                                                            uid, &license);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
     RUNNER_ASSERT(license == nullptr);
 
-    result = security_manager_get_client_privilege_license(privilegeA.c_str(),
+    result = security_manager_get_client_privilege_license(privilegeA,
                                                            clientLocal.getAppId().c_str(),
                                                            uid, nullptr);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
@@ -451,37 +440,37 @@ RUNNER_CHILD_TEST(app_defined_08_add_get_client_license)
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
     RUNNER_ASSERT(license == nullptr);
 
-    result = security_manager_get_client_privilege_license(privilegeA.c_str(), "noExistingApp",
+    result = security_manager_get_client_privilege_license(privilegeA, "noExistingApp",
                                                            uid, &license);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
     RUNNER_ASSERT(license == nullptr);
 
-    result = security_manager_get_client_privilege_license(privilegeC.c_str(),
+    result = security_manager_get_client_privilege_license(privilegeC,
                                                            clientLocal.getAppId().c_str(),
                                                            uid, &license);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
     RUNNER_ASSERT(license == nullptr);
 
-    result = security_manager_get_client_privilege_license(privilegeA.c_str(),
+    result = security_manager_get_client_privilege_license(privilegeA,
                                                            clientLocal.getAppId().c_str(),
                                                            uid+1, &license);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
     RUNNER_ASSERT(license == nullptr);
 
-    result = security_manager_get_client_privilege_license(privilegeA.c_str(),
+    result = security_manager_get_client_privilege_license(privilegeA,
                                                            clientLocal.getAppId().c_str(),
                                                            uid, &license);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege license failed");
-    RUNNER_ASSERT(license && std::string(license) == licenseA);
+    RUNNER_ASSERT(license && privilegeA.getLicense() == license);
     free(license);
     license = nullptr;
 
     req2.uninstallApp();
-    result = security_manager_get_client_privilege_license(privilegeB.c_str(),
+    result = security_manager_get_client_privilege_license(privilegeB,
                                                            clientGlobal.getAppId().c_str(),
                                                            uid, &license);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege license failed");
-    RUNNER_ASSERT(license && std::string(license) == licenseB);
+    RUNNER_ASSERT(license && privilegeB.getLicense() == license);
     free(license);
     license = nullptr;
 }

diff --git a/src/security-manager-tests/test_cases_privacy_manager.cpp b/src/security-manager-tests/test_cases_privacy_manager.cpp
index 58d1b63..99faed9 100644 (file)
--- a/src/security-manager-tests/test_cases_privacy_manager.cpp
+++ b/src/security-manager-tests/test_cases_privacy_manager.cpp
@@ -95,11 +95,11 @@ const std::vector<Privileges> TEST_PRIVACY_PRIVILEGES = {
     }
 };
 
-bool isPrivilegePrivacy(const std::string &priv) {
-    return (1 == privilege_info_is_privacy(priv.c_str()));
+bool isPrivilegePrivacy(const Privilege &priv) {
+    return (1 == privilege_info_is_privacy(priv));
 }
 
-int countPrivacyPrivileges(const Privileges &privs) {
+int countPrivacyPrivileges(const PrivilegeVector &privs) {
     return std::count_if(privs.begin(), privs.end(), isPrivilegePrivacy);
 }
 
@@ -160,7 +160,7 @@ RUNNER_CHILD_TEST(security_manager_10_privacy_manager_fetch_whole_policy_for_sel
             RUNNER_ASSERT_MSG(appIt != appIdToAIH.end(), "Policy returned unexpected app: " << app);
 
             AppInstallHelper &aih = appIt->second;
-            auto appPrivileges = aih.getPrivileges();
+            auto appPrivileges = aih.getPrivilegesNames();
             auto privIt = std::find(appPrivileges.begin(), appPrivileges.end(), privilege);
             RUNNER_ASSERT_MSG(privIt != appPrivileges.end(),
                               "Unexpected privilege " << privilege << " for app " << app);
@@ -241,7 +241,7 @@ RUNNER_CHILD_TEST(security_manager_11_privacy_manager_fetch_whole_policy_for_adm
             AppInstallHelper &aih = userAppIdToAIHIt->second;
             auto privs = aih.getPrivileges();
 
-            auto appPrivileges = aih.getPrivileges();
+            auto appPrivileges = aih.getPrivilegesNames();
             auto privIt = std::find(appPrivileges.begin(), appPrivileges.end(), privilege);
             RUNNER_ASSERT_MSG(privIt != appPrivileges.end(),
                               "Unexpected privilege " << privilege << " for app " << app);
@@ -333,7 +333,7 @@ RUNNER_CHILD_TEST(security_manager_12_privacy_manager_fetch_whole_policy_for_adm
             AppInstallHelper &aih = userAppIdToAIHIt->second;
             auto privs = aih.getPrivileges();
 
-            auto appPrivileges = aih.getPrivileges();
+            auto appPrivileges = aih.getPrivilegesNames();
             auto privIt = std::find(appPrivileges.begin(), appPrivileges.end(), privilege);
             RUNNER_ASSERT_MSG(privIt != appPrivileges.end(),
                               "Unexpected privilege " << privilege << " for app " << app);
@@ -962,11 +962,11 @@ RUNNER_CHILD_TEST(security_manager_20_privacy_manager_privacy_related_privileges
     for (auto &priv : app.getPrivileges()) {
         if (PolicyConfiguration::getIsAskuserEnabled() && isPrivilegePrivacy(priv)) {
             admin.adminCheck("", true, app.generateAppLabel().c_str(),
-                             user.getUidString().c_str(), priv.c_str(), privacyPolicyType,
+                             user.getUidString().c_str(), priv, privacyPolicyType,
                              nullptr);
         } else {
             admin.adminCheck("", true, app.generateAppLabel().c_str(),
-                             user.getUidString().c_str(), priv.c_str(), policyType, nullptr);
+                             user.getUidString().c_str(), priv, policyType, nullptr);
         }
     }
 }