[UTC][capi-maps-service][NON-ACR][Fixed fail issue when mapzen plugin package is...

Change-Id: Ie40c7e8beb6315fd85e6fa5715ca3e97f4417ed1
Signed-off-by: jomui <jongmun.woo@samsung.com>

diff --git a/src/utc/capi-maps-service/utc_maps_service_mapzen.c b/src/utc/capi-maps-service/utc_maps_service_mapzen.c
index 930b100d02dcf48a87ee49de2106c5001d3ce04d..3f1aecfbe4113e6737b6774fe1ec1edaa05e8f27 100755 (executable)
--- a/src/utc/capi-maps-service/utc_maps_service_mapzen.c
+++ b/src/utc/capi-maps-service/utc_maps_service_mapzen.c
@@ -33,6 +33,7 @@ static char maps_provider_key[CONFIG_VALUE_LEN_MAX] = {0,};
 static const int INVALID_REQUEST_ID = -1;
 static bool is_internet_supported = false;
 static bool is_maps_supported = false;
+static bool is_mapzen_included = false;
 
 /**
  * @function           utc_maps_service_startup2
@@ -44,6 +45,7 @@ void utc_maps_service_startup2(void)
 {
        is_internet_supported = _is_internet_feature_supported();
        is_maps_supported = _is_maps_feature_supported();
+       is_mapzen_included = _is_included_mapzen_plugin();
 
        GetValueFromConfigFile("MAPZEN_MAPS_PROVIDER_KEY", maps_provider_key, API_NAMESPACE);
 
@@ -107,8 +109,9 @@ static void quit_for_service(void)
 
 static bool __utc_maps_service_provider_info_cb(char *maps_provider, void *user_data)
 {
+       if (strcmp("MAPZEN", maps_provider) == 0)
+               service_available = true;
        free(maps_provider);
-       service_available = true;
        return true;
 }
 
@@ -121,7 +124,7 @@ int utc_maps_service_foreach_provider_p2(void)
 {
        ret = maps_service_foreach_provider(__utc_maps_service_provider_info_cb, NULL);
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-       if (is_maps_supported)
+       if (is_maps_supported && is_mapzen_included)
                assert(service_available);
        service_available = false;
 
@@ -151,12 +154,16 @@ int utc_maps_service_create_p2(void)
        maps_service_h service = NULL;
 
        ret = maps_service_create(__utc_get_maps_provider_name_mapzen(), &service);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-       if (is_maps_supported)
+       ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported && is_mapzen_included)
                assert(service);
 
        ret = maps_service_destroy(service);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        return 0;
 }
@@ -217,7 +224,11 @@ int utc_maps_service_destroy_n2(void)
 int utc_maps_service_set_provider_key_p2(void)
 {
        ret = maps_service_set_provider_key(__pMaps, maps_provider_key);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        return 0;
 }
@@ -250,8 +261,12 @@ int utc_maps_service_get_provider_key_p2(void)
        char *maps_key = NULL;
 
        ret = maps_service_get_provider_key(__pMaps, &maps_key);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-       if (is_maps_supported)
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+       if (is_maps_supported && is_mapzen_included)
                assert(maps_key);
        return 0;
 }
@@ -290,7 +305,11 @@ int utc_maps_service_set_preference_p2(void)
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_service_set_preference(__pMaps, preference);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_preference_destroy(preference);
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
@@ -327,7 +346,11 @@ int utc_maps_service_get_preference_p2(void)
        maps_preference_h preference = NULL;
 
        ret = maps_service_get_preference(__pMaps, &preference);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        return 0;
 }
@@ -363,49 +386,109 @@ int utc_maps_service_provider_is_service_supported_p2(void)
        bool test = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_GEOCODE, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_GEOCODE_INSIDE_AREA, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_GEOCODE_BY_STRUCTURED_ADDRESS, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_REVERSE_GEOCODE, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE_BY_AREA, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE_BY_ADDRESS, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_ROUTE, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_ROUTE_WAYPOINTS, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_CANCEL_REQUEST, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_MULTI_REVERSE_GEOCODE, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE_LIST, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_GET_PLACE_DETAILS, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_VIEW, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_VIEW_SNAPSHOT, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        return 0;
 }
@@ -444,55 +527,123 @@ int utc_maps_service_provider_is_data_supported_p2(void)
        bool test = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_PLACE_ADDRESS, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_PLACE_RATING, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_PLACE_CATEGORIES, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_PLACE_ATTRIBUTES, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_PLACE_CONTACTS, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_PLACE_EDITORIALS, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_PLACE_REVIEWS, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_PLACE_IMAGE, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_PLACE_SUPPLIER, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_PLACE_RELATED, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_ROUTE_PATH, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_ROUTE_SEGMENTS_PATH, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_ROUTE_SEGMENTS_MANEUVERS, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_TRAFFIC, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_PUBLIC_TRANSIT, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_BUILDING, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_SCALEBAR, &test);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        return 0;
 }
@@ -545,10 +696,22 @@ int utc_maps_service_geocode_p2(void)
        bool is_geocode_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_GEOCODE, &is_geocode_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode(__pMaps, "Berlin", __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_geocode_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
        if (is_internet_supported && is_maps_supported && is_geocode_supported) {
                wait_for_service();
                assert(service_available);
@@ -568,22 +731,50 @@ int utc_maps_service_geocode_n2(void)
        bool is_geocode_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_GEOCODE, &is_geocode_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode(NULL, "Bangalore, India", __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_service_geocode(__pMaps, NULL, __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode(__pMaps, "Bangalore, India", __preference, NULL, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode(__pMaps, "Bangalore, India", __preference, __utc_maps_location_foreach_cb, NULL, NULL);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode(NULL, NULL, NULL, NULL, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        return 0;
 }
@@ -602,9 +793,13 @@ int utc_maps_service_geocode_inside_area_p2(void)
        bool is_geocode_inside_area_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_GEOCODE_INSIDE_AREA, &is_geocode_inside_area_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_internet_supported && is_mapzen_included) {
                maps_coordinates_create(15.665354, 74.311523, &top_left);
                maps_coordinates_create(10.617418, 79.145508, &bottom_right);
                assert(top_left);
@@ -619,7 +814,7 @@ int utc_maps_service_geocode_inside_area_p2(void)
                assert(boundary);
 
                ret = maps_service_geocode_inside_area(__pMaps, "Bengaluru", boundary, __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
-               if (is_internet_supported && is_geocode_inside_area_supported) {
+               if (is_geocode_inside_area_supported) {
                        assert_eq(ret, MAPS_ERROR_NONE);
 
                        wait_for_service();
@@ -635,7 +830,7 @@ int utc_maps_service_geocode_inside_area_p2(void)
                }
        } else {
                ret = maps_service_geocode_inside_area(__pMaps, "Bengaluru", boundary, __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_internet_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -654,7 +849,11 @@ int utc_maps_service_geocode_inside_area_n2(void)
        bool is_geocode_inside_area_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_GEOCODE_INSIDE_AREA, &is_geocode_inside_area_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        if (is_maps_supported) {
                maps_coordinates_create(15.665354, 74.311523, &top_left);
@@ -666,20 +865,37 @@ int utc_maps_service_geocode_inside_area_n2(void)
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(boundary);
        }
+
        ret = maps_service_geocode_inside_area(NULL, "Berlin", boundary, __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_service_geocode_inside_area(__pMaps, NULL, boundary, __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_inside_area_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_geocode_inside_area_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode_inside_area(__pMaps, "Berlin", NULL, __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_inside_area_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_geocode_inside_area_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode_inside_area(__pMaps, "Berlin", boundary, __preference, NULL, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_inside_area_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_geocode_inside_area_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode_inside_area(__pMaps, "Berlin", boundary, __preference, __utc_maps_location_foreach_cb, NULL, NULL);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_inside_area_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_geocode_inside_area_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode_inside_area(NULL, NULL, NULL, NULL, NULL, NULL, &request_id);
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
@@ -708,9 +924,13 @@ int utc_maps_service_geocode_by_structured_address_p2(void)
        bool is_geocode_by_structured_address_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_GEOCODE_BY_STRUCTURED_ADDRESS, &is_geocode_by_structured_address_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_internet_supported && is_mapzen_included) {
                ret = maps_address_create(&address);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(address);
@@ -723,7 +943,7 @@ int utc_maps_service_geocode_by_structured_address_p2(void)
                /* assert_eq(ret, MAPS_ERROR_NONE); */
 
                ret = maps_service_geocode_by_structured_address(__pMaps, address, __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
-               if (is_internet_supported && is_geocode_by_structured_address_supported) {
+               if (is_geocode_by_structured_address_supported) {
                        assert_eq(ret, MAPS_ERROR_NONE);
 
                        wait_for_service();
@@ -738,7 +958,7 @@ int utc_maps_service_geocode_by_structured_address_p2(void)
                }
        } else {
                ret = maps_service_geocode_by_structured_address(__pMaps, address, __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_internet_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -755,13 +975,18 @@ int utc_maps_service_geocode_by_structured_address_n2(void)
        bool is_geocode_by_structured_address_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_GEOCODE_BY_STRUCTURED_ADDRESS, &is_geocode_by_structured_address_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        if (is_maps_supported) {
                ret = maps_address_create(&address);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(address);
        }
+
        ret = maps_address_set_city(address, "Seoul");
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
 
@@ -769,13 +994,25 @@ int utc_maps_service_geocode_by_structured_address_n2(void)
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_service_geocode_by_structured_address(__pMaps, NULL, __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_by_structured_address_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_geocode_by_structured_address_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode_by_structured_address(__pMaps, address, __preference, NULL, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_by_structured_address_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_geocode_by_structured_address_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode_by_structured_address(__pMaps, address, __preference, __utc_maps_location_foreach_cb, NULL, NULL);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_geocode_by_structured_address_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_geocode_by_structured_address_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_geocode_by_structured_address(NULL, NULL, NULL, NULL, NULL, &request_id);
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
@@ -809,15 +1046,23 @@ int utc_maps_service_reverse_geocode_p2(void)
        bool is_reverse_geocode_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_REVERSE_GEOCODE, &is_reverse_geocode_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_reverse_geocode(__pMaps, 12.944594, 77.554303, __preference, __utc_maps_address_foreach_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_reverse_geocode_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-       if (is_internet_supported && is_maps_supported && is_reverse_geocode_supported) {
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_reverse_geocode_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+
                wait_for_service();
                assert(service_available);
                service_available = false;
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
+
        return 0;
 }
 
@@ -832,22 +1077,58 @@ int utc_maps_service_reverse_geocode_n2(void)
        bool is_reverse_geocode_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_REVERSE_GEOCODE, &is_reverse_geocode_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_reverse_geocode(NULL, 12.944594, 77.554303, __preference, __utc_maps_address_foreach_cb, NULL, &request_id);
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_service_reverse_geocode(__pMaps,  12.944594, 77.554303, __preference, __utc_maps_address_foreach_cb, NULL, NULL);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_reverse_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_reverse_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_reverse_geocode(__pMaps,  -91.00, 77.554303, __preference, __utc_maps_address_foreach_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_reverse_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_reverse_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_reverse_geocode(__pMaps,  12.944594, 181.4546, __preference, __utc_maps_address_foreach_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_reverse_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_reverse_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_reverse_geocode(__pMaps,  12.944594, 77.554303, __preference, NULL, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_reverse_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_reverse_geocode_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_reverse_geocode(NULL,  12.944594, 77.554303, NULL, NULL, NULL, NULL);
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
@@ -866,13 +1147,21 @@ int utc_maps_service_cancel_request_p2(void)
        bool is_cancel_request_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_CANCEL_REQUEST, &is_cancel_request_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
-       ret = maps_service_geocode(__pMaps, "Bangalore, India", __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_cancel_request_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-       if (is_internet_supported && is_maps_supported && is_cancel_request_supported) {
-               ret = maps_service_cancel_request(__pMaps, request_id);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ret = maps_service_geocode(__pMaps, "Bangalore, India", __preference, __utc_maps_location_foreach_cb, NULL, &request_id);
                assert_eq(ret, MAPS_ERROR_NONE);
+
+               ret = maps_service_cancel_request(__pMaps, request_id);
+               ASSERT_IF_VAL_REF2(ret, is_cancel_request_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ret = maps_service_cancel_request(__pMaps, request_id);
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -888,13 +1177,25 @@ int utc_maps_service_cancel_request_n2(void)
        bool is_cancel_request_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_CANCEL_REQUEST, &is_cancel_request_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_cancel_request(NULL, request_id);
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_service_cancel_request(__pMaps, -1);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_cancel_request_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_cancel_request_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_cancel_request(NULL, -1);
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
@@ -928,16 +1229,20 @@ int utc_maps_service_search_route_p2(void)
        bool is_search_route_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_ROUTE, &is_search_route_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_internet_supported && is_mapzen_included) {
                maps_coordinates_create(37.564263, 126.974676, &origin);
                maps_coordinates_create(37.557120, 126.992410, &dest);
                assert(origin);
                assert(dest);
 
                ret = maps_service_search_route(__pMaps, origin, dest, __preference, __utc_maps_route_service_found_cb, NULL, &request_id);
-               if (is_internet_supported && is_search_route_supported) {
+               if (is_search_route_supported) {
                        assert_eq(ret, MAPS_ERROR_NONE);
 
                        wait_for_service();
@@ -953,7 +1258,7 @@ int utc_maps_service_search_route_p2(void)
                }
        } else {
                ret = maps_service_search_route(__pMaps, origin, dest, __preference, __utc_maps_route_service_found_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_internet_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -971,7 +1276,11 @@ int utc_maps_service_search_route_n2(void)
        bool is_search_route_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_ROUTE, &is_search_route_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        if (is_maps_supported) {
                ret = maps_coordinates_create(37.564263, 126.974676, &origin);
@@ -986,16 +1295,32 @@ int utc_maps_service_search_route_n2(void)
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_service_search_route(__pMaps, NULL, dest, __preference, __utc_maps_route_service_found_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_search_route_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_search_route_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_search_route(__pMaps, origin, NULL, __preference, __utc_maps_route_service_found_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_search_route_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_search_route_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_search_route(__pMaps, origin, dest, __preference,  NULL, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_search_route_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_search_route_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_search_route(__pMaps, origin, dest, __preference, __utc_maps_route_service_found_cb, NULL, NULL);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_search_route_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_search_route_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_search_route(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
@@ -1021,9 +1346,13 @@ int utc_maps_service_search_route_waypoints_p2(void)
        bool is_search_route_waypoint_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_ROUTE_WAYPOINTS, &is_search_route_waypoint_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_internet_supported && is_mapzen_included) {
                waypoints = (maps_coordinates_h *)g_malloc(sizeof(maps_coordinates_h)*3);
                maps_coordinates_create(37.564263, 126.974676, &waypoints[0]);
                maps_coordinates_create(37.557120, 126.992410, &waypoints[1]);
@@ -1033,7 +1362,7 @@ int utc_maps_service_search_route_waypoints_p2(void)
                assert(waypoints[2]);
 
                ret = maps_service_search_route_waypoints(__pMaps, waypoints, 3, __preference, __utc_maps_route_service_found_cb, NULL, &request_id);
-               if (is_internet_supported && is_search_route_waypoint_supported) {
+               if (is_search_route_waypoint_supported) {
                        assert_eq(ret, MAPS_ERROR_NONE);
 
                        wait_for_service();
@@ -1052,7 +1381,7 @@ int utc_maps_service_search_route_waypoints_p2(void)
                g_free(waypoints);
        } else {
                ret = maps_service_search_route_waypoints(__pMaps, waypoints, 3, __preference, __utc_maps_route_service_found_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_internet_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1069,9 +1398,13 @@ int utc_maps_service_search_route_waypoints_n2(void)
        bool is_search_route_waypoint_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_ROUTE_WAYPOINTS, &is_search_route_waypoint_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_mapzen_included) {
                waypoints = (maps_coordinates_h *)g_malloc(sizeof(maps_coordinates_h)*3);
                maps_coordinates_create(37.564263, 126.974676, &waypoints[0]);
                maps_coordinates_create(37.557120, 126.992410, &waypoints[1]);
@@ -1111,22 +1444,22 @@ int utc_maps_service_search_route_waypoints_n2(void)
                g_free(waypoints);
        } else {
                ret = maps_service_search_route_waypoints(NULL, waypoints, 3, __preference, __utc_maps_route_service_found_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_route_waypoints(__pMaps, NULL, 3, __preference, __utc_maps_route_service_found_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_route_waypoints(__pMaps, waypoints, 3, __preference, NULL, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_route_waypoints(__pMaps, waypoints, 3, __preference, __utc_maps_route_service_found_cb, NULL, NULL);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_route_waypoints(__pMaps, waypoints, -1, __preference, __utc_maps_route_service_found_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_route_waypoints(NULL, NULL, 0, NULL, NULL, NULL, NULL);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1157,9 +1490,13 @@ int utc_maps_service_search_place_p2(void)
        bool is_search_place_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE, &is_search_place_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_internet_supported && is_mapzen_included) {
                ret = maps_place_filter_create(&places_fil);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(places_fil);
@@ -1175,7 +1512,7 @@ int utc_maps_service_search_place_p2(void)
                assert(coords);
 
                ret = maps_service_search_place(__pMaps, coords, 100, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               if (is_internet_supported && is_search_place_supported) {
+               if (is_search_place_supported) {
                        assert_eq(ret, MAPS_ERROR_NONE);
 
                        wait_for_service();
@@ -1192,7 +1529,7 @@ int utc_maps_service_search_place_p2(void)
                }
        } else {
                ret = maps_service_search_place(__pMaps, coords, 100, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_internet_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1210,9 +1547,13 @@ int utc_maps_service_search_place_n2(void)
        bool is_search_place_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE, &is_search_place_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_mapzen_included) {
                ret = maps_place_filter_create(&places_fil);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(places_fil);
@@ -1258,25 +1599,25 @@ int utc_maps_service_search_place_n2(void)
                assert_eq(ret, MAPS_ERROR_NONE);
        } else {
                ret = maps_service_search_place(NULL, coords, 100, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place(__pMaps, NULL, 100, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place(__pMaps, coords, 100, NULL, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place(__pMaps, coords, 0,  places_fil, __preference, NULL, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place(__pMaps, coords, 0,  places_fil, __preference, __utc_maps_service_search_place_cb, NULL, NULL);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place(NULL, NULL, 0,  NULL, NULL, NULL, NULL, NULL);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place(__pMaps, coords, -1, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1296,9 +1637,13 @@ int utc_maps_service_search_place_by_area_p2(void)
        bool is_search_place_by_area_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE_BY_AREA, &is_search_place_by_area_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_internet_supported && is_mapzen_included) {
                ret = maps_place_filter_create(&places_fil);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(places_fil);
@@ -1319,7 +1664,7 @@ int utc_maps_service_search_place_by_area_p2(void)
                assert(area);
 
                ret = maps_service_search_place_by_area(__pMaps, area,  places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               if (is_internet_supported && is_search_place_by_area_supported) {
+               if (is_search_place_by_area_supported) {
                        assert_eq(ret, MAPS_ERROR_NONE);
 
                        wait_for_service();
@@ -1341,7 +1686,7 @@ int utc_maps_service_search_place_by_area_p2(void)
                        assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
        } else {
                ret = maps_service_search_place_by_area(__pMaps, area,  places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_internet_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1361,9 +1706,13 @@ int utc_maps_service_search_place_by_area_n2(void)
        bool is_search_place_by_area_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE_BY_AREA, &is_search_place_by_area_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_mapzen_included) {
                ret = maps_place_filter_create(&places_fil);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(places_fil);
@@ -1417,22 +1766,22 @@ int utc_maps_service_search_place_by_area_n2(void)
                assert_eq(ret, MAPS_ERROR_NONE);
        } else {
                ret = maps_service_search_place_by_area(NULL, area,  places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_area(__pMaps, NULL,  places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_area(__pMaps, area, NULL, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_area(__pMaps, area, places_fil, __preference, NULL, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_area(__pMaps, area, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, NULL);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_area(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1452,9 +1801,13 @@ int utc_maps_service_search_place_by_address_p2(void)
        bool is_search_place_by_address_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE_BY_ADDRESS, &is_search_place_by_address_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_internet_supported && is_mapzen_included) {
                ret = maps_place_filter_create(&places_fil);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(places_fil);
@@ -1469,7 +1822,7 @@ int utc_maps_service_search_place_by_address_p2(void)
                assert(area);
 
                ret = maps_service_search_place_by_address(__pMaps, "Bengaluru", area, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               if (is_internet_supported && is_search_place_by_address_supported) {
+               if (is_search_place_by_address_supported) {
                        assert_eq(ret, MAPS_ERROR_NONE);
 
                        wait_for_service();
@@ -1482,7 +1835,7 @@ int utc_maps_service_search_place_by_address_p2(void)
                        assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
        } else {
                ret = maps_service_search_place_by_address(__pMaps, "Bengaluru", area, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_internet_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1502,9 +1855,13 @@ int utc_maps_service_search_place_by_address_n2(void)
        bool is_search_place_by_address_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE_BY_ADDRESS, &is_search_place_by_address_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_mapzen_included) {
                ret = maps_place_filter_create(&places_fil);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(places_fil);
@@ -1552,25 +1909,25 @@ int utc_maps_service_search_place_by_address_n2(void)
                assert_eq(ret, MAPS_ERROR_NONE);
        } else {
                ret = maps_service_search_place_by_address(NULL, "Berlin", area, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_address(__pMaps, NULL, area, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_address(__pMaps, "Berlin", NULL, places_fil, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_address(__pMaps, "Berlin", area, NULL, __preference, __utc_maps_service_search_place_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_address(__pMaps, "Berlin", area, places_fil, __preference, NULL, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_address(__pMaps, "Berlin", area,  places_fil, __preference, __utc_maps_service_search_place_cb, NULL, NULL);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_by_address(NULL, NULL, NULL,  NULL, NULL, NULL, NULL, NULL);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1599,9 +1956,13 @@ int utc_maps_service_multi_reverse_geocode_p2(void)
        bool is_multi_reverse_geocode_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_MULTI_REVERSE_GEOCODE, &is_multi_reverse_geocode_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_internet_supported && is_mapzen_included) {
                ret = maps_coordinates_list_create(&coordinates_list);
                assert_eq(ret, MAPS_ERROR_NONE);
 
@@ -1623,7 +1984,7 @@ int utc_maps_service_multi_reverse_geocode_p2(void)
                assert_eq(ret, MAPS_ERROR_NONE);
 
                ret = maps_service_multi_reverse_geocode(__pMaps, coordinates_list, __preference, __utc_maps_service_multi_reverse_geocode_cb, NULL, &request_id);
-               if (is_internet_supported && is_multi_reverse_geocode_supported) {
+               if (is_multi_reverse_geocode_supported) {
                        assert_eq(ret, MAPS_ERROR_NONE);
 
                        wait_for_service();
@@ -1637,7 +1998,7 @@ int utc_maps_service_multi_reverse_geocode_p2(void)
                g_free(coord);
        } else {
                ret = maps_service_multi_reverse_geocode(__pMaps, coordinates_list, __preference, __utc_maps_service_multi_reverse_geocode_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_internet_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1655,9 +2016,13 @@ int utc_maps_service_multi_reverse_geocode_n2(void)
        bool is_multi_reverse_geocode_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_MULTI_REVERSE_GEOCODE, &is_multi_reverse_geocode_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_mapzen_included) {
                ret = maps_coordinates_list_create(&coordinates_list);
                assert_eq(ret, MAPS_ERROR_NONE);
 
@@ -1699,16 +2064,16 @@ int utc_maps_service_multi_reverse_geocode_n2(void)
                g_free(coord);
        } else {
                ret = maps_service_multi_reverse_geocode(NULL, coordinates_list, __preference, __utc_maps_service_multi_reverse_geocode_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_multi_reverse_geocode(__pMaps, NULL, __preference, __utc_maps_service_multi_reverse_geocode_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_multi_reverse_geocode(__pMaps, coordinates_list, __preference, NULL, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_multi_reverse_geocode(__pMaps, coordinates_list, __preference, __utc_maps_service_multi_reverse_geocode_cb, NULL, NULL);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1753,9 +2118,13 @@ int utc_maps_service_search_place_list_p2(void)
        bool is_search_place_list_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE_LIST, &is_search_place_list_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_internet_supported && is_mapzen_included) {
                ret = maps_place_filter_create(&places_fil);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(places_fil);
@@ -1774,7 +2143,7 @@ int utc_maps_service_search_place_list_p2(void)
                assert(boundary);
 
                ret = maps_service_search_place_list(__pMaps, boundary, places_fil, __preference, __utc_maps_service_search_place_list_cb, NULL, &request_id);
-               if (is_internet_supported && is_search_place_list_supported) {
+               if (is_search_place_list_supported) {
                        assert_eq(ret, MAPS_ERROR_NONE);
 
                        wait_for_service();
@@ -1793,7 +2162,7 @@ int utc_maps_service_search_place_list_p2(void)
                        assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
        } else {
                ret = maps_service_search_place_list(__pMaps, boundary, places_fil, __preference, __utc_maps_service_search_place_list_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_internet_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -1813,9 +2182,13 @@ int utc_maps_service_search_place_list_n2(void)
        bool is_search_place_list_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE_LIST, &is_search_place_list_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_mapzen_included) {
                ret = maps_place_filter_create(&places_fil);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(places_fil);
@@ -1853,19 +2226,19 @@ int utc_maps_service_search_place_list_n2(void)
                assert_eq(ret, MAPS_ERROR_NONE);
        } else {
                ret = maps_service_search_place_list(NULL, boundary, places_fil, __preference, __utc_maps_service_search_place_list_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_list(__pMaps, NULL, places_fil, __preference, __utc_maps_service_search_place_list_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_list(__pMaps, boundary, NULL, __preference, __utc_maps_service_search_place_list_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_list(__pMaps, boundary, places_fil, __preference, NULL, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
                ret = maps_service_search_place_list(__pMaps, boundary, places_fil, __preference, __utc_maps_service_search_place_list_cb, NULL, NULL);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1901,12 +2274,20 @@ int utc_maps_service_get_place_details_p2(void)
        bool is_search_get_place_details_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_PLACE_LIST, &is_search_place_list_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_GET_PLACE_DETAILS, &is_search_get_place_details_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
+
+       if (is_maps_supported && is_internet_supported && is_mapzen_included) {
                ret = maps_place_filter_create(&places_fil);
                assert_eq(ret, MAPS_ERROR_NONE);
                assert(places_fil);
@@ -1925,7 +2306,7 @@ int utc_maps_service_get_place_details_p2(void)
                assert(boundary);
 
                ret = maps_service_search_place_list(__pMaps, boundary, places_fil, __preference, __utc_maps_service_search_place_list_cb, NULL, &request_id);
-               if (is_internet_supported && is_search_place_list_supported) {
+               if (is_search_place_list_supported) {
                        assert_eq(ret, MAPS_ERROR_NONE);
 
                        if (!service_available)
@@ -1934,7 +2315,7 @@ int utc_maps_service_get_place_details_p2(void)
                        service_available = false;
 
                        ret = maps_service_get_place_details(__pMaps, __place_uri, __utc_maps_service_get_place_details_cb, NULL, &request_id);
-                       if (is_internet_supported && is_search_get_place_details_supported) {
+                       if (is_search_get_place_details_supported) {
                                assert_eq(ret, MAPS_ERROR_NONE);
 
                                if (!service_available)
@@ -1956,7 +2337,7 @@ int utc_maps_service_get_place_details_p2(void)
                        assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
        } else {
                ret = maps_service_get_place_details(__pMaps, __place_uri, __utc_maps_service_get_place_details_cb, NULL, &request_id);
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_internet_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
        return 0;
 }
@@ -1972,19 +2353,47 @@ int utc_maps_service_get_place_details_n2(void)
        bool is_search_get_place_details_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_SEARCH_GET_PLACE_DETAILS, &is_search_get_place_details_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_get_place_details(NULL, __place_uri, __utc_maps_service_get_place_details_cb, NULL, &request_id);
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_service_get_place_details(__pMaps, NULL, __utc_maps_service_get_place_details_cb, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_search_get_place_details_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_search_get_place_details_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_get_place_details(__pMaps, __place_uri, NULL, NULL, &request_id);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_search_get_place_details_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_search_get_place_details_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_service_get_place_details(__pMaps, __place_uri, __utc_maps_service_get_place_details_cb, NULL, NULL);
-       ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported && is_search_get_place_details_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_internet_supported && is_maps_supported) {
+               if (is_mapzen_included) {
+                       ASSERT_IF_VAL_REF2(ret, is_search_get_place_details_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+               } else {
+                       assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
+               }
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        return 0;
 }
@@ -2000,7 +2409,7 @@ static void __utc_maps_service_request_user_consent_cb(bool consented, const cha
 int utc_maps_service_request_user_consent_p2(void)
 {
        ret = maps_service_request_user_consent(__utc_get_maps_provider_name_mapzen(), __utc_maps_service_request_user_consent_cb, NULL);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
 
        return 0;
 }

diff --git a/src/utc/capi-maps-service/utc_maps_utils.c b/src/utc/capi-maps-service/utc_maps_utils.c
index c21d586793ccd3a9f0d4f1d45352d81dc79c056d..08541a3ce786defc5d17bcea6a00fe8e56c3226b 100755 (executable)
--- a/src/utc/capi-maps-service/utc_maps_utils.c
+++ b/src/utc/capi-maps-service/utc_maps_utils.c
@@ -16,9 +16,32 @@
 
 #include "utc_maps_utils.h"
 
+static bool _is_removed_checked_providers = false;
+static bool _is_removed_HERE = false;
+static bool _is_removed_MAPZEN = true;
+
 static char *MAPS_PROVIDER_NAME_HERE = "HERE";
 static char *MAPS_PROVIDER_NAME_MAPZEN = "MAPZEN";
 
+static bool __check_removed_provider_cb(char *maps_provider, void *user_data)
+{
+       if (strcmp(MAPS_PROVIDER_NAME_MAPZEN, maps_provider) == 0)
+               _is_removed_MAPZEN = false;
+       free(maps_provider);
+       return true;
+}
+
+bool _is_included_mapzen_plugin()
+{
+       if (_is_removed_checked_providers == false)
+               maps_service_foreach_provider( __check_removed_provider_cb, NULL);
+       _is_removed_checked_providers = true;
+
+       if (_is_removed_MAPZEN)
+               return false;
+       return true;
+}
+
 char *__utc_get_maps_provider_name_here()
 {
        return MAPS_PROVIDER_NAME_HERE;

diff --git a/src/utc/capi-maps-service/utc_maps_utils.h b/src/utc/capi-maps-service/utc_maps_utils.h
index a2252659be3b2c65ae1a82c80c75dcd4c583d822..d34b6edeae8e0b3f00253ea4f299db57077f220a 100755 (executable)
--- a/src/utc/capi-maps-service/utc_maps_utils.h
+++ b/src/utc/capi-maps-service/utc_maps_utils.h
@@ -43,6 +43,9 @@
                } \
        } \
 
+/* Returns false if maps-plugin-mapzen package is not included */
+bool _is_included_mapzen_plugin();
+
 /* Returns the name of current provider */
 char *__utc_get_maps_provider_name_here();
 char *__utc_get_maps_provider_name_mapzen();

diff --git a/src/utc/capi-maps-service/utc_maps_view_mapzen.c b/src/utc/capi-maps-service/utc_maps_view_mapzen.c
index 6043822215ed45fddd7539800735f3f6cc972908..23c787b4261fb1b31a6fa2b323a3d07adf7e2bb8 100755 (executable)
--- a/src/utc/capi-maps-service/utc_maps_view_mapzen.c
+++ b/src/utc/capi-maps-service/utc_maps_view_mapzen.c
@@ -34,6 +34,7 @@ static Evas_Object *win = NULL;
 static bool is_internet_supported = false;
 static bool is_maps_supported = false;
 static bool is_maps_view_supported = false;
+static bool is_mapzen_included = false;
 
 static void dummy_utc_maps_view_on_event_cb(maps_view_event_type_e type, maps_view_event_data_h event_data, void *user_data) { }
 
@@ -52,6 +53,7 @@ void utc_maps_view_startup2(void)
 {
        is_internet_supported = _is_internet_feature_supported();
        is_maps_supported = _is_maps_feature_supported();
+       is_mapzen_included = _is_included_mapzen_plugin();
 
        elm_init(0, NULL);
        elm_config_accel_preference_set("opengl");
@@ -97,7 +99,7 @@ void utc_maps_view_cleanup2(void)
 int utc_maps_view_create_p2(void)
 {
        ret = maps_view_destroy(maps_view_handle);
-       if (is_maps_supported == true) {
+       if (is_maps_supported) {
                ASSERT_IF_VAL_REF2(ret, is_maps_view_supported, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
        } else
                assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
@@ -105,7 +107,11 @@ int utc_maps_view_create_p2(void)
        maps_view_handle = NULL;
 
        ret = maps_view_create(__pMaps, win, &maps_view_handle);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_maps_view_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_maps_view_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        return 0;
 }
@@ -121,10 +127,18 @@ int utc_maps_view_create_n2(void)
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_view_create(__pMaps, NULL, &maps_view_handle);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_maps_view_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_maps_view_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_create(__pMaps, win, NULL);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported && is_maps_view_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported && is_mapzen_included) {
+               ASSERT_IF_VAL_REF2(ret, is_maps_view_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       } else {
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        return 0;
 }
@@ -604,17 +618,21 @@ int utc_maps_view_set_buildings_enabled_p2(void)
        bool is_building_supported = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_BUILDING, &is_building_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_set_buildings_enabled(maps_view_handle, false);
-       if (is_internet_supported && is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_building_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -644,17 +662,21 @@ int utc_maps_view_get_buildings_enabled_p2(void)
        bool enabled = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_BUILDING, &is_building_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_get_buildings_enabled(maps_view_handle, &enabled);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_building_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -671,20 +693,24 @@ int utc_maps_view_get_buildings_enabled_n2(void)
        bool is_building_supported = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_BUILDING, &is_building_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_get_buildings_enabled(NULL, &enabled);
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_view_get_buildings_enabled(maps_view_handle, NULL);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_building_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -700,17 +726,21 @@ int utc_maps_view_set_traffic_enabled_p2(void)
        bool is_traffic_supported = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_TRAFFIC, &is_traffic_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_set_traffic_enabled(maps_view_handle, false);
-       if (is_internet_supported && is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_traffic_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -740,17 +770,21 @@ int utc_maps_view_get_traffic_enabled_p2(void)
        bool enabled = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_TRAFFIC, &is_traffic_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_get_traffic_enabled(maps_view_handle, &enabled);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_traffic_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -767,20 +801,24 @@ int utc_maps_view_get_traffic_enabled_n2(void)
        bool is_traffic_supported = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_TRAFFIC, &is_traffic_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_get_traffic_enabled(NULL, &enabled);
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_view_get_traffic_enabled(maps_view_handle, NULL);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_traffic_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -796,17 +834,21 @@ int utc_maps_view_set_public_transit_enabled_p2(void)
        bool is_public_transit_supported = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_PUBLIC_TRANSIT, &is_public_transit_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_set_public_transit_enabled(maps_view_handle, false);
-       if (is_internet_supported && is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_public_transit_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -836,17 +878,21 @@ int utc_maps_view_get_public_transit_enabled_p2(void)
        bool enabled = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_PUBLIC_TRANSIT, &is_public_transit_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_get_public_transit_enabled(maps_view_handle, &enabled);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_public_transit_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -863,20 +909,24 @@ int utc_maps_view_get_public_transit_enabled_n2(void)
        bool is_public_transit_supported = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_PUBLIC_TRANSIT, &is_public_transit_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_get_public_transit_enabled(NULL, &enabled);
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_view_get_public_transit_enabled(maps_view_handle, NULL);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_public_transit_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -1352,17 +1402,21 @@ int utc_maps_view_set_scalebar_enabled_p2(void)
        bool is_scalebar_supported = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_SCALEBAR, &is_scalebar_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_set_scalebar_enabled(maps_view_handle, false);
-       if (is_internet_supported && is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_internet_supported && is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_scalebar_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -1375,11 +1429,6 @@ int utc_maps_view_set_scalebar_enabled_p2(void)
 */
 int utc_maps_view_set_scalebar_enabled_n2(void)
 {
-       bool is_scalebar_supported = false;
-
-       ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_SCALEBAR, &is_scalebar_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
-
        ret = maps_view_set_scalebar_enabled(NULL, false);
        ASSERT_IF_VAL_REF2(ret, is_internet_supported && is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
@@ -1397,17 +1446,21 @@ int utc_maps_view_get_scalebar_enabled_p2(void)
        bool is_scalebar_supported = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_SCALEBAR, &is_scalebar_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_get_scalebar_enabled(maps_view_handle, &enabled);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_scalebar_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -1424,20 +1477,24 @@ int utc_maps_view_get_scalebar_enabled_n2(void)
        bool enabled = false;
 
        ret = maps_service_provider_is_data_supported(__pMaps, MAPS_VIEW_SCALEBAR, &is_scalebar_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_get_scalebar_enabled(NULL, &enabled);
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_view_get_scalebar_enabled(maps_view_handle, NULL);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_scalebar_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -1748,28 +1805,32 @@ int utc_maps_view_capture_snapshot_p2(void)
        bool is_snapshot_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_VIEW_SNAPSHOT, &is_snapshot_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_capture_snapshot(maps_view_handle, MAPS_VIEW_SNAPSHOT_BMP, 90, "/tmp/maps_tmp_image.bmp");
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_snapshot_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        ret = maps_view_capture_snapshot(maps_view_handle, MAPS_VIEW_SNAPSHOT_JPEG, 90, "/tmp/maps_tmp_image.jpg");
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_snapshot_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;
@@ -1786,42 +1847,46 @@ int utc_maps_view_capture_snapshot_n2(void)
        bool is_snapshot_supported = false;
 
        ret = maps_service_provider_is_service_supported(__pMaps, MAPS_SERVICE_VIEW_SNAPSHOT, &is_snapshot_supported);
-       ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_NONE, MAPS_ERROR_NOT_SUPPORTED);
+       if (is_maps_supported) {
+               ASSERT_IF_VAL_REF2(ret, is_mapzen_included, MAPS_ERROR_NONE, MAPS_ERROR_INVALID_PARAMETER);
+       } else {
+               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+       }
 
        ret = maps_view_capture_snapshot(NULL, MAPS_VIEW_SNAPSHOT_BMP, 50, path);
        ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
 
        ret = maps_view_capture_snapshot(maps_view_handle, MAPS_VIEW_SNAPSHOT_BMP - 1, 50, path);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_snapshot_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        ret = maps_view_capture_snapshot(maps_view_handle, MAPS_VIEW_SNAPSHOT_BMP, -1, path);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_snapshot_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        ret = maps_view_capture_snapshot(maps_view_handle, MAPS_VIEW_SNAPSHOT_BMP, 50, NULL);
-       if (is_maps_supported == true) {
-               if (is_maps_view_supported == true) {
+       if (is_maps_supported && is_mapzen_included) {
+               if (is_maps_view_supported) {
                        ASSERT_IF_VAL_REF2(ret, is_snapshot_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
                } else {
                        assert_eq(ret, MAPS_ERROR_INVALID_PARAMETER);
                }
        } else {
-               assert_eq(ret, MAPS_ERROR_NOT_SUPPORTED);
+               ASSERT_IF_VAL_REF2(ret, is_maps_supported, MAPS_ERROR_INVALID_PARAMETER, MAPS_ERROR_NOT_SUPPORTED);
        }
 
        return 0;