installd_utils_test.cpp revision 871a8f236ef2a055b9955b47a342b2c44c020ef7
1/* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include <stdlib.h> 18#include <string.h> 19 20#include <gtest/gtest.h> 21 22#include "InstalldNativeService.h" 23#include "globals.h" 24#include "utils.h" 25 26#undef LOG_TAG 27#define LOG_TAG "utils_test" 28 29#define TEST_DATA_DIR "/data/" 30#define TEST_APP_DIR "/data/app/" 31#define TEST_APP_PRIVATE_DIR "/data/app-private/" 32#define TEST_APP_EPHEMERAL_DIR "/data/app-ephemeral/" 33#define TEST_ASEC_DIR "/mnt/asec/" 34#define TEST_EXPAND_DIR "/mnt/expand/" 35 36#define TEST_SYSTEM_DIR1 "/system/app/" 37#define TEST_SYSTEM_DIR2 "/vendor/app/" 38 39#define REALLY_LONG_APP_NAME "com.example." \ 40 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa." \ 41 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa." \ 42 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 43 44#define REALLY_LONG_LEAF_NAME "shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_" \ 45 "shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_" \ 46 "shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_" \ 47 "shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_shared_prefs_" 48 49namespace android { 50namespace installd { 51 52class UtilsTest : public testing::Test { 53protected: 54 virtual void SetUp() { 55 android_app_dir.path = (char*) TEST_APP_DIR; 56 android_app_dir.len = strlen(TEST_APP_DIR); 57 58 android_app_private_dir.path = (char*) TEST_APP_PRIVATE_DIR; 59 android_app_private_dir.len = strlen(TEST_APP_PRIVATE_DIR); 60 61 android_app_ephemeral_dir.path = (char*) TEST_APP_EPHEMERAL_DIR; 62 android_app_ephemeral_dir.len = strlen(TEST_APP_EPHEMERAL_DIR); 63 64 android_data_dir.path = (char*) TEST_DATA_DIR; 65 android_data_dir.len = strlen(TEST_DATA_DIR); 66 67 android_asec_dir.path = (char*) TEST_ASEC_DIR; 68 android_asec_dir.len = strlen(TEST_ASEC_DIR); 69 70 android_mnt_expand_dir.path = (char*) TEST_EXPAND_DIR; 71 android_mnt_expand_dir.len = strlen(TEST_EXPAND_DIR); 72 73 android_system_dirs.count = 2; 74 75 android_system_dirs.dirs = (dir_rec_t*) calloc(android_system_dirs.count, sizeof(dir_rec_t)); 76 android_system_dirs.dirs[0].path = (char*) TEST_SYSTEM_DIR1; 77 android_system_dirs.dirs[0].len = strlen(TEST_SYSTEM_DIR1); 78 79 android_system_dirs.dirs[1].path = (char*) TEST_SYSTEM_DIR2; 80 android_system_dirs.dirs[1].len = strlen(TEST_SYSTEM_DIR2); 81 } 82 83 virtual void TearDown() { 84 free(android_system_dirs.dirs); 85 } 86}; 87 88TEST_F(UtilsTest, IsValidApkPath_BadPrefix) { 89 // Bad prefixes directories 90 const char *badprefix1 = "/etc/passwd"; 91 EXPECT_EQ(-1, validate_apk_path(badprefix1)) 92 << badprefix1 << " should not be allowed as a valid path"; 93 94 const char *badprefix2 = "../.." TEST_APP_DIR "../../../blah"; 95 EXPECT_EQ(-1, validate_apk_path(badprefix2)) 96 << badprefix2 << " should not be allowed as a valid path"; 97 98 const char *badprefix3 = "init.rc"; 99 EXPECT_EQ(-1, validate_apk_path(badprefix3)) 100 << badprefix3 << " should not be allowed as a valid path"; 101 102 const char *badprefix4 = "/init.rc"; 103 EXPECT_EQ(-1, validate_apk_path(badprefix4)) 104 << badprefix4 << " should not be allowed as a valid path"; 105} 106 107TEST_F(UtilsTest, IsValidApkPath_Internal) { 108 // Internal directories 109 const char *internal1 = TEST_APP_DIR "example.apk"; 110 EXPECT_EQ(0, validate_apk_path(internal1)) 111 << internal1 << " should be allowed as a valid path"; 112 113 // b/16888084 114 const char *path2 = TEST_APP_DIR "example.com/example.apk"; 115 EXPECT_EQ(0, validate_apk_path(path2)) 116 << path2 << " should be allowed as a valid path"; 117 118 const char *badint1 = TEST_APP_DIR "../example.apk"; 119 EXPECT_EQ(-1, validate_apk_path(badint1)) 120 << badint1 << " should be rejected as a invalid path"; 121 122 const char *badint2 = TEST_APP_DIR "/../example.apk"; 123 EXPECT_EQ(-1, validate_apk_path(badint2)) 124 << badint2 << " should be rejected as a invalid path"; 125 126 // Only one subdir should be allowed. 127 const char *bad_path3 = TEST_APP_DIR "example.com/subdir/pkg.apk"; 128 EXPECT_EQ(-1, validate_apk_path(bad_path3)) 129 << bad_path3 << " should be rejected as a invalid path"; 130 131 const char *bad_path4 = TEST_APP_DIR "example.com/subdir/../pkg.apk"; 132 EXPECT_EQ(-1, validate_apk_path(bad_path4)) 133 << bad_path4 << " should be rejected as a invalid path"; 134 135 const char *bad_path5 = TEST_APP_DIR "example.com1/../example.com2/pkg.apk"; 136 EXPECT_EQ(-1, validate_apk_path(bad_path5)) 137 << bad_path5 << " should be rejected as a invalid path"; 138} 139 140TEST_F(UtilsTest, IsValidApkPath_Private) { 141 // Internal directories 142 const char *private1 = TEST_APP_PRIVATE_DIR "example.apk"; 143 EXPECT_EQ(0, validate_apk_path(private1)) 144 << private1 << " should be allowed as a valid path"; 145 146 // b/16888084 147 const char *path2 = TEST_APP_DIR "example.com/example.apk"; 148 EXPECT_EQ(0, validate_apk_path(path2)) 149 << path2 << " should be allowed as a valid path"; 150 151 const char *badpriv1 = TEST_APP_PRIVATE_DIR "../example.apk"; 152 EXPECT_EQ(-1, validate_apk_path(badpriv1)) 153 << badpriv1 << " should be rejected as a invalid path"; 154 155 const char *badpriv2 = TEST_APP_PRIVATE_DIR "/../example.apk"; 156 EXPECT_EQ(-1, validate_apk_path(badpriv2)) 157 << badpriv2 << " should be rejected as a invalid path"; 158 159 // Only one subdir should be allowed. 160 const char *bad_path3 = TEST_APP_PRIVATE_DIR "example.com/subdir/pkg.apk"; 161 EXPECT_EQ(-1, validate_apk_path(bad_path3)) 162 << bad_path3 << " should be rejected as a invalid path"; 163 164 const char *bad_path4 = TEST_APP_PRIVATE_DIR "example.com/subdir/../pkg.apk"; 165 EXPECT_EQ(-1, validate_apk_path(bad_path4)) 166 << bad_path4 << " should be rejected as a invalid path"; 167 168 const char *bad_path5 = TEST_APP_PRIVATE_DIR "example.com1/../example.com2/pkg.apk"; 169 EXPECT_EQ(-1, validate_apk_path(bad_path5)) 170 << bad_path5 << " should be rejected as a invalid path"; 171} 172 173 174TEST_F(UtilsTest, IsValidApkPath_AsecGood1) { 175 const char *asec1 = TEST_ASEC_DIR "example.apk"; 176 EXPECT_EQ(0, validate_apk_path(asec1)) 177 << asec1 << " should be allowed as a valid path"; 178} 179 180TEST_F(UtilsTest, IsValidApkPath_AsecGood2) { 181 const char *asec2 = TEST_ASEC_DIR "com.example.asec/pkg.apk"; 182 EXPECT_EQ(0, validate_apk_path(asec2)) 183 << asec2 << " should be allowed as a valid path"; 184} 185 186TEST_F(UtilsTest, IsValidApkPath_EscapeFail) { 187 const char *badasec1 = TEST_ASEC_DIR "../example.apk"; 188 EXPECT_EQ(-1, validate_apk_path(badasec1)) 189 << badasec1 << " should be rejected as a invalid path"; 190} 191 192TEST_F(UtilsTest, IsValidApkPath_DoubleSlashFail) { 193 const char *badasec2 = TEST_ASEC_DIR "com.example.asec//pkg.apk"; 194 EXPECT_EQ(-1, validate_apk_path(badasec2)) 195 << badasec2 << " should be rejected as a invalid path"; 196} 197 198TEST_F(UtilsTest, IsValidApkPath_SubdirEscapeFail) { 199 const char *badasec3 = TEST_ASEC_DIR "com.example.asec/../../../pkg.apk"; 200 EXPECT_EQ(-1, validate_apk_path(badasec3)) 201 << badasec3 << " should be rejected as a invalid path"; 202} 203 204TEST_F(UtilsTest, IsValidApkPath_SlashEscapeFail) { 205 const char *badasec4 = TEST_ASEC_DIR "/../example.apk"; 206 EXPECT_EQ(-1, validate_apk_path(badasec4)) 207 << badasec4 << " should be rejected as a invalid path"; 208} 209 210TEST_F(UtilsTest, IsValidApkPath_CrazyDirFail) { 211 const char *badasec5 = TEST_ASEC_DIR ".//../.."; 212 EXPECT_EQ(-1, validate_apk_path(badasec5)) 213 << badasec5 << " should be rejected as a invalid path"; 214} 215 216TEST_F(UtilsTest, IsValidApkPath_SubdirEscapeSingleFail) { 217 const char *badasec6 = TEST_ASEC_DIR "com.example.asec/../pkg.apk"; 218 EXPECT_EQ(-1, validate_apk_path(badasec6)) 219 << badasec6 << " should be rejected as a invalid path"; 220} 221 222TEST_F(UtilsTest, IsValidApkPath_TwoSubdirFail) { 223 const char *badasec7 = TEST_ASEC_DIR "com.example.asec/subdir1/pkg.apk"; 224 EXPECT_EQ(-1, validate_apk_path(badasec7)) 225 << badasec7 << " should be rejected as a invalid path"; 226} 227 228TEST_F(UtilsTest, CheckSystemApp_Dir1) { 229 const char *sysapp1 = TEST_SYSTEM_DIR1 "Voice.apk"; 230 EXPECT_EQ(0, validate_system_app_path(sysapp1)) 231 << sysapp1 << " should be allowed as a system path"; 232} 233 234TEST_F(UtilsTest, CheckSystemApp_Dir2) { 235 const char *sysapp2 = TEST_SYSTEM_DIR2 "com.example.myapp.apk"; 236 EXPECT_EQ(0, validate_system_app_path(sysapp2)) 237 << sysapp2 << " should be allowed as a system path"; 238} 239 240TEST_F(UtilsTest, CheckSystemApp_EscapeFail) { 241 const char *badapp1 = TEST_SYSTEM_DIR1 "../com.example.apk"; 242 EXPECT_EQ(-1, validate_system_app_path(badapp1)) 243 << badapp1 << " should be rejected not a system path"; 244} 245 246TEST_F(UtilsTest, CheckSystemApp_DoubleEscapeFail) { 247 const char *badapp2 = TEST_SYSTEM_DIR2 "/../../com.example.apk"; 248 EXPECT_EQ(-1, validate_system_app_path(badapp2)) 249 << badapp2 << " should be rejected not a system path"; 250} 251 252TEST_F(UtilsTest, CheckSystemApp_BadPathEscapeFail) { 253 const char *badapp3 = TEST_APP_DIR "/../../com.example.apk"; 254 EXPECT_EQ(-1, validate_system_app_path(badapp3)) 255 << badapp3 << " should be rejected not a system path"; 256} 257 258TEST_F(UtilsTest, CheckSystemApp_Subdir) { 259 const char *sysapp = TEST_SYSTEM_DIR1 "com.example/com.example.apk"; 260 EXPECT_EQ(0, validate_system_app_path(sysapp)) 261 << sysapp << " should be allowed as a system path"; 262 263 const char *badapp = TEST_SYSTEM_DIR1 "com.example/subdir/com.example.apk"; 264 EXPECT_EQ(-1, validate_system_app_path(badapp)) 265 << badapp << " should be rejected not a system path"; 266 267 const char *badapp1 = TEST_SYSTEM_DIR1 "com.example/subdir/../com.example.apk"; 268 EXPECT_EQ(-1, validate_system_app_path(badapp1)) 269 << badapp1 << " should be rejected not a system path"; 270 271 const char *badapp2 = TEST_SYSTEM_DIR1 "com.example1/../com.example2/com.example.apk"; 272 EXPECT_EQ(-1, validate_system_app_path(badapp2)) 273 << badapp2 << " should be rejected not a system path"; 274} 275 276TEST_F(UtilsTest, GetPathFromString_NullPathFail) { 277 dir_rec_t test1; 278 EXPECT_EQ(-1, get_path_from_string(&test1, (const char *) NULL)) 279 << "Should not allow NULL as a path."; 280} 281 282TEST_F(UtilsTest, GetPathFromString_EmptyPathFail) { 283 dir_rec_t test1; 284 EXPECT_EQ(-1, get_path_from_string(&test1, "")) 285 << "Should not allow empty paths."; 286} 287 288TEST_F(UtilsTest, GetPathFromString_RelativePathFail) { 289 dir_rec_t test1; 290 EXPECT_EQ(-1, get_path_from_string(&test1, "mnt/asec")) 291 << "Should not allow relative paths."; 292} 293 294TEST_F(UtilsTest, GetPathFromString_NonCanonical) { 295 dir_rec_t test1; 296 297 EXPECT_EQ(0, get_path_from_string(&test1, "/mnt/asec")) 298 << "Should be able to canonicalize directory /mnt/asec"; 299 EXPECT_STREQ("/mnt/asec/", test1.path) 300 << "/mnt/asec should be canonicalized to /mnt/asec/"; 301 EXPECT_EQ(10, (ssize_t) test1.len) 302 << "path len should be equal to the length of /mnt/asec/ (10)"; 303 free(test1.path); 304} 305 306TEST_F(UtilsTest, GetPathFromString_CanonicalPath) { 307 dir_rec_t test3; 308 EXPECT_EQ(0, get_path_from_string(&test3, "/data/app/")) 309 << "Should be able to canonicalize directory /data/app/"; 310 EXPECT_STREQ("/data/app/", test3.path) 311 << "/data/app/ should be canonicalized to /data/app/"; 312 EXPECT_EQ(10, (ssize_t) test3.len) 313 << "path len should be equal to the length of /data/app/ (10)"; 314 free(test3.path); 315} 316 317TEST_F(UtilsTest, CreatePkgPath_LongPkgNameSuccess) { 318 char path[PKG_PATH_MAX]; 319 320 // Create long packagename of "aaaaa..." 321 size_t pkgnameSize = PKG_NAME_MAX; 322 char pkgname[pkgnameSize + 1]; 323 memset(pkgname, 'a', pkgnameSize); 324 pkgname[pkgnameSize] = '\0'; 325 326 EXPECT_EQ(0, create_pkg_path(path, pkgname, "", 0)) 327 << "Should successfully be able to create package name."; 328 329 std::string prefix = std::string(TEST_DATA_DIR) + PRIMARY_USER_PREFIX; 330 size_t offset = prefix.length(); 331 332 EXPECT_STREQ(pkgname, path + offset) 333 << "Package path should be a really long string of a's"; 334} 335 336TEST_F(UtilsTest, CreatePkgPath_LongPkgNameFail) { 337 char path[PKG_PATH_MAX]; 338 339 // Create long packagename of "aaaaa..." 340 size_t pkgnameSize = PKG_NAME_MAX + 1; 341 char pkgname[pkgnameSize + 1]; 342 memset(pkgname, 'a', pkgnameSize); 343 pkgname[pkgnameSize] = '\0'; 344 345 EXPECT_EQ(-1, create_pkg_path(path, pkgname, "", 0)) 346 << "Should return error because package name is too long."; 347} 348 349TEST_F(UtilsTest, CreatePkgPath_LongPostfixFail) { 350 char path[PKG_PATH_MAX]; 351 352 // Create long packagename of "aaaaa..." 353 size_t postfixSize = PKG_PATH_MAX; 354 char postfix[postfixSize + 1]; 355 memset(postfix, 'a', postfixSize); 356 postfix[postfixSize] = '\0'; 357 358 EXPECT_EQ(-1, create_pkg_path(path, "com.example.package", postfix, 0)) 359 << "Should return error because postfix is too long."; 360} 361 362TEST_F(UtilsTest, CreatePkgPath_PrimaryUser) { 363 char path[PKG_PATH_MAX]; 364 365 EXPECT_EQ(0, create_pkg_path(path, "com.example.package", "", 0)) 366 << "Should return error because postfix is too long."; 367 368 std::string p = std::string(TEST_DATA_DIR) 369 + PRIMARY_USER_PREFIX 370 + "com.example.package"; 371 EXPECT_STREQ(p.c_str(), path) 372 << "Package path should be in /data/data/"; 373} 374 375TEST_F(UtilsTest, CreatePkgPath_SecondaryUser) { 376 char path[PKG_PATH_MAX]; 377 378 EXPECT_EQ(0, create_pkg_path(path, "com.example.package", "", 1)) 379 << "Should successfully create package path."; 380 381 std::string p = std::string(TEST_DATA_DIR) 382 + SECONDARY_USER_PREFIX 383 + "1/com.example.package"; 384 EXPECT_STREQ(p.c_str(), path) 385 << "Package path should be in /data/user/"; 386} 387 388TEST_F(UtilsTest, CreateMovePath_Primary) { 389 char path[PKG_PATH_MAX]; 390 391 EXPECT_EQ(0, create_move_path(path, "com.android.test", "shared_prefs", 0)) 392 << "Should be able to create move path for primary user"; 393 394 EXPECT_STREQ("/data/data/com.android.test/shared_prefs", path) 395 << "Primary user package directory should be created correctly"; 396} 397 398TEST_F(UtilsTest, CreateMovePath_Fail_AppTooLong) { 399 char path[PKG_PATH_MAX]; 400 401 EXPECT_EQ(-1, create_move_path(path, REALLY_LONG_APP_NAME, "shared_prefs", 0)) 402 << "Should fail to create move path for primary user"; 403} 404 405TEST_F(UtilsTest, CreateMovePath_Fail_LeafTooLong) { 406 char path[PKG_PATH_MAX]; 407 408 EXPECT_EQ(-1, create_move_path(path, "com.android.test", REALLY_LONG_LEAF_NAME, 0)) 409 << "Should fail to create move path for primary user"; 410} 411 412TEST_F(UtilsTest, CopyAndAppend_Normal) { 413 //int copy_and_append(dir_rec_t* dst, dir_rec_t* src, char* suffix) 414 dir_rec_t dst; 415 dir_rec_t src; 416 417 src.path = (char*) "/data/"; 418 src.len = strlen(src.path); 419 420 EXPECT_EQ(0, copy_and_append(&dst, &src, "app/")) 421 << "Should return error because postfix is too long."; 422 423 EXPECT_STREQ("/data/app/", dst.path) 424 << "Appended path should be correct"; 425 426 EXPECT_EQ(10, (ssize_t) dst.len) 427 << "Appended path should be length of '/data/app/' (10)"; 428} 429 430TEST_F(UtilsTest, AppendAndIncrement_Normal) { 431 size_t dst_size = 10; 432 char dst[dst_size]; 433 char *dstp = dst; 434 const char* src = "FOO"; 435 436 EXPECT_EQ(0, append_and_increment(&dstp, src, &dst_size)) 437 << "String should append successfully"; 438 439 EXPECT_STREQ("FOO", dst) 440 << "String should append correctly"; 441 442 EXPECT_EQ(0, append_and_increment(&dstp, src, &dst_size)) 443 << "String should append successfully again"; 444 445 EXPECT_STREQ("FOOFOO", dst) 446 << "String should append correctly again"; 447} 448 449TEST_F(UtilsTest, AppendAndIncrement_TooBig) { 450 size_t dst_size = 5; 451 char dst[dst_size]; 452 char *dstp = dst; 453 const char* src = "FOO"; 454 455 EXPECT_EQ(0, append_and_increment(&dstp, src, &dst_size)) 456 << "String should append successfully"; 457 458 EXPECT_STREQ("FOO", dst) 459 << "String should append correctly"; 460 461 EXPECT_EQ(-1, append_and_increment(&dstp, src, &dst_size)) 462 << "String should fail because it's too large to fit"; 463} 464 465TEST_F(UtilsTest, CreateDataPath) { 466 EXPECT_EQ("/data", create_data_path(nullptr)); 467 EXPECT_EQ("/mnt/expand/57f8f4bc-abf4-655f-bf67-946fc0f9f25b", 468 create_data_path("57f8f4bc-abf4-655f-bf67-946fc0f9f25b")); 469} 470 471TEST_F(UtilsTest, CreateDataAppPath) { 472 EXPECT_EQ("/data/app", create_data_app_path(nullptr)); 473 474 EXPECT_EQ("/mnt/expand/57f8f4bc-abf4-655f-bf67-946fc0f9f25b/app", 475 create_data_app_path("57f8f4bc-abf4-655f-bf67-946fc0f9f25b")); 476} 477 478TEST_F(UtilsTest, CreateDataUserPath) { 479 EXPECT_EQ("/data/data", create_data_user_ce_path(nullptr, 0)); 480 EXPECT_EQ("/data/user/10", create_data_user_ce_path(nullptr, 10)); 481 482 EXPECT_EQ("/mnt/expand/57f8f4bc-abf4-655f-bf67-946fc0f9f25b/user/0", 483 create_data_user_ce_path("57f8f4bc-abf4-655f-bf67-946fc0f9f25b", 0)); 484 EXPECT_EQ("/mnt/expand/57f8f4bc-abf4-655f-bf67-946fc0f9f25b/user/10", 485 create_data_user_ce_path("57f8f4bc-abf4-655f-bf67-946fc0f9f25b", 10)); 486} 487 488TEST_F(UtilsTest, CreateDataMediaPath) { 489 EXPECT_EQ("/data/media/0", create_data_media_path(nullptr, 0)); 490 EXPECT_EQ("/data/media/10", create_data_media_path(nullptr, 10)); 491 492 EXPECT_EQ("/mnt/expand/57f8f4bc-abf4-655f-bf67-946fc0f9f25b/media/0", 493 create_data_media_path("57f8f4bc-abf4-655f-bf67-946fc0f9f25b", 0)); 494 EXPECT_EQ("/mnt/expand/57f8f4bc-abf4-655f-bf67-946fc0f9f25b/media/10", 495 create_data_media_path("57f8f4bc-abf4-655f-bf67-946fc0f9f25b", 10)); 496} 497 498TEST_F(UtilsTest, CreateDataAppPackagePath) { 499 EXPECT_EQ("/data/app/com.example", create_data_app_package_path(nullptr, "com.example")); 500 501 EXPECT_EQ("/mnt/expand/57f8f4bc-abf4-655f-bf67-946fc0f9f25b/app/com.example", 502 create_data_app_package_path("57f8f4bc-abf4-655f-bf67-946fc0f9f25b", "com.example")); 503} 504 505TEST_F(UtilsTest, CreateDataUserPackagePath) { 506 EXPECT_EQ("/data/data/com.example", create_data_user_ce_package_path(nullptr, 0, "com.example")); 507 EXPECT_EQ("/data/user/10/com.example", create_data_user_ce_package_path(nullptr, 10, "com.example")); 508 509 EXPECT_EQ("/mnt/expand/57f8f4bc-abf4-655f-bf67-946fc0f9f25b/user/0/com.example", 510 create_data_user_ce_package_path("57f8f4bc-abf4-655f-bf67-946fc0f9f25b", 0, "com.example")); 511 EXPECT_EQ("/mnt/expand/57f8f4bc-abf4-655f-bf67-946fc0f9f25b/user/10/com.example", 512 create_data_user_ce_package_path("57f8f4bc-abf4-655f-bf67-946fc0f9f25b", 10, "com.example")); 513} 514 515} // namespace installd 516} // namespace android 517