[UTC][account-manager][ACR-1028][added account model feature check]

Change-Id: I17d0439f7b2226676f9e379da0f78da21334441c

diff --git a/src/utc/accounts-svc/utc-accounts-svc.c b/src/utc/accounts-svc/utc-accounts-svc.c
index ac699b7..868bc2c 100755 (executable)
--- a/src/utc/accounts-svc/utc-accounts-svc.c
+++ b/src/utc/accounts-svc/utc-accounts-svc.c
@@ -22,6 +22,7 @@
 #include <dlog.h>
 #include <app.h>
 #include <tct_common.h>
+#include <system_info.h>
 
 #define TEST_PACKAGE_NAME              "core.accounts-svc-tests"       // app_id
 #define USER_NAME                      "user_name"
@@ -35,6 +36,7 @@
 #define TPK_APP_PREFIX                 "org.tizen."
 #define API_NAMESPACE                  "accounts-svc"
 
+#define ACCOUNT_FEATURE                        "http://tizen.org/feature/account"
 
 #define check_fail(exp) \
        if (!(exp)) { \
@@ -86,8 +88,8 @@ enum ICON_PATH_TYPE {
 //& set: AccountsSvc
 static bool created = false;
 static account_h account = NULL;
-static GMainLoop* mainloop = NULL;
 static int _is_fail = true;
+static bool is_account_supported = false;
 static const char* package_name = TEST_PACKAGE_NAME;
 static const char* test_label_default = LABEL_DEFAULT;
 static const char* test_label_en_gb = LABEL_EN_GB;
@@ -136,8 +138,9 @@ char* AppGetError(int nRet)
  */
 void utc_account_startup(void)
 {
-       account_type_h account_type = NULL;
-       int account_type_id = -1;
+       /* start of TC */
+       system_info_get_platform_bool(ACCOUNT_FEATURE, &is_account_supported);
+       
        int ret1 = account_create(&account);
        if (ACCOUNT_ERROR_NONE == ret1) {
                created = true;
@@ -152,7 +155,7 @@ void utc_account_startup(void)
  */
 void utc_account_cleanup(void)
 {
-       int ret1 = ACCOUNT_ERROR_NONE, ret2 = ACCOUNT_ERROR_NONE;
+       int ret1 = ACCOUNT_ERROR_NONE;
        ret1 = account_destroy(account);
        if (ACCOUNT_ERROR_NONE == ret1) {
                created = false;
@@ -306,10 +309,12 @@ int utc_account_destroy_p(void)
        account_h account_data = NULL;
 
        ret = account_create(&account_data);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_destroy(account_data);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -364,7 +369,8 @@ int utc_account_create_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_create(NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -410,163 +416,304 @@ int utc_account_insert_to_db_p(void)
        int i = -1;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_display_name(account, display_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_icon_path(account, icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_domain_name(account, domain_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_email_address(account, email_address);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_source(account, source);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_custom(account, key, value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, capability_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_access_token(account, access_token);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        for (i = 0; i < 5; i++){
                ret = account_set_user_text(account, i, user_text);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        for (i = 0; i < 5; i++){
                ret = account_set_user_int(account, i, i*10);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        ret = account_set_auth_type(account, auth_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_secret(account, secrecy_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_sync_support(account, sync_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_create(&ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_account_by_account_id(account_id, &ret_account);
-       if(ret != ACCOUNT_ERROR_NONE) {
-               account_destroy(ret_account);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               if(ret != ACCOUNT_ERROR_NONE) {
+                       account_destroy(ret_account);
+               }
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
        }
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
 
        // User Name
        ret = account_get_user_name(ret_account, &ret_user_name);
-       assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_user_name, ret_account);
-       assert_eq_free_text(strcmp(ret_user_name, user_name), 0, ret_user_name, ret_account);
-       _account_free_text(ret_user_name);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               _account_free_text(ret_user_name);
+       }
+       else
+       {
+               assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_user_name, ret_account);
+               assert_eq_free_text(strcmp(ret_user_name, user_name), 0, ret_user_name, ret_account);
+               _account_free_text(ret_user_name);
+       }
 
        // Package Name
        ret = account_get_package_name(ret_account, &ret_package_name);
-       assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_package_name, ret_account);
-       assert_eq_free_text(strcmp(ret_package_name, package_name), 0, ret_package_name, ret_account);
-       _account_free_text(ret_package_name);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               _account_free_text(ret_package_name);
+       }
+       else
+       {
+               assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_package_name, ret_account);
+               assert_eq_free_text(strcmp(ret_package_name, package_name), 0, ret_package_name, ret_account);
+               _account_free_text(ret_package_name);
+       }
 
        // Display Name
        ret = account_get_display_name(ret_account, &ret_display_name);
-       assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_display_name, ret_account);
-       assert_eq_free_text(strcmp(ret_display_name, display_name), 0, ret_display_name, ret_account);
-       _account_free_text(ret_display_name);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               _account_free_text(ret_display_name);
+       }
+       else
+       {
+               assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_display_name, ret_account);
+               assert_eq_free_text(strcmp(ret_display_name, display_name), 0, ret_display_name, ret_account);
+               _account_free_text(ret_display_name);
+       }
 
        // Icon Path
        ret = account_get_icon_path(ret_account, &ret_icon_path);
-       assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_icon_path, ret_account);
-       assert_eq_free_text(strcmp(ret_icon_path, icon_path), 0, ret_icon_path, ret_account);
-       _account_free_text(ret_icon_path);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               _account_free_text(ret_icon_path);
+       }
+       else
+       {
+               assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_icon_path, ret_account);
+               assert_eq_free_text(strcmp(ret_icon_path, icon_path), 0, ret_icon_path, ret_account);
+               _account_free_text(ret_icon_path);
+       }
 
        // Domain Name
        ret = account_get_domain_name(ret_account, &ret_domain_name);
-       assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_domain_name, ret_account);
-       assert_eq_free_text(strcmp(ret_domain_name, domain_name), 0, ret_domain_name, ret_account);
-       _account_free_text(ret_domain_name);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               _account_free_text(ret_domain_name);
+       }
+       else
+       {
+               assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_domain_name, ret_account);
+               assert_eq_free_text(strcmp(ret_domain_name, domain_name), 0, ret_domain_name, ret_account);
+               _account_free_text(ret_domain_name);
+       }
 
        // Email Address
        ret = account_get_email_address(ret_account, &ret_email_address);
-       assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_email_address, ret_account);
-       assert_eq_free_text(strcmp(ret_email_address, email_address), 0, ret_email_address, ret_account);
-       _account_free_text(ret_email_address);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               _account_free_text(ret_email_address);
+       }
+       else
+       {
+               assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_email_address, ret_account);
+               assert_eq_free_text(strcmp(ret_email_address, email_address), 0, ret_email_address, ret_account);
+               _account_free_text(ret_email_address);
+       }
 
        // Source
        ret = account_get_source(ret_account, &ret_source);
-       assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_source, ret_account);
-       assert_eq_free_text(strcmp(ret_source, source), 0, ret_source, ret_account);
-       _account_free_text(ret_source);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               _account_free_text(ret_source);
+       }
+       else
+       {
+               assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_source, ret_account);
+               assert_eq_free_text(strcmp(ret_source, source), 0, ret_source, ret_account);
+               _account_free_text(ret_source);
+       }
 
        // Custom
        ret = account_get_custom(ret_account, key, &ret_value);
-       assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_value, ret_account);
-       assert_eq_free_text(strcmp(ret_value, value), 0, ret_value, ret_account);
-       _account_free_text(ret_value);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               _account_free_text(ret_value);
+       }
+       else
+       {
+               assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_value, ret_account);
+               assert_eq_free_text(strcmp(ret_value, value), 0, ret_value, ret_account);
+               _account_free_text(ret_value);
+       }
 
        // Capability
        ret = account_get_capability(ret_account, contact_capability, &ret_capability_state);
