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