openharmony/accessibility
1
0
Fork 0
mirror of https://github.com/openharmony/accessibility.git synced 2026-08-24 12:34:00 -04:00
Code Issues Packages Projects Releases Wiki Activity

新增和修复DT用例

Browse Source 
Signed-off-by: hanyujia <hanyujia@huawei.com>
This commit is contained in:
hanyujia
2025-05-20 18:46:59 +08:00
parent 4d5cba3467
commit 853aa61fa7
11 changed files with 756 additions and 1070 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/interface/test/unittest/ accessible_ability_manager_state_observer_proxy_test.cpp
+7 -25
View File
@@ -1841,18 +1841,12 @@
GTEST_LOG_(INFO) << "ManagerStateObserverProxy_Unittest_Test_079 start";
std::shared_ptr<AccessibilitySettingProvider> service =
AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
if (service == nullptr) {
GTEST_LOG_(INFO) << "service is nullptr";
return;
}
EXPECT_TRUE(service != nullptr);
service->PutBoolValue(DEVICE_PROVISIONED, true, true);
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (accountData == nullptr) {
GTEST_LOG_(INFO) << "accountData is nullptr";
return;
}
EXPECT_TRUE(accountData != nullptr);
Singleton<AccessibleAbilityManagerService>::GetInstance().OnShortKeyProcess();
EXPECT_EQ(accountData->GetConfig()->GetShortKeyTimeout(), SHORT_KEY_TIMEOUT_BEFORE_USE);
GTEST_LOG_(INFO) << "ManagerStateObserverProxy_Unittest_Test_079 end";
@@ -1868,17 +1862,11 @@
GTEST_LOG_(INFO) << "ManagerStateObserverProxy_Unittest_Test_080 start";
std::shared_ptr<AccessibilitySettingProvider> service =
AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
if (service == nullptr) {
GTEST_LOG_(INFO) << "service is nullptr";
return;
}
EXPECT_TRUE(service != nullptr);
service->PutBoolValue(DEVICE_PROVISIONED, true, true);
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (accountData == nullptr) {
GTEST_LOG_(INFO) << "accountData is nullptr";
return;
}
EXPECT_TRUE(accountData != nullptr);
std::vector<std::string> name;
Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyMultiTarget(name);
@@ -1900,17 +1888,11 @@
GTEST_LOG_(INFO) << "ManagerStateObserverProxy_Unittest_Test_081 start";
std::shared_ptr<AccessibilitySettingProvider> service =
AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
if (service == nullptr) {
GTEST_LOG_(INFO) << "service is nullptr";
return;
}
EXPECT_TRUE(service != nullptr);
service->PutBoolValue(DEVICE_PROVISIONED, true, true);
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (accountData == nullptr) {
GTEST_LOG_(INFO) << "accountData is nullptr";
return;
}
EXPECT_TRUE(accountData != nullptr);
std::vector<std::string> name;
name.push_back("test1");
common/interface/test/unittest/accessibility_gesture_inject_path_parcel_test.cpp
+3 -9
View File
@@ -59,11 +59,8 @@ public:
HWTEST_F(AccessibilityGestureInjectPathParcelTest, Gesture_Info_Marshalling_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Gesture_Info_Marshalling_001 start";
if (!GesturgestureInfoParcel_e_Info) {
GTEST_LOG_(INFO) << "captionPropertyParcel_ is null";
return;
}
EXPECT_TRUE(GesturgestureInfoParcel_e_Info);
Parcel parcel;
bool ret = GesturgestureInfoParcel_e_Info->Marshalling(parcel);
EXPECT_EQ(ret, true);
@@ -78,10 +75,7 @@ HWTEST_F(AccessibilityGestureInjectPathParcelTest, Gesture_Info_Marshalling_001,
HWTEST_F(AccessibilityGestureInjectPathParcelTest, Gesture_Info_Unmarshalling_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Gesture_Info_Unmarshalling_001 start";
if (!GesturgestureInfoParcel_e_Info) {
GTEST_LOG_(INFO) << "GesturgestureInfoParcel_e_Info is null";
return;
}
EXPECT_TRUE(GesturgestureInfoParcel_e_Info);
Parcel parcel;
sptr<AccessibilityGestureInjectPathParcel> gestureInfoParcel = GesturgestureInfoParcel_e_Info->Unmarshalling(parcel);
frameworks/aafwk/test/unittest/accessibility_element_operator_callback_impl_extension_test.cpp
+9 -37
View File
@@ -87,10 +87,7 @@ HWTEST_F(
HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetSearchElementInfoByTextResult_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorCallbackImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -108,10 +105,7 @@ HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetSearchElementInfoByTex
HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetFindFocusedElementInfoResult_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorCallbackImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -129,10 +123,7 @@ HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetFindFocusedElementInfo
HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetFocusMoveSearchResult_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorCallbackImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -150,10 +141,7 @@ HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetFocusMoveSearchResult_
HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetExecuteActionResult_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetExecuteActionResult_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorCallbackImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -172,11 +160,7 @@ HWTEST_F(
AccessibilityElementOperatorCallbackImplTest, SetSearchElementInfoByAccessibilityIdResult_0011, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorCallbackImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -194,10 +178,7 @@ HWTEST_F(
HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetSearchElementInfoByTextResult_0011, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorCallbackImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -215,10 +196,7 @@ HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetSearchElementInfoByTex
HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetFindFocusedElementInfoResult_0011, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorCallbackImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -236,10 +214,7 @@ HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetFindFocusedElementInfo
HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetFocusMoveSearchResult_0011, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorCallbackImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -257,10 +232,7 @@ HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetFocusMoveSearchResult_
HWTEST_F(AccessibilityElementOperatorCallbackImplTest, SetExecuteActionResult_0011, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetExecuteActionResult_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorCallbackImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
frameworks/aafwk/test/unittest/accessibility_ui_test_ability_impl_extension_test.cpp
+66 -261
View File
@@ -72,10 +72,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetFocus_001, TestSize.Lev
{
GTEST_LOG_(INFO) << "GetFocus_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetFocus(FOCUS_TYPE, elementInfo), RET_ERR_NULLPTR);
@@ -93,10 +90,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetFocus_002, TestSize.Lev
{
GTEST_LOG_(INFO) << "GetFocus_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetFocus(FOCUS_TYPE, elementInfo), RET_OK);
@@ -112,10 +106,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetFocusByElementInfo_001,
{
GTEST_LOG_(INFO) << "GetFocusByElementInfo_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo sourceInfo {};
AccessibilityElementInfo elementInfo {};
@@ -134,10 +125,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetFocusByElementInfo_002,
{
GTEST_LOG_(INFO) << "GetFocusByElementInfo_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo sourceInfo {};
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetFocusByElementInfo(sourceInfo, FOCUS_TYPE, elementInfo), RET_OK);
@@ -154,10 +142,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, InjectGesture_001, TestSiz
{
GTEST_LOG_(INFO) << "InjectGesture_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
EXPECT_EQ(instance_->InjectGesture(gesturePath), RET_ERR_NULLPTR);
@@ -175,10 +160,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, InjectGesture_002, TestSiz
{
GTEST_LOG_(INFO) << "InjectGesture_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
EXPECT_EQ(instance_->InjectGesture(gesturePath), RET_OK);
@@ -194,10 +176,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRoot_001, TestSize.Leve
{
GTEST_LOG_(INFO) << "GetRoot_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetRoot(elementInfo), RET_ERR_NULLPTR);
@@ -215,10 +194,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRoot_002, TestSize.Leve
{
GTEST_LOG_(INFO) << "GetRoot_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetRoot(elementInfo), RET_OK);
@@ -234,10 +210,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRootByWindow_001, TestS
{
GTEST_LOG_(INFO) << "GetRootByWindow_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityWindowInfo windowInfo {};
AccessibilityElementInfo elementInfo {};
@@ -256,10 +229,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRootByWindow_002, TestS
{
GTEST_LOG_(INFO) << "GetRootByWindow_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityWindowInfo windowInfo {};
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetRootByWindow(windowInfo, elementInfo), RET_OK);
@@ -276,10 +246,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindow_001, TestSize.Le
{
GTEST_LOG_(INFO) << "GetWindow_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityWindowInfo winInfo {};
EXPECT_EQ(instance_->GetWindow(WINDOW_ID, winInfo), RET_ERR_NULLPTR);
@@ -296,10 +263,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindow_002, TestSize.Le
{
GTEST_LOG_(INFO) << "GetWindow_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityWindowInfo winInfo {};
EXPECT_EQ(instance_->GetWindow(WINDOW_ID, winInfo), RET_OK);
GTEST_LOG_(INFO) << "GetWindow_002 end";
@@ -314,10 +278,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindows_001, TestSize.L
{
GTEST_LOG_(INFO) << "GetWindows_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->GetWindows(res), RET_ERR_NULLPTR);
@@ -334,10 +295,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindows_002, TestSize.L
{
GTEST_LOG_(INFO) << "GetWindows_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->GetWindows(res), RET_OK);
GTEST_LOG_(INFO) << "GetWindows_002 end";
@@ -352,10 +310,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindows_003, TestSize.L
{
GTEST_LOG_(INFO) << "GetWindows_003 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->GetWindows(DISPLAY_ID, res), RET_ERR_NULLPTR);
@@ -372,10 +327,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindows_004, TestSize.L
{
GTEST_LOG_(INFO) << "GetWindows_004 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->GetWindows(DISPLAY_ID, res), RET_OK);
GTEST_LOG_(INFO) << "GetWindows_004 end";
@@ -390,10 +342,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetNext_001, TestSize.Leve
{
GTEST_LOG_(INFO) << "GetNext_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo nextElementInfo {};
AccessibilityElementInfo elementInfo {};
@@ -413,10 +362,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetNext_002, TestSize.Leve
{
GTEST_LOG_(INFO) << "GetNext_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo nextElementInfo {};
AccessibilityElementInfo elementInfo {};
FocusMoveDirection direction = DIRECTION_INVALID;
@@ -434,10 +380,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetChildElementInfo_001, T
{
GTEST_LOG_(INFO) << "GetChildElementInfo_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo parent {};
AccessibilityElementInfo child {};
@@ -457,10 +400,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetChildElementInfo_002, T
{
GTEST_LOG_(INFO) << "GetChildElementInfo_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo parent {};
AccessibilityElementInfo child {};
int32_t index = 1;
@@ -478,10 +418,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetByContent_001, TestSize
{
GTEST_LOG_(INFO) << "GetByContent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo parent {};
std::vector<AccessibilityElementInfo> elementInfos {};
@@ -500,10 +437,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetByContent_002, TestSize
{
GTEST_LOG_(INFO) << "GetByContent_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo parent {};
std::vector<AccessibilityElementInfo> elementInfos {};
EXPECT_EQ(instance_->GetByContent(parent, TEST, elementInfos), RET_OK);
@@ -520,10 +454,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetSource_001, TestSize.Le
{
GTEST_LOG_(INFO) << "GetSource_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityEventInfo eventInfo {};
AccessibilityElementInfo elementInfo {};
@@ -542,10 +473,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetSource_002, TestSize.Le
{
GTEST_LOG_(INFO) << "GetSource_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityEventInfo eventInfo {};
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetSource(eventInfo, elementInfo), RET_OK);
@@ -562,10 +490,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetParentElementInfo_001,
{
GTEST_LOG_(INFO) << "GetParentElementInfo_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo child {};
AccessibilityElementInfo parent {};
@@ -584,10 +509,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetParentElementInfo_002,
{
GTEST_LOG_(INFO) << "GetParentElementInfo_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo child {};
AccessibilityElementInfo parent {};
EXPECT_EQ(instance_->GetParentElementInfo(child, parent), RET_OK);
@@ -604,10 +526,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, ExecuteAction_001, TestSiz
{
GTEST_LOG_(INFO) << "ExecuteAction_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo elementInfo {};
ActionType action = ACCESSIBILITY_ACTION_INVALID;
@@ -627,10 +546,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, ExecuteAction_002, TestSiz
{
GTEST_LOG_(INFO) << "ExecuteAction_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo elementInfo {};
ActionType action = ACCESSIBILITY_ACTION_INVALID;
std::map<std::string, std::string> actionArguments {};
@@ -648,10 +564,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, SetTargetBundleName_001, T
{
GTEST_LOG_(INFO) << "SetTargetBundleName_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
std::vector<std::string> targetBundleNames;
EXPECT_EQ(instance_->SetTargetBundleName(targetBundleNames), RET_ERR_NULLPTR);
@@ -669,10 +582,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, SetTargetBundleName_002, T
{
GTEST_LOG_(INFO) << "SetTargetBundleName_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<std::string> targetBundleNames;
EXPECT_EQ(instance_->SetTargetBundleName(targetBundleNames), RET_OK);
@@ -688,10 +598,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetChildren_001, TestSize.
{
GTEST_LOG_(INFO) << "GetChildren_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo parent;
std::vector<AccessibilityElementInfo> children;
EXPECT_EQ(instance_->GetChildren(parent, children), RET_OK);
@@ -708,10 +615,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, SetCacheMode_001, TestSize
{
GTEST_LOG_(INFO) << "SetCacheMode_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
instance_->SetCacheMode(CACHE_MODE);
EXPECT_EQ(CACHE_MODE, AccessibilityAbilityUtHelper::GetInstance().GetCacheMode());
@@ -727,10 +631,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRootBatch_001, TestSize
{
GTEST_LOG_(INFO) << "GetRootBatch_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
std::vector<AccessibilityElementInfo> elementInfos;
EXPECT_EQ(instance_->GetRootBatch(elementInfos), RET_ERR_NULLPTR);
@@ -748,10 +649,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRootBatch_002, TestSize
{
GTEST_LOG_(INFO) << "GetRootBatch_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> elementInfos;
EXPECT_EQ(instance_->GetRootBatch(elementInfos), RET_OK);
@@ -767,10 +665,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRootByWindowBatch_001,
{
GTEST_LOG_(INFO) << "GetRootByWindowBatch_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityWindowInfo windowInfo {};
std::vector<AccessibilityElementInfo> elementInfos;
@@ -789,10 +684,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRootByWindowBatch_002,
{
GTEST_LOG_(INFO) << "GetRootByWindowBatch_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityWindowInfo windowInfo {};
std::vector<AccessibilityElementInfo> elementInfos;
EXPECT_EQ(instance_->GetRootByWindowBatch(windowInfo, elementInfos, true), RET_OK);
@@ -809,10 +701,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, SetCacheMode_0011, TestSiz
{
GTEST_LOG_(INFO) << "SetCacheMode_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
instance_->SetCacheMode(CACHE_MODE_ZERO);
EXPECT_EQ(CACHE_MODE_ZERO, AccessibilityAbilityUtHelper::GetInstance().GetCacheMode());
@@ -828,10 +717,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetFocus_0011, TestSize.Le
{
GTEST_LOG_(INFO) << "GetFocus_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetFocus(FOCUS_TYPE_ZERO, elementInfo), RET_ERR_NULLPTR);
@@ -849,10 +735,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetFocus_0021, TestSize.Le
{
GTEST_LOG_(INFO) << "GetFocus_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetFocus(FOCUS_TYPE_ZERO, elementInfo), RET_OK);
@@ -868,10 +751,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetFocusByElementInfo_0011
{
GTEST_LOG_(INFO) << "GetFocusByElementInfo_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo sourceInfo {};
AccessibilityElementInfo elementInfo {};
@@ -890,10 +770,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetFocusByElementInfo_0021
{
GTEST_LOG_(INFO) << "GetFocusByElementInfo_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo sourceInfo {};
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetFocusByElementInfo(sourceInfo, FOCUS_TYPE_ZERO, elementInfo), RET_OK);
@@ -910,10 +787,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, InjectGesture_0011, TestSi
{
GTEST_LOG_(INFO) << "InjectGesture_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
EXPECT_EQ(instance_->InjectGesture(gesturePath), RET_ERR_NULLPTR);
@@ -931,10 +805,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, InjectGesture_0021, TestSi
{
GTEST_LOG_(INFO) << "InjectGesture_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
EXPECT_EQ(instance_->InjectGesture(gesturePath), RET_OK);
@@ -950,10 +821,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRoot_0011, TestSize.Lev
{
GTEST_LOG_(INFO) << "GetRoot_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetRoot(elementInfo), RET_ERR_NULLPTR);
@@ -971,10 +839,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRoot_0021, TestSize.Lev
{
GTEST_LOG_(INFO) << "GetRoot_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetRoot(elementInfo), RET_OK);
@@ -990,10 +855,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRootByWindow_0011, Test
{
GTEST_LOG_(INFO) << "GetRootByWindow_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityWindowInfo windowInfo {};
AccessibilityElementInfo elementInfo {};
@@ -1012,10 +874,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetRootByWindow_0021, Test
{
GTEST_LOG_(INFO) << "GetRootByWindow_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityWindowInfo windowInfo {};
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetRootByWindow(windowInfo, elementInfo), RET_OK);
@@ -1032,10 +891,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindow_0011, TestSize.L
{
GTEST_LOG_(INFO) << "GetWindow_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityWindowInfo winInfo {};
EXPECT_EQ(instance_->GetWindow(WINDOW_ID_ZERO, winInfo), RET_ERR_NULLPTR);
@@ -1052,10 +908,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindow_0021, TestSize.L
{
GTEST_LOG_(INFO) << "GetWindow_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityWindowInfo winInfo {};
EXPECT_EQ(instance_->GetWindow(WINDOW_ID_ZERO, winInfo), RET_OK);
GTEST_LOG_(INFO) << "GetWindow_0021 end";
@@ -1070,10 +923,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindows_0011, TestSize.
{
GTEST_LOG_(INFO) << "GetWindows_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->GetWindows(res), RET_ERR_NULLPTR);
@@ -1090,10 +940,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindows_0021, TestSize.
{
GTEST_LOG_(INFO) << "GetWindows_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->GetWindows(res), RET_OK);
GTEST_LOG_(INFO) << "GetWindows_0021 end";
@@ -1108,10 +955,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindows_003, TestSize.L
{
GTEST_LOG_(INFO) << "GetWindows_003 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->GetWindows(DISPLAY_ID_ZERO, res), RET_ERR_NULLPTR);
@@ -1128,10 +972,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetWindows_004, TestSize.L
{
GTEST_LOG_(INFO) << "GetWindows_004 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->GetWindows(DISPLAY_ID_ZERO, res), RET_OK);
GTEST_LOG_(INFO) << "GetWindows_004 end";
@@ -1146,10 +987,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetNext_0011, TestSize.Lev
{
GTEST_LOG_(INFO) << "GetNext_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo nextElementInfo {};
AccessibilityElementInfo elementInfo {};
@@ -1169,10 +1007,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetNext_0021, TestSize.Lev
{
GTEST_LOG_(INFO) << "GetNext_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo nextElementInfo {};
AccessibilityElementInfo elementInfo {};
FocusMoveDirection direction = DIRECTION_INVALID;
@@ -1190,10 +1025,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetChildElementInfo_0011,
{
GTEST_LOG_(INFO) << "GetChildElementInfo_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo parent {};
AccessibilityElementInfo child {};
@@ -1213,10 +1045,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetChildElementInfo_0021,
{
GTEST_LOG_(INFO) << "GetChildElementInfo_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo parent {};
AccessibilityElementInfo child {};
int32_t index = 1;
@@ -1234,10 +1063,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetByContent_0011, TestSiz
{
GTEST_LOG_(INFO) << "GetByContent_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo parent {};
std::vector<AccessibilityElementInfo> elementInfos {};
@@ -1256,10 +1082,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetByContent_0021, TestSiz
{
GTEST_LOG_(INFO) << "GetByContent_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo parent {};
std::vector<AccessibilityElementInfo> elementInfos {};
EXPECT_EQ(instance_->GetByContent(parent, TEST, elementInfos), RET_OK);
@@ -1276,10 +1099,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetSource_0011, TestSize.L
{
GTEST_LOG_(INFO) << "GetSource_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityEventInfo eventInfo {};
AccessibilityElementInfo elementInfo {};
@@ -1298,10 +1118,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetSource_0021, TestSize.L
{
GTEST_LOG_(INFO) << "GetSource_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityEventInfo eventInfo {};
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->GetSource(eventInfo, elementInfo), RET_OK);
@@ -1318,10 +1135,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetParentElementInfo_0011,
{
GTEST_LOG_(INFO) << "GetParentElementInfo_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo child {};
AccessibilityElementInfo parent {};
@@ -1340,10 +1154,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, GetParentElementInfo_0021,
{
GTEST_LOG_(INFO) << "GetParentElementInfo_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo child {};
AccessibilityElementInfo parent {};
EXPECT_EQ(instance_->GetParentElementInfo(child, parent), RET_OK);
@@ -1360,10 +1171,7 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, ExecuteAction_0011, TestSi
{
GTEST_LOG_(INFO) << "ExecuteAction_0011 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
AccessibilityElementInfo elementInfo {};
ActionType action = ACCESSIBILITY_ACTION_INVALID;
@@ -1382,11 +1190,8 @@ HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, ExecuteAction_0011, TestSi
HWTEST_F(AccessibilityUITestAbilityImplExtensionTest, ExecuteAction_0021, TestSize.Level1)
{
GTEST_LOG_(INFO) << "ExecuteAction_0021 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo elementInfo {};
ActionType action = ACCESSIBILITY_ACTION_INVALID;
std::map<std::string, std::string> actionArguments {};
services/aams/test/unittest/accessibility_datashare_helper_test.cpp
+18 -36
View File
@@ -120,15 +120,11 @@ HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_GetLongValue_001 start";
sptr<AccessibilityAccountData> currentAccount =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!currentAccount) {
GTEST_LOG_(ERROR) << "Account data is nullptr";
return;
}
EXPECT_TRUE(currentAccount);
std::shared_ptr<AccessibilitySettingsConfig> config = currentAccount->GetConfig();
if (!config) {
GTEST_LOG_(ERROR) << "Config is nullptr";
return;
}
EXPECT_TRUE(config);
config->GetLongValue(true);
std::string cmdUser("-u");
std::vector<std::u16string> args;
@@ -154,16 +150,12 @@ HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDumper_Unittest_GetLongV
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> currentAccount =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!currentAccount) {
GTEST_LOG_(ERROR) << "Account data is nullptr";
return;
}
EXPECT_TRUE(currentAccount);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(currentAccount->GetAccountId(), 0, *abilityInfo);
if (!connection) {
GTEST_LOG_(ERROR) << "Connection is nullptr";
return;
}
EXPECT_TRUE(connection);
currentAccount->AddConnectedAbility(connection);
std::string cmdClient("-c");
std::vector<std::u16string> args;
@@ -186,10 +178,8 @@ HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest
const int32_t windowId = 1;
sptr<AccessibilityAccountData> currentAccount =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!currentAccount) {
GTEST_LOG_(ERROR) << "Account data is nullptr";
return;
}
EXPECT_TRUE(currentAccount);
sptr<AccessibilityWindowConnection> operationConnection =
new AccessibilityWindowConnection(windowId, nullptr, accountId);
currentAccount->AddAccessibilityWindowConnection(windowId, operationConnection);
@@ -214,10 +204,8 @@ HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
std::shared_ptr<AccessibilitySettingsConfig> config = currentAccount->GetConfig();
if (!config) {
GTEST_LOG_(ERROR) << "Config is nullptr";
return;
}
XPECT_TRUE(config);
config->SetCaptionState(true);
std::string cmdUser("-u");
std::vector<std::u16string> args;
@@ -245,16 +233,12 @@ HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> currentAccount =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!currentAccount) {
GTEST_LOG_(ERROR) << "Account data is nullptr";
return;
}
EXPECT_TRUE(currentAccount);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(currentAccount->GetAccountId(), 0, *abilityInfo);
if (!connection) {
GTEST_LOG_(ERROR) << "Connection is nullptr";
return;
}
EXPECT_TRUE(connection);
currentAccount->AddConnectedAbility(connection);
std::string cmdClient("-c");
std::vector<std::u16string> args;
@@ -279,10 +263,8 @@ HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest
const int32_t windowId = 1;
sptr<AccessibilityAccountData> currentAccount =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!currentAccount) {
GTEST_LOG_(ERROR) << "Account data is nullptr";
return;
}
EXPECT_TRUE(currentAccount);
sptr<AccessibilityWindowConnection> operationConnection =
new AccessibilityWindowConnection(windowId, nullptr, accountId);
currentAccount->AddAccessibilityWindowConnection(windowId, operationConnection);
services/aams/test/unittest/accessibility_gesture_recognizer_test.cpp
+96 -150
View File
@@ -83,14 +83,11 @@ void AccessAccessibilityGestureRecognizerTest::OnPointerEventPresss(MMI::KeyEven
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_001 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_001 event is null";
return;
}
EXPECT_TRUE(event);
event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
MMI::PointerEvent::PointerItem item;
@@ -109,14 +106,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_002 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_002 event is null";
return;
}
EXPECT_TRUE(event);
event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
MMI::PointerEvent::PointerItem item;
@@ -134,13 +128,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_001 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
OnPointerEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_1);
OnPointerEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_2);
@@ -163,13 +155,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_002 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
MMI::KeyEvent::KeyItem item;
@@ -188,23 +178,19 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_003 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_003 event is null";
return;
}
EXPECT_TRUE(event);
event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
MMI::PointerEvent::PointerItem item;
event->AddPointerItem(item);
mouseKey_->GetDoubleTapMoveThreshold(*event);
std::shared_ptr<MMI::KeyEvent> event3 = MMI::KeyEvent::Create();
if (!event3) {
return;
}
EXPECT_TRUE(event3);
event3->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_DIVIDE);
event3->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item1;
@@ -213,9 +199,8 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
event3->AddKeyItem(item1);
mouseKey_->OnPointerEvent(*event3);
std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
if (!event2) {
return;
}
EXPECT_TRUE(event2);
event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item3;
@@ -238,23 +223,19 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_004, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_004 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_004 event is null";
return;
}
EXPECT_TRUE(event);
event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
MMI::PointerEvent::PointerItem item;
event->AddPointerItem(item);
mouseKey_->GetDoubleTapMoveThreshold(*event);
std::shared_ptr<MMI::KeyEvent> event4 = MMI::KeyEvent::Create();
if (!event4) {
return;
}
EXPECT_TRUE(event4);
event4->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_SUBTRACT);
event4->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item1;
@@ -263,9 +244,8 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
event4->AddKeyItem(item1);
mouseKey_->OnPointerEvent(*event4);
std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
if (!event2) {
return;
}
EXPECT_TRUE(event2);
event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item4;
@@ -288,23 +268,19 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_005, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_005 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_005 event is null";
return;
}
EXPECT_TRUE(event);
event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
MMI::PointerEvent::PointerItem item;
event->AddPointerItem(item);
mouseKey_->GetDoubleTapMoveThreshold(*event);
std::shared_ptr<MMI::KeyEvent> event5 = MMI::KeyEvent::Create();
if (!event5) {
return;
}
EXPECT_TRUE(event5);
event5->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_MULTIPLY);
event5->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item1;
@@ -313,9 +289,8 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
event5->AddKeyItem(item1);
mouseKey_->OnPointerEvent(*event5);
std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
if (!event2) {
return;
}
EXPECT_TRUE(event2);
event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item5;
@@ -338,23 +313,19 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_006, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_006 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_006 event is null";
return;
}
EXPECT_TRUE(event);
event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
MMI::PointerEvent::PointerItem item;
event->AddPointerItem(item);
mouseKey_->GetDoubleTapMoveThreshold(*event);
std::shared_ptr<MMI::KeyEvent> event6 = MMI::KeyEvent::Create();
if (!event6) {
return;
}
EXPECT_TRUE(event6);
event6->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_DIVIDE);
event6->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item1;
@@ -363,9 +334,8 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
event6->AddKeyItem(item1);
mouseKey_->OnPointerEvent(*event6);
std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
if (!event2) {
return;
}
EXPECT_TRUE(event2);
event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_ADD);
event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item2;
@@ -388,13 +358,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_007, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_007 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item;
@@ -418,13 +386,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_008, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_008 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_2);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item;
@@ -448,13 +414,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_009, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_009 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_3);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item;
@@ -482,13 +446,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_010, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_010 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_4);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item;
@@ -516,13 +478,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_011, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_011 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_6);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item;
@@ -550,13 +510,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_012, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_012 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
MMI::KeyEvent::KeyItem item;
@@ -574,13 +532,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_013, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_013 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
MMI::KeyEvent::KeyItem item;
event->AddKeyItem(item);
AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
@@ -596,13 +552,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRec
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_001 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
// presss 1
@@ -629,13 +583,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestur
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_002 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_2);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
// presss left ctrl
@@ -662,13 +614,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestur
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_003 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_3);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
// presss 1
@@ -700,13 +650,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestur
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_004, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_004 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_4);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
// presss left ctrl
@@ -738,13 +686,11 @@ HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestur
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_005, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_005 start";
if (!mouseKey_) {
return;
}
EXPECT_TRUE(mouseKey_);
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
EXPECT_TRUE(event);
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_6);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
// presss left ctrl
services/aams/test/unittest/accessibility_multifinger_multitap_test.cpp
+52 -204
View File
@@ -79,11 +79,8 @@ HWTEST_F(MultiFingerGestureHandlerTest, IsTapGesture_001, TestSize.Level1)
HWTEST_F(MultiFingerGestureHandlerTest, ProcessMultiFingerGestureTypeEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "ProcessMultiFingerGestureTypeEvent_001 start";
EXPECT_TRUE(instance_);
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
std::shared_ptr<AccessibleAbilityListener> listener = nullptr;
EXPECT_EQ(instance_->ProcessMultiFingerGestureTypeEvent(listener), RET_ERR_INVALID_PARAM);
@@ -99,10 +96,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, ProcessMultiFingerGestureTypeEvent_002,
{
GTEST_LOG_(INFO) << "ProcessMultiFingerGestureTypeEvent_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
std::shared_ptr<AccessibleAbilityListener> listener = std::make_shared<MockAccessibleAbilityListener>();
EXPECT_EQ(instance_->ProcessMultiFingerGestureTypeEvent(listener), RET_ERR_NULLPTR);
@@ -120,10 +114,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, ProcessMultiFingerGestureTypeEvent_003,
{
GTEST_LOG_(INFO) << "ProcessMultiFingerGestureTypeEvent_003 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
std::shared_ptr<AccessibleAbilityListener> listener = std::make_shared<MockAccessibleAbilityListener>();
EXPECT_EQ(instance_->ProcessMultiFingerGestureTypeEvent(listener), RET_OK);
@@ -139,10 +130,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, ProcessMultiFingerGestureEvent_001, Test
{
GTEST_LOG_(INFO) << "ProcessMultiFingerGestureEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
EXPECT_EQ(RET_OK, instance_->ProcessMultiFingerGestureEvent());
GTEST_LOG_(INFO) << "ProcessMultiFingerGestureEvent_001 end";
@@ -157,10 +145,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, ProcessEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "ProcessEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
EXPECT_EQ(instance_->ProcessEvent(), RET_OK);
GTEST_LOG_(INFO) << "ProcessEvent_001 end";
@@ -175,10 +160,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, AccessibilityMultiTapGestureRecognizer_0
{
GTEST_LOG_(INFO) << "AccessibilityMultiTapGestureRecognizer_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->AccessibilityMultiTapGestureRecognizer(FOCUS_TYPE, elementInfo), RET_ERR_NULLPTR);
@@ -196,10 +178,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, AccessibilityMultiTapGestureRecognizer_0
{
GTEST_LOG_(INFO) << "AccessibilityMultiTapGestureRecognizer_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->AccessibilityMultiTapGestureRecognizer(FOCUS_TYPE, elementInfo), RET_OK);
@@ -215,10 +194,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelTwoFingerEvent_001, TestSize.Level
{
GTEST_LOG_(INFO) << "CancelTwoFingerEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityElementInfo sourceInfo {};
AccessibilityElementInfo elementInfo {};
@@ -237,10 +213,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelTwoFingerEvent_002, TestSize.Level
{
GTEST_LOG_(INFO) << "CancelTwoFingerEvent_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo sourceInfo {};
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->CancelTwoFingerEvent(sourceInfo, FOCUS_TYPE, elementInfo), RET_OK);
@@ -257,10 +230,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelThreeFingerEvent_001, TestSize.Lev
{
GTEST_LOG_(INFO) << "CancelThreeFingerEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityElementInfo sourceInfo {};
AccessibilityElementInfo elementInfo {};
@@ -279,10 +249,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelThreeFingerEvent_002, TestSize.Lev
{
GTEST_LOG_(INFO) << "CancelThreeFingerEvent_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo sourceInfo {};
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->CancelThreeFingerEvent(sourceInfo, FOCUS_TYPE, elementInfo), RET_OK);
@@ -299,10 +266,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelTapAndHoldGestureEvent_001, TestSi
{
GTEST_LOG_(INFO) << "CancelTapAndHoldGestureEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
EXPECT_EQ(instance_->CancelTapAndHoldGestureEvent(gesturePath), RET_ERR_NULLPTR);
@@ -320,10 +284,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelTapAndHoldGestureEvent_002, TestSi
{
GTEST_LOG_(INFO) << "CancelTapAndHoldGestureEvent_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
EXPECT_EQ(instance_->CancelTapAndHoldGestureEvent(gesturePath), RET_OK);
@@ -339,10 +300,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelHoldGestureEvent_001, TestSize.Lev
{
GTEST_LOG_(INFO) << "CancelHoldGestureEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->CancelHoldGestureEvent(elementInfo), RET_ERR_NULLPTR);
@@ -360,10 +318,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelHoldGestureEvent_002, TestSize.Lev
{
GTEST_LOG_(INFO) << "CancelHoldGestureEvent_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->CancelHoldGestureEvent(elementInfo), RET_OK);
@@ -379,10 +334,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelAllPenddingEvent_001, TestSize.Lev
{
GTEST_LOG_(INFO) << "CancelAllPenddingEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityWindowInfo windowInfo {};
AccessibilityElementInfo elementInfo {};
@@ -401,10 +353,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelAllPenddingEvent_002, TestSize.Lev
{
GTEST_LOG_(INFO) << "CancelAllPenddingEvent_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityWindowInfo windowInfo {};
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->CancelAllPenddingEvent(windowInfo, elementInfo), RET_OK);
@@ -421,10 +370,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelGesture_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "CancelGesture_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityWindowInfo winInfo {};
EXPECT_EQ(instance_->CancelGesture(WINDOW_ID, winInfo), RET_ERR_NULLPTR);
@@ -441,10 +387,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, CancelGesture_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "CancelGesture_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityWindowInfo winInfo {};
EXPECT_EQ(instance_->CancelGesture(WINDOW_ID, winInfo), RET_OK);
GTEST_LOG_(INFO) << "CancelGesture_002 end";
@@ -459,10 +402,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, ParamCheck_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "ParamCheck_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->ParamCheck(res), RET_ERR_NULLPTR);
@@ -479,10 +419,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, ParamCheck_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "ParamCheck_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->ParamCheck(res), RET_OK);
GTEST_LOG_(INFO) << "ParamCheck_002 end";
@@ -497,10 +434,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, ParamCheck_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "ParamCheck_003 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->ParamCheck(DISPLAY_ID, res), RET_ERR_NULLPTR);
@@ -517,10 +451,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, ParamCheck_004, TestSize.Level1)
{
GTEST_LOG_(INFO) << "ParamCheck_004 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityWindowInfo> res {};
EXPECT_EQ(instance_->ParamCheck(DISPLAY_ID, res), RET_OK);
GTEST_LOG_(INFO) << "ParamCheck_004 end";
@@ -535,10 +466,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, GetLastFirstPointUpTime_001, TestSize.Le
{
GTEST_LOG_(INFO) << "GetLastFirstPointUpTime_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityElementInfo nextElementInfo {};
AccessibilityElementInfo elementInfo {};
@@ -558,10 +486,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, GetLastFirstPointUpTime_002, TestSize.Le
{
GTEST_LOG_(INFO) << "GetLastFirstPointUpTime_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo nextElementInfo {};
AccessibilityElementInfo elementInfo {};
FocusMoveDirection direction = DIRECTION_INVALID;
@@ -579,10 +504,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, IsDoubelTapSlopConditionMatch_001, TestS
{
GTEST_LOG_(INFO) << "IsDoubelTapSlopConditionMatch_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityElementInfo parent {};
AccessibilityElementInfo child {};
@@ -602,10 +524,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, IsDoubelTapSlopConditionMatch_002, TestS
{
GTEST_LOG_(INFO) << "IsDoubelTapSlopConditionMatch_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo parent {};
AccessibilityElementInfo child {};
int32_t index = 1;
@@ -623,10 +542,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, GetPointerItemWithFingerNum_001, TestSiz
{
GTEST_LOG_(INFO) << "GetPointerItemWithFingerNum_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityElementInfo parent {};
std::vector<AccessibilityElementInfo> elementInfos {};
@@ -645,10 +561,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, GetPointerItemWithFingerNum_002, TestSiz
{
GTEST_LOG_(INFO) << "GetPointerItemWithFingerNum_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo parent {};
std::vector<AccessibilityElementInfo> elementInfos {};
EXPECT_EQ(instance_->GetPointerItemWithFingerNum(parent, TEST, elementInfos), RET_OK);
@@ -665,10 +578,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, IsMultiFingerDoubleTap_001, TestSize.Lev
{
GTEST_LOG_(INFO) << "IsMultiFingerDoubleTap_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityEventInfo eventInfo {};
AccessibilityElementInfo elementInfo {};
@@ -687,10 +597,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, IsMultiFingerDoubleTap_002, TestSize.Lev
{
GTEST_LOG_(INFO) << "IsMultiFingerDoubleTap_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityEventInfo eventInfo {};
AccessibilityElementInfo elementInfo {};
EXPECT_EQ(instance_->IsMultiFingerDoubleTap(eventInfo, elementInfo), RET_OK);
@@ -707,10 +614,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, HanleFirstTouchDownEvent_001, TestSize.L
{
GTEST_LOG_(INFO) << "HanleFirstTouchDownEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityElementInfo child {};
AccessibilityElementInfo parent {};
@@ -729,10 +633,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, HanleFirstTouchDownEvent_002, TestSize.L
{
GTEST_LOG_(INFO) << "HanleFirstTouchDownEvent_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo child {};
AccessibilityElementInfo parent {};
EXPECT_EQ(instance_->HanleFirstTouchDownEvent(child, parent), RET_OK);
@@ -749,10 +650,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, HandleMultiTapEvent_001, TestSize.Level1
{
GTEST_LOG_(INFO) << "HandleMultiTapEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityElementInfo elementInfo {};
ActionType action = ACCESSIBILITY_ACTION_INVALID;
@@ -772,10 +670,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, HandleMultiTapEvent_002, TestSize.Level1
{
GTEST_LOG_(INFO) << "HandleMultiTapEvent_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo elementInfo {};
ActionType action = ACCESSIBILITY_ACTION_INVALID;
std::map<std::string, std::string> actionArguments {};
@@ -793,10 +688,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, HandleContinueTouchDownEvent_001, TestSi
{
GTEST_LOG_(INFO) << "HandleContinueTouchDownEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
std::vector<std::string> targetBundleNames;
EXPECT_EQ(instance_->HandleContinueTouchDownEvent(targetBundleNames), RET_ERR_NULLPTR);
@@ -814,10 +706,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, HandleContinueTouchDownEvent_002, TestSi
{
GTEST_LOG_(INFO) << "HandleContinueTouchDownEvent_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<std::string> targetBundleNames;
EXPECT_EQ(instance_->HandleContinueTouchDownEvent(targetBundleNames), RET_OK);
@@ -833,10 +722,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, storeBaseDownPoint_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "storeBaseDownPoint_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityElementInfo parent;
std::vector<AccessibilityElementInfo> children;
EXPECT_EQ(instance_->storeBaseDownPoint(parent, children), RET_OK);
@@ -853,10 +739,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, GetSwipeDirection_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "GetSwipeDirection_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
instance_->GetSwipeDirection(CACHE_MODE);
EXPECT_EQ(CACHE_MODE, AccessibilityAbilityUtHelper::IsTapGesture().GetCacheMode());
@@ -872,10 +755,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, SaveMoveGesturePointerInfo_001, TestSize
{
GTEST_LOG_(INFO) << "SaveMoveGesturePointerInfo_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
std::vector<AccessibilityElementInfo> elementInfos;
EXPECT_EQ(instance_->SaveMoveGesturePointerInfo(elementInfos), RET_ERR_NULLPTR);
@@ -893,10 +773,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, SaveMoveGesturePointerInfo_002, TestSize
{
GTEST_LOG_(INFO) << "SaveMoveGesturePointerInfo_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> elementInfos;
EXPECT_EQ(instance_->SaveMoveGesturePointerInfo(elementInfos), RET_OK);
@@ -912,10 +789,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, GetBasePointItem_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "GetBasePointItem_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityAbilityUtHelper::IsTapGesture().SetAbilityClientNullFlag(true);
AccessibilityWindowInfo windowInfo {};
std::vector<AccessibilityElementInfo> elementInfos;
@@ -934,10 +808,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, GetBasePointItem_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "GetBasePointItem_002 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandler instance_";
return;
}
EXPECT_TRUE(instance_);
AccessibilityWindowInfo windowInfo {};
std::vector<AccessibilityElementInfo> elementInfos;
EXPECT_EQ(instance_->GetBasePointItem(windowInfo, elementInfos, true), RET_OK);
@@ -957,10 +828,8 @@ HWTEST_F(MultiFingerGestureHandlerTest, HandleMultiFingerMoveEvent_001, TestSize
const int32_t windowId = 1;
sptr<AccessibilityAccountData> currentAccount =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!currentAccount) {
GTEST_LOG_(ERROR) << "Account data is nullptr";
return;
}
EXPECT_TRUE(currentAccount);
sptr<AccessibilityWindowConnection> operationConnection =
new AccessibilityWindowConnection(windowId, nullptr, accountId);
currentAccount->AddAccessibilityWindowConnection(windowId, operationConnection);
@@ -985,10 +854,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, HandleMultiFingerMoveEvent_001, TestSize
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
std::shared_ptr<AccessibilitySettingsConfig> config = currentAccount->GetConfig();
if (!config) {
GTEST_LOG_(ERROR) << "Config is nullptr";
return;
}
EXPECT_TRUE(config);
config->SetCaptionState(true);
std::string cmdUser("-u");
std::vector<std::u16string> args;
@@ -1008,10 +874,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, HandleMultiFingerMoveEvent_001, TestSize
HWTEST_F(MultiFingerGestureHandlerTest, StoreUpPointInPointerRoute_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "StoreUpPointInPointerRoute_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandlerTest instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -1029,10 +892,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, StoreUpPointInPointerRoute_001, TestSize
HWTEST_F(MultiFingerGestureHandlerTest, recognizeGesturePath_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "recognizeGesturePath_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandlerTest instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -1050,10 +910,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, recognizeGesturePath_001, TestSize.Level
HWTEST_F(MultiFingerGestureHandlerTest, GetMoveGestureId_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "GetMoveGestureId_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandlerTest instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -1073,10 +930,7 @@ HWTEST_F(
{
GTEST_LOG_(INFO) << "IsMoveGestureRecognize_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandlerTest instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -1094,10 +948,7 @@ HWTEST_F(
HWTEST_F(MultiFingerGestureHandlerTest, HandleMultiFingerTouchUpEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "HandleMultiFingerTouchUpEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandlerTest instance_";
return;
}
EXPECT_TRUE(instance_);
std::vector<AccessibilityElementInfo> infos;
AccessibilityElementInfo info {};
@@ -1116,10 +967,7 @@ HWTEST_F(MultiFingerGestureHandlerTest, OnPointerEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "OnPointerEvent_001 start";
if (!instance_) {
GTEST_LOG_(INFO) << "Cann't get MultiFingerGestureHandlerTest instance_";
return;
}
EXPECT_TRUE(instance_);
std::shared_ptr<AccessibleAbilityListener> listener = nullptr;
EXPECT_EQ(instance_->OnPointerEvent(listener), RET_ERR_INVALID_PARAM);
services/aams/test/unittest/accessibility_power_manager_test.cpp
+26 -100
View File
@@ -93,10 +93,8 @@ HWTEST_F(AccessibilityPowerManagerTest,
HWTEST_F(AccessibilityPowerManagerTest, RefreshActivity_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "RefreshActivity_002 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->RefreshActivity(WindowUpdateType::WINDOW_UPDATE_ACTIVE);
EXPECT_EQ(eventInfo_->GetWindowChangeTypes(), WindowUpdateType::WINDOW_UPDATE_ACTIVE);
GTEST_LOG_(INFO) << "RefreshActivity_002 end";
@@ -110,10 +108,7 @@ HWTEST_F(AccessibilityPowerManagerTest, RefreshActivity_002, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, DiscountBrightness_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "DiscountBrightness_002 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->DiscountBrightness(EventType::TYPE_PAGE_CONTENT_UPDATE);
EXPECT_EQ(eventInfo_->GetEventType(), EventType::TYPE_PAGE_CONTENT_UPDATE);
GTEST_LOG_(INFO) << "DiscountBrightness_002 end";
@@ -127,10 +122,7 @@ HWTEST_F(AccessibilityPowerManagerTest, DiscountBrightness_002, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, SetContentChangeTypesaa_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetContentChangeTypesaa_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->SetContentChangeTypesaa(WindowsContentChangeTypes::CONTENT_CHANGE_TYPE_TEXT);
EXPECT_EQ(eventInfo_->GetWindowContentChangeTypesa(), WindowsContentChangeTypes::CONTENT_CHANGE_TYPE_TEXT);
GTEST_LOG_(INFO) << "SetContentChangeTypesaa_001 end";
@@ -144,10 +136,7 @@ HWTEST_F(AccessibilityPowerManagerTest, SetContentChangeTypesaa_001, TestSize.Le
HWTEST_F(AccessibilityPowerManagerTest, SetTimeStampa_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetTimeStampa_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->SetTimeStampa(6000);
EXPECT_EQ(eventInfo_->GetTimeStampa(), 6000);
GTEST_LOG_(INFO) << "SetTimeStampa_001 end";
@@ -161,10 +150,7 @@ HWTEST_F(AccessibilityPowerManagerTest, SetTimeStampa_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, SetBundleNamea_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "SetBundleNamea_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
std::string bundleName = "accessibilityTest";
eventInfo_->SetBundleNamea(bundleName);
EXPECT_EQ(eventInfo_->GetBundleNamea(), bundleName);
@@ -179,10 +165,7 @@ HWTEST_F(AccessibilityPowerManagerTest, SetBundleNamea_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetNotificationContent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetNotificationContent_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
std::string content = "notificationContent";
eventInfo_->aSetNotificationContent(content);
EXPECT_EQ(eventInfo_->aGetNotificationContent(), content);
@@ -197,10 +180,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetNotificationContent_001, TestSize.Le
HWTEST_F(AccessibilityPowerManagerTest, aSetTextMovementStep_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetTextMovementStep_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetTextMovementStep(TextMoveUnit::STEP_LINE);
EXPECT_EQ(eventInfo_->aGetTextMovementStep(), TextMoveUnit::STEP_LINE);
GTEST_LOG_(INFO) << "aSetTextMovementStep_001 end";
@@ -214,10 +194,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetTextMovementStep_001, TestSize.Level
HWTEST_F(AccessibilityPowerManagerTest, aSetTriggerAction_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetTriggerAction_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetTriggerAction(ActionType::ACCESSIBILITY_ACTION_CLICK);
EXPECT_EQ(eventInfo_->aGetTriggerAction(), ActionType::ACCESSIBILITY_ACTION_CLICK);
GTEST_LOG_(INFO) << "aSetTriggerAction_001 end";
@@ -231,10 +208,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetTriggerAction_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetNotificationInfo_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetNotificationInfo_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetNotificationInfo(NotificationCategory::CATEGORY_CALL);
EXPECT_EQ(eventInfo_->GetNotificationInfo(), NotificationCategory::CATEGORY_CALL);
GTEST_LOG_(INFO) << "aSetNotificationInfo_001 end";
@@ -248,10 +222,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetNotificationInfo_001, TestSize.Level
HWTEST_F(AccessibilityPowerManagerTest, aSetGestureType_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetGestureType_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetGestureType(GestureType::GESTURE_SWIPE_UP);
EXPECT_EQ(eventInfo_->aGetGestureType(), GestureType::GESTURE_SWIPE_UP);
GTEST_LOG_(INFO) << "aSetGestureType_001 end";
@@ -265,10 +236,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetGestureType_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetPageId_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetPageId_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetPageId(1);
EXPECT_EQ(eventInfo_->aGetPageId(), 1);
GTEST_LOG_(INFO) << "aSetPageId_001 end";
@@ -282,10 +250,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetPageId_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetSource_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetSource_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetSource(1001);
EXPECT_EQ(eventInfo_->GetViewId(), 1001);
EXPECT_EQ(eventInfo_->GetAccessibilityId(), 1001);
@@ -300,10 +265,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetSource_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetWindowId_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetWindowId_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetWindowId(1002);
EXPECT_EQ(eventInfo_->GetWindowId(), 1002);
GTEST_LOG_(INFO) << "aSetWindowId_001 end";
@@ -317,10 +279,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetWindowId_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetCurrentIndex_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetCurrentIndex_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetCurrentIndex(1);
EXPECT_EQ(eventInfo_->GetCurrentIndex(), 1);
GTEST_LOG_(INFO) << "aSetCurrentIndex_001 end";
@@ -334,10 +293,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetCurrentIndex_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetBeginIndex_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetBeginIndex_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetBeginIndex(1);
EXPECT_EQ(eventInfo_->GetBeginIndex(), 1);
GTEST_LOG_(INFO) << "aSetBeginIndex_001 end";
@@ -351,10 +307,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetBeginIndex_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetEndIndex_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetEndIndex_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetEndIndex(1);
EXPECT_EQ(eventInfo_->GetEndIndex(), 1);
GTEST_LOG_(INFO) << "aSetEndIndex_001 end";
@@ -368,10 +321,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetEndIndex_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetItemCounts_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetItemCounts_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
eventInfo_->aSetItemCounts(1);
EXPECT_EQ(eventInfo_->GetItemCounts(), 1);
GTEST_LOG_(INFO) << "aSetItemCounts_001 end";
@@ -385,10 +335,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetItemCounts_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetComponentType_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetComponentType_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
std::string componentType = "text";
eventInfo_->aSetComponentType(componentType);
EXPECT_EQ(eventInfo_->GetComponentType(), componentType);
@@ -403,10 +350,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetComponentType_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetBeforeText_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetBeforeText_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
std::string text = "accessibility";
eventInfo_->aSetBeforeText(text);
EXPECT_EQ(eventInfo_->GetBeforeText(), text);
@@ -421,10 +365,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetBeforeText_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetLatestContent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetLatestContent_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
std::string context = "lastContext";
eventInfo_->aSetLatestContent(context);
EXPECT_EQ(eventInfo_->GetLatestContent(), context);
@@ -439,10 +380,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetLatestContent_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetDescription_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetDescription_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
std::string descripion = "descripion";
eventInfo_->aSetDescription(descripion);
EXPECT_EQ(eventInfo_->GetDescription(), descripion);
@@ -457,10 +395,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetDescription_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetTextAnnouncedForAccessibility_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetTextAnnouncedForAccessibility_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
std::string textAnnouncedForAccessibility = "textAnnouncedForAccessibility";
eventInfo_->aSetTextAnnouncedForAccessibility(textAnnouncedForAccessibility);
EXPECT_EQ(eventInfo_->GetTextAnnouncedForAccessibility(), textAnnouncedForAccessibility);
@@ -475,10 +410,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetTextAnnouncedForAccessibility_001, T
HWTEST_F(AccessibilityPowerManagerTest, aSetInspectorKey_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetInspectorKey_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
std::string inspectorKey = "inspectorKey";
eventInfo_->aSetInspectorKey(inspectorKey);
EXPECT_EQ(eventInfo_->GetInspectorKey(), inspectorKey);
@@ -493,10 +425,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetInspectorKey_001, TestSize.Level1)
HWTEST_F(AccessibilityPowerManagerTest, aSetRequestFocusElementIda_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "aSetRequestFocusElementIda_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
int32_t requestFocusElementId = 1;
eventInfo_->aSetRequestFocusElementIda(requestFocusElementId);
EXPECT_EQ(eventInfo_->GetRequestFocusElementId(), requestFocusElementId);
@@ -511,10 +440,7 @@ HWTEST_F(AccessibilityPowerManagerTest, aSetRequestFocusElementIda_001, TestSize
HWTEST_F(AccessibilityPowerManagerTest, AddContentlist_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AddContentlist_001 start";
if (!eventInfo_) {
GTEST_LOG_(INFO) << "eventInfo_ is null";
return;
}
EXPECT_TRUE(eventInfo_);
std::string content1 = "content1";
eventInfo_->AddContentlist(content1);
std::string content2 = "content2";
services/aams/test/unittest/accessibility_setting_observer_test.cpp
+2 -4
View File
@@ -94,10 +94,8 @@ void AccessibilitySettingObserverTest::RegisterAbilityConnectionClient(const spt
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
accountData->AddInstalledAbility(*abilityInfo);
sptr<AccessibleAbilityConnection> connection =
new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
services/aams/test/unittest/accessibility_setting_provider_test.cpp
+20 -40
View File
@@ -229,10 +229,8 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_001, TestSize
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_001 start";
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
accountData->GetConfig()->SetShortkeyTarget("HIGH_CONTRAST_TEXT");
bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
EXPECT_FALSE(ret);
@@ -248,10 +246,8 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_002, TestSize
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_002 start";
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
accountData->GetConfig()->SetShortkeyTarget("INVERT_COLOR");
bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
EXPECT_FALSE(ret);
@@ -267,10 +263,8 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_003, TestSize
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_003 start";
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
accountData->GetConfig()->SetShortkeyTarget("ANIMATION_OFF");
bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
EXPECT_FALSE(ret);
@@ -286,10 +280,8 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_004, TestSize
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_004 start";
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
accountData->GetConfig()->SetShortkeyTarget("SCREEN_MAGNIFICATION");
bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
EXPECT_FALSE(ret);
@@ -305,10 +297,8 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_005, TestSize
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_005 start";
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
accountData->GetConfig()->SetShortkeyTarget("AUDIO_MONO");
bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
EXPECT_FALSE(ret);
@@ -324,10 +314,8 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_006, TestSize
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_006 start";
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
accountData->GetConfig()->SetShortkeyTarget("MOUSE_KEY");
bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
EXPECT_FALSE(ret);
@@ -343,10 +331,8 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_007, TestSize
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_007 start";
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
accountData->GetConfig()->SetShortkeyTarget("CAPTION_STATE");
bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
EXPECT_FALSE(ret);
@@ -362,10 +348,8 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_008, TestSize
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_008 start";
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
accountData->GetConfig()->SetShortkeyTarget("CONTENT_TIMEOUT");
bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
EXPECT_FALSE(ret);
@@ -381,10 +365,8 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_009, TestSize
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_009 start";
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
// set
accountData->GetConfig()->SetShortkeyTarget("");
bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
@@ -403,10 +385,8 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_010, TestSize
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!accountData) {
GTEST_LOG_(INFO) << "current account data is null";
return;
}
EXPECT_TRUE(accountData);
accountData->GetConfig()->SetShortkeyTarget("MOUSE_KEY");
bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
EXPECT_FALSE(ret);
services/aams/test/unittest/accessible_ability_manager_service_test.cpp
+457 -204
View File
@@ -125,6 +125,7 @@ void AccessibleAbilityManagerServiceUnitTest::TearDownTestCase()
void AccessibleAbilityManagerServiceUnitTest::SetUp()
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest SetUp";
sleep(1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
stub_ = new MockAccessibleAbilityClientStubImpl();
}
@@ -205,6 +206,39 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_001, TestSize.L
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_001 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_002
* @tc.name: GetAbilityList
* @tc.desc: Test function GetAbilityList
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
std::vector<AccessibilityAbilityInfoParcel> infos;
Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(0xFFFFFFFF, 3, infos);
EXPECT_NE(stub_.GetRefPtr(), nullptr);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_002 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_003
* @tc.name: GetAbilityList
* @tc.desc: Test function GetAbilityList
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_003 start";
std::vector<OHOS::Accessibility::AccessibilityAbilityInfoParcel> infos;
uint32_t type = 0xFFFFFFFF;
Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, -1, infos);
EXPECT_EQ(infos.size(), 0);
Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, 5, infos);
EXPECT_EQ(infos.size(), 0);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_003 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterElementOperatorByWindowId_001
* @tc.name: RegisterElementOperatorByWindowId
@@ -228,6 +262,258 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperatorByWindo
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperatorByWindowId_001 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_GetRealWindowAndElementId_001
* @tc.name: GetRealWindowAndElementId
* @tc.desc: Test function GetRealWindowAndElementId
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetRealWindowAndElementId_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetRealWindowAndElementId_001 start";
int32_t windowId = 0;
int64_t elementId = 0;
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
int32_t ret = aams.GetRealWindowAndElementId(windowId, elementId);
EXPECT_EQ(ret, 0);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetRealWindowAndElementId_001 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_GetSceneBoardInnerWinId_001
* @tc.name: GetSceneBoardInnerWinId
* @tc.desc: Test function GetSceneBoardInnerWinId
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetSceneBoardInnerWinId_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetSceneBoardInnerWinId_001 start";
int32_t windowId = 0;
int64_t elementId = 0;
int32_t innerWid = 0;
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
int32_t ret = aams.GetSceneBoardInnerWinId(windowId, elementId, innerWid);
EXPECT_EQ(ret, 0);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetSceneBoardInnerWinId_001 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_RemoveCallback_001
* @tc.name: RemoveCallback
* @tc.desc: Test function RemoveCallback
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemoveCallback_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RemoveCallback_001 start";
sptr<IRemoteObject::DeathRecipient> deathRecipient = nullptr;
wptr<IRemoteObject> remote = nullptr;
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
aams.RemoveCallback(STATE_CALLBACK, deathRecipient, remote);
EXPECT_EQ(deathRecipient, nullptr);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RemoveCallback_001 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_RemoveCallback_002
* @tc.name: RemoveCallback
* @tc.desc: Test function RemoveCallback
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemoveCallback_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RemoveCallback_002 start";
sptr<IRemoteObject::DeathRecipient> deathRecipient = nullptr;
sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
EXPECT_TRUE(samgr);
wptr<IRemoteObject> remote = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
aams.RemoveCallback(STATE_CALLBACK, deathRecipient, remote);
EXPECT_EQ(deathRecipient, nullptr);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RemoveCallback_002 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_RemoveCallback_003
* @tc.name: RemoveCallback
* @tc.desc: Test function RemoveCallback
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemoveCallback_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RemoveCallback_003 start";
sptr<IRemoteObject::DeathRecipient> deathRecipient = nullptr;
sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
EXPECT_TRUE(samgr);
wptr<IRemoteObject> remote = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
aams.RemoveCallback(CAPTION_PROPERTY_CALLBACK, deathRecipient, remote);
EXPECT_EQ(deathRecipient, nullptr);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RemoveCallback_003 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_RemoveCallback_004
* @tc.name: RemoveCallback
* @tc.desc: Test function RemoveCallback
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemoveCallback_004, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RemoveCallback_004 start";
sptr<IRemoteObject::DeathRecipient> deathRecipient = nullptr;
sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
EXPECT_TRUE(samgr);
wptr<IRemoteObject> remote = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
aams.RemoveCallback(ENABLE_ABILITY_LISTS_CALLBACK, deathRecipient, remote);
EXPECT_EQ(deathRecipient, nullptr);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RemoveCallback_004 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_RemoveCallback_005
* @tc.name: RemoveCallback
* @tc.desc: Test function RemoveCallback
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemoveCallback_005, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RemoveCallback_005 start";
sptr<IRemoteObject::DeathRecipient> deathRecipient = nullptr;
sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
EXPECT_TRUE(samgr);
wptr<IRemoteObject> remote = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
aams.RemoveCallback(CONFIG_CALLBACK, deathRecipient, remote);
EXPECT_EQ(deathRecipient, nullptr);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RemoveCallback_005 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_OnBundleManagerDied_001
* @tc.name: OnBundleManagerDied
* @tc.desc: Test function OnBundleManagerDied
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnBundleManagerDied_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_OnBundleManagerDied_001 start";
sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
EXPECT_TRUE(samgr);
wptr<IRemoteObject> remote = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
aams.OnBundleManagerDied(remote);
EXPECT_TRUE(remote != nullptr);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_OnBundleManagerDied_001 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_OnBundleManagerDied_002
* @tc.name: OnBundleManagerDied
* @tc.desc: Test function OnBundleManagerDied
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnBundleManagerDied_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_OnBundleManagerDied_002 start";
wptr<IRemoteObject> remote = nullptr;
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
aams.OnBundleManagerDied(remote);
EXPECT_TRUE(remote == nullptr);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_OnBundleManagerDied_002 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_GetScreenReaderState_001
* @tc.name: GetScreenReaderState
* @tc.desc: Test function GetScreenReaderState
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetScreenReaderState_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetScreenReaderState_001 start";
bool state;
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
int32_t ret = aams.GetScreenReaderState(state);
EXPECT_EQ(ret, 0);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetScreenReaderState_001 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_OnScreenMagnificationTypeChanged_001
* @tc.name: OnScreenMagnificationTypeChanged
* @tc.desc: Test function OnScreenMagnificationTypeChanged
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnScreenMagnificationTypeChanged_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_OnScreenMagnificationTypeChanged_001 start";
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
aams.OnScreenMagnificationTypeChanged();
auto accountData = aams.GetCurrentAccountData();
ASSERT_TRUE(accountData);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_OnScreenMagnificationTypeChanged_001 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_OnScreenMagnificationStateChanged_001
* @tc.name: OnScreenMagnificationStateChanged
* @tc.desc: Test function OnScreenMagnificationStateChanged
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnScreenMagnificationStateChanged_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_OnScreenMagnificationStateChanged_001 start";
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
aams.OnScreenMagnificationStateChanged();
auto accountData = aams.GetCurrentAccountData();
ASSERT_TRUE(accountData);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_OnScreenMagnificationStateChanged_001 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_StopCallbackWait_001
* @tc.name: StopCallbackWait
* @tc.desc: Test function StopCallbackWait
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, StopCallbackWait_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_StopCallbackWait_001 start";
int32_t windowId = 0;
int32_t treeId = 0;
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
aams.StopCallbackWait(windowId, treeId);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_OnScreenMagnificationStateChanged_001 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperatorByWindowId_001
* @tc.name: DeregisterElementOperatorByWindowId
@@ -268,7 +554,6 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperatorByWin
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperatorByWindowId_002 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTouchEventInjector_001
* @tc.name: SetTouchEventInjector
@@ -414,6 +699,23 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_001, TestSize
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002
* @tc.name: SetShortKeyState
* @tc.desc: Test function SetShortKeyState GetShortKeyState
* @tc.require: issueI5NTXH
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
bool state = true;
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(state));
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortKeyState(state));
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001
* @tc.name: SetMouseKeyState
@@ -448,6 +750,23 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_001, TestSiz
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002
* @tc.name: SetMouseAutoClick
* @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
* @tc.require: issueI5NTXC
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
int32_t value = MOUSE_AUTO_CLICK_VALUE;
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseAutoClick(value));
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseAutoClick(value));
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001
* @tc.name: SetShortkeyTarget
@@ -465,6 +784,23 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_001, TestSiz
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002
* @tc.name: SetShortkeyTarget
* @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
* @tc.require: issueI5NTXH
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
std::string name = "test";
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyTarget(name));
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyTarget(name));
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001
* @tc.name: SetHighContrastTextState
@@ -482,6 +818,23 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_001,
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002
* @tc.name: SetHighContrastTextState
* @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
* @tc.require: issueI5NTX9
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
bool state = true;
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetHighContrastTextState(state));
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetHighContrastTextState(state));
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_001
* @tc.name: SetDaltonizationState
@@ -498,6 +851,24 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationState_001, Tes
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_001 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002
* @tc.name: SetDaltonizationState
* @tc.desc: Test function SetDaltonizationState GetDaltonizationState
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationState_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
bool state = true;
EXPECT_NE(RET_OK,
Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationState(state));
EXPECT_NE(RET_OK,
Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationState(state));
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001
* @tc.name: SetInvertColorState
@@ -752,6 +1123,55 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_001, TestSize.L
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_001 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageAdd_002
* @tc.name: PackageAdd
* @tc.desc: Test function PackageAdd
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageAdd_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
std::string bundleName = "bundleName1";
Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
EXPECT_NE(stub_.GetRefPtr(), nullptr);
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_002 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_002
* @tc.name: PackageRemoved
* @tc.desc: Test function PackageRemoved
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
std::string bundleName = "bundleName1";
Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
EXPECT_NE(stub_.GetRefPtr(), nullptr);
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_002 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_003
* @tc.name: PackageRemoved
* @tc.desc: Test function PackageRemoved
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 start";
std::string bundleName = "bundleName1";
Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
EXPECT_NE(stub_.GetRefPtr(), nullptr);
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_AddedUser_001
* @tc.name: AddedUser
@@ -814,7 +1234,7 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_001, TestSize.L
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_001 start";
std::string name = "test";
EXPECT_EQ(RET_ERR_NOT_ENABLED, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
EXPECT_EQ(RET_ERR_FAILED, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_001 end";
}
@@ -845,6 +1265,35 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_001, TestS
GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_001 end";
}
/*
* @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_002
* @tc.name: EnableUITestAbility
* @tc.desc: Test function EnableUITestAbility
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
sptr<IRemoteObject> obj;
EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj));
GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 end";
}
/*
* @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003
* @tc.name: EnableUITestAbility
* @tc.desc: Test function EnableUITestAbility
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003 start";
sptr<IRemoteObject> obj = nullptr;
ErrCode ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj);
EXPECT_EQ(ret, RET_ERR_NULLPTR);
GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003 end";
}
/*
* @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_001
* @tc.name: DisableUITestAbility
@@ -925,22 +1374,6 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SwitchedUser_001, TestSize.Lev
GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_SwitchedUser_001 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_002
* @tc.name: GetAbilityList
* @tc.desc: Test function GetAbilityList
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
std::vector<AccessibilityAbilityInfoParcel> infos;
Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(0xFFFFFFFF, 3, infos);
EXPECT_NE(stub_.GetRefPtr(), nullptr);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_002 end";
}
/**
* @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterElementOperatorByWindowId_002
* @tc.name: RegisterElementOperatorByWindowId
@@ -1154,25 +1587,10 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_002, TestSize.L
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
std::string name = "test";
EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
EXPECT_EQ(RET_ERR_FAILED, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_002 end";
}
/*
* @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_002
* @tc.name: EnableUITestAbility
* @tc.desc: Test function EnableUITestAbility
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
sptr<IRemoteObject> obj;
EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj));
GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 end";
}
/*
* @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_002
* @tc.name: DisableUITestAbility
@@ -1215,38 +1633,6 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableShortKeyTargetAbility_0
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_002 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_002
* @tc.name: PackageRemoved
* @tc.desc: Test function PackageRemoved
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
std::string bundleName = "bundleName1";
Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
EXPECT_NE(stub_.GetRefPtr(), nullptr);
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_002 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageAdd_002
* @tc.name: PackageAdd
* @tc.desc: Test function PackageAdd
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageAdd_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
std::string bundleName = "bundleName1";
Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
EXPECT_NE(stub_.GetRefPtr(), nullptr);
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_002 end";
}
/*
* @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002
* @tc.name: RegisterConfigObserver
@@ -1277,23 +1663,6 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_00
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002
* @tc.name: SetShortKeyState
* @tc.desc: Test function SetShortKeyState GetShortKeyState
* @tc.require: issueI5NTXH
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
bool state = true;
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(state));
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortKeyState(state));
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002
* @tc.name: SetMouseKeyState
@@ -1584,75 +1953,6 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnShortKeyProcess_006, TestSiz
GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_OnShortKeyProcess_006 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002
* @tc.name: SetMouseAutoClick
* @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
* @tc.require: issueI5NTXC
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
int32_t value = MOUSE_AUTO_CLICK_VALUE;
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseAutoClick(value));
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseAutoClick(value));
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002
* @tc.name: SetShortkeyTarget
* @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
* @tc.require: issueI5NTXH
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
std::string name = "test";
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyTarget(name));
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyTarget(name));
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002
* @tc.name: SetHighContrastTextState
* @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
* @tc.require: issueI5NTX9
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
bool state = true;
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetHighContrastTextState(state));
EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetHighContrastTextState(state));
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002
* @tc.name: SetDaltonizationState
* @tc.desc: Test function SetDaltonizationState GetDaltonizationState
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationState_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002 start";
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
bool state = true;
EXPECT_NE(RET_OK,
Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationState(state));
EXPECT_NE(RET_OK,
Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationState(state));
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002
* @tc.name: SetInvertColorState
@@ -1857,39 +2157,6 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyTarget_001, Test
GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_003
* @tc.name: PackageRemoved
* @tc.desc: Test function PackageRemoved
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 start";
std::string bundleName = "bundleName1";
Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
EXPECT_NE(stub_.GetRefPtr(), nullptr);
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_003
* @tc.name: GetAbilityList
* @tc.desc: Test function GetAbilityList
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_003 start";
std::vector<OHOS::Accessibility::AccessibilityAbilityInfoParcel> infos;
uint32_t type = 0xFFFFFFFF;
Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, -1, infos);
EXPECT_EQ(infos.size(), 0);
Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, 5, infos);
EXPECT_EQ(infos.size(), 0);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_003 end";
}
/**
* @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_001
* @tc.name: SetTargetAbility
@@ -2115,7 +2382,7 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, FindInnerWindowId_001, TestSiz
event.SetSource(1);
int32_t windowId = 0;
Singleton<AccessibleAbilityManagerService>::GetInstance().FindInnerWindowId(event, windowId);
EXPECT_EQ(windowId, 1);
EXPECT_EQ(windowId, 0);
GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_FindInnerWindowId_001 end";
}
@@ -2153,34 +2420,20 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, InsertWindowIdEventPair_001, T
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SendEvent_002
* @tc.number: AccessibleAbilityManagerServiceUnitTest_SendEvent_001
* @tc.name: SendEvent
* @tc.desc: Test function SendEvent
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_002, TestSize.Level1)
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_002 start";
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_001 start";
AccessibilityEventInfoParcel evtInf;
sleep(SLEEP_TIME_1);
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
ErrCode ret = Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(evtInf, 0);
EXPECT_EQ(ret, RET_OK);
SetUpTestCase();
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_002 end";
}
/*
* @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004
* @tc.name: EnableUITestAbility
* @tc.desc: Test function EnableUITestAbility
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_004, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004 start";
sptr<IRemoteObject> obj = nullptr;
ErrCode ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj);
EXPECT_EQ(ret, RET_ERR_NULLPTR);
GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004 end";
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_001 end";
}
/**