-       assert_eq_free(ret, ACCOUNT_ERROR_NONE, ret_account);
-       assert_eq_free(ret_capability_state, capability_state, ret_account);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq_free(ret, ACCOUNT_ERROR_NONE, ret_account);
+               assert_eq_free(ret_capability_state, capability_state, ret_account);
+       }
 
        // Access Token
        ret = account_get_access_token(ret_account, &ret_access_token);
-       assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_access_token, ret_account);
-       if (ret_access_token != NULL && access_token != NULL) {
-               assert_eq_free_text(strcmp(ret_access_token, access_token), 0, ret_access_token, ret_account);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               _account_free_text(ret_access_token);
+       }
+       else
+       {
+               assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_access_token, ret_account);
+               if (ret_access_token != NULL && access_token != NULL) {
+                       assert_eq_free_text(strcmp(ret_access_token, access_token), 0, ret_access_token, ret_account);
+               }
+               _account_free_text(ret_access_token);
        }
-       _account_free_text(ret_access_token);
 
        // User Text
        for (i = 0; i < 5; i++){
                ret = account_get_user_text(ret_account, i, &ret_user_text);
-               assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_user_text, ret_account);
-               assert_eq_free_text(strcmp(ret_user_text, user_text), 0, ret_user_text, ret_account);
-               _account_free_text(ret_user_text);
+               if(!is_account_supported)
+               {
+                       assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+                       _account_free_text(ret_user_text);
+               }
+               else
+               {
+                       assert_eq_free_text(ret, ACCOUNT_ERROR_NONE, ret_user_text, ret_account);
+                       assert_eq_free_text(strcmp(ret_user_text, user_text), 0, ret_user_text, ret_account);
+                       _account_free_text(ret_user_text);
+               }
        }
 
        // User Int
        for (i = 0; i < 5; i++){
                int ret_user_int = -1;
                ret = account_get_user_int(ret_account, i, &ret_user_int);
-               assert_eq_free(ret, ACCOUNT_ERROR_NONE, ret_account);
-               assert_eq_free(ret_user_int, i*10, ret_account);
+               if(!is_account_supported)
+               {
+                       assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               }
+               else
+               {
+                       assert_eq_free(ret, ACCOUNT_ERROR_NONE, ret_account);
+                       assert_eq_free(ret_user_int, i*10, ret_account);
+               }
        }
 
        // Auth Type
        ret = account_get_auth_type(ret_account, &ret_auth_type);
-       assert_eq_free(ret, ACCOUNT_ERROR_NONE, ret_account);
-       assert_eq_free(ret_auth_type, auth_type, ret_account);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq_free(ret, ACCOUNT_ERROR_NONE, ret_account);
+               assert_eq_free(ret_auth_type, auth_type, ret_account);
+       }
 
        // Secret
        ret = account_get_secret(ret_account, &ret_secrecy_state);
-       assert_eq_free(ret, ACCOUNT_ERROR_NONE, ret_account);
-       assert_eq_free(ret_secrecy_state, secrecy_state, ret_account);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq_free(ret, ACCOUNT_ERROR_NONE, ret_account);
+               assert_eq_free(ret_secrecy_state, secrecy_state, ret_account);
+       }
 
        // Sync Support
        ret = account_get_sync_support(ret_account, &ret_sync_state);
