Adjust tests to API change

Change-Id: I80bf8674e371793af0ba28db57e35bb10e69520f

diff --git a/src/security-manager-tests/common/app_def_privilege.h b/src/security-manager-tests/common/app_def_privilege.h
index cbc626d..db25a03 100644 (file)
--- a/src/security-manager-tests/common/app_def_privilege.h
+++ b/src/security-manager-tests/common/app_def_privilege.h
@@ -18,9 +18,9 @@
 #include <string>
 #include <utility>
 #include <vector>
+#include <tuple>
 
 #include <security-manager-types.h>
 
-typedef std::pair<std::string, app_defined_privilege_type> AppDefPrivilege;
-typedef std::vector<AppDefPrivilege> AppDefPrivilegeVector;
-
+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 edd5a2a..767be06 100644 (file)
--- a/src/security-manager-tests/common/app_install_helper.cpp
+++ b/src/security-manager-tests/common/app_install_helper.cpp
@@ -142,22 +142,36 @@ bool AppInstallHelper::getIsHybrid() const {
 }
 
 void AppInstallHelper::addPrivilege(const std::string &privilege) {
-    m_privileges.push_back(privilege);
+    m_privileges.push_back(std::make_pair(privilege, std::string()));
 }
 
 void AppInstallHelper::addPrivileges(const std::vector<std::string> &privileges) {
-    std::copy(privileges.begin(), privileges.end(), std::back_inserter(m_privileges));
+    for (auto &p : privileges)  {
+        m_privileges.push_back(std::make_pair(p, std::string()));
+    }
 }
 
 std::vector<std::string> AppInstallHelper::getPrivileges() const {
+    std::vector<std::string> privileges;
+    for (auto &p : m_privileges) {
+        privileges.push_back(p.first);
+    }
+    return privileges;
+}
+
+void AppInstallHelper::addClientPrivilege(const std::pair<std::string, std::string> &privilege) {
+    m_privileges.push_back(privilege);
+}
+
+std::vector<std::pair<std::string, std::string>> AppInstallHelper::getClientPrivileges() const {
     return m_privileges;
 }
 
