openharmony/accessibility
1
0
Fork 0
mirror of https://gitee.com/openharmony/accessibility synced 2024-11-23 06:50:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

!1454 DT新增test用例

Browse Source 
Merge pull request !1454 from lsl/DT
This commit is contained in:
openharmony_ci 2024-09-27 09:40:30 +00:00 committed by Gitee
commit 09f358b762
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
4 changed files with 1746 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

359
services/aams/test/unittest/accessibility_circle_drawing_manager_test.cpp Normal file
View File

@ -0,0 +1,359 @@
/*
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "accessibility_circle_drawing_manager.h"
#include <gtest/gtest.h>
#include "accessibility_common_helper.h"
#include "accessibility_element_operator_proxy.h"
#include "accessibility_element_operator_stub.h"
#include "accessibility_ut_helper.h"
#include "accessible_ability_manager_service.h"
#include "mock_accessible_ability_manager_service_config_observer_proxy.h"
#include "mock_accessible_ability_manager_service_config_observer_stub.h"
#include "mock_accessible_ability_manager_service_state_observer_proxy.h"
#include "mock_accessible_ability_manager_service_state_observer_stub.h"
#include "mock_accessibility_setting_provider.h"
#include "utils.h"
using namespace testing;
using namespace testing::ext;
namespace OHOS {
namespace Accessibility {
namespace {
constexpr uint32_t SLEEP_TIME_1 = 1;
constexpr size_t IMPORTANT_ABILITIES_SIZE = 0;
} // namespace
class AccessibilityCircleDrawingManagerTest : public testing::Test {
public:
AccessibilityCircleDrawingManagerTest()
{}
~AccessibilityCircleDrawingManagerTest()
{}
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp() override;
void TearDown() override;
};
void AccessibilityCircleDrawingManagerTest::SetUpTestCase()
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManagerTest SetUpTestCase";
Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
}
void AccessibilityCircleDrawingManagerTest::TearDownTestCase()
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManagerTest TearDownTestCase";
Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
}
void AccessibilityCircleDrawingManagerTest::SetUp()
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManagerTest SetUp";
}
void AccessibilityCircleDrawingManagerTest::TearDown()
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManagerTest TearDown";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow001
* @tc.name: CreatePointerWindow
* @tc.desc: Check the get accessibility state.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest, AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow001 start";
int32_t accountId = 1;
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
/* Initial state */
accountData->Init();
accountData->GetConfig()->SetTouchGuideState(true);
uint32_t stateType = accountData->CreatePointerWindow();
uint32_t stateTypeTest = Accessibility::STATE_EXPLORATION_ENABLED;
EXPECT_EQ(stateTypeTest, stateType);
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow001 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow002
* @tc.name: CreatePointerWindow
* @tc.desc: Check the get accessibility state.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest, AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow_002 start";
const int32_t accountId = 1;
int32_t connectCounter = 0;
AccessibilityAbilityInitParams initParams;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
/* add connected ability */
accountData->DrawingProgressByOpenSource(connection);
const std::string elementName = Utils::GetUri(connection->GetElementName());
EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
// init
accountData->Init();
uint32_t stateType = accountData->CreatePointerWindow();
EXPECT_EQ(stateType, Accessibility::STATE_ACCESSIBILITY_ENABLED);
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow_002 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow003
* @tc.name: CreatePointerWindow
* @tc.desc: Check the get accessibility state.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest, AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow_003 start";
const int32_t accountId = 1;
int32_t connectCounter = 0;
AccessibilityAbilityInitParams initParams;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
const std::string bundleName = "abc";
EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
accountData->AddConnectingA11yAbility(bundleName, connection);
EXPECT_TRUE(accountData->GetConnectingA11yAbility(bundleName));
accountData->Init();
accountData->GetConfig()->SetKeyEventObserverState(true);
uint32_t stateType = accountData->CreatePointerWindow();
EXPECT_EQ(stateType, Accessibility::STATE_ACCESSIBILITY_ENABLED | Accessibility::STATE_KEYEVENT_ENABLED);
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow_003 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow004
* @tc.name: CreatePointerWindow
* @tc.desc: Check the get accessibility state.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest, AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow004, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow_004 start";
const int32_t accountId = 1;
int32_t connectCounter = 0;
AccessibilityAbilityInitParams initParams;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
accountData->DrawingProgressByOpenSource(connection);
accountData->Init();
accountData->GetConfig()->SetGestureState(true);
uint32_t stateType = accountData->CreatePointerWindow();
EXPECT_EQ(stateType, Accessibility::STATE_ACCESSIBILITY_ENABLED | Accessibility::STATE_GESTURE_ENABLED);
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_CreatePointerWindow_004 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_DrawingProgressByOpenSource001
* @tc.name: DrawingProgressByOpenSource
* @tc.desc: Check the add connected ability.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest, AccessibilityCircleDrawingManager_Unittest_DrawingProgressByOpenSource001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_DrawingProgressByOpenSource_001 start";
const int32_t accountId = 1;
int32_t connectCounter = 0;
AccessibilityAbilityInitParams initParams;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
accountData->DrawingProgressByOpenSource(connection);
const std::string elementName = Utils::GetUri(connection->GetElementName());
EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_DrawingProgressByOpenSource_001 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_DrawingProgressByOpenSource002
* @tc.name: DrawingProgressByOpenSource
* @tc.desc: Check the add connected ability.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest, AccessibilityCircleDrawingManager_Unittest_DrawingProgressByOpenSource002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_DrawingProgressByOpenSource_002 start";
const int32_t accountId = 1;
sptr<AccessibleAbilityConnection> connection = nullptr;
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
accountData->DrawingProgressByOpenSource(connection);
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_DrawingProgressByOpenSource_002 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_DrawingProgressByRosenDrawing001
* @tc.name: DrawingProgressByRosenDrawing
* @tc.desc: Check the remove connected ability.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest,
AccessibilityCircleDrawingManager_Unittest_DrawingProgressByRosenDrawing001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_DrawingProgressByRosenDrawing001 start";
const int32_t accountId = 1;
int32_t connectCounter = 0;
AccessibilityAbilityInitParams initParams;
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
accountData->DrawingProgressByOpenSource(connection);
EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
const std::string elementName = Utils::GetUri(connection->GetElementName());
EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
accountData->DrawingProgressByRosenDrawing(connection->GetElementName());
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_DrawingProgressByRosenDrawing001 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_DrawingProgress001
* @tc.name: DrawingProgress
* @tc.desc: Check DrawingProgress.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest,
AccessibilityCircleDrawingManager_Unittest_DrawingProgress001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_DrawingProgress001 start";
const int32_t accountId = 0;
const std::string bundleName = "abc";
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
accountData->DrawingProgress(bundleName);
EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_DrawingProgress001 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_SetPointerLocation001
* @tc.name: SetPointerLocation
* @tc.desc: Check SetPointerLocation.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest,
AccessibilityCircleDrawingManager_Unittest_SetPointerLocation002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_SetPointerLocation002 start";
const int32_t accountId = 1;
const std::string name = "aaa";
const std::string bundleName = "abc";
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
AccessibilityAbilityInitParams initParams;
initParams.name = name;
initParams.bundleName = bundleName;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
abilityInfo->SetCapabilityValues(1);
accountData->GetStagingProperties(*abilityInfo);
accountData->SetPointerLocation(bundleName);
std::string abilityId = bundleName + "/" + name;
bool ret = accountData->GetAbilityAutoStartState(abilityId);
EXPECT_EQ(false, ret);
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_SetPointerLocation002 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_DrawPointer001
* @tc.name: DrawPointer
* @tc.desc: Check the DrawPointer.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest, AccessibilityCircleDrawingManager_Unittest_DrawPointer001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_DrawPointer001 start";
const int32_t accountId = 2;
int32_t connectCounter = 0;
AccessibilityAbilityInitParams initParams;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
EXPECT_EQ(0, (int)accountData->UpdatePointerVisible().size());
/* add */
accountData->DrawingProgressByOpenSource(connection);
const std::string elementNameURI = Utils::GetUri(connection->GetElementName());
EXPECT_EQ(1, (int)accountData->SetPointerLocation().size());
EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementNameURI));
EXPECT_FALSE(accountData->CreatePointerWindow(elementNameURI));
/* disconnect */
accountData->DrawingProgress(connection->GetElementName());
EXPECT_EQ(0, (int)accountData->DrawPointer().size());
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_DrawPointer001 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_ParseStringToInteger001
* @tc.name: ParseStringToInteger
* @tc.desc: Check the remove connecting A11y ability.GetAccessibilityWindows
*/
HWTEST_F(
AccessibilityCircleDrawingManagerTest, AccessibilityCircleDrawingManager_Unittest_ParseStringToInteger001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_ParseStringToInteger001 start";
const int32_t accountId = 1;
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
const std::string bundleName = "abc";
EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
AccessibilityAbilityInitParams initParams;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountId, 0, *abilityInfo);
accountData->AddConnectingA11yAbility(bundleName, connection);
EXPECT_TRUE(accountData->GetConnectingA11yAbility(bundleName));
accountData->ParseStringToInteger(bundleName);
EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_ParseStringToInteger001 end";
}
/**
* @tc.number: AccessibilityCircleDrawingManager_Unittest_ParseColorString001
* @tc.name: ParseColorString
* @tc.desc: Check the add enable ability.
*/
HWTEST_F(AccessibilityCircleDrawingManagerTest, AccessibilityCircleDrawingManager_Unittest_ParseColorString001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_ParseColorString001 start";
const int32_t accountId = 1;
sptr<AccessibilityCircleDrawingManager> accountData = new AccessibilityCircleDrawingManager(accountId);
const std::string bundleName = "/ccc";
accountData->Init();
AccessibilityAbilityInitParams initParams;
initParams.name = "ccc";
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
abilityInfo->SetCapabilityValues(1);
accountData->AddInstalledAbility(*abilityInfo);
accountData->ParseColorString(bundleName);
accountData->ParseColorString(bundleName);
EXPECT_EQ(1, (int)accountData->GetEnabledAbilities().size());
GTEST_LOG_(INFO) << "AccessibilityCircleDrawingManager_Unittest_ParseColorString001 end";
}