-       assert_eq_free(ret, ACCOUNT_ERROR_NONE, ret_account);
-       assert_eq_free(ret_sync_state, sync_state, ret_account);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq_free(ret, ACCOUNT_ERROR_NONE, ret_account);
+               assert_eq_free(ret_sync_state, sync_state, ret_account);
+       }
 
        ret = account_destroy(ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -583,10 +730,12 @@ int utc_account_insert_to_db_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_insert_to_db(NULL, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_insert_to_db(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -603,7 +752,8 @@ int utc_account_set_display_name_p(void)
        const char* display_name = "display_name";
 
        ret = account_set_display_name(account, display_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -620,10 +770,12 @@ int utc_account_set_display_name_n(void)
        const char* display_name = "display_name";
 
        ret = account_set_display_name(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_display_name(NULL, display_name);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -639,7 +791,8 @@ int utc_account_set_user_name_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -655,10 +808,12 @@ int utc_account_set_user_name_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_user_name(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_user_name(NULL, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -675,7 +830,8 @@ int utc_account_set_icon_path_p(void)
        const char* icon_path = "icon_path";
 
        ret = account_set_icon_path(account, icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -692,10 +848,12 @@ int utc_account_set_icon_path_n(void)
        const char* icon_path = "icon_path";
 
        ret = account_set_icon_path(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_icon_path(NULL, icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -712,7 +870,8 @@ int utc_account_set_domain_name_p(void)
        const char* domain_name = "domain_name";
 
        ret = account_set_domain_name(account, domain_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -729,10 +888,12 @@ int utc_account_set_domain_name_n(void)
        const char* domain_name = "domain_name";
 
        ret = account_set_domain_name(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_domain_name(NULL, domain_name);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -749,7 +910,8 @@ int utc_account_set_email_address_p(void)
        const char* email_address = "email_address";
 
        ret = account_set_email_address(account, email_address);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -766,10 +928,12 @@ int utc_account_set_email_address_n(void)
        const char* email_address = "email_address";
 
        ret = account_set_email_address(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_email_address(NULL, email_address);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -786,7 +950,8 @@ int utc_account_set_source_p(void)
        const char* source = "source";
 
        ret = account_set_source(account, source);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -803,10 +968,12 @@ int utc_account_set_source_n(void)
        const char* source = "source";
 
        ret = account_set_source(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_source(NULL, source);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -824,10 +991,12 @@ int utc_account_set_custom_p(void)
        const char* value = "value";
 
        ret = account_set_custom(account, key, value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_custom(account, key, value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -845,13 +1014,16 @@ int utc_account_set_custom_n(void)
        const char* value = "value";
 
        ret = account_set_custom(account, NULL, value);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_custom(account, key, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_custom(NULL, key, value);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -870,12 +1042,20 @@ int utc_account_get_custom_p(void)
        char* ret_value = NULL;
 
        ret = account_set_custom(account, key, value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_custom(account, key, &ret_value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_value, value), 0);
-       _account_free_text(ret_value);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               _account_free_text(ret_value);
+       }
+       else{
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_value, value), 0);
+               _account_free_text(ret_value);
+       }
 
        return 0;
 }
@@ -893,11 +1073,13 @@ int utc_account_get_custom_n(void)
        char *returned_val = NULL;
 
        ret = account_get_custom(account, not_set_key, &returned_val);
-       assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);}
 
        ret = account_get_custom(account, NULL, &returned_val);
        free(returned_val);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -912,9 +1094,6 @@ static bool account_custom_cb_func (char* key, char* value, void *user_data) {
                _is_fail = true;
        }
 
-//     g_main_loop_quit(mainloop);
-//     mainloop = NULL;
-
        return true;
 }
 
@@ -932,21 +1111,24 @@ int utc_account_get_custom_all_p(void)
        const char* value = "value";
 
        ret = account_set_custom(account, key, value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_custom(account, key2, value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        _is_fail = false;
-//     mainloop = g_main_loop_new(NULL, FALSE);
-//     assert(mainloop);
        ret = account_get_custom_all(account, account_custom_cb_func, value);
-//     assert_eq(_is_fail, false);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-//     int timeout_id = g_timeout_add(3000, timeout_cb, mainloop);
-//     g_main_loop_run(mainloop);
-//     g_source_remove(timeout_id);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
        _is_fail = true;
 
        return 0;
@@ -963,10 +1145,12 @@ int utc_account_get_custom_all_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_custom_all(account, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_custom_all(NULL, account_custom_cb_func, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -982,7 +1166,8 @@ int utc_account_set_package_name_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -998,10 +1183,12 @@ int utc_account_set_package_name_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_package_name(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_package_name(NULL, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1018,7 +1205,8 @@ int utc_account_set_access_token_p(void)
        const char* access_token = "access_token";
 
        ret = account_set_access_token(account, access_token);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -1034,7 +1222,8 @@ int utc_account_set_access_token_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_access_token(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1050,7 +1239,8 @@ int utc_account_set_auth_type_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_auth_type(account, ACCOUNT_AUTH_TYPE_OAUTH);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -1066,10 +1256,12 @@ int utc_account_set_auth_type_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_auth_type(account, -999);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_auth_type(NULL, ACCOUNT_AUTH_TYPE_OAUTH);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1085,7 +1277,8 @@ int utc_account_set_secret_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_secret(account, ACCOUNT_SECRECY_INVISIBLE);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -1101,10 +1294,12 @@ int utc_account_set_secret_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_secret(account, -999);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_secret(NULL, ACCOUNT_SECRECY_INVISIBLE);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1120,7 +1315,8 @@ int utc_account_set_sync_support_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_sync_support(account, ACCOUNT_SYNC_STATUS_IDLE);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -1136,10 +1332,12 @@ int utc_account_set_sync_support_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_sync_support(account, -999);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_sync_support(NULL, ACCOUNT_SYNC_STATUS_IDLE);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1158,7 +1356,8 @@ int utc_account_set_user_text_p(void)
        int i;
        for ( i = 0; i < 5; i++){
                ret = account_set_user_text(account, i, user_text);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        return 0;
@@ -1178,16 +1377,20 @@ int utc_account_set_user_text_n(void)
        int i;
        for (i = 0; i < 5; i++){
                ret = account_set_user_text(account, i, NULL);
-               assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
        }
        ret = account_set_user_text(account, 100, user_text);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_user_text(account, -1, user_text);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_user_text(NULL, 1, user_text);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1205,7 +1408,8 @@ int utc_account_set_user_int_p(void)
        int i;
        for (i = 0; i < 5; i++){
                ret = account_set_user_int(account, i, 999);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        return 0;
@@ -1224,14 +1428,17 @@ int utc_account_set_user_int_n(void)
        int i;
        for (i = 0; i < 5; i++){
                ret = account_set_user_int(NULL, i, 999);
-               assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
        }
 
        ret = account_set_user_int(account, 100, 999);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_user_int(account, -1, 999);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1247,10 +1454,12 @@ int utc_account_set_capability_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_capability(account, contact_capability, ACCOUNT_CAPABILITY_ENABLED);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, ACCOUNT_CAPABILITY_ENABLED);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -1267,25 +1476,25 @@ int utc_account_set_capability_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_capability(NULL, contact_capability, ACCOUNT_CAPABILITY_ENABLED);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_capability(account, NULL, ACCOUNT_CAPABILITY_ENABLED);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_set_capability(account, contact_capability, -1);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
 
 static bool capability_cb_func (const char* capability_type, account_capability_state_e capability_state, void *user_data) {
        account_capability_state_e* _capability_state = (account_capability_state_e*)user_data;
-//     if(capability_state == *_capability_state)
-//             _is_fail = false;
+
        if(capability_state != *_capability_state)
                _is_fail = true;
-//     g_main_loop_quit(mainloop);
-//     mainloop = NULL;
 
        return true;
 }
@@ -1302,17 +1511,26 @@ int utc_account_get_capability_all_p(void)
        const account_capability_state_e capability_state = ACCOUNT_CAPABILITY_ENABLED;
 
        ret = account_set_capability(account, contact_capability, capability_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, calendar_capability, capability_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        _is_fail = false;
 
        ret = account_get_capability_all(account, capability_cb_func, &capability_state);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
+       
        _is_fail = true;
 
        return 0;
@@ -1329,10 +1547,12 @@ int utc_account_get_capability_all_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_capability_all(NULL, capability_cb_func, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_capability_all(account, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1350,11 +1570,19 @@ int utc_account_get_display_name_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_display_name(account, display_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_display_name(account, &ret_display_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_display_name, display_name), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_display_name, display_name), 0);
+       }
        _account_free_text(ret_display_name);
 
        return 0;
@@ -1372,10 +1600,12 @@ int utc_account_get_display_name_n(void)
        char * display_name;
 
        ret = account_get_display_name(NULL, &display_name);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_display_name(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1393,20 +1623,31 @@ int utc_account_get_account_id_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_account_by_account_id(account_id, &account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_account_id(account, &ret_account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(account_id, ret_account_id);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(account_id, ret_account_id);
+       }
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -1423,10 +1664,12 @@ int utc_account_get_account_id_n(void)
        int account_id = -1;
 
        ret = account_get_account_id(NULL, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_account_id(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1443,11 +1686,19 @@ int utc_account_get_user_name_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_user_name(account, &ret_user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_user_name, user_name), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_user_name, user_name), 0);
+       }
        _account_free_text(ret_user_name);
 
        return 0;
@@ -1465,10 +1716,12 @@ int utc_account_get_user_name_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_user_name(NULL, &get_user_name);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_user_name(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1486,11 +1739,19 @@ int utc_account_get_icon_path_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_icon_path(account, icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_icon_path(account, &ret_icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_icon_path, icon_path), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_icon_path, icon_path), 0);
+       }
        _account_free_text(ret_icon_path);
 
        return 0;
@@ -1508,10 +1769,12 @@ int utc_account_get_icon_path_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_icon_path(NULL, &ret_icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_icon_path(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1529,15 +1792,23 @@ int utc_account_get_domain_name_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_domain_name(account, domain_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_domain_name(account, &ret_domain_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_domain_name, domain_name), 0);
-       _account_free_text(ret_domain_name);
-
-       return 0;
-}
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_domain_name, domain_name), 0);
+       }
+       _account_free_text(ret_domain_name);
+
+       return 0;
+}
 
 /**
  * @testcase           utc_account_get_domain_name_n
@@ -1551,10 +1822,12 @@ int utc_account_get_domain_name_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_domain_name(NULL, &domain_name);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_domain_name(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1572,11 +1845,19 @@ int utc_account_get_email_address_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_email_address(account, email_address);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_email_address(account, &ret_email_address);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_email_address, email_address), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_email_address, email_address), 0);
+       }
        _account_free_text(ret_email_address);
 
        return 0;
@@ -1594,10 +1875,12 @@ int utc_account_get_email_address_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_email_address(NULL, &ret_email_address);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_email_address(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1615,11 +1898,19 @@ int utc_account_get_source_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_source(account, source);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_source(account, &ret_source);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_source, source), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_source, source), 0);
+       }
        _account_free_text(ret_source);
 
        return 0;
@@ -1637,10 +1928,12 @@ int utc_account_get_source_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_source(NULL, &ret_source);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_source(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1657,11 +1950,19 @@ int utc_account_get_package_name_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_package_name(account, &ret_package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_package_name, package_name), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_package_name, package_name), 0);
+       }
        _account_free_text(ret_package_name);
 
        return 0;
@@ -1679,10 +1980,12 @@ int utc_account_get_package_name_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_package_name(NULL, &ret_package_name);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_package_name(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1700,11 +2003,19 @@ int utc_account_get_access_token_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_access_token(account, access_token);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_access_token(account, &ret_access_token);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(access_token, ret_access_token), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(access_token, ret_access_token), 0);
+       }
        _account_free_text(ret_access_token);
 
        return 0;
@@ -1722,10 +2033,12 @@ int utc_account_get_access_token_n(void)
        char *ret_access_token = NULL;
 
        ret = account_get_access_token(NULL, &ret_access_token);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_access_token(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1742,11 +2055,19 @@ int utc_account_get_auth_type_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_auth_type(account, ACCOUNT_AUTH_TYPE_XAUTH);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_auth_type(account, &auth_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(auth_type, ACCOUNT_AUTH_TYPE_XAUTH);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(auth_type, ACCOUNT_AUTH_TYPE_XAUTH);
+       }
 
        return 0;
 }
@@ -1763,10 +2084,12 @@ int utc_account_get_auth_type_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_auth_type(NULL, &auth_type);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_auth_type(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1783,11 +2106,19 @@ int utc_account_get_secret_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_secret(account, ACCOUNT_SECRECY_INVISIBLE);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_secret(account, &secret);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(secret, ACCOUNT_SECRECY_INVISIBLE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(secret, ACCOUNT_SECRECY_INVISIBLE);
+       }
 
        return 0;
 }
@@ -1804,11 +2135,19 @@ int utc_account_get_sync_support_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_sync_support(account, ACCOUNT_SYNC_STATUS_IDLE);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_sync_support(account, &sync_support);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(sync_support, ACCOUNT_SYNC_STATUS_IDLE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(sync_support, ACCOUNT_SYNC_STATUS_IDLE);
+       }
 
        return 0;
 }
@@ -1825,10 +2164,12 @@ int utc_account_get_secret_n(void)
        account_secrecy_state_e secret;
 
        ret = account_get_secret(NULL, &secret);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_secret(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1845,10 +2186,12 @@ int utc_account_get_sync_support_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_sync_support(NULL, &sync_support);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_sync_support(account, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1868,12 +2211,20 @@ int utc_account_get_user_text_p(void)
        int i;
        for ( i = 0; i < 5; i++){
                ret = account_set_user_text(account, i, user_text);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
        for ( i = 0; i < 5; i++){
                ret = account_get_user_text(account, i, &ret_user_text);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
-               assert_eq(strcmp(ret_user_text, user_text), 0);
+               if(!is_account_supported)
+               {
+                       assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               }
+               else
+               {
+                       assert_eq(ret, ACCOUNT_ERROR_NONE);
+                       assert_eq(strcmp(ret_user_text, user_text), 0);
+               }
                _account_free_text(ret_user_text);
        }
 
@@ -1892,16 +2243,20 @@ int utc_account_get_user_text_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_user_text(NULL, 0, &ret_user_text);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_user_text(account, 100, &ret_user_text);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_user_text(account, -1, &ret_user_text);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_user_text(account, 0, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1920,13 +2275,21 @@ int utc_account_get_user_int_p(void)
        int i;
        for (i = 0; i < 5; i++){
                ret = account_set_user_int(account, i, i*10);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        for (i = 0; i < 5; i++){
                ret = account_get_user_int(account, i, &user_int);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
-               assert_eq(user_int, i*10);
+               if(!is_account_supported)
+               {
+                       assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+               }
+               else
+               {
+                       assert_eq(ret, ACCOUNT_ERROR_NONE);
+                       assert_eq(user_int, i*10);
+               }
        }
 
        return 0;
@@ -1943,16 +2306,20 @@ int utc_account_get_user_int_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_user_int(NULL, 0, 100);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_user_int(account, 100, 100);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_user_int(account, -1, 100);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_user_int(account, 0, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -1972,43 +2339,51 @@ static bool capability_call_back(const char* capability_type, account_capability
        const char* capability = contact_capability;
 
        ret = account_get_package_name(account_data, &str);
-       if(ret != ACCOUNT_ERROR_NONE) {
-               _account_free_text(str);
-               _is_fail = true;
-               return true;
-       }
-       if(strcmp(str, package_name) !=0) {
-               _account_free_text(str);
-               _is_fail = true;
-               return true;
+       if(is_account_supported)
+       {
+               if(ret != ACCOUNT_ERROR_NONE) {
+                       _account_free_text(str);
+                       _is_fail = true;
+                       return true;
+               }
+               if(strcmp(str, package_name) !=0) {
+                       _account_free_text(str);
+                       _is_fail = true;
+                       return true;
+               }
        }
 
        ret = account_get_user_name(account_data, &str);
-       if(ret != ACCOUNT_ERROR_NONE) {
-               _account_free_text(str);
-               _is_fail = true;
-               return true;
-       }
-       if(strcmp(str, user_name) !=0) {
-               _account_free_text(str);
-               _is_fail = true;
-               return true;
-       }
-
-       if( strcmp(capability_type, capability)==0 ) {
-               ret = account_get_capability(account_data, capability, &_capability_state);
+       if(is_account_supported)
+       {
                if(ret != ACCOUNT_ERROR_NONE) {
                        _account_free_text(str);
                        _is_fail = true;
                        return true;
                }
-               if(_capability_state != capability_state) {
+               if(strcmp(str, user_name) !=0) {
                        _account_free_text(str);
                        _is_fail = true;
                        return true;
                }
        }
 
+       if( strcmp(capability_type, capability)==0 ) {
+               ret = account_get_capability(account_data, capability, &_capability_state);
+               if(is_account_supported) {
+                       if(ret != ACCOUNT_ERROR_NONE) {
+                               _account_free_text(str);
+                               _is_fail = true;
+                               return true;
+                       }
+                       if(_capability_state != capability_state) {
+                               _account_free_text(str);
+                               _is_fail = true;
+                               return true;
+                       }
+               }
+       }
+
        _account_free_text(str);
        _is_fail = false;
 
@@ -2027,11 +2402,19 @@ int utc_account_get_capability_p(void)
        account_capability_state_e value;
 
        ret = account_set_capability(account, contact_capability, ACCOUNT_CAPABILITY_ENABLED);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_capability(account, contact_capability, &value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(value, ACCOUNT_CAPABILITY_ENABLED);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(value, ACCOUNT_CAPABILITY_ENABLED);
+       }
 
        return 0;
 }
@@ -2047,13 +2430,16 @@ int utc_account_get_capability_n(void)
        account_capability_state_e value;
 
        ret = account_get_capability(NULL, contact_capability, &value);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_capability(account, NULL, &value);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_get_capability(account, contact_capability, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -2075,133 +2461,194 @@ static bool account_call_back(account_h account, void *user_data)
        account_h _account = *((account_h*)user_data);
 
        ret = account_get_package_name(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_package_name(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_user_name(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_user_name(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_display_name(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_display_name(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_icon_path(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_icon_path(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_domain_name(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_domain_name(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_email_address(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_email_address(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_email_address(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_email_address(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_source(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_source(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_custom(_account, key, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_custom(account, key, &comparison_str);
-       check_fail_eq(ret, ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail_eq(ret, ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_capability(_account, contact_capability, &value);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_capability(account, contact_capability, &comparison_value);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(value == comparison_value);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(value == comparison_value);
+       }
 
        ret = account_get_access_token(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_access_token(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       if (str != NULL && comparison_str != NULL)
-               check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               if (str != NULL && comparison_str != NULL)
+                       check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        for (i = 0; i < 5; i++){
                ret = account_get_user_text(_account, i, &str);
-               check_fail(ret == ACCOUNT_ERROR_NONE);
+               if(is_account_supported)
+                       check_fail(ret == ACCOUNT_ERROR_NONE);
+
                ret = account_get_user_text(account, i, &comparison_str);
-               check_fail(ret == ACCOUNT_ERROR_NONE);
-               check_fail(strcmp(str, comparison_str)==0);
+               if(is_account_supported) {
+                       check_fail(ret == ACCOUNT_ERROR_NONE);
+                       check_fail(strcmp(str, comparison_str)==0);
+               }
                _account_free_text(str);
                _account_free_text(comparison_str);
        }
 
        for (i = 0; i < 5; i++){
                ret = account_get_user_int(_account, i, &value);
-               check_fail(ret == ACCOUNT_ERROR_NONE);
+               if(is_account_supported)
+                       check_fail(ret == ACCOUNT_ERROR_NONE);
+
                ret = account_get_user_int(account, i, &comparison_value);
-               check_fail(ret == ACCOUNT_ERROR_NONE);
-               check_fail(value == comparison_value);
+               if(is_account_supported) {
+                       check_fail(ret == ACCOUNT_ERROR_NONE);
+                       check_fail(value == comparison_value);
+               }
        }
 
        ret = account_get_auth_type(_account, &value);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_auth_type(account, &comparison_value);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(value == comparison_value);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(value == comparison_value);
+       }
 
        ret = account_get_secret(_account, &value);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_secret(account, &comparison_value);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(value == comparison_value);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(value == comparison_value);
+       }
 
        ret = account_get_sync_support(_account, &value);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_sync_support(account, &comparison_value);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(value == comparison_value);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(value == comparison_value);
+       }
 
        _is_fail = false;
 
-//     g_main_loop_quit(mainloop);
-//     mainloop = NULL;
-
        return true;
 }
 
@@ -2231,74 +2678,92 @@ int utc_account_foreach_account_from_db_p(void)
        int i = -1;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_display_name(account, display_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_icon_path(account, icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_domain_name(account, domain_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_email_address(account, email_address);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_source(account, source);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_custom(account, key, value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, capability_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_access_token(account, access_token);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        for (i = 0; i < 5; i++){
                ret = account_set_user_text(account, i, user_text);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        for (i = 0; i < 5; i++){
                ret = account_set_user_int(account, i, i*10);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        ret = account_set_auth_type(account, auth_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_secret(account, secrecy_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_sync_support(account, sync_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-
-//     mainloop = g_main_loop_new(NULL, FALSE);
-//     assert(mainloop);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_foreach_account_from_db(account_call_back, &account);
-//     assert_eq(_is_fail, false);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
 
        ret = account_foreach_account_from_db(account_call_back_return_false, &account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
-//     int timeout_id = g_timeout_add(3000, timeout_cb, mainloop);
-//     g_main_loop_run(mainloop);
-//     g_source_remove(timeout_id);
        _is_fail = true;
 
        return 0;
@@ -2314,7 +2779,8 @@ int utc_account_foreach_account_from_db_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_foreach_account_from_db(NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -2335,38 +2801,59 @@ int utc_account_query_account_by_account_id_p(void)
        account_capability_state_e ret_capability_type = 0;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, ACCOUNT_CAPABILITY_ENABLED);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_create(&ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_account_by_account_id(account_id, &ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
+
        ret = account_get_user_name(ret_account, &ret_user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
+
        ret = account_get_package_name(ret_account, &ret_package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
+
        ret = account_get_capability(ret_account, contact_capability, &ret_capability_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_user_name, user_name), 0);
-       assert_eq(strcmp(ret_package_name, package_name), 0);
-       assert_eq(ret_capability_type, ACCOUNT_CAPABILITY_ENABLED);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_user_name, user_name), 0);
+               assert_eq(strcmp(ret_package_name, package_name), 0);
+               assert_eq(ret_capability_type, ACCOUNT_CAPABILITY_ENABLED);
+       }
        _account_free_text(ret_user_name);
        _account_free_text(ret_package_name);
+
        ret = account_destroy(ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -2382,10 +2869,12 @@ int utc_account_query_account_by_account_id_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_query_account_by_account_id(100, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_query_account_by_account_id(-999, &account);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -2416,74 +2905,94 @@ int utc_account_query_account_by_user_name_p(void)
        int i = -1;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_display_name(account, display_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_icon_path(account, icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_domain_name(account, domain_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_email_address(account, email_address);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_source(account, source);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_custom(account, key, value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, capability_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_access_token(account, access_token);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        for (i = 0; i < 5; i++){
                ret = account_set_user_text(account, i, user_text);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        for (i = 0; i < 5; i++){
                ret = account_set_user_int(account, i, i*10);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        ret = account_set_auth_type(account, auth_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_secret(account, secrecy_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_sync_support(account, sync_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
-//     mainloop = g_main_loop_new(NULL, FALSE);
-//     assert(mainloop);
 
        ret = account_query_account_by_user_name(account_call_back, user_name, &account);
-//     assert_eq(_is_fail, false);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
 
        ret = account_query_account_by_user_name(account_call_back_return_false, user_name, &account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-//     int timeout_id = g_timeout_add(3000, timeout_cb, mainloop);
-//     g_main_loop_run(mainloop);
-//     g_source_remove(timeout_id);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
+
        _is_fail = true;
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -2498,10 +3007,12 @@ int utc_account_query_account_by_user_name_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_query_account_by_user_name(account_call_back, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_query_account_by_user_name(NULL, user_name, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -2532,74 +3043,93 @@ int utc_account_query_account_by_package_name_p(void)
        int i = -1;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_display_name(account, display_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_icon_path(account, icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_domain_name(account, domain_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_email_address(account, email_address);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_source(account, source);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_custom(account, key, value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, capability_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_access_token(account, access_token);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        for (i = 0; i < 5; i++){
                ret = account_set_user_text(account, i, user_text);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        for (i = 0; i < 5; i++){
                ret = account_set_user_int(account, i, i*10);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        ret = account_set_auth_type(account, auth_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_secret(account, secrecy_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_sync_support(account, sync_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-
-//     mainloop = g_main_loop_new(NULL, FALSE);
-//     assert(mainloop);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_account_by_package_name(account_call_back, package_name, &account);
-//     assert_eq(_is_fail, false);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
 
        ret = account_query_account_by_package_name(account_call_back_return_false, package_name, &account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-//     int timeout_id = g_timeout_add(3000, timeout_cb, mainloop);
-//     g_main_loop_run(mainloop);
-//     g_source_remove(timeout_id);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
+
        _is_fail = true;
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -2614,10 +3144,12 @@ int utc_account_query_account_by_package_name_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_query_account_by_package_name(account_call_back, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_query_account_by_package_name(NULL, package_name, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -2648,74 +3180,93 @@ int utc_account_query_account_by_capability_p(void)
        int i = -1;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_display_name(account, display_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_icon_path(account, icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_domain_name(account, domain_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_email_address(account, email_address);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_source(account, source);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_custom(account, key, value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, capability_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_access_token(account, access_token);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        for (i = 0; i < 5; i++){
                ret = account_set_user_text(account, i, user_text);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        for (i = 0; i < 5; i++){
                ret = account_set_user_int(account, i, i*10);
-               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+               else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
        }
 
        ret = account_set_auth_type(account, auth_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_secret(account, secrecy_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_sync_support(account, sync_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-
-//     mainloop = g_main_loop_new(NULL, FALSE);
-//     assert(mainloop);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_account_by_capability(account_call_back, contact_capability, capability_state, &account);
-//     assert_eq(_is_fail, false);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
 
        ret = account_query_account_by_capability(account_call_back_return_false, contact_capability, capability_state, &account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-//     int timeout_id = g_timeout_add(3000, timeout_cb, mainloop);
-//     g_main_loop_run(mainloop);
-//     g_source_remove(timeout_id);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
+
        _is_fail = true;
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -2730,13 +3281,16 @@ int utc_account_query_account_by_capability_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_query_account_by_capability(NULL, contact_capability, ACCOUNT_CAPABILITY_ENABLED, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_query_account_by_capability(account_call_back, NULL, ACCOUNT_CAPABILITY_ENABLED, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_query_account_by_capability(account_call_back, contact_capability, -1, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -2756,30 +3310,40 @@ static bool account_cb_func(account_h account, void *user_data)
        account_h _account = *((account_h*)user_data);
 
        ret = account_get_package_name(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_package_name(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_user_name(_account, &str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_user_name(account, &comparison_str);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(str, comparison_str)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(str, comparison_str)==0);
+       }
        _account_free_text(str);
        _account_free_text(comparison_str);
 
        ret = account_get_capability(_account, contact_capability, &value);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported)
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+
        ret = account_get_capability(account, contact_capability, &comparison_value);
-       check_fail_eq(ret, ACCOUNT_ERROR_NONE);
-       check_fail(value == comparison_value);
+       if(is_account_supported) {
+               check_fail_eq(ret, ACCOUNT_ERROR_NONE);
+               check_fail(value == comparison_value);
+       }
 
        _is_fail = false;
-//     g_main_loop_quit(mainloop);
-//     mainloop = NULL;
 
        return true;
 }
@@ -2796,34 +3360,41 @@ int utc_account_query_account_by_capability_type_p(void)
        int account_id = -1;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, ACCOUNT_CAPABILITY_ENABLED);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-
-//     mainloop = g_main_loop_new(NULL, FALSE);
-//     assert(mainloop);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_account_by_capability_type(account_cb_func, contact_capability, &account);
-//     assert_eq(_is_fail, false);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
 
        ret = account_query_account_by_capability_type(account_cb_func_return_false, contact_capability, &account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-//     int timeout_id = g_timeout_add(3000, timeout_cb, mainloop);
-//     g_main_loop_run(mainloop);
-//     g_source_remove(timeout_id);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
+
        _is_fail = true;
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -2839,10 +3410,12 @@ int utc_account_query_account_by_capability_type_n(void)
        const char* type = "type";
 
        ret = account_query_account_by_capability_type(NULL, type, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_query_account_by_capability_type(account_cb_func, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -2860,37 +3433,45 @@ int utc_account_query_capability_by_account_id_p(void)
        account_capability_state_e capability_state = ACCOUNT_CAPABILITY_ENABLED;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, capability_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, capability_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-
-//     mainloop = g_main_loop_new(NULL, FALSE);
-//     assert(mainloop);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_capability_by_account_id(capability_call_back, account_id, &account);
-//     assert_eq(_is_fail, false);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
 
        ret = account_query_capability_by_account_id(capability_call_back_return_false, account_id, &account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-//     int timeout_id = g_timeout_add(3000, timeout_cb, mainloop);
-//     g_main_loop_run(mainloop);
-//     g_source_remove(timeout_id);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
+
        _is_fail = true;
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -2905,10 +3486,12 @@ int utc_account_query_capability_by_account_id_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_query_capability_by_account_id(capability_call_back, -1, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_query_capability_by_account_id(NULL, 1, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -2924,7 +3507,8 @@ int utc_account_get_total_count_from_db_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_total_count_from_db(&count);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -2939,7 +3523,8 @@ int utc_account_get_total_count_from_db_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_get_total_count_from_db(NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -2957,32 +3542,47 @@ int utc_account_update_sync_status_by_id_p(void)
        account_sync_state_e sync_state = -1;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_update_sync_status_by_id(account_id, ACCOUNT_SYNC_STATUS_IDLE);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_create(&ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_account_by_account_id(account_id, &ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_sync_support(ret_account, &sync_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(sync_state, ACCOUNT_SYNC_STATUS_IDLE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(sync_state, ACCOUNT_SYNC_STATUS_IDLE);
+       }
 
        ret = account_destroy(ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -2997,7 +3597,8 @@ int utc_account_update_sync_status_by_id_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_update_sync_status_by_id(-1, ACCOUNT_SYNC_STATUS_IDLE);
-       assert_neq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_neq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3014,16 +3615,20 @@ int utc_account_delete_from_db_by_id_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3038,10 +3643,12 @@ int utc_account_delete_from_db_by_id_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_delete_from_db_by_id(-1);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_delete_from_db_by_id(1000000);
-       assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);}
 
        return 0;
 }
@@ -3058,13 +3665,16 @@ int utc_account_delete_from_db_by_user_name_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_delete_from_db_by_user_name(user_name, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3081,13 +3691,16 @@ int utc_account_delete_from_db_by_user_name_n(void)
        char *delete_user_name = "non_registered_user_name";
 
        ret = account_delete_from_db_by_user_name(NULL, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_delete_from_db_by_user_name(user_name, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_delete_from_db_by_user_name(delete_user_name, delete_package_name);
-       assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);}
 
        return 0;
 }
@@ -3105,16 +3718,20 @@ int utc_account_delete_from_db_by_package_name_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_delete_from_db_by_package_name(package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3130,10 +3747,12 @@ int utc_account_delete_from_db_by_package_name_n(void)
        char *delete_package_name = "non_registered_package_name";
 
        ret = account_delete_from_db_by_package_name(NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_delete_from_db_by_package_name(delete_package_name);
-       assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);}
 
        return 0;
 }
@@ -3153,36 +3772,52 @@ int utc_account_update_to_db_by_id_p(void)
        account_h ret_account = NULL;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_user_name(account, update_user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_update_to_db_by_id(account, account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_create(&ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_account_by_account_id(account_id, &ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_user_name(account, &ret_user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_user_name, update_user_name), 0);
-
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_user_name, update_user_name), 0);
+       }
        _account_free_text(ret_user_name);
+
        ret = account_destroy(ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3198,10 +3833,12 @@ int utc_account_update_to_db_by_id_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_update_to_db_by_id(account, -1);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_update_to_db_by_id(account, 1000000);
-       assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);}
 
        return 0;
 }
@@ -3222,40 +3859,63 @@ int utc_account_update_to_db_by_user_name_p(void)
        account_capability_state_e capability_state = ACCOUNT_CAPABILITY_ENABLED;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_capability(account, contact_capability, capability_state);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_update_to_db_by_user_name(account, user_name, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_create(&ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_account_by_account_id(account_id, &ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_user_name(account, &ret_user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_user_name, user_name), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_user_name, user_name), 0);
+       }
        _account_free_text(ret_user_name);
 
        ret = account_get_capability(account, contact_capability, &value);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(value, ACCOUNT_CAPABILITY_ENABLED);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(value, ACCOUNT_CAPABILITY_ENABLED);
+       }
 
        ret = account_destroy(ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3279,9 +3939,6 @@ int utc_account_update_to_db_by_user_name_n(void)
        ret = account_update_to_db_by_user_name(account, user_name, NULL);
        assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
 
-//     ret = account_update_to_db_by_user_name(account, user_name, package_name);
-//     assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);
-
        return 0;
 }
 
@@ -3298,13 +3955,16 @@ int utc_account_subscribe_create_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_subscribe_create(&account_subscribe);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_subscribe_notification(account_subscribe, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_unsubscribe_notification(account_subscribe);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3320,7 +3980,8 @@ int utc_account_subscribe_create_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_subscribe_create(NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -3337,13 +3998,16 @@ int utc_account_subscribe_notification_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_subscribe_create(&account_subscribe);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_subscribe_notification(account_subscribe, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_unsubscribe_notification(account_subscribe);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3360,16 +4024,20 @@ int utc_account_subscribe_notification_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_subscribe_create(&account_subscribe);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_subscribe_notification(NULL, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_subscribe_notification(account_subscribe, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_unsubscribe_notification(account_subscribe);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3385,13 +4053,16 @@ int utc_account_unsubscribe_notification_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_subscribe_create(&account_subscribe);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_subscribe_notification(account_subscribe, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_unsubscribe_notification(account_subscribe);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3407,7 +4078,8 @@ int utc_account_unsubscribe_notification_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_unsubscribe_notification(NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -3423,10 +4095,12 @@ int utc_account_type_create_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3441,7 +4115,8 @@ int utc_account_type_create_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_type_create(NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -3457,10 +4132,12 @@ int utc_account_type_destroy_p(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3475,7 +4152,8 @@ int utc_account_type_destroy_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_type_destroy(NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -3493,18 +4171,28 @@ int utc_account_type_get_app_id_p(void)
        char* ret_app_id = NULL;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_by_app_id(app_id, &account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_app_id(account_type, &ret_app_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_app_id, app_id), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_app_id, app_id), 0);
+       }
        _account_free_text(ret_app_id);
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3521,16 +4209,20 @@ int utc_account_type_get_app_id_n(void)
        char* ret_app_id = NULL;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_app_id(NULL, &ret_app_id);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_get_app_id(account_type, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3552,21 +4244,30 @@ int utc_account_type_get_icon_path_p(void)
        dlog_print(DLOG_ERROR, "ACCOUNT_TC", "icon_path %s", icon_path);
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_by_app_id(app_id, &account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_icon_path(account_type, &ret_icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       dlog_print(DLOG_ERROR, "ACCOUNT_TC", "ret_icon_path %s", ret_icon_path);
-
-       assert_eq(strcmp(ret_icon_path, icon_path), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               dlog_print(DLOG_ERROR, "ACCOUNT_TC", "ret_icon_path %s", ret_icon_path);
+               assert_eq(strcmp(ret_icon_path, icon_path), 0);
+       }
        _account_free_text(ret_icon_path);
        _account_free_text(icon_path);
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3583,16 +4284,20 @@ int utc_account_type_get_icon_path_n(void)
        char* ret_icon_path = NULL;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_icon_path(NULL, &ret_icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_get_icon_path(account_type, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3611,18 +4316,28 @@ int utc_account_type_get_label_by_locale_p(void)
        char* ret_label = NULL;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_by_app_id(app_id, &account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_label_by_locale(account_type, locale, &ret_label);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_label, test_label_en_gb), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_label, test_label_en_gb), 0);
+       }
        _account_free_text(ret_label);
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3640,16 +4355,20 @@ int utc_account_type_get_label_by_locale_n(void)
        const char* locale = "locale";
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_label_by_locale(NULL, locale, &ret_label);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_get_label_by_locale(account_type, locale, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3663,8 +4382,6 @@ static bool account_label_cb_func(char* app_id, char* label, char* locale, void
                        _is_fail = false;
        }
 
-//     g_main_loop_quit(mainloop);
-//     mainloop = NULL;
        return TRUE;
 }
 
@@ -3682,25 +4399,29 @@ int utc_account_type_get_label_p(void)
        const char* locale = "locale";
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_by_app_id(app_id, &account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-
-//     mainloop = g_main_loop_new(NULL, FALSE);
-//     assert(mainloop);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_label(account_type, account_label_cb_func, (void*)test_label_en_gb);
-//     assert_eq(_is_fail, false);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-//     int timeout_id = g_timeout_add(3000, timeout_cb, mainloop);
-//     g_main_loop_run(mainloop);
-//     g_source_remove(timeout_id);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
+
        _is_fail = true;
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3716,16 +4437,20 @@ int utc_account_type_get_label_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_label(NULL, account_label_cb_func, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_get_label(account_type, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3743,17 +4468,27 @@ int utc_account_type_get_multiple_account_support_p(void)
        const char *app_id = TEST_PACKAGE_NAME;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_by_app_id(app_id, &account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_multiple_account_support(account_type, &ret_val);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(ret_val, true);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(ret_val, true);
+       }
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3770,16 +4505,20 @@ int utc_account_type_get_multiple_account_support_n(void)
        bool ret_val = true;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_multiple_account_support(NULL, &ret_val);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_get_multiple_account_support(account_type, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3798,8 +4537,6 @@ static bool provider_feature_cb_func(char* app_id, char* key, void* user_data)
        }
 
        _is_fail = false;
-//     g_main_loop_quit(mainloop);
-//     mainloop = NULL;
 
        return TRUE;
 }
@@ -3817,26 +4554,30 @@ int utc_account_type_get_provider_feature_all_p(void)
        const char* app_id = TEST_PACKAGE_NAME;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_by_app_id(app_id, &account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-
-//     mainloop = g_main_loop_new(NULL, FALSE);
-//     assert(mainloop);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        _is_fail = true;
        ret = account_type_get_provider_feature_all(account_type, provider_feature_cb_func, (void *)provider_feature);
-//     assert_eq(_is_fail, false);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-//     int timeout_id = g_timeout_add(3000, timeout_cb, mainloop);
-//     g_main_loop_run(mainloop);
-//     g_source_remove(timeout_id);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
+
        _is_fail = true;
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3852,16 +4593,20 @@ int utc_account_type_get_provider_feature_all_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_provider_feature_all(NULL, provider_feature_cb_func, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_get_provider_feature_all(account_type, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3880,18 +4625,29 @@ int utc_account_type_get_service_provider_id_p(void)
        char* ret_service_provider_id = NULL;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_by_app_id(app_id, &account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_service_provider_id(account_type, &ret_service_provider_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_service_provider_id, service_provider_id), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_service_provider_id, service_provider_id), 0);
+       }
+
        _account_free_text(ret_service_provider_id);
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3908,16 +4664,20 @@ int utc_account_type_get_service_provider_id_n(void)
        char* ret_service_provider_id = NULL;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_service_provider_id(account_type, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_get_service_provider_id(NULL, &ret_service_provider_id);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3939,21 +4699,30 @@ int utc_account_type_get_small_icon_path_p(void)
        dlog_print(DLOG_ERROR, "ACCOUNT_TC", "small_icon_path %s", small_icon_path);
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_by_app_id(app_id, &account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_small_icon_path(account_type, &ret_small_icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       dlog_print(DLOG_ERROR, "ACCOUNT_TC", "ret_small_icon_path %s", ret_small_icon_path);
-
-       assert_eq(strcmp(ret_small_icon_path, small_icon_path), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               dlog_print(DLOG_ERROR, "ACCOUNT_TC", "ret_small_icon_path %s", ret_small_icon_path);
+               assert_eq(strcmp(ret_small_icon_path, small_icon_path), 0);
+       }
        _account_free_text(ret_small_icon_path);
        _account_free_text(small_icon_path);
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3970,16 +4739,20 @@ int utc_account_type_get_small_icon_path_n(void)
        char* ret_small_icon_path = NULL;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_small_icon_path(NULL, &ret_small_icon_path);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_get_small_icon_path(account_type, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -3998,18 +4771,29 @@ int utc_account_type_query_by_app_id_p(void)
        int account_type_id = 0;
 
        ret = account_type_create(&ret_account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_by_app_id(app_id, &ret_account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_get_app_id(ret_account_type, &ret_app_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_app_id, app_id), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_app_id, app_id), 0);
+       }
+
        _account_free_text(ret_app_id);
 
        ret = account_type_destroy(ret_account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -4027,19 +4811,24 @@ int utc_account_type_query_by_app_id_n(void)
        const char* app_id = "account_type_query_by_app_id";
 
        ret = account_type_query_by_app_id(app_id, &account_type);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_by_app_id(NULL, &account_type);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_query_by_app_id(app_id, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -4059,10 +4848,12 @@ int utc_account_type_query_app_id_exist_p(void)
        int a_type_id = -1;
 
        ret = account_type_query_app_id_exist(not_registered_app_id);
-       assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);}
 
        ret = account_type_query_app_id_exist(app_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -4077,7 +4868,8 @@ int utc_account_type_query_app_id_exist_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_type_query_app_id_exist(NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -4111,35 +4903,47 @@ static bool account_type_for_query_by_provider_cb(account_type_h account_type, v
        dlog_print(DLOG_ERROR, "ACCOUNT_TC", "test_small_icon_path %s", test_small_icon_path);
 
        ret = account_type_get_app_id(account_type, &app_id);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(package_name, app_id)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(package_name, app_id)==0);
+       }
        _account_free_text(app_id);
 
        ret = account_type_get_icon_path(account_type, &icon_path);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(test_icon_path, icon_path)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(test_icon_path, icon_path)==0);
+       }
        _account_free_text(icon_path);
        _account_free_text(test_icon_path);
 
        ret = account_type_get_small_icon_path(account_type, &small_icon_path);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(test_small_icon_path, small_icon_path)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(test_small_icon_path, small_icon_path)==0);
+       }
        _account_free_text(small_icon_path);
        _account_free_text(test_small_icon_path);
 
        ret = account_type_get_multiple_account_support(account_type, &multi_account_support);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(test_multi_account_support == multi_account_support);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(test_multi_account_support == multi_account_support);
+       }
 
        ret = account_type_get_label_by_locale(account_type, locale, &label);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(test_label_en_gb, label) == 0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(test_label_en_gb, label) == 0);
+       }
        _account_free_text(label);
 
        _is_fail = true;
        ret = account_type_get_provider_feature_all(account_type, provider_feature_cb_func,  capability);
-       check_fail(_is_fail == false);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
+       if(is_account_supported) {
+               check_fail(_is_fail == false);
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+       }
 
        _is_fail = false;
 
@@ -4167,11 +4971,19 @@ int utc_account_type_query_by_provider_feature_p(void)
        int a_type_id = -1;
 
        ret = account_type_query_by_provider_feature(account_type_for_query_by_provider_cb, contact_capability, NULL);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
 
        ret = account_type_query_by_provider_feature(account_type_for_query_by_provider_cb_return_false, contact_capability, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        _is_fail = true;
 
@@ -4190,10 +5002,12 @@ int utc_account_type_query_by_provider_feature_n(void)
        const char* key = contact_capability;
 
        ret = account_type_query_by_provider_feature(account_type_for_query_by_provider_cb, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_query_by_provider_feature(NULL, key, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -4238,19 +5052,29 @@ int utc_account_type_query_label_by_app_id_p(void)
        const char* service_provider_id = TEST_PACKAGE_NAME;
 
        ret = account_type_create(&account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_type_query_label_by_app_id(account_type_for_query_by_app_id_cb, package_name, test_label_en_gb);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
 
        ret = account_type_query_label_by_app_id(account_type_for_query_by_app_id_cb_return_false, package_name, test_label_en_gb);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        _is_fail = true;
 
        account_type_destroy(account_type);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -4266,10 +5090,12 @@ int utc_account_type_query_label_by_app_id_n(void)
        const char* app_id = "account_type_query_label_by_app_id";
 
        ret = account_type_query_label_by_app_id(NULL, app_id, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_query_label_by_app_id(account_type_for_query_by_app_id_cb, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -4287,8 +5113,15 @@ int utc_account_type_query_label_by_locale_p(void)
        char* ret_label = NULL;
 
        ret = account_type_query_label_by_locale(app_id, locale, &ret_label);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_label, test_label_en_gb), 0);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_label, test_label_en_gb), 0);
+       }
        _account_free_text(ret_label);
 
        return 0;
@@ -4307,10 +5140,12 @@ int utc_account_type_query_label_by_locale_n(void)
        char* ret_label = NULL;
 
        ret = account_type_get_label_by_locale(NULL, locale, &ret_label);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_get_label_by_locale(app_id, locale, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -4328,8 +5163,15 @@ int utc_account_type_query_provider_feature_by_app_id_p(void)
        int account_type_id = -1;
 
        ret = account_type_query_provider_feature_by_app_id(provider_feature_cb_func, app_id, NULL);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
        _is_fail = true;
 
        return 0;
@@ -4347,13 +5189,16 @@ int utc_account_type_query_provider_feature_by_app_id_n(void)
        const char* provider_feature = "provider_feature";
 
        ret = account_type_query_provider_feature_by_app_id(provider_feature_cb_func, app_id,provider_feature);
-       assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);}
 
        ret = account_type_query_provider_feature_by_app_id(NULL, app_id, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_type_query_provider_feature_by_app_id(provider_feature_cb_func, NULL, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }
@@ -4387,15 +5232,36 @@ int utc_account_type_query_supported_feature_n(void)
        const char* capability = "capability";
 
        ret = account_type_query_supported_feature(app_id, capability);
-       assert_eq(ret, false);
-       assert_eq(get_last_result(), ACCOUNT_ERROR_RECORD_NOT_FOUND);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, true);
+       }
+       else
+       {
+               assert_eq(ret, false);
+               assert_eq(get_last_result(), ACCOUNT_ERROR_RECORD_NOT_FOUND);
+       }
 
        ret = account_type_query_supported_feature(NULL, capability);
-       assert_eq(ret, false);
-       assert_eq(get_last_result(), ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, true);
+       }
+       else
+       {
+               assert_eq(ret, false);
+               assert_eq(get_last_result(), ACCOUNT_ERROR_INVALID_PARAMETER);
+       }
 
        ret = account_type_query_supported_feature(app_id, NULL);
-       assert_eq(ret, FALSE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, true);
+       }
+       else
+       {
+               assert_eq(ret, FALSE);
+       }
 
        return 0;
 }
@@ -4415,36 +5281,52 @@ int utc_account_update_to_db_by_id_ex_p(void)
        account_h ret_account = NULL;
 
        ret = account_set_user_name(account, user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_package_name(account, package_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_insert_to_db(account, &account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_set_user_name(account, update_user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_update_to_db_by_id_ex(account, account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_create(&ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_query_account_by_account_id(account_id, &ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_get_user_name(account, &ret_user_name);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
-       assert_eq(strcmp(ret_user_name, update_user_name), 0);
-
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+               assert_eq(strcmp(ret_user_name, update_user_name), 0);
+       }
        _account_free_text(ret_user_name);
+
        ret = account_destroy(ret_account);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        ret = account_delete_from_db_by_id(account_id);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        return 0;
 }
@@ -4460,13 +5342,16 @@ int utc_account_update_to_db_by_id_ex_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_update_to_db_by_id_ex(account, -1);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_update_to_db_by_id_ex(NULL, 1);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        ret = account_update_to_db_by_id(account, 1000000);
-       assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_RECORD_NOT_FOUND);}
 
        return 0;
 }
@@ -4500,50 +5385,63 @@ static bool account_type_cb_func(account_type_h account_type, void *user_data) {
        dlog_print(DLOG_ERROR, "ACCOUNT_TC", "test_small_icon_path %s", test_small_icon_path);
 
        ret = account_type_get_app_id(account_type, &app_id);
-       if(ret != ACCOUNT_ERROR_NONE) {
-               _is_fail=true;
-               _account_free_text(app_id);
-               return true;
-       }
-       if( strcmp(app_id, package_name) != 0 )
-       {
-               _is_fail=true;
-               _account_free_text(app_id);
-               return true;
+       if(is_account_supported) {
+               if(ret != ACCOUNT_ERROR_NONE) {
+                       _is_fail=true;
+                       _account_free_text(app_id);
+                       return true;
+               }
+               if( strcmp(app_id, package_name) != 0 )
+               {
+                       _is_fail=true;
+                       _account_free_text(app_id);
+                       return true;
+               }
        }
        _account_free_text(app_id);
 
        ret = account_type_get_icon_path(account_type, &icon_path);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(test_icon_path, icon_path)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(test_icon_path, icon_path)==0);
+       }
        _account_free_text(icon_path);
        _account_free_text(test_icon_path);
 
        ret = account_type_get_small_icon_path(account_type, &small_icon_path);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(test_small_icon_path, small_icon_path)==0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(test_small_icon_path, small_icon_path)==0);
+       }
        _account_free_text(small_icon_path);
        _account_free_text(test_small_icon_path);
 
        ret = account_type_get_multiple_account_support(account_type, &multi_account_support);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(test_multi_account_support == multi_account_support);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(test_multi_account_support == multi_account_support);
+       }
 
        ret = account_type_get_label_by_locale(account_type, locale, &label);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(strcmp(test_label_en_gb, label) == 0);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(strcmp(test_label_en_gb, label) == 0);
+       }
        _account_free_text(label);
 
        _is_fail = true;
        ret = account_type_get_provider_feature_all(account_type, provider_feature_cb_func, (void *)contact_capability);
-
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(_is_fail == false);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(_is_fail == false);
+       }
 
        _is_fail = true;
        ret = account_type_get_provider_feature_all(account_type, provider_feature_cb_func_return_false, (void *)contact_capability);
-       check_fail(ret == ACCOUNT_ERROR_NONE);
-       check_fail(_is_fail == false);
+       if(is_account_supported) {
+               check_fail(ret == ACCOUNT_ERROR_NONE);
+               check_fail(_is_fail == false);
+       }
 
        _is_fail = false;
 
@@ -4562,11 +5460,19 @@ int utc_account_type_foreach_account_type_from_db_p(void)
        _is_fail = true;
 
        ret = account_type_foreach_account_type_from_db(account_type_cb_func, NULL);
-       is_callback_fail();
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported)
+       {
+               assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);
+       }
+       else
+       {
+               is_callback_fail();
+               assert_eq(ret, ACCOUNT_ERROR_NONE);
+       }
 
        ret = account_type_foreach_account_type_from_db(account_type_cb_func_return_false, NULL);
-       assert_eq(ret, ACCOUNT_ERROR_NONE);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_NONE);}
 
        _is_fail = false;
 
@@ -4583,7 +5489,8 @@ int utc_account_type_foreach_account_type_from_db_n(void)
        int ret = ACCOUNT_ERROR_NONE;
 
        ret = account_type_foreach_account_type_from_db(NULL, account);
-       assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);
+       if(!is_account_supported){assert_eq(ret, ACCOUNT_ERROR_NOT_SUPPORTED);}
+       else{assert_eq(ret, ACCOUNT_ERROR_INVALID_PARAMETER);}
 
        return 0;
 }