-void AppInstallHelper::addAppDefinedPrivilege(const AppDefPrivilege &privilege) {
+void AppInstallHelper::addAppDefinedPrivilege(const AppDefinedPrivilege &privilege) {
     m_appDefinedPrivileges.push_back(privilege);
 }
 
-AppDefPrivilegeVector AppInstallHelper::getAppDefinedPrivileges() const {
+AppDefinedPrivilegesVector 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 1150ecc..f59a49e 100644 (file)
--- a/src/security-manager-tests/common/app_install_helper.h
+++ b/src/security-manager-tests/common/app_install_helper.h
@@ -113,8 +113,11 @@ struct AppInstallHelper {
     void addPrivileges(const std::vector<std::string> &privileges);
     std::vector<std::string> getPrivileges() const;
 
-    void addAppDefinedPrivilege(const AppDefPrivilege &privilege);
-    AppDefPrivilegeVector getAppDefinedPrivileges() 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;
 
     // Smack
     std::string generateAppLabel() const;
@@ -139,8 +142,8 @@ protected:
     bool m_isInstallDirCreated;
     TypePathsMap m_dirTypeMap;
     TypePathsMap m_fileTypeMap;
-    std::vector<std::string> m_privileges;
-    AppDefPrivilegeVector m_appDefinedPrivileges;
+    std::vector<std::pair<std::string, std::string>> m_privileges;
+    AppDefinedPrivilegesVector 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 1856ec9..b7a4e0c 100644 (file)
--- a/src/security-manager-tests/common/scoped_installer.h
+++ b/src/security-manager-tests/common/scoped_installer.h
@@ -64,6 +64,8 @@ public:
                 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);
         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 61ead51..2acce12 100644 (file)
--- a/src/security-manager-tests/common/sm_request.cpp
+++ b/src/security-manager-tests/common/sm_request.cpp
@@ -92,16 +92,31 @@ void InstallRequest::addPrivilege(const std::string &privilege, lib_retcode expe
                           << " 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)
+{
+    int result = security_manager_app_inst_req_add_client_privilege(m_req,
+                                                                    privilege.first.c_str(),
+                                                                    privilege.second.c_str());
+    RUNNER_ASSERT_MSG((lib_retcode)result == expectedResult,
+                      "adding privilege returned wrong value."
+                          << " Privilege: " << privilege.first << ";"
+                          << " Result: " << result << ";"
+                          << " Expected result: " << expectedResult);
     m_privileges.push_back(privilege);
 }
 
-void InstallRequest::addAppDefinedPrivilege(const AppDefPrivilege &privilege, lib_retcode expectedResult)
+void InstallRequest::addAppDefinedPrivilege(const AppDefinedPrivilege &privilege, lib_retcode expectedResult)
 {
-    int result = security_manager_app_inst_req_add_app_defined_privilege(m_req, privilege.first.c_str(),
-                                                                         static_cast<app_defined_privilege_type>(privilege.second));
+    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());
     RUNNER_ASSERT_MSG((lib_retcode)result == expectedResult,
                       "adding app defined privilege returned wrong value."
-                          << " Privilege: " << privilege.first << ";"
+                          << " Privilege: " << std::get<0>(privilege) << ";"
                           << " Result: " << result << ";"
                           << " Expected result: " << expectedResult);
     m_appDefinedPrivileges.push_back(privilege);
@@ -168,18 +183,22 @@ 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];
-        for (size_t i=1; i < request.m_privileges.size(); ++i) {
-            os << "; " << request.m_privileges[i];
+        os << "privileges: [ "  << "< " << request.m_privileges[0].first << "; "
+                                        << request.m_privileges[0].second << " >";
+        for (size_t i = 1; i < request.m_privileges.size(); ++i) {
+            os << "; <" << request.m_privileges[i].first << "; "
+                        << request.m_privileges[i].second << " >";
         }
         os << " ]";
     }
     if (!request.m_appDefinedPrivileges.empty()) {
-        os << "app defined privileges: [ "  << "< " << request.m_appDefinedPrivileges[0].first << "; "
-                                                    << request.m_appDefinedPrivileges[0].second << " >";
+        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]) << " >";
         for (size_t i = 1; i < request.m_appDefinedPrivileges.size(); ++i) {
-            os << "; <" << request.m_appDefinedPrivileges[i].first << "; "
-                        << request.m_appDefinedPrivileges[i].second << " >";
+            os << "; <" << std::get<0>(request.m_appDefinedPrivileges[i]) << "; "
+                        << std::get<1>(request.m_appDefinedPrivileges[i]) << "; "
+                        << std::get<2>(request.m_appDefinedPrivileges[i]) << " >";
         }
         os << " ]";
     }

diff --git a/src/security-manager-tests/common/sm_request.h b/src/security-manager-tests/common/sm_request.h
index cb7e97c..260fa11 100644 (file)
--- a/src/security-manager-tests/common/sm_request.h
+++ b/src/security-manager-tests/common/sm_request.h
@@ -60,7 +60,8 @@ public:
     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 addAppDefinedPrivilege(const AppDefPrivilege &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 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);
@@ -79,8 +80,8 @@ private:
     std::string m_appId;
     std::string m_pkgId;
     std::string m_authorId;
-    std::vector<std::string> m_privileges;
-    AppDefPrivilegeVector m_appDefinedPrivileges;
+    std::vector<std::pair<std::string, std::string>> m_privileges;
+    AppDefinedPrivilegesVector 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_app_defined_privilege.cpp b/src/security-manager-tests/test_cases_app_defined_privilege.cpp
index c681d1a..a652243 100644 (file)
--- a/src/security-manager-tests/test_cases_app_defined_privilege.cpp
+++ b/src/security-manager-tests/test_cases_app_defined_privilege.cpp
@@ -48,8 +48,8 @@ RUNNER_CHILD_TEST(app_defined_01_global_install_untrusted)
 
     std::string consumerLabel = consumer.generateAppLabel();
 
