1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #include "error_multimodal.h"
19 #include "event_log_helper.h"
20 #include "input_manager_impl.h"
21 #include "switch_event_input_subscribe_manager.h"
22 
23 #undef MMI_LOG_TAG
24 #define MMI_LOG_TAG "SwitchEventInputSubscribeManagerTest"
25 
26 namespace OHOS {
27 namespace MMI {
28 namespace {
29 using namespace testing::ext;
30 constexpr int32_t INVAID_VALUE = -1;
31 constexpr int32_t SUBSCRIBER_ID = 0;
32 constexpr int32_t MIN_SUBSCRIBER_ID = 0;
33 } // namespace
34 
35 class SwitchEventInputSubscribeManagerTest : public testing::Test {
36 public:
SetUpTestCase(void)37     static void SetUpTestCase(void) {}
TearDownTestCase(void)38     static void TearDownTestCase(void) {}
39 };
40 
41 /**
42  * @tc.name: SwitchEventInputSubscribeManagerTest_SubscribeSwitchEvent_001
43  * @tc.desc: Verify SubscribeSwitchEvent
44  * @tc.type: FUNC
45  * @tc.require:
46  */
47 HWTEST_F(SwitchEventInputSubscribeManagerTest,
48     SwitchEventInputSubscribeManagerTest_SubscribeSwitchEvent_001, TestSize.Level1)
49 {
__anon8bb811880202(std::shared_ptr<SwitchEvent> event) 50     auto func = [](std::shared_ptr<SwitchEvent> event) {
51         MMI_HILOGD("Subscribe switch event success, type:%{public}d, value:%{public}d",
52             event->GetSwitchType(), event->GetSwitchValue());
53     };
54 
55     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(INVAID_VALUE, nullptr), RET_ERR);
56     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(INVAID_VALUE, func), RET_ERR);
57     int32_t subscribeId =
58         SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(SwitchEvent::SwitchType::SWITCH_DEFAULT, func);
59     ASSERT_GE(subscribeId, MIN_SUBSCRIBER_ID);
60     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(subscribeId), RET_OK);
61 }
62 
63 /**
64  * @tc.name: SwitchEventInputSubscribeManagerTest_UnsubscribeSwitchEvent_001
65  * @tc.desc: Verify UnsubscribeSwitchEvent
66  * @tc.type: FUNC
67  * @tc.require:
68  */
69 HWTEST_F(SwitchEventInputSubscribeManagerTest,
70     SwitchEventInputSubscribeManagerTest_UnsubscribeSwitchEvent_001, TestSize.Level1)
71 {
__anon8bb811880302(std::shared_ptr<SwitchEvent> event) 72     auto func = [](std::shared_ptr<SwitchEvent> event) {
73         MMI_HILOGD("Subscribe switch event success, type:%{public}d, value:%{public}d",
74             event->GetSwitchType(), event->GetSwitchValue());
75     };
76 
77     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(INVAID_VALUE), RET_ERR);
78     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(SUBSCRIBER_ID), RET_ERR);
79     int32_t subscribeId =
80         SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(SwitchEvent::SwitchType::SWITCH_DEFAULT, func);
81     ASSERT_GE(subscribeId, MIN_SUBSCRIBER_ID);
82     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(subscribeId), RET_OK);
83 }
84 
85 /**
86  * @tc.name: SwitchEventInputSubscribeManagerTest_OnSubscribeSwitchEventCallback_001
87  * @tc.desc: Verify OnSubscribeSwitchEventCallback
88  * @tc.type: FUNC
89  * @tc.require:
90  */
91 HWTEST_F(SwitchEventInputSubscribeManagerTest,
92     SwitchEventInputSubscribeManagerTest_OnSubscribeSwitchEventCallback_001, TestSize.Level1)
93 {
__anon8bb811880402(std::shared_ptr<SwitchEvent> event) 94     auto func = [](std::shared_ptr<SwitchEvent> event) {
95         MMI_HILOGD("Subscribe switch event success, type:%{public}d, value:%{public}d",
96             event->GetSwitchType(), event->GetSwitchValue());
97     };
98     auto switchEvent = std::make_shared<SwitchEvent>(INVAID_VALUE);
99     ASSERT_NE(switchEvent, nullptr);
100 
101     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnSubscribeSwitchEventCallback(
102         nullptr, SUBSCRIBER_ID), ERROR_NULL_POINTER);
103     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnSubscribeSwitchEventCallback(
104         switchEvent, INVAID_VALUE), RET_ERR);
105     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnSubscribeSwitchEventCallback(
106         switchEvent, SUBSCRIBER_ID), ERROR_NULL_POINTER);
107     int32_t subscribeId =
108         SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(SwitchEvent::SwitchType::SWITCH_DEFAULT, func);
109     ASSERT_GE(subscribeId, MIN_SUBSCRIBER_ID);
110     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnSubscribeSwitchEventCallback(
111         switchEvent, subscribeId), RET_OK);
112     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(subscribeId), RET_OK);
113 }
114 
115 /**
116  * @tc.name: SwitchEventInputSubscribeManagerTest_OnConnected_001
117  * @tc.desc: Verify OnConnected
118  * @tc.type: FUNC
119  * @tc.require:
120  */
121 HWTEST_F(SwitchEventInputSubscribeManagerTest,
122     SwitchEventInputSubscribeManagerTest_OnConnected_001, TestSize.Level1)
123 {
__anon8bb811880502(std::shared_ptr<SwitchEvent> event) 124     auto func = [](std::shared_ptr<SwitchEvent> event) {
125         MMI_HILOGD("Subscribe switch event success, type:%{public}d, value:%{public}d",
126             event->GetSwitchType(), event->GetSwitchValue());
127     };
128 
129     SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnConnected();
130     int32_t subscribeId =
131         SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(SwitchEvent::SwitchType::SWITCH_DEFAULT, func);
132     ASSERT_GE(subscribeId, MIN_SUBSCRIBER_ID);
133     SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnConnected();
134     ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(subscribeId), RET_OK);
135 }
136 
137 /**
138  * @tc.name: SwitchEventInputSubscribeManagerTest_OnDisconnected_001
139  * @tc.desc: Verify OnDisconnected
140  * @tc.type: FUNC
141  * @tc.require:
142  */
143 HWTEST_F(SwitchEventInputSubscribeManagerTest,
144     SwitchEventInputSubscribeManagerTest_OnDisconnected_001, TestSize.Level1)
145 {
146     InputManagerImpl inputManager;
147     EXPECT_NO_FATAL_FAILURE(inputManager.OnDisconnected());
148 }
149 
150 /**
151  * @tc.name: SwitchEventInputSubscribeManagerTest_ReAddInputEventFilter_001
152  * @tc.desc: Verify ReAddInputEventFilter
153  * @tc.type: FUNC
154  * @tc.require:
155  */
156 HWTEST_F(SwitchEventInputSubscribeManagerTest,
157     SwitchEventInputSubscribeManagerTest_ReAddInputEventFilter_001, TestSize.Level1)
158 {
159     InputManagerImpl inputManager;
160     EXPECT_NO_FATAL_FAILURE(inputManager.ReAddInputEventFilter());
161 }
162 
163 /**
164  * @tc.name: SwitchEventInputSubscribeManagerTest_SetTouchpadScrollSwitch_001
165  * @tc.desc: Verify SetTouchpadScrollSwitch
166  * @tc.type: FUNC
167  * @tc.require:
168  */
169 HWTEST_F(SwitchEventInputSubscribeManagerTest,
170     SwitchEventInputSubscribeManagerTest_SetTouchpadScrollSwitch_001, TestSize.Level1)
171 {
172     InputManagerImpl inputManager;
173     bool switchFlag = true;
174     int32_t ret = inputManager.SetTouchpadScrollSwitch(switchFlag);
175     ASSERT_EQ(ret, RET_OK);
176     switchFlag = false;
177     ret = inputManager.SetTouchpadScrollSwitch(switchFlag);
178     ASSERT_EQ(ret, RET_OK);
179 }
180 
181 /**
182  * @tc.name: SwitchEventInputSubscribeManagerTest_GetTouchpadScrollSwitch_001
183  * @tc.desc: Verify GetTouchpadScrollSwitch
184  * @tc.type: FUNC
185  * @tc.require:
186  */
187 HWTEST_F(SwitchEventInputSubscribeManagerTest,
188     SwitchEventInputSubscribeManagerTest_GetTouchpadScrollSwitch_001, TestSize.Level1)
189 {
190     InputManagerImpl inputManager;
191     bool switchFlag = true;
192     int32_t ret = inputManager.GetTouchpadScrollSwitch(switchFlag);
193     ASSERT_EQ(ret, RET_OK);
194     switchFlag = false;
195     ret = inputManager.GetTouchpadScrollSwitch(switchFlag);
196     ASSERT_EQ(ret, RET_OK);
197 }
198 } // namespace MMI
199 } // namespace OHOS
200