From 3ff71b0e908bb7e8f15268075e0fc28ecceb44ac Mon Sep 17 00:00:00 2001 From: hunili Date: Sat, 6 Jul 2024 17:42:38 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BD=8E=E7=BA=A7=E7=BC=96=E7=A0=81=E9=97=AE?= =?UTF-8?q?=E9=A2=98=20issue:=20https://gitee.com/openharmony/filemanageme?= =?UTF-8?q?nt=5Fapp=5Ffile=5Fservice/issues/IAB2XJ=20Signed-off-by:=20huni?= =?UTF-8?q?li=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/main/ets/entryability/EntryAbility.ts | 1 - .../src/main/ets/entryability/EntryAbility.ts | 1 - .../src/sandbox_mock.cpp | 21 ++ tests/mock/module_ipc/message_parcel_mock.cpp | 80 ++++++ .../b_session_backup_test.cpp | 18 +- .../b_session_restore_async_test.cpp | 26 +- .../b_session_restore_test.cpp | 50 +++- .../backup_impl/service_proxy_test.cpp | 127 ++++++++- .../backup_impl/service_reverse_test.cpp | 252 ++++++++++++++++++ 9 files changed, 563 insertions(+), 13 deletions(-) diff --git a/test/unittest/resource/bundle_dependencies/fileShareA/entry/src/main/ets/entryability/EntryAbility.ts b/test/unittest/resource/bundle_dependencies/fileShareA/entry/src/main/ets/entryability/EntryAbility.ts index 9b5b72a37..9dd0adbea 100644 --- a/test/unittest/resource/bundle_dependencies/fileShareA/entry/src/main/ets/entryability/EntryAbility.ts +++ b/test/unittest/resource/bundle_dependencies/fileShareA/entry/src/main/ets/entryability/EntryAbility.ts @@ -21,7 +21,6 @@ export default class EntryAbility extends UIAbility { onCreate(want, launchParam) { hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate'); - hilog.info(0x0000, 'testTag', '%{public}s', 'want param:' + JSON.stringify(want) ?? ''); hilog.info(0x0000, 'testTag', '%{public}s', 'launchParam:' + JSON.stringify(launchParam) ?? ''); } diff --git a/test/unittest/resource/bundle_dependencies/fileShareB/entry/src/main/ets/entryability/EntryAbility.ts b/test/unittest/resource/bundle_dependencies/fileShareB/entry/src/main/ets/entryability/EntryAbility.ts index 9b5b72a37..9dd0adbea 100644 --- a/test/unittest/resource/bundle_dependencies/fileShareB/entry/src/main/ets/entryability/EntryAbility.ts +++ b/test/unittest/resource/bundle_dependencies/fileShareB/entry/src/main/ets/entryability/EntryAbility.ts @@ -21,7 +21,6 @@ export default class EntryAbility extends UIAbility { onCreate(want, launchParam) { hilog.isLoggable(0x0000, 'testTag', hilog.LogLevel.INFO); hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate'); - hilog.info(0x0000, 'testTag', '%{public}s', 'want param:' + JSON.stringify(want) ?? ''); hilog.info(0x0000, 'testTag', '%{public}s', 'launchParam:' + JSON.stringify(launchParam) ?? ''); } diff --git a/tests/mock/file_permission_native/src/sandbox_mock.cpp b/tests/mock/file_permission_native/src/sandbox_mock.cpp index d9ed2bf54..0feb52f6d 100644 --- a/tests/mock/file_permission_native/src/sandbox_mock.cpp +++ b/tests/mock/file_permission_native/src/sandbox_mock.cpp @@ -16,27 +16,48 @@ #include "sandbox_mock.h" using namespace OHOS::AccessControl::SandboxManager; +const int32_t DEFAULT_VALUE = -1; int32_t CheckPersistPolicy(uint64_t tokenId, const std::vector &policy, std::vector &result) { + if (SandboxManagerKit::sandboxManagerKit == nullptr) { + GTEST_LOG_(INFO) << "CheckPersistPolicy sandboxManagerKit == nulpptr"; + return DEFAULT_VALUE; + } return SandboxManagerKit::sandboxManagerKit->CheckPersistPolicy(tokenId, policy, result); } int32_t PersistPolicy(const std::vector &policy, std::vector &result) { + if (SandboxManagerKit::sandboxManagerKit == nullptr) { + GTEST_LOG_(INFO) << "PersistPolicy sandboxManagerKit == nulpptr"; + return DEFAULT_VALUE; + } return SandboxManagerKit::sandboxManagerKit->PersistPolicy(policy, result); } int32_t UnPersistPolicy(const std::vector &policy, std::vector &result) { + if (SandboxManagerKit::sandboxManagerKit == nullptr) { + GTEST_LOG_(INFO) << "UnPersistPolicy sandboxManagerKit == nulpptr"; + return DEFAULT_VALUE; + } return SandboxManagerKit::sandboxManagerKit->UnPersistPolicy(policy, result); } int32_t StartAccessingPolicy(const std::vector &policy, std::vector &result) { + if (SandboxManagerKit::sandboxManagerKit == nullptr) { + GTEST_LOG_(INFO) << "StartAccessingPolicy sandboxManagerKit == nulpptr"; + return DEFAULT_VALUE; + } return SandboxManagerKit::sandboxManagerKit->StartAccessingPolicy(policy, result); } int32_t StopAccessingPolicy(const std::vector &policy, std::vector &result) { + if (SandboxManagerKit::sandboxManagerKit == nullptr) { + GTEST_LOG_(INFO) << "StopAccessingPolicy sandboxManagerKit == nulpptr"; + return DEFAULT_VALUE; + } return SandboxManagerKit::sandboxManagerKit->StopAccessingPolicy(policy, result); } \ No newline at end of file diff --git a/tests/mock/module_ipc/message_parcel_mock.cpp b/tests/mock/module_ipc/message_parcel_mock.cpp index bba15b0dc..01cb16649 100644 --- a/tests/mock/module_ipc/message_parcel_mock.cpp +++ b/tests/mock/module_ipc/message_parcel_mock.cpp @@ -1,6 +1,8 @@ /* * Copyright (C) 2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); + } + return ; * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * @@ -17,8 +19,14 @@ namespace OHOS { using namespace OHOS::FileManagement::Backup; +const int DEFAULT_INT_VALUE = -1; +const int32_t DEFAULT_INT32_T_VALUE = -1; sptr BrokerRegistration::NewInstance(const std::u16string &descriptor, const sptr &object) { + if (BackupIfaceCast::cast == nullptr) { + GTEST_LOG_(INFO) << "cast == nullptr"; + return nullptr; + } return BackupIfaceCast::cast->iface_cast(object); } @@ -33,91 +41,163 @@ Parcelable::Parcelable(bool asRemote) bool MessageParcel::WriteInterfaceToken(std::u16string name) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->WriteInterfaceToken(name); } std::u16string MessageParcel::ReadInterfaceToken() { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return std::u16string(u""); + } return BackupMessageParcel::messageParcel->ReadInterfaceToken(); } bool Parcel::WriteParcelable(const Parcelable *object) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->WriteParcelable(object); } bool Parcel::WriteInt32(int32_t value) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->WriteInt32(value); } int32_t Parcel::ReadInt32() { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return DEFAULT_INT32_T_VALUE; + } return BackupMessageParcel::messageParcel->ReadInt32(); } bool Parcel::ReadInt32(int32_t &value) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->ReadInt32(value); } bool Parcel::WriteRemoteObject(const Parcelable *object) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->WriteRemoteObject(object); } bool MessageParcel::WriteRemoteObject(const sptr &object) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->WriteRemoteObject(object); } sptr MessageParcel::ReadRemoteObject() { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return nullptr; + } return BackupMessageParcel::messageParcel->ReadRemoteObject(); } bool Parcel::ReadBool() { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->ReadBool(); } bool Parcel::ReadBool(bool &value) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->ReadBool(value); } bool Parcel::WriteBool(bool value) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->WriteBool(value); } bool Parcel::WriteString(const std::string &value) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->WriteString(value); } bool Parcel::ReadString(std::string &value) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->ReadString(value); } bool Parcel::ReadStringVector(std::vector *value) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->ReadStringVector(value); } bool MessageParcel::WriteFileDescriptor(int fd) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->WriteFileDescriptor(fd); } int MessageParcel::ReadFileDescriptor() { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return DEFAULT_INT_VALUE; + } return BackupMessageParcel::messageParcel->ReadFileDescriptor(); } bool Parcel::ReadUint32(uint32_t &value) { + if (BackupMessageParcel::messageParcel == nullptr) { + GTEST_LOG_(INFO) << "messageParcel == nullptr"; + return false; + } return BackupMessageParcel::messageParcel->ReadUint32(value); } } // namespace OHOS \ No newline at end of file diff --git a/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp b/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp index 89e5dcc76..814cd7b54 100644 --- a/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp @@ -58,7 +58,7 @@ public: void Init(); - unique_ptr backupPtr_; + unique_ptr backupPtr_ = nullptr; BSessionBackup::Callbacks callbacks_; }; @@ -98,6 +98,10 @@ HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0100, testing::ext::Tes GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_0100"; try { GTEST_LOG_(INFO) << "GetInstance is true"; + if (backupPtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0100 backupPtr_ == nullptr"; + return; + } auto ret = backupPtr_->Start(); EXPECT_EQ(ret, ErrCode(BError::Codes::OK)); GTEST_LOG_(INFO) << "GetInstance is false"; @@ -124,6 +128,10 @@ HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0200, testing::ext::Tes { GTEST_LOG_(INFO) << "BSessionBackupTest-Finish SUB_backup_b_session_backup_0200"; try { + if (backupPtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0200 backupPtr_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "GetInstance is true"; SetMockGetInstance(true); auto ret = backupPtr_->Finish(); @@ -152,6 +160,10 @@ HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0300, testing::ext::Tes { GTEST_LOG_(INFO) << "BSessionBackupTest-AppendBundles SUB_backup_b_session_backup_0300"; try { + if (backupPtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0300 backupPtr_ == nullptr"; + return; + } vector bundleNames; GTEST_LOG_(INFO) << "GetInstance is true"; SetMockGetInstance(true); @@ -243,6 +255,10 @@ HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0600, testing::ext::Tes { GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_0600"; try { + if (backupPtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0600 backupPtr_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "GetInstance is false"; SetMockGetInstance(false); backupPtr_->RegisterBackupServiceDied(nullptr); diff --git a/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp b/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp index ea2779a1e..a25d4c1b3 100644 --- a/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp @@ -68,7 +68,7 @@ public: void Init(); - shared_ptr restorePtr_; + shared_ptr restorePtr_ = nullptr; BSessionRestoreAsync::Callbacks callbacks_; }; @@ -158,6 +158,10 @@ HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0300, test { GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-begin SUB_backup_b_session_restore_async_0300"; try { + if (restorePtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_async_0300 restorePtr_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "Mock instance set to false"; SetMockGetInstance(false); BFileInfo bFileInfo("", "", 0); @@ -187,6 +191,10 @@ HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0400, test { GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-begin SUB_backup_b_session_restore_async_0400"; try { + if (restorePtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_async_0400 restorePtr_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "Mock instance set to false"; SetMockGetInstance(false); string bundleName = ""; @@ -217,6 +225,10 @@ HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0500, test { GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-begin SUB_backup_b_session_restore_async_0500"; try { + if (restorePtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_async_0500 restorePtr_ == nullptr"; + return; + } SetMockGetInstance(true); SetMockLoadSystemAbility(true); vector bundleNames; @@ -243,8 +255,12 @@ HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0500, test */ HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0501, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-begin SUB_backup_b_session_restore_async_0500"; + GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-begin SUB_backup_b_session_restore_async_0501"; try { + if (restorePtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_async_0501 restorePtr_ == nullptr"; + return; + } SetMockGetInstance(true); SetMockLoadSystemAbility(true); vector bundleNames; @@ -258,7 +274,7 @@ HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0501, test EXPECT_TRUE(false); GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-an exception occurred by ~BSessionRestoreAsync."; } - GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-end SUB_backup_b_session_restore_async_0500"; + GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-end SUB_backup_b_session_restore_async_0501"; } /** @@ -274,6 +290,10 @@ HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0600, test { GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-begin SUB_backup_b_session_restore_async_0600"; try { + if (restorePtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_async_0600 restorePtr_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "GetInstance is false"; SetMockGetInstance(false); restorePtr_->RegisterBackupServiceDied(nullptr); diff --git a/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp b/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp index 15df1f118..5af9140af 100644 --- a/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp @@ -69,7 +69,7 @@ public: void Init(); - unique_ptr restorePtr_; + unique_ptr restorePtr_ = nullptr; BSessionRestore::Callbacks callbacks_; }; @@ -110,6 +110,10 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0100, testing::ext::T GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0100"; try { GTEST_LOG_(INFO) << "GetInstance is true"; + if (restorePtr_ != nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_0100 restorePtr_ == nullptr"; + return; + } auto ret = restorePtr_->Start(); EXPECT_EQ(ret, ErrCode(BError::Codes::OK)); GTEST_LOG_(INFO) << "GetInstance is false"; @@ -136,6 +140,11 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0200, testing::ext::T { GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0200"; try { + GTEST_LOG_(INFO) << "GetInstance is true"; + if (restorePtr_ != nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_0200 restorePtr_ == nullptr"; + return; + } Init(); BFileInfo bFileInfo("", "", 0); callbacks_.onFileReady(bFileInfo, UniqueFd(-1), 0); @@ -163,6 +172,11 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0300, testing::ext::T { GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0300"; try { + GTEST_LOG_(INFO) << "GetInstance is true"; + if (restorePtr_ != nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_0300 restorePtr_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "GetInstance is false"; SetMockGetInstance(false); vector bundlesToRestore; @@ -199,6 +213,10 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0400, testing::ext::T { GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0400"; try { + if (restorePtr_ != nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_0400 restorePtr_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "GetInstance is false"; SetMockGetInstance(false); BFileInfo bFileInfo("", "", 0); @@ -228,6 +246,10 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0500, testing::ext::T { GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0500"; try { + if (restorePtr_ != nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_0500 restorePtr_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "GetInstance is false"; SetMockGetInstance(false); string bundleName = ""; @@ -258,6 +280,10 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0600, testing::ext::T { GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0600"; try { + if (restorePtr_ != nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_0600 restorePtr_ == nullptr"; + return; + } const string fileName = "1.tar"; TestManager tm("SUB_backup_b_session_restore_0600"); string filePath = tm.GetRootDirCurTest().append(fileName); @@ -294,10 +320,14 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0600, testing::ext::T */ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0601, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0600"; + GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0601"; try { + if (restorePtr_ != nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_0601 restorePtr_ == nullptr"; + return; + } const string fileName = "1.tar"; - TestManager tm("SUB_backup_b_session_restore_0600"); + TestManager tm("SUB_backup_b_session_restore_0601"); string filePath = tm.GetRootDirCurTest().append(fileName); UniqueFd remoteCap(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); string bundleName = ""; @@ -315,7 +345,7 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0601, testing::ext::T EXPECT_TRUE(false); GTEST_LOG_(INFO) << "BSessionRestoreTest-an exception occurred by AppendBundles."; } - GTEST_LOG_(INFO) << "BSessionRestoreTest-end SUB_backup_b_session_restore_0600"; + GTEST_LOG_(INFO) << "BSessionRestoreTest-end SUB_backup_b_session_restore_0601"; } /** @@ -331,6 +361,10 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0700, testing::ext::T { GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0700"; try { + if (restorePtr_ != nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_0700 restorePtr_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "GetInstance is false"; SetMockGetInstance(false); auto ret = restorePtr_->Finish(); @@ -360,6 +394,10 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0800, testing::ext::T { GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0800"; try { + if (restorePtr_ != nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_0800 restorePtr_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "GetInstance is false"; SetMockGetInstance(false); restorePtr_->RegisterBackupServiceDied(nullptr); @@ -386,6 +424,10 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_0900, testing::ext::T { GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_0900"; try { + if (restorePtr_ != nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_0900 restorePtr_ == nullptr"; + return; + } SetMockGetInstance(true); SetMockLoadSystemAbility(true); Init(); diff --git a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp index eb1776ccc..f95584e61 100644 --- a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp +++ b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp @@ -75,6 +75,10 @@ void ServiceProxyTest::TearDown() HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitRestoreSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitRestoreSession_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_InitRestoreSession_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)); @@ -98,6 +102,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitRestoreSession_0100, testing::e HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitBackupSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitBackupSession_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_InitBackupSession_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)); @@ -122,6 +130,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitBackupSession_0100, testing::ex HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Start_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Start_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_Start_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -146,13 +158,16 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Start_0100, testing::ext::TestSize. HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilities_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetLocalCapabilities_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilities_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeGetLocalSendRequest)) .WillOnce(Return(EPERM)); UniqueFd fd = proxy_->GetLocalCapabilities(); EXPECT_GT(fd, BError(BError::Codes::OK)); - UniqueFd fdErr = proxy_->GetLocalCapabilities(); EXPECT_LT(fdErr, BError(BError::Codes::OK)); GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetLocalCapabilities_0100"; @@ -170,6 +185,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilities_0100, testing: HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishFile_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_PublishFile_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilities_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -197,6 +216,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishFile_0100, testing::ext::Tes HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppFileReady_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppFileReady_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_AppFileReady_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(3) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -232,6 +255,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppFileReady_0100, testing::ext::Te HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppDone_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppDone_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_AppDone_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -256,6 +283,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppDone_0100, testing::ext::TestSiz HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetFileHandle_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetFileHandle_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_GetFileHandle_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -282,6 +313,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetFileHandle_0100, testing::ext::T HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesRestoreSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesRestoreSession_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesRestoreSession_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)); @@ -309,6 +344,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesRestoreSession_0100, t HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesRestoreSession_0101, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesRestoreSession_0101"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesRestoreSession_0101 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)); @@ -337,6 +376,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesRestoreSession_0101, t HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesBackupSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesBackupSession_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesBackupSession_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -363,6 +406,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesBackupSession_0100, te HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Finish_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Finish_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_Finish_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -387,6 +434,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Finish_0100, testing::ext::TestSize HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Release_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Release_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_Release_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -411,6 +462,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Release_0100, testing::ext::TestSiz HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeGetLocalSendRequest)) @@ -439,6 +494,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilitiesIncremental_010 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitIncrementalBackupSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitIncrementalBackupSession_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_InitIncrementalBackupSession_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)); @@ -463,6 +522,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitIncrementalBackupSession_0100, HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -490,6 +553,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesIncrementalBackupSessi testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesDetailsIncrementalBackupSession_0101"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesDetailsIncrementalBackupSession_0101 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -517,6 +584,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesIncrementalBackupSessi HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishIncrementalFile_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_PublishIncrementalFile_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_PublishIncrementalFile_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -545,6 +616,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishIncrementalFile_0100, testin HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalFileReady_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppIncrementalFileReady_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_AppIncrementalFileReady_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -580,6 +655,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalFileReady_0100, testi HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalDone_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppIncrementalDone_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_AppIncrementalDone_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -604,6 +683,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalDone_0100, testing::e HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetIncrementalFileHandle_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetIncrementalFileHandle_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_GetIncrementalFileHandle_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) @@ -630,6 +713,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetIncrementalFileHandle_0100, test HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100 proxy_ == nullptr"; + return; + } sptr loadCallback = new ServiceProxy::ServiceProxyLoadCallback(); EXPECT_NE(loadCallback, nullptr); loadCallback->OnLoadSystemAbilitySuccess(SERVICE_ID, nullptr); @@ -649,11 +736,13 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100, te HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101 proxy_ == nullptr"; + return; + } sptr loadCallback = new ServiceProxy::ServiceProxyLoadCallback(); EXPECT_NE(loadCallback, nullptr); int32_t systemAbilityId = 0; - // const OHOS::sptr &remoteObject = make_shared(); - // shared_ptr remoteObject = make_shared(); sptr remoteObject = new MockIRemoteObject(); loadCallback->OnLoadSystemAbilitySuccess(systemAbilityId, remoteObject); loadCallback = nullptr; @@ -672,6 +761,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101, te HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102 proxy_ == nullptr"; + return; + } sptr loadCallback = new ServiceProxy::ServiceProxyLoadCallback(); EXPECT_NE(loadCallback, nullptr); int32_t systemAbilityId = 0; @@ -692,6 +785,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102, te HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilityFail_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilityFail_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilityFail_0100 proxy_ == nullptr"; + return; + } sptr loadCallback = new ServiceProxy::ServiceProxyLoadCallback(); EXPECT_NE(loadCallback, nullptr); loadCallback->OnLoadSystemAbilityFail(SERVICE_ID); @@ -711,6 +808,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilityFail_0100, testi HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetInstance_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetInstance_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_GetInstance_0100 proxy_ == nullptr"; + return; + } GTEST_LOG_(INFO) << "MockLoadSystemAbility is false"; SetMockLoadSystemAbility(false); auto proxy = ServiceProxy::GetInstance(); @@ -740,6 +841,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetInstance_0100, testing::ext::Tes HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InvaildInstance_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InvaildInstance_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_InvaildInstance_0100 proxy_ == nullptr"; + return; + } ServiceProxy::InvaildInstance(); GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InvaildInstance_0100"; } @@ -756,6 +861,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InvaildInstance_0100, testing::ext: HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetBackupInfo_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetBackupInfo_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_GetBackupInfo_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)); @@ -778,6 +887,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetBackupInfo_0100, testing::ext::T HWTEST_F(ServiceProxyTest, SUB_Service_proxy_UpdateTimer_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_UpdateTimer_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_UpdateTimer_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)); @@ -801,6 +914,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_UpdateTimer_0100, testing::ext::Tes HWTEST_F(ServiceProxyTest, SUB_Service_proxy_UpdateSendRate_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_UpdateSendRate_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_UpdateSendRate_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)); @@ -824,6 +941,10 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_UpdateSendRate_0100, testing::ext:: HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100 proxy_ == nullptr"; + return; + } EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) .Times(2) .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) diff --git a/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp b/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp index ced8672d8..3cbff6de2 100644 --- a/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp +++ b/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp @@ -180,6 +180,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnFileReady_0100, t GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReady_0100"; try { Init(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnFileReady_0100 service_ == nullptr"; + return; + } service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); } catch (...) { @@ -203,6 +208,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnFileReady_0101, t GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReady_0101"; try { Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnFileReady_0101 service_ == nullptr"; + return; + } service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); } catch (...) { EXPECT_TRUE(false); @@ -225,6 +235,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnFileReady_0102, t GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReady_0102"; try { Init(IServiceReverse::Scenario::BACKUP, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnFileReady_0102 service_ == nullptr"; + return; + } service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); } catch (...) { EXPECT_TRUE(false); @@ -247,6 +262,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_010 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0100"; try { Init(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnBundleStarted_0100 service_ == nullptr"; + return; + } service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { @@ -270,6 +290,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_010 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0101"; try { Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnBundleStarted_0101 service_ == nullptr"; + return; + } service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -292,6 +317,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_010 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0102"; try { Init(IServiceReverse::Scenario::BACKUP, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnBundleStarted_0102 service_ == nullptr"; + return; + } service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -314,6 +344,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_01 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0100"; try { Init(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnBundleFinished_0100 service_ == nullptr"; + return; + } service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { @@ -337,6 +372,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_01 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0101"; try { Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnBundleFinished_0101 service_ == nullptr"; + return; + } service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -359,6 +399,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_01 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0102"; try { Init(IServiceReverse::Scenario::BACKUP, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnBundleFinished_0102 service_ == nullptr"; + return; + } service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -381,6 +426,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinishe GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100"; try { Init(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100 service_ == nullptr"; + return; + } service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK)); service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { @@ -404,6 +454,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinishe GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101"; try { Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101 service_ == nullptr"; + return; + } service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -426,6 +481,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinishe GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102"; try { Init(IServiceReverse::Scenario::BACKUP, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102 service_ == nullptr"; + return; + } service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -448,6 +508,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0100, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0100"; try { Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnFileReady_0100 service_ == nullptr"; + return; + } service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); } catch (...) { @@ -471,6 +536,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0101, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0101"; try { Init(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnFileReady_0101 service_ == nullptr"; + return; + } service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); } catch (...) { EXPECT_TRUE(false); @@ -493,6 +563,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0102, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0102"; try { Init(IServiceReverse::Scenario::RESTORE, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnFileReady_0102 service_ == nullptr"; + return; + } service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); } catch (...) { EXPECT_TRUE(false); @@ -515,6 +590,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_01 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100"; try { Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100 service_ == nullptr"; + return; + } service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { @@ -538,6 +618,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_01 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101"; try { Init(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101 service_ == nullptr"; + return; + } service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -560,6 +645,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_01 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102"; try { Init(IServiceReverse::Scenario::RESTORE, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102 service_ == nullptr"; + return; + } service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -582,6 +672,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100"; try { Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100 service_ == nullptr"; + return; + } service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { @@ -605,6 +700,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101"; try { Init(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101 service_ == nullptr"; + return; + } service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -627,6 +727,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102"; try { Init(IServiceReverse::Scenario::RESTORE, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102 service_ == nullptr"; + return; + } service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -649,6 +754,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinish GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100"; try { Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100 service_ == nullptr"; + return; + } service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK)); service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { @@ -672,6 +782,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinish GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101"; try { Init(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101 service_ == nullptr"; + return; + } service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -694,6 +809,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinish GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102"; try { Init(IServiceReverse::Scenario::RESTORE, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102 service_ == nullptr"; + return; + } service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -716,6 +836,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0200, testing::ext::TestS GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0200"; try { Init(IServiceReverse::Scenario::RESTORE, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_0200 service_ == nullptr"; + return; + } service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); @@ -741,6 +866,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0201, testing::ext::TestS GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0201"; try { Init(IServiceReverse::Scenario::RESTORE, 0); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_0201 service_ == nullptr"; + return; + } service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); @@ -766,6 +896,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0300, testing::ext::TestS GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0300"; try { Init(IServiceReverse::Scenario::BACKUP, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_0300 service_ == nullptr"; + return; + } service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); @@ -791,6 +926,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0301, testing::ext::TestS GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0301"; try { Init(IServiceReverse::Scenario::BACKUP, 0); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_0301 service_ == nullptr"; + return; + } service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); @@ -816,6 +956,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileRe GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100"; try { IncrementalInit(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100 service_ == nullptr"; + return; + } service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0); service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0); } catch (...) { @@ -839,6 +984,11 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileRe GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101"; try { IncrementalInit(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101 service_ == nullptr"; + return; + } service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0); IncrementalInit(IServiceReverse::Scenario::BACKUP, 1); @@ -866,6 +1016,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100"; try { IncrementalInit(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100 service_ == nullptr"; + return; + } service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { @@ -891,6 +1046,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101"; try { IncrementalInit(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101 service_ == nullptr"; + return; + } service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); IncrementalInit(IServiceReverse::Scenario::BACKUP, 1); @@ -918,6 +1078,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100"; try { IncrementalInit(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100 service_ == nullptr"; + return; + } service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { @@ -943,6 +1108,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101"; try { IncrementalInit(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101 service_ == nullptr"; + return; + } service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); IncrementalInit(IServiceReverse::Scenario::BACKUP, 1); @@ -970,6 +1140,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100"; try { IncrementalInit(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100 service_ == nullptr"; + return; + } service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK)); service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { @@ -995,6 +1170,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101"; try { IncrementalInit(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101 service_ == nullptr"; + return; + } service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK)); IncrementalInit(IServiceReverse::Scenario::BACKUP, 1); @@ -1022,6 +1202,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100"; try { IncrementalInit(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100 service_ == nullptr"; + return; + } service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0); service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0); } catch (...) { @@ -1047,6 +1232,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101"; try { IncrementalInit(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101 service_ == nullptr"; + return; + } service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0); IncrementalInit(IServiceReverse::Scenario::RESTORE, 1); @@ -1074,6 +1264,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100"; try { IncrementalInit(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100 service_ == nullptr"; + return; + } service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { @@ -1099,6 +1294,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101"; try { IncrementalInit(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101 service_ == nullptr"; + return; + } service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); IncrementalInit(IServiceReverse::Scenario::RESTORE, 1); @@ -1126,6 +1326,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100"; try { IncrementalInit(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100 service_ == nullptr"; + return; + } service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { @@ -1151,6 +1356,11 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101"; try { IncrementalInit(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101 service_ == nullptr"; + return; + } service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); IncrementalInit(IServiceReverse::Scenario::RESTORE, 1); @@ -1179,6 +1389,11 @@ HWTEST_F(ServiceReverseTest, << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100"; try { IncrementalInit(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100 service_ == nullptr"; + return; + } service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK)); service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { @@ -1205,6 +1420,11 @@ HWTEST_F(ServiceReverseTest, << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101"; try { IncrementalInit(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101 service_ == nullptr"; + return; + } service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK)); IncrementalInit(IServiceReverse::Scenario::RESTORE, 1); @@ -1230,6 +1450,10 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnResultReport_010 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnResultReport_0100"; try { Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnResultReport_0100 service_ == nullptr"; + return; + } std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; service_->RestoreOnResultReport(resultReport, bundleName); @@ -1254,6 +1478,10 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnResultReport_010 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnResultReport_0101"; try { Init(IServiceReverse::Scenario::RESTORE, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnResultReport_0101 service_ == nullptr"; + return; + } std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; service_->RestoreOnResultReport(resultReport, bundleName); @@ -1279,6 +1507,10 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalRestoreOnResul GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100"; try { IncrementalInit(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100 service_ == nullptr"; + return; + } std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; service_->IncrementalRestoreOnResultReport(resultReport, bundleName); @@ -1304,6 +1536,10 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalRestoreOnResul GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101"; try { IncrementalInit(IServiceReverse::Scenario::RESTORE, 1); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101 service_ == nullptr"; + return; + } std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; service_->IncrementalRestoreOnResultReport(resultReport, bundleName); @@ -1330,6 +1566,10 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnResultReport_0100 Init(IServiceReverse::Scenario::BACKUP); std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; + if (service_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnResultReport_0100 service_ == nullptr"; + return; + } service_->BackupOnResultReport(resultReport, bundleName); } catch (...) { EXPECT_TRUE(false); @@ -1354,6 +1594,10 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnResultReport_0101 Init(IServiceReverse::Scenario::BACKUP, 1); std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; + if (service_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnResultReport_0101 service_ == nullptr"; + return; + } service_->BackupOnResultReport(resultReport, bundleName); } catch (...) { EXPECT_TRUE(false); @@ -1379,6 +1623,10 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResult IncrementalInit(IServiceReverse::Scenario::BACKUP); std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; + if (service_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100 service_ == nullptr"; + return; + } service_->IncrementalBackupOnResultReport(resultReport, bundleName); } catch (...) { EXPECT_TRUE(false); @@ -1404,6 +1652,10 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResult IncrementalInit(IServiceReverse::Scenario::BACKUP, 1); std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; + if (service_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101 service_ == nullptr"; + return; + } service_->IncrementalBackupOnResultReport(resultReport, bundleName); } catch (...) { EXPECT_TRUE(false); -- Gitee