-    provider.addAppDefinedPrivilege(std::make_pair(privilege, type));
-    consumer.addPrivilege(privilege);
+    provider.addAppDefinedPrivilege(std::make_tuple(privilege, type, ""));
+    consumer.addClientPrivilege(std::make_pair(privilege, ""));
 
     ScopedInstaller req1(provider);
     ScopedInstaller req2(consumer);
@@ -67,6 +67,7 @@ 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 std::string providerAppId = "app_def_02_provider_appid";
     const std::string consumerAppId = "app_def_02_client_appid";
     const std::string ownerId = "5001";
@@ -77,8 +78,8 @@ RUNNER_CHILD_TEST(app_defined_02_global_install_licensed)
 
     std::string consumerLabel = consumer.generateAppLabel();
 
-    provider.addAppDefinedPrivilege(std::make_pair(privilege, type));
-    consumer.addPrivilege(privilege);
+    provider.addAppDefinedPrivilege(std::make_tuple(privilege, type, license));
+    consumer.addClientPrivilege(std::make_pair(privilege, license));
 
     ScopedInstaller req1(provider);
     ScopedInstaller req2(consumer);
@@ -100,6 +101,8 @@ RUNNER_CHILD_TEST(app_defined_03_database_update)
     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";
     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";
@@ -112,10 +115,10 @@ RUNNER_CHILD_TEST(app_defined_03_database_update)
 
     std::string consumerLabel = consumer.generateAppLabel();
 
-    providerA.addAppDefinedPrivilege(std::make_pair(privilegeA, type));
-    providerB.addAppDefinedPrivilege(std::make_pair(privilegeB, type));
-    consumer.addPrivilege(privilegeA);
-    consumer.addPrivilege(privilegeB);
+    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));
 
     ScopedInstaller req1(providerA);
     ScopedInstaller req2(providerB);
@@ -143,6 +146,8 @@ 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 std::string providerAppId = "app_def_04_provider_appid";
     const std::string consumerAppId = "app_def_04_client_appid";
     const std::string ownerId = "5001";
@@ -154,11 +159,15 @@ RUNNER_CHILD_TEST(app_defined_04_app_update)
 
     std::string consumerLabel = consumer.generateAppLabel();
 
-    providerV1.addAppDefinedPrivilege(std::make_pair(privilegeA, SM_APP_DEFINED_PRIVILEGE_TYPE_LICENSED));
-    providerV1.addAppDefinedPrivilege(std::make_pair(privilegeB, SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED));
-    consumer.addPrivilege(privilegeA);
-    consumer.addPrivilege(privilegeB);
-    consumer.addPrivilege(privilegeC);
+    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));
 
     ScopedInstaller req1(providerV1);
     ScopedInstaller req2(consumer);
@@ -169,8 +178,12 @@ 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_pair(privilegeB, SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED));
-    providerV2.addAppDefinedPrivilege(std::make_pair(privilegeC, SM_APP_DEFINED_PRIVILEGE_TYPE_LICENSED));
+    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));
     ScopedInstaller req3(providerV2);
 
     cynara.check(consumerLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_DENIED);
@@ -183,6 +196,7 @@ 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 std::string providerAppId = "app_def_05_provider_appid";
     const std::string consumerAppId = "app_def_05_client_appid";
     const std::string ownerId = "5001";
@@ -197,18 +211,26 @@ RUNNER_CHILD_TEST(app_defined_05_global_local_install)
     std::string consumerGlobalLabel = consumerGlobal.generateAppLabel();
     std::string consumerLocalLabel = consumerLocal.generateAppLabel();
 
-    providerGlobal.addAppDefinedPrivilege(std::make_pair(privilegeA, SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED));
-    providerGlobal.addAppDefinedPrivilege(std::make_pair(privilegeC, SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED));
+    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_pair(privilegeA, SM_APP_DEFINED_PRIVILEGE_TYPE_UNTRUSTED));
-    providerLocal.addAppDefinedPrivilege(std::make_pair(privilegeB, SM_APP_DEFINED_PRIVILEGE_TYPE_LICENSED));
+    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));
 
