1 /* 2 * Copyright (C) 2010 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 #define LOG_TAG "ObbFile_test" 18 #include <androidfw/BackupHelpers.h> 19 #include <utils/Log.h> 20 #include <utils/String8.h> 21 22 #include <gtest/gtest.h> 23 24 #include <sys/types.h> 25 #include <sys/stat.h> 26 #include <fcntl.h> 27 #include <string.h> 28 29 namespace android { 30 31 #define TEST_FILENAME "/test.bd" 32 33 // keys of different lengths to test padding 34 #define KEY1 "key1" 35 #define KEY2 "key2a" 36 #define KEY3 "key3bc" 37 #define KEY4 "key4def" 38 39 // payloads of different lengths to test padding 40 #define DATA1 "abcdefg" 41 #define DATA2 "hijklmnopq" 42 #define DATA3 "rstuvwxyz" 43 // KEY4 is only ever deleted 44 45 class BackupDataTest : public testing::Test { 46 protected: 47 char* m_external_storage; 48 String8 mFilename; 49 String8 mKey1; 50 String8 mKey2; 51 String8 mKey3; 52 String8 mKey4; 53 54 virtual void SetUp() { 55 m_external_storage = getenv("EXTERNAL_STORAGE"); 56 mFilename.append(m_external_storage); 57 mFilename.append(TEST_FILENAME); 58 59 ::unlink(mFilename.string()); 60 int fd = ::open(mFilename.string(), O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR); 61 if (fd < 0) { 62 FAIL() << "Couldn't create " << mFilename.string() << " for writing"; 63 } 64 mKey1 = String8(KEY1); 65 mKey2 = String8(KEY2); 66 mKey3 = String8(KEY3); 67 mKey4 = String8(KEY4); 68 } 69 70 virtual void TearDown() { 71 } 72 }; 73 74 TEST_F(BackupDataTest, WriteAndReadSingle) { 75 int fd = ::open(mFilename.string(), O_WRONLY); 76 BackupDataWriter* writer = new BackupDataWriter(fd); 77 78 EXPECT_EQ(NO_ERROR, writer->WriteEntityHeader(mKey1, sizeof(DATA1))) 79 << "WriteEntityHeader returned an error"; 80 EXPECT_EQ(NO_ERROR, writer->WriteEntityData(DATA1, sizeof(DATA1))) 81 << "WriteEntityData returned an error"; 82 83 ::close(fd); 84 fd = ::open(mFilename.string(), O_RDONLY); 85 BackupDataReader* reader = new BackupDataReader(fd); 86 EXPECT_EQ(NO_ERROR, reader->Status()) 87 << "Reader ctor failed"; 88 89 bool done; 90 int type; 91 reader->ReadNextHeader(&done, &type); 92 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 93 << "wrong type from ReadNextHeader"; 94 95 String8 key; 96 size_t dataSize; 97 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 98 << "ReadEntityHeader returned an error"; 99 EXPECT_EQ(mKey1, key) 100 << "wrong key from ReadEntityHeader"; 101 EXPECT_EQ(sizeof(DATA1), dataSize) 102 << "wrong size from ReadEntityHeader"; 103 104 char* dataBytes = new char[dataSize]; 105 EXPECT_EQ((int) dataSize, reader->ReadEntityData(dataBytes, dataSize)) 106 << "ReadEntityData returned an error"; 107 for (unsigned int i = 0; i < sizeof(DATA1); i++) { 108 EXPECT_EQ(DATA1[i], dataBytes[i]) 109 << "data character " << i << " should be equal"; 110 } 111 delete dataBytes; 112 delete writer; 113 delete reader; 114 } 115 116 TEST_F(BackupDataTest, WriteAndReadMultiple) { 117 int fd = ::open(mFilename.string(), O_WRONLY); 118 BackupDataWriter* writer = new BackupDataWriter(fd); 119 writer->WriteEntityHeader(mKey1, sizeof(DATA1)); 120 writer->WriteEntityData(DATA1, sizeof(DATA1)); 121 writer->WriteEntityHeader(mKey2, sizeof(DATA2)); 122 writer->WriteEntityData(DATA2, sizeof(DATA2)); 123 124 ::close(fd); 125 fd = ::open(mFilename.string(), O_RDONLY); 126 BackupDataReader* reader = new BackupDataReader(fd); 127 128 bool done; 129 int type; 130 String8 key; 131 size_t dataSize; 132 char* dataBytes; 133 // read first entity 134 reader->ReadNextHeader(&done, &type); 135 reader->ReadEntityHeader(&key, &dataSize); 136 dataBytes = new char[dataSize]; 137 reader->ReadEntityData(dataBytes, dataSize); 138 delete dataBytes; 139 140 // read and verify second entity 141 reader->ReadNextHeader(&done, &type); 142 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 143 << "wrong type from ReadNextHeader"; 144 145 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 146 << "ReadEntityHeader returned an error on second entity"; 147 EXPECT_EQ(mKey2, key) 148 << "wrong key from ReadEntityHeader on second entity"; 149 EXPECT_EQ(sizeof(DATA2), dataSize) 150 << "wrong size from ReadEntityHeader on second entity"; 151 152 dataBytes = new char[dataSize]; 153 EXPECT_EQ((int)dataSize, reader->ReadEntityData(dataBytes, dataSize)) 154 << "ReadEntityData returned an error on second entity"; 155 for (unsigned int i = 0; i < sizeof(DATA2); i++) { 156 EXPECT_EQ(DATA2[i], dataBytes[i]) 157 << "data character " << i << " should be equal"; 158 } 159 delete dataBytes; 160 delete writer; 161 delete reader; 162 } 163 164 TEST_F(BackupDataTest, SkipEntity) { 165 int fd = ::open(mFilename.string(), O_WRONLY); 166 BackupDataWriter* writer = new BackupDataWriter(fd); 167 writer->WriteEntityHeader(mKey1, sizeof(DATA1)); 168 writer->WriteEntityData(DATA1, sizeof(DATA1)); 169 writer->WriteEntityHeader(mKey2, sizeof(DATA2)); 170 writer->WriteEntityData(DATA2, sizeof(DATA2)); 171 writer->WriteEntityHeader(mKey3, sizeof(DATA3)); 172 writer->WriteEntityData(DATA3, sizeof(DATA3)); 173 174 ::close(fd); 175 fd = ::open(mFilename.string(), O_RDONLY); 176 BackupDataReader* reader = new BackupDataReader(fd); 177 178 bool done; 179 int type; 180 String8 key; 181 size_t dataSize; 182 char* dataBytes; 183 // read first entity 184 reader->ReadNextHeader(&done, &type); 185 reader->ReadEntityHeader(&key, &dataSize); 186 dataBytes = new char[dataSize]; 187 reader->ReadEntityData(dataBytes, dataSize); 188 delete dataBytes; 189 190 // skip second entity 191 reader->ReadNextHeader(&done, &type); 192 reader->ReadEntityHeader(&key, &dataSize); 193 reader->SkipEntityData(); 194 195 // read and verify third entity 196 reader->ReadNextHeader(&done, &type); 197 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 198 << "wrong type from ReadNextHeader after skip"; 199 200 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 201 << "ReadEntityHeader returned an error on third entity"; 202 EXPECT_EQ(mKey3, key) 203 << "wrong key from ReadEntityHeader on third entity"; 204 EXPECT_EQ(sizeof(DATA3), dataSize) 205 << "wrong size from ReadEntityHeader on third entity"; 206 207 dataBytes = new char[dataSize]; 208 EXPECT_EQ((int) dataSize, reader->ReadEntityData(dataBytes, dataSize)) 209 << "ReadEntityData returned an error on third entity"; 210 for (unsigned int i = 0; i < sizeof(DATA3); i++) { 211 EXPECT_EQ(DATA3[i], dataBytes[i]) 212 << "data character " << i << " should be equal"; 213 } 214 delete dataBytes; 215 delete writer; 216 delete reader; 217 } 218 219 TEST_F(BackupDataTest, DeleteEntity) { 220 int fd = ::open(mFilename.string(), O_WRONLY); 221 BackupDataWriter* writer = new BackupDataWriter(fd); 222 writer->WriteEntityHeader(mKey1, sizeof(DATA1)); 223 writer->WriteEntityData(DATA1, sizeof(DATA1)); 224 writer->WriteEntityHeader(mKey2, -1); 225 226 ::close(fd); 227 fd = ::open(mFilename.string(), O_RDONLY); 228 BackupDataReader* reader = new BackupDataReader(fd); 229 230 bool done; 231 int type; 232 String8 key; 233 size_t dataSize; 234 char* dataBytes; 235 // read first entity 236 reader->ReadNextHeader(&done, &type); 237 reader->ReadEntityHeader(&key, &dataSize); 238 dataBytes = new char[dataSize]; 239 reader->ReadEntityData(dataBytes, dataSize); 240 delete dataBytes; 241 242 // read and verify deletion 243 reader->ReadNextHeader(&done, &type); 244 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 245 << "wrong type from ReadNextHeader on deletion"; 246 247 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 248 << "ReadEntityHeader returned an error on second entity"; 249 EXPECT_EQ(mKey2, key) 250 << "wrong key from ReadEntityHeader on second entity"; 251 EXPECT_EQ(-1, (int) dataSize) 252 << "not recognizing deletion on second entity"; 253 254 delete writer; 255 delete reader; 256 } 257 258 TEST_F(BackupDataTest, EneityAfterDelete) { 259 int fd = ::open(mFilename.string(), O_WRONLY); 260 BackupDataWriter* writer = new BackupDataWriter(fd); 261 writer->WriteEntityHeader(mKey1, sizeof(DATA1)); 262 writer->WriteEntityData(DATA1, sizeof(DATA1)); 263 writer->WriteEntityHeader(mKey2, -1); 264 writer->WriteEntityHeader(mKey3, sizeof(DATA3)); 265 writer->WriteEntityData(DATA3, sizeof(DATA3)); 266 267 ::close(fd); 268 fd = ::open(mFilename.string(), O_RDONLY); 269 BackupDataReader* reader = new BackupDataReader(fd); 270 271 bool done; 272 int type; 273 String8 key; 274 size_t dataSize; 275 char* dataBytes; 276 // read first entity 277 reader->ReadNextHeader(&done, &type); 278 reader->ReadEntityHeader(&key, &dataSize); 279 dataBytes = new char[dataSize]; 280 reader->ReadEntityData(dataBytes, dataSize); 281 delete dataBytes; 282 283 // read and verify deletion 284 reader->ReadNextHeader(&done, &type); 285 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 286 << "wrong type from ReadNextHeader on deletion"; 287 288 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 289 << "ReadEntityHeader returned an error on second entity"; 290 EXPECT_EQ(mKey2, key) 291 << "wrong key from ReadEntityHeader on second entity"; 292 EXPECT_EQ(-1, (int)dataSize) 293 << "not recognizing deletion on second entity"; 294 295 // read and verify third entity 296 reader->ReadNextHeader(&done, &type); 297 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 298 << "wrong type from ReadNextHeader after deletion"; 299 300 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 301 << "ReadEntityHeader returned an error on third entity"; 302 EXPECT_EQ(mKey3, key) 303 << "wrong key from ReadEntityHeader on third entity"; 304 EXPECT_EQ(sizeof(DATA3), dataSize) 305 << "wrong size from ReadEntityHeader on third entity"; 306 307 dataBytes = new char[dataSize]; 308 EXPECT_EQ((int) dataSize, reader->ReadEntityData(dataBytes, dataSize)) 309 << "ReadEntityData returned an error on third entity"; 310 for (unsigned int i = 0; i < sizeof(DATA3); i++) { 311 EXPECT_EQ(DATA3[i], dataBytes[i]) 312 << "data character " << i << " should be equal"; 313 } 314 delete dataBytes; 315 delete writer; 316 delete reader; 317 } 318 319 TEST_F(BackupDataTest, OnlyDeleteEntities) { 320 int fd = ::open(mFilename.string(), O_WRONLY); 321 BackupDataWriter* writer = new BackupDataWriter(fd); 322 writer->WriteEntityHeader(mKey1, -1); 323 writer->WriteEntityHeader(mKey2, -1); 324 writer->WriteEntityHeader(mKey3, -1); 325 writer->WriteEntityHeader(mKey4, -1); 326 327 ::close(fd); 328 fd = ::open(mFilename.string(), O_RDONLY); 329 BackupDataReader* reader = new BackupDataReader(fd); 330 331 bool done; 332 int type; 333 String8 key; 334 size_t dataSize; 335 // read and verify first deletion 336 reader->ReadNextHeader(&done, &type); 337 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 338 << "wrong type from ReadNextHeader first deletion"; 339 340 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 341 << "ReadEntityHeader returned an error on first entity"; 342 EXPECT_EQ(mKey1, key) 343 << "wrong key from ReadEntityHeader on first entity"; 344 EXPECT_EQ(-1, (int) dataSize) 345 << "not recognizing deletion on first entity"; 346 347 // read and verify second deletion 348 reader->ReadNextHeader(&done, &type); 349 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 350 << "wrong type from ReadNextHeader second deletion"; 351 352 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 353 << "ReadEntityHeader returned an error on second entity"; 354 EXPECT_EQ(mKey2, key) 355 << "wrong key from ReadEntityHeader on second entity"; 356 EXPECT_EQ(-1, (int) dataSize) 357 << "not recognizing deletion on second entity"; 358 359 // read and verify third deletion 360 reader->ReadNextHeader(&done, &type); 361 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 362 << "wrong type from ReadNextHeader third deletion"; 363 364 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 365 << "ReadEntityHeader returned an error on third entity"; 366 EXPECT_EQ(mKey3, key) 367 << "wrong key from ReadEntityHeader on third entity"; 368 EXPECT_EQ(-1, (int) dataSize) 369 << "not recognizing deletion on third entity"; 370 371 // read and verify fourth deletion 372 reader->ReadNextHeader(&done, &type); 373 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 374 << "wrong type from ReadNextHeader fourth deletion"; 375 376 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 377 << "ReadEntityHeader returned an error on fourth entity"; 378 EXPECT_EQ(mKey4, key) 379 << "wrong key from ReadEntityHeader on fourth entity"; 380 EXPECT_EQ(-1, (int) dataSize) 381 << "not recognizing deletion on fourth entity"; 382 383 delete writer; 384 delete reader; 385 } 386 387 TEST_F(BackupDataTest, ReadDeletedEntityData) { 388 int fd = ::open(mFilename.string(), O_WRONLY); 389 BackupDataWriter* writer = new BackupDataWriter(fd); 390 writer->WriteEntityHeader(mKey1, -1); 391 writer->WriteEntityHeader(mKey2, -1); 392 393 ::close(fd); 394 fd = ::open(mFilename.string(), O_RDONLY); 395 BackupDataReader* reader = new BackupDataReader(fd); 396 397 bool done; 398 int type; 399 String8 key; 400 size_t dataSize; 401 // read and verify first deletion 402 reader->ReadNextHeader(&done, &type); 403 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 404 << "wrong type from ReadNextHeader first deletion"; 405 406 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 407 << "ReadEntityHeader returned an error on first entity"; 408 EXPECT_EQ(mKey1, key) 409 << "wrong key from ReadEntityHeader on first entity"; 410 EXPECT_EQ(-1, (int) dataSize) 411 << "not recognizing deletion on first entity"; 412 413 // erroneously try to read first entity data 414 char* dataBytes = new char[10]; 415 dataBytes[0] = 'A'; 416 EXPECT_EQ(NO_ERROR, reader->ReadEntityData(dataBytes, dataSize)); 417 // expect dataBytes to be unmodofied 418 EXPECT_EQ('A', dataBytes[0]); 419 420 // read and verify second deletion 421 reader->ReadNextHeader(&done, &type); 422 EXPECT_EQ(BACKUP_HEADER_ENTITY_V1, type) 423 << "wrong type from ReadNextHeader second deletion"; 424 425 EXPECT_EQ(NO_ERROR, reader->ReadEntityHeader(&key, &dataSize)) 426 << "ReadEntityHeader returned an error on second entity"; 427 EXPECT_EQ(mKey2, key) 428 << "wrong key from ReadEntityHeader on second entity"; 429 EXPECT_EQ(-1, (int) dataSize) 430 << "not recognizing deletion on second entity"; 431 432 delete[] dataBytes; 433 delete writer; 434 delete reader; 435 } 436 437 } 438