300
services/aams/test/unittest/accessibility_datashare_helper_test.cpp Normal file
View File

@ -0,0 +1,300 @@
/*
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <fcntl.h>
#include <gtest/gtest.h>
#include <unistd.h>
#include "accessibility_dumper.h"
#include "accessibility_ut_helper.h"
#include "mock_accessible_ability_connection.h"
#include "mock_accessible_ability_manager_service.h"
#include "string_ex.h"
using namespace testing;
using namespace testing::ext;
namespace OHOS {
namespace Accessibility {
class AccessibilityDatashareHelperTest : public ::testing::Test {
public:
AccessibilityDatashareHelperTest()
{}
~AccessibilityDatashareHelperTest()
{}
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp() override;
void TearDown() override;
int fd_ = -1;
sptr<AccessibilityDumper> dumper_ = nullptr;
};
void AccessibilityDatashareHelperTest::SetUpTestCase()
{
GTEST_LOG_(INFO) << "###################### AccessibilityDatashareHelperTest Start ######################";
}
void AccessibilityDatashareHelperTest::TearDownTestCase()
{
GTEST_LOG_(INFO) << "###################### AccessibilityDatashareHelperTest End ######################";
}
void AccessibilityDatashareHelperTest::SetUp()
{
fd_ = open("/dev/stdout", O_WRONLY);
dumper_ = new AccessibilityDumper();
}
void AccessibilityDatashareHelperTest::TearDown()
{
close(fd_);
fd_ = -1;
dumper_ = nullptr;
}
/**
* @tc.number: AccessibilityDatashareHelper_Unittest_GetStringValue_001
* @tc.name: GetStringValue
* @tc.desc: Test function GetStringValue
*/
HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest_GetStringValue_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_GetStringValue_001 start";
std::vector<std::u16string> args;
int ret = GetStringValueer_->GetStringValue(-1, args);
EXPECT_EQ(-1, ret);
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_GetStringValue_001 end";
}
/**
* @tc.number: AccessibilityDatashareHelper_Unittest_GetStringValue_002
* @tc.name: GetStringValue
* @tc.desc: Test function GetStringValue
*/
HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest_GetStringValue_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_GetStringValue_002 start";
std::vector<std::u16string> args;
int ret = GetStringValueer_->GetStringValue(fd_, args);
EXPECT_GE(ret, -1);
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_GetStringValue_002 end";
}
/**
* @tc.number: AccessibilityDatashareHelper_Unittest_GetStringValue_003
* @tc.name: GetStringValue
* @tc.desc: Test function GetStringValue
*/
HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest_GetStringValue_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_GetStringValue_003 start";
std::string cmdHelp("-h");
std::vector<std::u16string> args;
args.emplace_back(Str8ToStr16(cmdHelp));
int ret = GetStringValueer_->GetStringValue(fd_, args);
EXPECT_GE(ret, -1);
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_GetStringValue_003 end";
}
/**
* @tc.number: AccessibilityDatashareHelper_Unittest_GetLongValue_001
* @tc.name: GetLongValue
* @tc.desc: Test function GetLongValue
*/
HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest_GetLongValue_001, TestSize.Level1)
{
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;
}
std::shared_ptr<AccessibilitySettingsConfig> config = currentAccount->GetConfig();
if (!config) {
GTEST_LOG_(ERROR) << "Config is nullptr";
return;
}
config->GetLongValue(true);
std::string cmdUser("-u");
std::vector<std::u16string> args;
args.emplace_back(Str8ToStr16(cmdUser));
int ret = dumper_->Dump(fd_, args);
EXPECT_GE(ret, -1);
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_GetLongValue_001 end";
}
/**
* @tc.number: AccessibilityDatashareHelper_Unittest_GetLongValue_002
* @tc.name: GetLongValue
* @tc.desc: Test function GetLongValue
*/
HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDumper_Unittest_GetLongValue_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_GetLongValue_002 start";
AccessibilityAbilityInitParams initParams;
initParams.bundleName = "ohos";
initParams.moduleName = "accessibility";
initParams.name = "test";
initParams.description = "for GetLongValue-ut";
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;
}
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(currentAccount->GetAccountId(), 0, *abilityInfo);
if (!connection) {
GTEST_LOG_(ERROR) << "Connection is nullptr";
return;
}
currentAccount->AddConnectedAbility(connection);
std::string cmdClient("-c");
std::vector<std::u16string> args;
args.emplace_back(Str8ToStr16(cmdClient));
int ret = GetLongValueer_->GetLongValue(fd_, args);
EXPECT_GE(ret, -1);
currentAccount->RemoveConnectedAbility(connection->GetElementName());
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_GetLongValue_002 end";
}
/**
* @tc.number: AccessibilityDatashareHelper_Unittest_PutStringValue_001
* @tc.name: PutStringValue
* @tc.desc: Test function PutStringValue.
*/
HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest_PutStringValue_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_PutStringValue_006 start";
const int32_t accountId = 1;
const int32_t windowId = 1;
sptr<AccessibilityAccountData> currentAccount =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!currentAccount) {
GTEST_LOG_(ERROR) << "Account data is nullptr";
return;
}
sptr<AccessibilityWindowConnection> operationConnection =
new AccessibilityWindowConnection(windowId, nullptr, accountId);
currentAccount->AddAccessibilityWindowConnection(windowId, operationConnection);
std::string cmdWindow("-w");
std::vector<std::u16string> args;
args.emplace_back(Str8ToStr16(cmdWindow));
int ret = PutStringValueer_->PutStringValue(fd_, args);
EXPECT_GE(ret, -1);
currentAccount->RemoveAccessibilityWindowConnection(windowId);
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_PutStringValue_006 end";
}
/**
* @tc.number: AccessibilityDatashareHelper_Unittest_PutStringValue_002
* @tc.name: PutStringValue
* @tc.desc: Test function PutStringValue
*/
HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest_PutStringValue_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_PutStringValue_001 start";
sptr<AccessibilityAccountData> currentAccount =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
std::shared_ptr<AccessibilitySettingsConfig> config = currentAccount->GetConfig();
if (!config) {
GTEST_LOG_(ERROR) << "Config is nullptr";
return;
}
config->SetCaptionState(true);
std::string cmdUser("-u");
std::vector<std::u16string> args;
args.emplace_back(Str8ToStr16(cmdUser));
AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(true);
int ret = PutStringValueer_->PutStringValue(fd_, args);
EXPECT_GE(ret, -1);
AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(false);
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_PutStringValue_002 end";
}
/**
* @tc.number: AccessibilityDatashareHelper_Unittest_Initialize_001
* @tc.name: Initialize
* @tc.desc: Test function Initialize
*/
HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest_Initialize_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_Initialize_001 start";
AccessibilityAbilityInitParams initParams;
initParams.bundleName = "ohos";
initParams.moduleName = "accessibility";
initParams.name = "test";
initParams.description = "for dumper-ut";
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;
}
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(currentAccount->GetAccountId(), 0, *abilityInfo);
if (!connection) {
GTEST_LOG_(ERROR) << "Connection is nullptr";
return;
}
currentAccount->AddConnectedAbility(connection);
std::string cmdClient("-c");
std::vector<std::u16string> args;
args.emplace_back(Str8ToStr16(cmdClient));
AccessibilityAbilityHelper::GetInstance().Initialize(true);
int ret = dumper_->Dump(fd_, args);
AccessibilityAbilityHelper::GetInstance().Initialize(false);
EXPECT_GE(ret, -1);
currentAccount->RemoveConnectedAbility(connection->GetElementName());
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_Initialize_001 end";
}
/**
* @tc.number: AccessibilityDatashareHelper_Unittest_Initialize_002
* @tc.name: Initialize
* @tc.desc: Test function Initialize.
*/
HWTEST_F(AccessibilityDatashareHelperTest, AccessibilityDatashareHelper_Unittest_Initialize_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_Initialize_002 start";
const int32_t accountId = 1;
const int32_t windowId = 1;
sptr<AccessibilityAccountData> currentAccount =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (!currentAccount) {
GTEST_LOG_(ERROR) << "Account data is nullptr";
return;
}
sptr<AccessibilityWindowConnection> operationConnection =
new AccessibilityWindowConnection(windowId, nullptr, accountId);
currentAccount->AddAccessibilityWindowConnection(windowId, operationConnection);
std::string cmdWindow("-w");
std::vector<std::u16string> args;
args.emplace_back(Str8ToStr16(cmdWindow));
AccessibilityAbilityHelper::GetInstance().Initialize(true);
int ret = Initializeer_->Initialize(fd_, args);
EXPECT_GE(ret, -1);
AccessibilityAbilityHelper::GetInstance().Initialize(false);
currentAccount->RemoveAccessibilityWindowConnection(windowId);
GTEST_LOG_(INFO) << "AccessibilityDatashareHelper_Unittest_Initialize_002 end";
}
} // namespace Accessibility
} // namespace OHOS