-    consumerGlobal.addPrivilege(privilegeA);
-    consumerGlobal.addPrivilege(privilegeB);
-    consumerGlobal.addPrivilege(privilegeC);
+    consumerGlobal.addClientPrivilege(std::make_pair(privilegeA, ""));
+    consumerGlobal.addClientPrivilege(std::make_pair(privilegeB, licenseB));
+    consumerGlobal.addClientPrivilege(std::make_pair(privilegeC, ""));
 
-    consumerLocal.addPrivilege(privilegeB);
-    consumerLocal.addPrivilege(privilegeC);
+    consumerLocal.addClientPrivilege(std::make_pair(privilegeB, licenseB));
+    consumerLocal.addClientPrivilege(std::make_pair(privilegeC, ""));
 
     CynaraTestClient::Client cynara;
 
@@ -266,37 +288,43 @@ RUNNER_CHILD_TEST(app_defined_06_get_provider)
 
     AppInstallHelper providerGlobal(providerId);
     AppInstallHelper providerLocal(providerId, uid);
-    providerGlobal.addAppDefinedPrivilege(std::make_pair(privilegeB, type));
-    providerLocal.addAppDefinedPrivilege(std::make_pair(privilegeA, type));
+    providerGlobal.addAppDefinedPrivilege(std::make_tuple(privilegeB, type, ""));
+    providerLocal.addAppDefinedPrivilege(std::make_tuple(privilegeA, type, ""));
     ScopedInstaller req1(providerGlobal);
     ScopedInstaller req2(providerLocal);
 
-    result = security_manager_identify_privilege_provider("noExistingPrivilege", uid, &pkgId, &appId);
+    result = security_manager_get_app_defined_privilege_provider("noExistingPrivilege",
+                                                                 uid, &pkgId, &appId);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
     RUNNER_ASSERT(appId == nullptr);
     RUNNER_ASSERT(pkgId == nullptr);
 
-    result = security_manager_identify_privilege_provider(privilegeA.c_str(), uid+1, &pkgId, &appId);
+    result = security_manager_get_app_defined_privilege_provider(privilegeA.c_str(),
+                                                                 uid+1, &pkgId, &appId);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
     RUNNER_ASSERT(appId == nullptr);
     RUNNER_ASSERT(pkgId == nullptr);
 
-    result = security_manager_identify_privilege_provider(privilegeA.c_str(), uid, nullptr, nullptr);
+    result = security_manager_get_app_defined_privilege_provider(privilegeA.c_str(),
+                                                                 uid, nullptr, nullptr);
     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
 
-    result = security_manager_identify_privilege_provider(privilegeA.c_str(), uid, &pkgId, nullptr);
+    result = security_manager_get_app_defined_privilege_provider(privilegeA.c_str(),
+                                                                 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_identify_privilege_provider(privilegeA.c_str(), uid, nullptr, &appId);
+    result = security_manager_get_app_defined_privilege_provider(privilegeA.c_str(),
+                                                                 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_identify_privilege_provider(privilegeA.c_str(), uid, &pkgId, &appId);
+    result = security_manager_get_app_defined_privilege_provider(privilegeA.c_str(),
+                                                                 uid, &pkgId, &appId);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider failed");
     RUNNER_ASSERT(appId && std::string(appId) == providerLocal.getAppId());
     RUNNER_ASSERT(pkgId && std::string(pkgId) == providerLocal.getPkgId());
@@ -305,7 +333,8 @@ RUNNER_CHILD_TEST(app_defined_06_get_provider)
     appId = nullptr;
     pkgId = nullptr;
 
-    result = security_manager_identify_privilege_provider(privilegeB.c_str(), uid, &pkgId, &appId);
+    result = security_manager_get_app_defined_privilege_provider(privilegeB.c_str(),
+                                                                 uid, &pkgId, &appId);
     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider failed");
     RUNNER_ASSERT(appId && std::string(appId) == providerGlobal.getAppId());
     RUNNER_ASSERT(pkgId && std::string(pkgId) == providerGlobal.getPkgId());