1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <sys/stat.h>
18 #include <sys/types.h>
19 #include <unistd.h>
20
21 #include <fstream>
22 #include <string>
23
24 #include "common.h"
25 #include "file_ex.h"
26 #include "rdb_errno.h"
27 #include "rdb_helper.h"
28 #include "rdb_open_callback.h"
29 #include "rdb_security_manager.h"
30
31 using namespace testing::ext;
32 using namespace OHOS::NativeRdb;
33
34 class RdbEncryptTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40
41 static const std::string ENCRYPTED_DATABASE_NAME;
42 static const std::string ENCRYPTED_DATABASE_BACKUP_NAME;
43 static const std::string ENCRYPTED_DATABASE_NAME2;
44 static const std::string ENCRYPTED_DATABASE_BACKUP_NAME2;
45 static const std::string UNENCRYPTED_DATABASE_NAME;
46 static std::shared_ptr<RdbStore> testStore;
47 };
48
49 const std::string RdbEncryptTest::ENCRYPTED_DATABASE_NAME = RDB_TEST_PATH + "encrypted.db";
50 const std::string RdbEncryptTest::ENCRYPTED_DATABASE_BACKUP_NAME = RDB_TEST_PATH + "encrypted_bak.db";
51 const std::string RdbEncryptTest::ENCRYPTED_DATABASE_NAME2 = RDB_TEST_PATH + "encrypted2.db";
52 const std::string RdbEncryptTest::ENCRYPTED_DATABASE_BACKUP_NAME2 = RDB_TEST_PATH + "encrypted2_bak.db";
53 const std::string RdbEncryptTest::UNENCRYPTED_DATABASE_NAME = RDB_TEST_PATH + "unencrypted.db";
54
55 std::shared_ptr<RdbStore> RdbEncryptTest::testStore = nullptr;
56
57 class EncryptTestOpenCallback : public RdbOpenCallback {
58 public:
59 int OnCreate(RdbStore &store) override;
60 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
61 static const std::string CREATE_TABLE_TEST;
62 };
63
64 std::string const EncryptTestOpenCallback::CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY "
65 "KEY AUTOINCREMENT, name TEXT NOT NULL, age INTEGER, "
66 "salary REAL, blobType BLOB)";
67
OnCreate(RdbStore & store)68 int EncryptTestOpenCallback::OnCreate(RdbStore &store)
69 {
70 return store.ExecuteSql(CREATE_TABLE_TEST);
71 }
72
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)73 int EncryptTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
74 {
75 return E_OK;
76 }
77
SetUpTestCase(void)78 void RdbEncryptTest::SetUpTestCase(void)
79 {
80 }
81
TearDownTestCase(void)82 void RdbEncryptTest::TearDownTestCase(void)
83 {
84 }
85
SetUp(void)86 void RdbEncryptTest::SetUp(void)
87 {
88 RdbHelper::ClearCache();
89 RdbHelper::DeleteRdbStore(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
90 RdbHelper::DeleteRdbStore(RdbEncryptTest::UNENCRYPTED_DATABASE_NAME);
91 }
92
TearDown(void)93 void RdbEncryptTest::TearDown(void)
94 {
95 RdbHelper::ClearCache();
96 RdbHelper::DeleteRdbStore(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
97 RdbHelper::DeleteRdbStore(RdbEncryptTest::UNENCRYPTED_DATABASE_NAME);
98 }
99
100 /**
101 * @tc.name: RdbStore_Encrypt_Decrypt_Test_001
102 * @tc.desc: test RdbStore Get Encrypt Store
103 * @tc.type: FUNC
104 */
105 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_01, TestSize.Level1)
106 {
107 RdbStoreConfig config(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
108 config.SetEncryptStatus(true);
109 config.SetBundleName("com.example.TestEncrypt1");
110 EncryptTestOpenCallback helper;
111 int errCode;
112 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
113 EXPECT_NE(store, nullptr);
114 }
115
116 /**
117 * @tc.name: RdbStore_Encrypt_Decrypt_Test_002
118 * @tc.desc: test RdbStore Get Unencrypted Store
119 * @tc.type: FUNC
120 */
121 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_02, TestSize.Level1)
122 {
123 RdbStoreConfig config(RdbEncryptTest::UNENCRYPTED_DATABASE_NAME);
124 config.SetEncryptStatus(false);
125 config.SetBundleName("com.example.TestEncrypt2");
126 EncryptTestOpenCallback helper;
127 int errCode;
128 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
129 EXPECT_NE(store, nullptr);
130 }
131
132 /**
133 * @tc.name: RdbStore_Encrypt_Decrypt_Test_003
134 * @tc.desc: test create encrypted Rdb and insert data ,then query
135 * @tc.type: FUNC
136 */
137 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_03, TestSize.Level1)
138 {
139 RdbStoreConfig config(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
140 config.SetEncryptStatus(true);
141 config.SetBundleName("com.example.TestEncrypt3");
142 EncryptTestOpenCallback helper;
143 int errCode;
144 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
145 EXPECT_NE(store, nullptr);
146
147 int64_t id;
148
149 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
150 EXPECT_EQ(ret, E_OK);
151 EXPECT_EQ(1, id);
152
153 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
154 EXPECT_NE(resultSet, nullptr);
155
156 ret = resultSet->GoToNextRow();
157 EXPECT_EQ(ret, E_OK);
158
159 int columnIndex;
160 int intVal;
161 std::string strVal;
162
163 ret = resultSet->GetColumnIndex("id", columnIndex);
164 EXPECT_EQ(ret, E_OK);
165 ret = resultSet->GetInt(columnIndex, intVal);
166 EXPECT_EQ(ret, E_OK);
167 EXPECT_EQ(1, intVal);
168
169 ret = resultSet->GetColumnIndex("name", columnIndex);
170 EXPECT_EQ(ret, E_OK);
171 ret = resultSet->GetString(columnIndex, strVal);
172 EXPECT_EQ(ret, E_OK);
173 EXPECT_EQ("zhangsan", strVal);
174
175 ret = resultSet->GoToNextRow();
176 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
177
178 ret = resultSet->Close();
179 EXPECT_EQ(ret, E_OK);
180 }
181
182 /**
183 * @tc.name: RdbStore_Encrypt_Decrypt_Test_004
184 * @tc.desc: test RdbStore key file.
185 * @tc.type: FUNC
186 */
187 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_04, TestSize.Level1)
188 {
189 RdbStoreConfig config(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
190 config.SetEncryptStatus(true);
191 config.SetBundleName("com.example.TestEncrypt4");
192 EncryptTestOpenCallback helper;
193 int errCode;
194 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
195 EXPECT_NE(store, nullptr);
196 std::string keyPath = RDB_TEST_PATH + "key/encrypted.pub_key";
197 int ret = access(keyPath.c_str(), F_OK);
198 EXPECT_EQ(ret, 0);
199
200 store = nullptr;
201 RdbHelper::DeleteRdbStore(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
202 ret = access(keyPath.c_str(), F_OK);
203 EXPECT_EQ(ret, -1);
204 }
205
206 /**
207 * @tc.name: RdbStore_Encrypt_Decrypt_Test_005
208 * @tc.desc: test RdbStore Get Encrypted Store with empty boundlename
209 * @tc.type: FUNC
210 */
211 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_05, TestSize.Level1)
212 {
213 RdbStoreConfig config(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
214 config.SetEncryptStatus(true);
215 config.SetBundleName("");
216 EncryptTestOpenCallback helper;
217 int errCode;
218 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
219 EXPECT_NE(store, nullptr);
220 }
221
222 /**
223 * @tc.name: RdbStore_Encrypt_Decrypt_Test_006
224 * @tc.desc: test GetRdbStore with specified key
225 * @tc.type: FUNC
226 */
227 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_06, TestSize.Level1)
228 {
229 std::vector<uint8_t> key{ 1, 2, 3 };
230 RdbStoreConfig config(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
231 config.SetEncryptKey(key);
232 EncryptTestOpenCallback helper;
233 int errCode;
234 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
235 EXPECT_NE(store, nullptr);
236
237 std::string keyPath = RDB_TEST_PATH + "key/" + "encrypted.pub_key";
238 std::string newKeyPath = RDB_TEST_PATH + "key/" + +"encrypted.pub_key.new";
239 bool isFileExists = OHOS::FileExists(keyPath);
240 EXPECT_EQ(isFileExists, false);
241 isFileExists = OHOS::FileExists(newKeyPath);
242 EXPECT_EQ(isFileExists, false);
243
244 store.reset();
245 RdbHelper::ClearCache();
246
247 std::vector<uint8_t> wrongKey{ 4, 5, 6 };
248 config.SetEncryptKey(wrongKey);
249 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
250 EXPECT_EQ(store, nullptr);
251 EXPECT_EQ(errCode, E_SQLITE_CORRUPT);
252 }
253
254 /**
255 * @tc.name: RdbStore_Encrypt_Decrypt_Test_007
256 * @tc.desc: test RemoveSuffix when pos == std::string::npos
257 * @tc.type: FUNC
258 */
259 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_07, TestSize.Level1)
260 {
261 std::string path = RDB_TEST_PATH + "test";
262 RdbHelper::DeleteRdbStore(path);
263 RdbStoreConfig config(path);
264 config.SetEncryptStatus(true);
265 config.SetBundleName("com.example.TestEncrypt7");
266 EncryptTestOpenCallback helper;
267 int errCode;
268 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
269 EXPECT_NE(store, nullptr);
270
271 store = nullptr;
272 errCode = RdbHelper::DeleteRdbStore(path);
273 EXPECT_EQ(errCode, E_OK);
274 }
275
276 /**
277 * @tc.name: RdbStore_Encrypt_Decrypt_Test_008
278 * @tc.desc: test RdbStore Get Encrypt Store without SetBundleName
279 * @tc.type: FUNC
280 */
281 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_008, TestSize.Level1)
282 {
283 RdbStoreConfig config(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
284 config.SetEncryptStatus(true);
285 EncryptTestOpenCallback helper;
286 int errCode;
287 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
288 EXPECT_NE(store, nullptr);
289 }
290
291 /**
292 * @tc.name: RdbStore_Encrypt_Decrypt_Test_009
293 * @tc.desc: test create encrypted Rdb and insert data ,then query
294 * @tc.type: FUNC
295 */
296 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_009, TestSize.Level1)
297 {
298 RdbStoreConfig config(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
299 config.SetEncryptStatus(true);
300 config.SetBundleName("com.example.TestEncrypt9");
301 EncryptTestOpenCallback helper;
302 int errCode;
303 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
304 EXPECT_NE(store, nullptr);
305
306 int64_t id;
307
308 int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
309 EXPECT_EQ(ret, E_OK);
310 EXPECT_EQ(1, id);
311
312 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
313 EXPECT_NE(resultSet, nullptr);
314
315 ret = resultSet->GoToNextRow();
316 EXPECT_EQ(ret, E_OK);
317
318 int columnIndex;
319 double dVal;
320 std::vector<uint8_t> blob;
321
322 ret = resultSet->GetColumnIndex("salary", columnIndex);
323 EXPECT_EQ(ret, E_OK);
324 ret = resultSet->GetDouble(columnIndex, dVal);
325 EXPECT_EQ(ret, E_OK);
326 EXPECT_EQ(100.5, dVal);
327
328 ret = resultSet->GetColumnIndex("blobType", columnIndex);
329 EXPECT_EQ(ret, E_OK);
330 ret = resultSet->GetBlob(columnIndex, blob);
331 EXPECT_EQ(ret, E_OK);
332 EXPECT_EQ(3, static_cast<int>(blob.size()));
333 EXPECT_EQ(1, blob[0]);
334
335 ret = resultSet->GoToNextRow();
336 EXPECT_EQ(ret, E_ROW_OUT_RANGE);
337
338 ret = resultSet->Close();
339 EXPECT_EQ(ret, E_OK);
340 }
341
342 /**
343 * @tc.name: RdbStore_Encrypt_010
344 * @tc.desc: test create encrypted Rdb and open in non encrypted mode ,then E_OK
345 * @tc.type: FUNC
346 */
347 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_010, TestSize.Level1)
348 {
349 RdbStoreConfig config(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
350 config.SetEncryptStatus(true);
351 config.SetBundleName("com.example.TestEncrypt10");
352
353 EncryptTestOpenCallback helper;
354 int errCode;
355 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
356 EXPECT_NE(store, nullptr);
357 EXPECT_EQ(errCode, E_OK);
358
359 std::string keyPath = RDB_TEST_PATH + "key/encrypted.pub_key";
360 int ret = access(keyPath.c_str(), F_OK);
361 EXPECT_EQ(ret, 0);
362
363 config.SetEncryptStatus(false);
364 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
365 EXPECT_NE(store, nullptr);
366 EXPECT_EQ(errCode, E_OK);
367 }
368
369 /**
370 * @tc.name: RdbStore_Encrypt_011
371 * @tc.desc: test create unencrypted Rdb and open in encrypted mode ,then E_OK
372 * @tc.type: FUNC
373 */
374 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_011, TestSize.Level1)
375 {
376 RdbStoreConfig config(RdbEncryptTest::UNENCRYPTED_DATABASE_NAME);
377 config.SetEncryptStatus(false);
378 config.SetBundleName("com.example.TestEncrypt11");
379 EncryptTestOpenCallback helper;
380 int errCode;
381 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
382 EXPECT_NE(store, nullptr);
383 EXPECT_EQ(errCode, E_OK);
384
385 std::string keyPath = RDB_TEST_PATH + "key/unencrypted.pub_key";
386 int ret = access(keyPath.c_str(), F_OK);
387 EXPECT_EQ(ret, -1);
388
389 config.SetEncryptStatus(true);
390 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
391 EXPECT_NE(store, nullptr);
392 EXPECT_EQ(errCode, E_OK);
393 }
394
395 /**
396 * @tc.name: RdbStore_Encrypt_012
397 * @tc.desc: test key damage, open encrypted database ,then E_INVALID_SECRET_KEY
398 * @tc.type: FUNC
399 */
400 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_012, TestSize.Level1)
401 {
402 RdbStoreConfig config(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
403 config.SetEncryptStatus(true);
404 EncryptTestOpenCallback helper;
405 int errCode;
406 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
407 EXPECT_NE(store, nullptr);
408 EXPECT_EQ(errCode, E_OK);
409 RdbSecurityManager::KeyFiles keyFile(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
410 std::string file = keyFile.GetKeyFile(RdbSecurityManager::KeyFileType::PUB_KEY_FILE);
411 RdbHelper::ClearCache();
412
413 std::ofstream fsDb(file, std::ios_base::binary | std::ios_base::out);
414 fsDb.seekp(64);
415 fsDb.write("hello", 5);
416 fsDb.close();
417
418 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
419 EXPECT_EQ(errCode, E_INVALID_SECRET_KEY);
420 ASSERT_EQ(store, nullptr);
421 }
422
423 /**
424 * @tc.name: RdbStore_Encrypt_013
425 * @tc.desc: test key damage, allowing rebuild and open encrypted database ,then E_OK
426 * @tc.type: FUNC
427 */
428 HWTEST_F(RdbEncryptTest, RdbStore_Encrypt_013, TestSize.Level1)
429 {
430 RdbStoreConfig config(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
431 config.SetEncryptStatus(true);
432 EncryptTestOpenCallback helper;
433 int errCode;
434 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
435 EXPECT_NE(store, nullptr);
436 EXPECT_EQ(errCode, E_OK);
437 int64_t rowid;
438 ValuesBucket values;
439 values.Put("id", 1);
440 values.Put("name", "zhangsan");
441 values.Put("age", 18);
442 values.Put("salary", 100.5);
443 values.Put("blobType", std::vector<uint8_t>{ 1, 2, 3 });
444 auto ret = store->Insert(rowid, "test", values);
445 EXPECT_EQ(ret, E_OK);
446 EXPECT_EQ(rowid, 1);
447 RdbSecurityManager::KeyFiles keyFile(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
448 std::string file = keyFile.GetKeyFile(RdbSecurityManager::KeyFileType::PUB_KEY_FILE);
449 RdbHelper::ClearCache();
450
451 std::ofstream fsDb(file, std::ios_base::binary | std::ios_base::out);
452 fsDb.seekp(64);
453 fsDb.write("hello", 5);
454 fsDb.close();
455
456 config.SetAllowRebuild(true);
457 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
458 EXPECT_EQ(errCode, E_OK);
459 ASSERT_NE(store, nullptr);
460
461 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
462 EXPECT_NE(resultSet, nullptr);
463 int count = 1;
464 resultSet->GetRowCount(count);
465 EXPECT_EQ(count, 0);
466 }
467
468 /**
469 * @tc.name: RdbStore_RdbPassword_001
470 * @tc.desc: Abnomal test RdbStore RdbPassword class
471 * @tc.type: FUNC
472 */
473 HWTEST_F(RdbEncryptTest, AbnomalRdbStore_RdbPassword_001, TestSize.Level2)
474 {
475 RdbPassword password1;
476 RdbPassword password2;
477 int errCode = E_OK;
478 uint8_t inputData[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
479 std::ostringstream ss;
480 std::copy(inputData, inputData + sizeof(inputData), std::ostream_iterator<int>(ss));
481
482 // if size_t > 128
483 errCode = password1.SetValue(inputData, 256);
484 EXPECT_EQ(E_ERROR, errCode);
485
486 // if inputData is nullptr
487 errCode = password1.SetValue(nullptr, sizeof(inputData));
488 EXPECT_EQ(E_ERROR, errCode);
489
490 errCode = password1.SetValue(inputData, sizeof(inputData));
491 EXPECT_EQ(E_OK, errCode);
492 errCode = password2.SetValue(inputData, sizeof(inputData));
493 EXPECT_EQ(E_OK, errCode);
494
495 EXPECT_EQ(true, password1 == password2);
496 }
497
498 /**
499 * @tc.name: KeyFilePath_test_001, open different databases and obtain the corresponding key files
500 * @tc.desc: 1.create db1
501 * 2.create db2
502 * 3.create table in the db2
503 * 4.backup db1
504 * 5.restore db1
505 *
506 * @tc.type: FUNC
507 */
508 HWTEST_F(RdbEncryptTest, KeyFilePath_test_001, TestSize.Level2)
509 {
510 RdbStoreConfig config1(RdbEncryptTest::ENCRYPTED_DATABASE_NAME);
511 config1.SetEncryptStatus(true);
512 config1.SetBundleName("com.example.TestEncrypt1");
513 EncryptTestOpenCallback helper1;
514 int errCode = E_ERROR;
515 std::shared_ptr<RdbStore> store1 = RdbHelper::GetRdbStore(config1, 1, helper1, errCode);
516 EXPECT_NE(nullptr, store1);
517 EXPECT_EQ(E_OK, errCode);
518
519 RdbStoreConfig config2(RdbEncryptTest::ENCRYPTED_DATABASE_NAME2);
520 config2.SetEncryptStatus(true);
521 config2.SetBundleName("com.example.TestEncrypt1");
522 EncryptTestOpenCallback helper2;
523 std::shared_ptr<RdbStore> store2 = RdbHelper::GetRdbStore(config2, 1, helper2, errCode);
524 EXPECT_NE(nullptr, store2);
525 EXPECT_EQ(E_OK, errCode);
526
527 EXPECT_EQ(E_OK, store1->Backup(RdbEncryptTest::ENCRYPTED_DATABASE_BACKUP_NAME));
528 EXPECT_EQ(E_OK, store1->Restore(RdbEncryptTest::ENCRYPTED_DATABASE_BACKUP_NAME));
529
530 EXPECT_EQ(E_OK, store2->Backup(RdbEncryptTest::ENCRYPTED_DATABASE_BACKUP_NAME2));
531 EXPECT_EQ(E_OK, store2->Restore(RdbEncryptTest::ENCRYPTED_DATABASE_BACKUP_NAME2));
532 }