* Copyright (c) 2021-2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <climits>
#include <gtest/gtest.h>
#include "ability_impl_factory.h"
#include "ability_loader.h"
#include "ability_local_record.h"
#include "context_deal.h"
#include "data_ability_helper.h"
#include "ability_manager_client.h"
#include "ability_manager_interface.h"
#include "demo_ability_test.h"
#include "fa_ability_thread.h"
#include "mock_ability_manager_service.h"
#include "mock_bundle_manager.h"
#include "ohos_application.h"
#include "sys_mgr_client.h"
#include "system_ability_definition.h"
namespace OHOS {
namespace AppExecFwk {
using namespace testing::ext;
using namespace OHOS;
using namespace AAFwk;
using OHOS::AppExecFwk::ElementName;
using namespace OHOS::AppExecFwk;
* Parameters:
* Action
* Entity
* Flag
* ElementName
*/
const std::string ABILITY_NAME("DemoAbility");
class AbilityBaseTest : public testing::Test {
public:
static void SetUpTestCase(void);
static void TearDownTestCase(void);
void SetUp();
void TearDown();
OHOS::sptr<OHOS::IRemoteObject> abilityObject_;
static constexpr int TEST_WAIT_TIME = 500 * 1000;
static const int RESULT_CODE = 1992;
};
void AbilityBaseTest::SetUpTestCase(void)
{}
void AbilityBaseTest::TearDownTestCase(void)
{}
void AbilityBaseTest::SetUp(void)
{
abilityObject_ = new MockAbilityManagerService();
auto sysMgr = OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance();
EXPECT_TRUE(sysMgr != nullptr);
sysMgr->RegisterSystemAbility(OHOS::ABILITY_MGR_SERVICE_ID, abilityObject_);
sysMgr->RegisterSystemAbility(OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
}
void AbilityBaseTest::TearDown(void)
{
abilityObject_ = nullptr;
}
* @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0100
* @tc.name: AbilityFwk Start
* @tc.desc: The first step of startability is the attach AMS.
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0100, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0200
* @tc.name: AbilityFwk Start
* @tc.desc: When connecting AMS,the instance of application is empty.
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0200, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = nullptr;
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0300
* @tc.name: AbilityFwk Start
* @tc.desc: When connecting AMS,the instance of abilityRecord is empty
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0300, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
std::shared_ptr<AbilityLocalRecord> abilityRecord = nullptr;
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
EXPECT_NE(application, nullptr);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
* @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0400
* @tc.name: AbilityFwk Start
* @tc.desc: The ability name is empty, so the ability instance cannot be created.
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0400, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0500
* @tc.name: AbilityFwk Start
* @tc.desc: The ability type is unknown, so the AbilityImpl instance cannot be created.
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0500, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0600
* @tc.name: AbilityFwk Start
* @tc.desc: The interface OnSaveAbilityState()/OnRestoreAbilityState() of demoability was called.
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0600, Function | MediumTest | Level1)
{
std::shared_ptr<ContextDeal> contextDeal = std::make_shared<ContextDeal>();
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
std::shared_ptr<ProcessInfo> processInfo = std::make_shared<ProcessInfo>();
appInfo->codePath = "codePath";
appInfo->dataBaseDir = "dataBaseDir";
appInfo->dataDir = "dataDir";
appInfo->cacheDir = "cacheDir";
appInfo->bundleName = "bundleName";
application->SetProcessInfo(processInfo);
contextDeal->SetApplicationInfo(appInfo);
contextDeal->SetApplicationContext(application);
application->AttachBaseContext(contextDeal);
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->codePath = "codePath";
abilityInfo->resourcePath = "resourcePath";
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
sptr<IAbilityConnection> connect = nullptr;
abms->ConnectAbility(want, connect, abilityToken);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_Lifecycle_Test_0100
* @tc.name: Ability Lifecycle
* @tc.desc: The ability life cycle will change from initial state initial to inactive by calling the interface
* OnnStart(), and then to active by calling OnActive().
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_Lifecycle_Test_0100, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_AbilityFwk_Lifecycle_Test_0200
* @tc.name: Ability Lifecycle
* @tc.desc: The ability life cycle will change from initial state initial to inactive by calling the interface
* OnnStart(), and then to active by calling OnNewWant()+OnActive().
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Lifecycle_Test_0200, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
abms->DisconnectAbility(nullptr);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_AbilityFwk_Lifecycle_Test_0300
* @tc.name: Ability Lifecycle
* @tc.desc: Ability life cycle changes: initial - > active - > background, the interface of demoability will be
called:
* OnStart()->OnActive()->OnInactive()->OnBackground().
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Lifecycle_Test_0300, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_AbilityFwk_Lifecycle_Test_0400
* @tc.name: Ability Lifecycle
* @tc.desc: Ability life cycle changes: initial - > active - > inactive, the interface of demoability will be
called:
* OnStart()->OnActive()->OnInactive().
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Lifecycle_Test_0400, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INACTIVE);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_AbilityFwk_Lifecycle_Test_0500
* @tc.name: Ability Lifecycle
* @tc.desc: Ability life cycle changes: initial - > active , the interface of demoability will be called:
* OnStart()->OnActive()->OnInactive()->OnBackground()->OnForeground().
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Lifecycle_Test_0500, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INACTIVE);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_AbilityFwk_Lifecycle_Test_0600
* @tc.name: Ability Lifecycle
* @tc.desc: Ability life cycle changes: initial - > active , the interface of demoability will be called:
* OnStart()->OnActive()->OnInactive()->OnBackground()->OnStop().
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Lifecycle_Test_0600, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INITIAL);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* @tc.number: AaFwk_Ability_TerminateAbility_ForResult_Test_0100
* @tc.name: TerminateAbility_ForResult
* @tc.desc: 1. TerminateAbility with parameters
* 2. AMS returns parameters through sendresult
* 3. Compare the returned parameters with the passed in parameters.
*/
HWTEST_F(AbilityBaseTest, AaFwk_Ability_TerminateAbility_ForResult_Test_0100, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
sptr<IAbilityConnection> connect = nullptr;
abms->TerminateAbility(nullptr, RESULT_CODE, &want);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
}
* Parameters:
* Action
* Entity
* Flag
* ElementName
*/
class AbilityTerminateTest : public testing::Test {
public:
static void SetUpTestCase(void);
static void TearDownTestCase(void);
void SetUp();
void TearDown();
public:
OHOS::sptr<OHOS::IRemoteObject> abilityObject_;
static constexpr int TEST_WAIT_TIME = 500 * 1000;
static const int RESULT_CODE = 1992;
};
void AbilityTerminateTest::SetUpTestCase(void)
{}
void AbilityTerminateTest::TearDownTestCase(void)
{}
void AbilityTerminateTest::SetUp(void)
{
abilityObject_ = new MockAbilityManagerService();
auto sysMgr = OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance();
EXPECT_TRUE(sysMgr != nullptr);
sysMgr->RegisterSystemAbility(OHOS::ABILITY_MGR_SERVICE_ID, abilityObject_);
}
void AbilityTerminateTest::TearDown(void)
{
abilityObject_ = nullptr;
}
* @tc.number: AaFwk_Ability_Terminate_test_0100
* @tc.name: TerminateAbility
* @tc.desc: When the ability state is inactive, the call to terminateability terminates.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0100, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_001 AbilityThreadMain";
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
Want want;
MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INACTIVE);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
auto ability = AbilityLoader::GetInstance().GetAbilityByName(abilityInfo->name);
EXPECT_NE(ability, nullptr);
if (ability != nullptr) {
ability->SetResult(RESULT_CODE, want);
ability->TerminateAbility();
}
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_001 TerminateAbility";
}
* @tc.number: AaFwk_Ability_Terminate_test_0200
* @tc.name: TerminateAbility
* @tc.desc: When the ability state is active, the call to terminateability terminates.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0200, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_002 AbilityThreadMain";
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
Want want;
MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
auto ability = AbilityLoader::GetInstance().GetAbilityByName(abilityInfo->name);
EXPECT_NE(ability, nullptr);
if (ability != nullptr) {
ability->SetResult(RESULT_CODE, want);
ability->TerminateAbility();
}
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_002 TerminateAbility";
}
* @tc.number: AaFwk_Ability_Terminate_test_0300
* @tc.name: TerminateAbility
* @tc.desc: When the ability state is BACKGROUND, the call to terminateability terminates.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0300, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_0300 AbilityThreadMain";
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
Want want;
MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
auto ability = AbilityLoader::GetInstance().GetAbilityByName(abilityInfo->name);
EXPECT_NE(ability, nullptr);
if (ability != nullptr) {
ability->SetResult(RESULT_CODE, want);
ability->TerminateAbility();
}
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_0300 TerminateAbility";
}
* @tc.number: AaFwk_Ability_Terminate_test_0400
* @tc.name: TerminateAbility
* @tc.desc: When the ability state is ABILITY_STATE_INITIAL, the call to terminateability terminates.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0400, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_0400 AbilityThreadMain";
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
Want want;
MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INITIAL);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
auto ability = AbilityLoader::GetInstance().GetAbilityByName(abilityInfo->name);
EXPECT_NE(ability, nullptr);
if (ability != nullptr) {
ability->SetResult(RESULT_CODE, want);
ability->TerminateAbility();
}
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_0400 TerminateAbility";
}
* @tc.number: AaFwk_Ability_Terminate_test_0500
* @tc.name: TerminateAbility
* @tc.desc: When the ability state is inactive, the call to terminateability terminates.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0500, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_005 AbilityThreadMain";
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
Want want;
MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INACTIVE);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_005 TerminateAbility";
}
* @tc.number: AaFwk_Ability_Terminate_test_0600
* @tc.name: TerminateAbility
* @tc.desc: When the ability state is active, the call to terminateability terminates.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0600, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_006 AbilityThreadMain";
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
Want want;
MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_006 TerminateAbility";
}
* @tc.number: AaFwk_Ability_Terminate_test_0700
* @tc.name: TerminateAbility
* @tc.desc: When the ability state is background, the call to terminateability terminates.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0700, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_007 AbilityThreadMain";
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
Want want;
MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_007 TerminateAbility";
}
* @tc.number: AaFwk_Ability_Terminate_test_0800
* @tc.name: TerminateAbility
* @tc.desc: When the ability state is initial, the call to terminateability terminates.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0800, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_008 AbilityThreadMain";
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
Want want;
MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INITIAL);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_008 TerminateAbility";
}
* @tc.number: AaFwk_WMS_window_test_0100
* @tc.name: WMS Link
* @tc.desc: Start pageability and call GetWindow to get the window handle.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_WMS_window_test_0100, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_001 AbilityThreadMain";
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
Want want;
MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_001 StartAbility";
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_001 TerminateAbility";
}
* @tc.number: AaFwk_WMS_window_test_0200
* @tc.name: WMS Link
* @tc.desc: Pageability switches to the foreground and calls Window.show.
* Pageability switches to the background and calls Window.hide.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_WMS_window_test_0200, Function | MediumTest | Level1)
{
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::PAGE;
abilityInfo->name = ABILITY_NAME;
abilityInfo->isNativeAbility = true;
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_002 AbilityThreadMain";
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
Want want;
MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_002 BackGround";
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_002 Active";
usleep(AbilityTerminateTest::TEST_WAIT_TIME);
mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
}
GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_002 TerminateAbility";
}
* @tc.number: AaFwk_DataAbility_Launch_0100
* @tc.name: DataAbilityHelper
* @tc.desc: The AbilityManager could receive the shelder of abilitythread for dataability when the dataability
* launched.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_DataAbility_Launch_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_DataAbility_Launch_0100";
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::DATA;
abilityInfo->name = "DemoAbility";
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Uri uri("testuri");
EXPECT_TRUE(abms->AcquireDataAbility(uri, false, nullptr) == nullptr);
}
GTEST_LOG_(INFO) << "AaFwk_DataAbility_Launch_0100";
}
* @tc.number: AaFwk_DataAbility_Start_0100
* @tc.name: DataAbilityHelper
* @tc.desc: The AbilityManager could receive the inactive state from abilitythread for dataability when the
dataability
* change its lifecycle state to inactive.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_DataAbility_Start_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0100";
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::DATA;
abilityInfo->name = "DemoAbility";
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INACTIVE);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0100";
}
* @tc.number: AaFwk_DataAbility_Start_0200
* @tc.name: DataAbilityHelper
* @tc.desc: The AbilityManager could not receive the initial state from abilitythread for dataability.
* And the OnStop coulde be called. When the dataability change its lifecycle state to initial.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_DataAbility_Start_0200, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0200";
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::DATA;
abilityInfo->name = "DemoAbility";
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INITIAL);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0200";
}
* @tc.number: AaFwk_DataAbility_Start_0300
* @tc.name: DataAbilityHelper
* @tc.desc: The AbilityManager could not receive the active state from abilitythread for dataability.
* And the OnActive coulde be called. When the dataability change its lifecycle state to active.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_DataAbility_Start_0300, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0300";
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::DATA;
abilityInfo->name = "DemoAbility";
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0300";
}
* @tc.number: AaFwk_DataAbility_Start_0400
* @tc.name: DataAbilityHelper
* @tc.desc: The AbilityManager could not receive the background state from abilitythread for dataability.
* And the OnBackground coulde be called. When the dataability change its lifecycle state to background.
*/
HWTEST_F(AbilityTerminateTest, AaFwk_DataAbility_Start_0400, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0400";
std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityRuntime::FAAbilityThread());
EXPECT_NE(abilityToken, nullptr);
if (abilityToken != nullptr) {
std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
abilityInfo->type = AppExecFwk::AbilityType::DATA;
abilityInfo->name = "DemoAbility";
auto abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken, nullptr, 0);
AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
Want want;
abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
usleep(AbilityBaseTest::TEST_WAIT_TIME);
}
GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0400";
}
* @tc.number: AaFwk_IAbilityManager_StartAbilityAsCaller_0100
* @tc.name: StartAbilityAsCaller
* @tc.desc: test StartAbilityAsCaller function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_StartAbilityAsCaller_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartAbilityAsCaller_0100";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
Want want;
EXPECT_EQ(0, abms->StartAbilityAsCaller(want, nullptr, nullptr));
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartAbilityAsCaller_0100";
}
* @tc.number: AaFwk_IAbilityManager_StartAbilityAsCaller_0200
* @tc.name: StartAbilityAsCaller
* @tc.desc: test StartAbilityAsCaller function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_StartAbilityAsCaller_0200, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartAbilityAsCaller_0200";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
Want want;
StartOptions startOptions;
EXPECT_EQ(0, abms->StartAbilityAsCaller(want, startOptions, nullptr, nullptr));
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartAbilityAsCaller_0200";
}
* @tc.number: AaFwk_IAbilityManager_StartUIExtensionAbility_0100
* @tc.name: StartUIExtensionAbility
* @tc.desc: test StartUIExtensionAbility function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_StartUIExtensionAbility_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartUIExtensionAbility_0100";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
Want want;
EXPECT_EQ(0, abms->StartAbilityAsCaller(want, nullptr, nullptr));
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartUIExtensionAbility_0100";
}
* @tc.number: AaFwk_IAbilityManager_TerminateUIExtensionAbility_0100
* @tc.name: TerminateUIExtensionAbility
* @tc.desc: test TerminateUIExtensionAbility function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_TerminateUIExtensionAbility_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_TerminateUIExtensionAbility_0100";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
int resultCode = 1;
EXPECT_EQ(0, abms->TerminateUIExtensionAbility(nullptr, resultCode));
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_TerminateUIExtensionAbility_0100";
}
* @tc.number: AaFwk_IAbilityManager_SendResultToAbility_0100
* @tc.name: SendResultToAbility
* @tc.desc: test SendResultToAbility function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_SendResultToAbility_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_SendResultToAbility_0100";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
int requestCode = 1;
int resultCode = 2;
Want resultWant;
EXPECT_EQ(0, abms->SendResultToAbility(requestCode, resultCode, resultWant));
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_SendResultToAbility_0100";
}
* @tc.number: AaFwk_IAbilityManager_MinimizeUIExtensionAbility_0100
* @tc.name: MinimizeUIExtensionAbility
* @tc.desc: test MinimizeUIExtensionAbility function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_MinimizeUIExtensionAbility_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_MinimizeUIExtensionAbility_0100";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
EXPECT_EQ(0, abms->MinimizeUIExtensionAbility(nullptr));
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_MinimizeUIExtensionAbility_0100";
}
* @tc.number: AaFwk_IAbilityManager_CallRequestDone_0100
* @tc.name: CallRequestDone
* @tc.desc: test CallRequestDone function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_CallRequestDone_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_CallRequestDone_0100";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
abms->CallRequestDone(nullptr, nullptr);
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_CallRequestDone_0100";
}
* @tc.number: AaFwk_IAbilityManager_AddFreeInstallObserver_0100
* @tc.name: AddFreeInstallObserver
* @tc.desc: test AddFreeInstallObserver function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_AddFreeInstallObserver_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_AddFreeInstallObserver_0100";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
EXPECT_EQ(0, abms->AddFreeInstallObserver(nullptr, nullptr));
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_AddFreeInstallObserver_0100";
}
* @tc.number: AaFwk_IAbilityManager_EnableRecoverAbility_0100
* @tc.name: EnableRecoverAbility
* @tc.desc: test EnableRecoverAbility function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_EnableRecoverAbility_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_EnableRecoverAbility_0100";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
abms->EnableRecoverAbility(nullptr);
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_EnableRecoverAbility_0100";
}
* @tc.number: AaFwk_IAbilityManager_ScheduleRecoverAbility_0100
* @tc.name: ScheduleRecoverAbility
* @tc.desc: test ScheduleRecoverAbility function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_ScheduleRecoverAbility_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_ScheduleRecoverAbility_0100";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
int32_t reason = 1;
abms->ScheduleRecoverAbility(nullptr, reason);
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_ScheduleRecoverAbility_0100";
}
* @tc.number: AaFwk_IAbilityManager_VerifyPermission_0100
* @tc.name: VerifyPermission
* @tc.desc: test VerifyPermission function
*/
HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_VerifyPermission_0100, Function | MediumTest | Level1)
{
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_VerifyPermission_0100";
sptr<IRemoteObject> remoteObject_ =
OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
EXPECT_NE(abms, nullptr);
std::string permission = "<permission>";
int pid = 1;
int uid = 1;
EXPECT_EQ(0, abms->VerifyPermission(permission, pid, uid));
GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_VerifyPermission_0100";
}
}
}