145
services/aams/test/unittest/accessibility_event_transmission_test.cpp Normal file
View File

@ -0,0 +1,145 @@
/*
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <vector>
#include "accessibility_event_transmission.h"
#include "hilog_wrapper.h"
using namespace testing;
using namespace testing::ext;
namespace OHOS {
namespace Accessibility {
class EventTransmissionTest : public ::testing::Test {
public:
EventTransmissionTest()
{}
~EventTransmissionTest()
{}
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp() override;
void TearDown() override;
};
void EventTransmissionTest::SetUpTestCase()
{
GTEST_LOG_(INFO) << "###################### EventTransmissionTest Start ######################";
}
void EventTransmissionTest::TearDownTestCase()
{
GTEST_LOG_(INFO) << "###################### EventTransmissionTest End ######################";
}
void EventTransmissionTest::SetUp()
{}
void EventTransmissionTest::TearDown()
{}
/**
* @tc.number: EventTransmission_Unittest_OnKeyEvent_001
* @tc.name: OnKeyEvent
* @tc.desc: Test function OnKeyEvent
*/
HWTEST_F(EventTransmissionTest,
EventTransmission_Unittest_OnKeyEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "EventTransmission_Unittest_OnKeyEvent_001 start";
Singleton<EventTransmission>::GetInstance().OnKeyEvent(nullptr);
GTEST_LOG_(INFO) << "EventTransmission_Unittest_OnKeyEvent_001 end";
}
/**
* @tc.number: EventTransmission_Unittest_OnPointerEvent_001
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(EventTransmissionTest,
EventTransmission_Unittest_OnPointerEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "EventTransmission_Unittest_OnPointerEvent_001 start";
Singleton<EventTransmission>::GetInstance().OnPointerEvent();
GTEST_LOG_(INFO) << "EventTransmission_Unittest_OnPointerEvent_001 end";
}
/**
* @tc.number: EventTransmission_Unittest_OnMoveMouse_001
* @tc.name: OnMoveMouse
* @tc.desc: Test function OnMoveMouse
*/
HWTEST_F(EventTransmissionTest, EventTransmission_Unittest_OnMoveMouse_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "EventTransmission_Unittest_OnMoveMouse_001 start";
std::vector<int> infos{1};
auto display = Singleton<EventTransmission>::GetInstance().OnMoveMouse(0);
EXPECT_EQ(infos.size(), 1);
GTEST_LOG_(INFO) << "EventTransmission_Unittest_OnMoveMouse_001 end";
}
/**
* @tc.number: EventTransmission_Unittest_SetNext_001
* @tc.name: SetNext
* @tc.desc: Test function SetNext
*/
HWTEST_F(EventTransmissionTest, EventTransmission_Unittest_SetNext_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "EventTransmission_Unittest_SetNext_001 start";
std::vector<int> infos{1};
auto displays = Singleton<EventTransmission>::GetInstance().SetNext();
EXPECT_EQ(infos.size(), 1);
GTEST_LOG_(INFO) << "EventTransmission_Unittest_SetNext_001 end";
}
/**
* @tc.number: EventTransmission_Unittest_GetNext_001
* @tc.name: GetNext
* @tc.desc: Test function GetNext
*/
HWTEST_F(
EventTransmissionTest, EventTransmission_Unittest_GetNext_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "EventTransmission_Unittest_GetNext_001 start";
auto display = Singleton<EventTransmission>::GetInstance().GetNext();
GTEST_LOG_(INFO) << "EventTransmission_Unittest_GetNext_001 end";
}
/**
* @tc.number: EventTransmission_Unittest_DestroyEvents_001
* @tc.name: DestroyEvents
* @tc.desc: Test function DestroyEvents
*/
HWTEST_F(
EventTransmissionTest, EventTransmission_Unittest_DestroyEvents_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "EventTransmission_Unittest_DestroyEvents_001 start";
uint64_t displayId = Singleton<EventTransmission>::GetInstance().DestroyEvents();
GTEST_LOG_(INFO) << "DefaultDisplayId" << displayId;
GTEST_LOG_(INFO) << "EventTransmission_Unittest_DestroyEvents_001 end";
}
} // namespace Accessibility
} // namespace OHOS

942
services/aams/test/unittest/accessibility_gesture_recognizer_test.cpp Normal file
View File

@ -0,0 +1,942 @@
/*
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <map>
#include <memory>
#include "accessibility_gesture_recognizer.h"
#include "hilog_wrapper.h"
#include <cinttypes>
using namespace testing;
using namespace testing::ext;
namespace OHOS {
namespace Accessibility {
class AccessAccessibilityGestureRecognizerTest : public ::testing::Test {
public:
AccessAccessibilityGestureRecognizerTest()
{}
~AccessAccessibilityGestureRecognizerTest()
{}
static void SetUpTestCase();
static void TearDownTestCase();
void OnPointerEventPresss(MMI::KeyEvent &event, const int32_t keycode);
void SetUp() override;
void TearDown() override;
std::shared_ptr<AccessAccessibilityGestureRecognizer> mouseKey_ = nullptr;
};
void AccessAccessibilityGestureRecognizerTest::SetUpTestCase()
{
GTEST_LOG_(INFO) << "###################### AccessAccessibilityGestureRecognizerTest Start ######################";
}
void AccessAccessibilityGestureRecognizerTest::TearDownTestCase()
{
GTEST_LOG_(INFO) << "###################### AccessAccessibilityGestureRecognizerTest End ######################";
}
void AccessAccessibilityGestureRecognizerTest::SetUp()
{
GTEST_LOG_(INFO) << "SetUp";
mouseKey_ = std::make_shared<AccessAccessibilityGestureRecognizer>();
}
void AccessAccessibilityGestureRecognizerTest::TearDown()
{
GTEST_LOG_(INFO) << "TearDown";
mouseKey_ = nullptr;
}
void AccessAccessibilityGestureRecognizerTest::OnPointerEventPresss(MMI::KeyEvent &event, const int32_t keycode)
{
// presss
event.SetKeyCode(keycode);
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(keycode);
item.SetPressed(true);
event.AddKeyItem(item);
mouseKey_->OnPointerEvent(event);
event.RemoveReleasedKeyItems(item);
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_001
* @tc.name: GetDoubleTapMoveThreshold
* @tc.desc: Test function GetDoubleTapMoveThreshold
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_001 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_001 event is null";
return;
}
event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
MMI::PointerEvent::PointerItem item;
event->AddPointerItem(item);
mouseKey_->GetDoubleTapMoveThreshold(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_001 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_002
* @tc.name: GetDoubleTapMoveThreshold
* @tc.desc: Test function GetDoubleTapMoveThreshold
* @tc.require: issueI5NTXA
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_002 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_002 event is null";
return;
}
event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
MMI::PointerEvent::PointerItem item;
event->AddPointerItem(item);
mouseKey_->GetDoubleTapMoveThreshold(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_GetDoubleTapMoveThreshold_002 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_001
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_001 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
OnPointerEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_1);
OnPointerEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_2);
OnPointerEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_3);
OnPointerEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_4);
OnPointerEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_6);
OnPointerEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_7);
OnPointerEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_8);
OnPointerEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_9);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_001 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_002
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_002 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
event->AddKeyItem(item);
mouseKey_->OnPointerEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_002 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_003
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_003 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_003 event is null";
return;
}
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;
}
event3->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_DIVIDE);
event3->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_DIVIDE);
item1.SetPressed(true);
event3->AddKeyItem(item1);
mouseKey_->OnPointerEvent(*event3);
std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
if (!event2) {
return;
}
event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item3;
item3.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
item3.SetPressed(true);
event2->AddKeyItem(item3);
AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
mouseKey_->OnPointerEvent(*event2);
int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_BUTTON_UP;
EXPECT_EQ(touchAction, expectValue);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_003 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_004
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_004, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_004 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_004 event is null";
return;
}
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;
}
event4->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_SUBTRACT);
event4->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_SUBTRACT);
item1.SetPressed(true);
event4->AddKeyItem(item1);
mouseKey_->OnPointerEvent(*event4);
std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
if (!event2) {
return;
}
event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item4;
item4.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
item4.SetPressed(true);
event2->AddKeyItem(item4);
AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
mouseKey_->OnPointerEvent(*event2);
int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_BUTTON_UP;
EXPECT_EQ(touchAction, expectValue);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_004 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_005
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_005, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_005 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_005 event is null";
return;
}
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;
}
event5->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_MULTIPLY);
event5->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_MULTIPLY);
item1.SetPressed(true);
event5->AddKeyItem(item1);
mouseKey_->OnPointerEvent(*event5);
std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
if (!event2) {
return;
}
event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item5;
item5.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
item5.SetPressed(true);
event2->AddKeyItem(item5);
AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
mouseKey_->OnPointerEvent(*event2);
int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN;
EXPECT_EQ(touchAction, expectValue);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_005 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_006
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_006, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_006 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
if (!event) {
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_006 event is null";
return;
}
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;
}
event6->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_DIVIDE);
event6->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_DIVIDE);
item1.SetPressed(true);
event6->AddKeyItem(item1);
mouseKey_->OnPointerEvent(*event6);
std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
if (!event2) {
return;
}
event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_ADD);
event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item2;
item2.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_ADD);
item2.SetPressed(true);
event2->AddKeyItem(item2);
AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
mouseKey_->OnPointerEvent(*event2);
int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(2);
int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN;
EXPECT_EQ(touchAction, expectValue);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_006 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_007
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_007, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_007 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
item.SetPressed(true);
event->AddKeyItem(item);
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_LEFT);
item1.SetPressed(true);
event->AddKeyItem(item1);
mouseKey_->OnPointerEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_007 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_008
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_008, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_008 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_2);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
item.SetPressed(true);
event->AddKeyItem(item);
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_2);
item1.SetPressed(true);
event->AddKeyItem(item1);
mouseKey_->OnPointerEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_008 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_009
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_009, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_009 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_3);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_3);
item.SetPressed(true);
event->AddKeyItem(item);
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_LEFT);
item1.SetPressed(true);
event->AddKeyItem(item1);
MMI::KeyEvent::KeyItem item2;
item2.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_RIGHT);
item2.SetPressed(true);
event->AddKeyItem(item2);
mouseKey_->OnPointerEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_009 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_010
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_010, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_010 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_4);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
item.SetPressed(true);
event->AddKeyItem(item);
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_4);
item1.SetPressed(true);
event->AddKeyItem(item1);
MMI::KeyEvent::KeyItem item2;
item2.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_RIGHT);
item2.SetPressed(true);
event->AddKeyItem(item2);
mouseKey_->OnPointerEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_010 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_011
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_011, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_011 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_6);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
item.SetPressed(true);
event->AddKeyItem(item);
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_6);
item1.SetPressed(true);
event->AddKeyItem(item1);
MMI::KeyEvent::KeyItem item2;
item2.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_RIGHT);
item2.SetPressed(true);
event->AddKeyItem(item2);
mouseKey_->OnPointerEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_011 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_012
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_012, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_012 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
event->AddKeyItem(item);
EXPECT_EQ(false, mouseKey_->OnPointerEvent(*event));
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_012 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_013
* @tc.name: OnPointerEvent
* @tc.desc: Test function OnPointerEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerTest, AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_013, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_013 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
MMI::KeyEvent::KeyItem item;
event->AddKeyItem(item);
AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
mouseKey_->OnPointerEvent(*event);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_OnPointerEvent_013 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_001
* @tc.name: HandleTouchMoveEvent
* @tc.desc: Test function HandleTouchMoveEvent
*/
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_001 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
// presss 1
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
item.SetPressed(true);
event->AddKeyItem(item);
// presss left shift
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_LEFT);
item1.SetPressed(true);
event->AddKeyItem(item1);
mouseKey_->HandleTouchMoveEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_001 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_002
* @tc.name: HandleTouchMoveEvent
* @tc.desc: Test function HandleTouchMoveEvent(press left crtl->2 in same time)
* @tc.require: issueI5NTXA
*/
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_002 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_2);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
// presss left ctrl
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
item.SetPressed(true);
event->AddKeyItem(item);
// presss 2
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_2);
item1.SetPressed(true);
event->AddKeyItem(item1);
mouseKey_->HandleTouchMoveEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_002 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_003
* @tc.name: HandleTouchMoveEvent
* @tc.desc: Test function HandleTouchMoveEvent(press 3->left shift->right shift in same time)
* @tc.require: issueI5NTXA
*/
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_003 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_3);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
// presss 1
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_3);
item.SetPressed(true);
event->AddKeyItem(item);
// presss left shift
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_LEFT);
item1.SetPressed(true);
event->AddKeyItem(item1);
// presss right shift
MMI::KeyEvent::KeyItem item2;
item2.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_RIGHT);
item2.SetPressed(true);
event->AddKeyItem(item2);
mouseKey_->HandleTouchMoveEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_003 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_004
* @tc.name: HandleTouchMoveEvent
* @tc.desc: Test function HandleTouchMoveEvent(press left ctrl->4->right ctrl in same time)
* @tc.require: issueI5NTXA
*/
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_004, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_004 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_4);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
// presss left ctrl
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
item.SetPressed(true);
event->AddKeyItem(item);
// presss 4
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_4);
item1.SetPressed(true);
event->AddKeyItem(item1);
// presss right ctrl
MMI::KeyEvent::KeyItem item2;
item2.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_RIGHT);
item2.SetPressed(true);
event->AddKeyItem(item2);
mouseKey_->HandleTouchMoveEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_004 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_005
* @tc.name: HandleTouchMoveEvent
* @tc.desc: Test function HandleTouchMoveEvent(press left ctrl->6->right shift in same time)
* @tc.require: issueI5NTXA
*/
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_005, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_005 start";
if (!mouseKey_) {
return;
}
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!event) {
return;
}
event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_6);
event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
// presss left ctrl
MMI::KeyEvent::KeyItem item;
item.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
item.SetPressed(true);
event->AddKeyItem(item);
// presss 4
MMI::KeyEvent::KeyItem item1;
item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_6);
item1.SetPressed(true);
event->AddKeyItem(item1);
// presss right shift
MMI::KeyEvent::KeyItem item2;
item2.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_RIGHT);
item2.SetPressed(true);
event->AddKeyItem(item2);
mouseKey_->HandleTouchMoveEvent(*event);
EXPECT_NE(event.get(), nullptr);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_HandleTouchMoveEvent_005 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_001
* @tc.name: StandardGestureRecognizer
* @tc.desc: Test function StandardGestureRecognizer
*/
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_001 start";
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
EXPECT_FALSE(AccessAccessibilityGestureRecognizer_->StandardGestureRecognizer(*event));
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_001 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_002
* @tc.name: StandardGestureRecognizer
* @tc.desc: Test function StandardGestureRecognizer
*/
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_002 start";
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
event->SetKeyCode(MMI::KeyEvent::KEYCODE_VOLUME_UP);
EXPECT_TRUE(AccessAccessibilityGestureRecognizer_->StandardGestureRecognizer(*event));
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_002 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_003
* @tc.name: StandardGestureRecognizer
* @tc.desc: Test function StandardGestureRecognizer
*/
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_003, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_003 start";
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
event->SetKeyCode(MMI::KeyEvent::KEYCODE_VOLUME_DOWN);
EXPECT_TRUE(AccessAccessibilityGestureRecognizer_->StandardGestureRecognizer(*event));
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_003 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_004
* @tc.name: StandardGestureRecognizer
* @tc.desc: Test function StandardGestureRecognizer
*/
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_004, TestSize.Level1)
{
AccessibilityAbilityInfo abilityInfo;
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_004 start";
sptr<AccessibilityAccountData> accountData =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
sptr<AccessibleAbilityConnection> connection = new(std::nothrow) AccessibleAbilityConnection(ACCOUNT_ID,
CONNECTION_ID, abilityInfo);
AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!AccessAccessibilityGestureRecognizerUnittest(accountData, connection, elementName, event,
MMI::KeyEvent::KEY_ACTION_UP)) {
return;
}
EXPECT_TRUE(AccessAccessibilityGestureRecognizer_->StandardGestureRecognizer(*event));
accountData->RemoveConnectedAbility(elementName);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_004 end";
}
/**
* @tc.number: AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_005
* @tc.name: StandardGestureRecognizer
* @tc.desc: Test function StandardGestureRecognizer
*/
HWTEST_F(AccessAccessibilityGestureRecognizerUnitTest, AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_005, TestSize.Level1)
{
AccessibilityAbilityInfo abilityInfo;
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_005 start";
sptr<AccessibilityAccountData> accountData =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
sptr<AccessibleAbilityConnection> connection = new(std::nothrow) AccessibleAbilityConnection(ACCOUNT_ID,
CONNECTION_ID, abilityInfo);
AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
if (!AccessAccessibilityGestureRecognizerUnittest(accountData, connection, elementName, event,
MMI::KeyEvent::KEY_ACTION_DOWN)) {
return;
}
EXPECT_TRUE(AccessAccessibilityGestureRecognizer_->StandardGestureRecognizer(*event));
bool ret5 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
if (AccessibilityAbilityHelper::GetInstance().GetKeyCode() == MMI::KeyEvent::KEYCODE_VOLUME_DOWN) {
return true;
} else {
return false;
}
}), SLEEP_TIME_3);
EXPECT_TRUE(ret5);
AccessibilityAbilityHelper::GetInstance().ClearKeyCode();
accountData->RemoveConnectedAbility(elementName);
GTEST_LOG_(INFO) << "AccessAccessibilityGestureRecognizer_Unittest_StandardGestureRecognizer_005 end";
}
/**
* @tc.number: AccessibilityGestureRecognizer_Unittest_recognizeDirectionGesture_001
* @tc.name: recognizeDirectionGesture
* @tc.desc: Test function recognizeDirectionGesture
*/
HWTEST_F(
AccessibilityGestureRecognizerUnitTest, AccessibilityGestureRecognizer_Unittest_recognizeDirectionGesture_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityGestureRecognizer_Unittest_recognizeDirectionGesture_001 start";
uint64_t displayId = Singleton<AccessibilityGestureRecognizer>::GetInstance().recognizeDirectionGesture();
GTEST_LOG_(INFO) << "DefaultDisplayId" << displayId;
GTEST_LOG_(INFO) << "AccessibilityGestureRecognizer_Unittest_recognizeDirectionGesture_001 end";
}
/**
* @tc.number: AccessibilityGestureRecognizer_Unittest_GetSwipeDirection_001
* @tc.name: GetSwipeDirection
* @tc.desc: Test function GetSwipeDirection
*/
HWTEST_F(
AccessibilityGestureRecognizerUnitTest, AccessibilityGestureRecognizer_Unittest_GetSwipeDirection_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityGestureRecognizer_Unittest_GetSwipeDirection_001 start";
auto dpi = Singleton<AccessibilityGestureRecognizer>::GetInstance().GetSwipeDirection();
EXPECT_NE(dpi, 0);
GTEST_LOG_(INFO) << "AccessibilityGestureRecognizer_Unittest_GetSwipeDirection_001 end.";
}
/**
* @tc.number: AccessibilityGestureRecognizer_Unittest_GetPointerPath_001
* @tc.name: GetPointerPath
* @tc.desc: Test function GetPointerPath
*/
HWTEST_F(
AccessibilityGestureRecognizerUnitTest, AccessibilityGestureRecognizer_Unittest_GetPointerPath_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityGestureRecognizer_Unittest_GetPointerPath_001 start";
auto status = Singleton<AccessibilityGestureRecognizer>::GetInstance().GetPointerPath();
EXPECT_GE(status, 0);
GTEST_LOG_(INFO) << "AccessibilityGestureRecognizer_Unittest_GetPointerPath_001 end.";
}
/**
* @tc.number: AccessibilityGestureRecognizer_Unittest_isDoubleTap_001
* @tc.name: isDoubleTap
* @tc.desc: Test function isDoubleTap
*/
HWTEST_F(
AccessibilityGestureRecognizerUnitTest, AccessibilityGestureRecognizer_Unittest_isDoubleTap_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityGestureRecognizer_Unittest_isDoubleTap_001 start";
auto mode = Singleton<AccessibilityGestureRecognizer>::GetInstance().isDoubleTap();
EXPECT_GE(static_cast<uint64_t>(mode), 0);
GTEST_LOG_(INFO) << "AccessibilityGestureRecognizer_Unittest_isDoubleTap_001 end.";
}
} // namespace Accessibility
} // namespace OHOS