1 /*
2  * Copyright (c) 2022 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 <array>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 
20 #include "key_event.h"
21 #include "mmi_adapter.h"
22 #include "ohos_adapter_helper.h"
23 
24 #define private public
25 #include "mmi_adapter_impl.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 
30 namespace OHOS::NWeb {
31 namespace {
32 const int RESULT_OK = 0;
33 const int RESULT_ERROR = -1;
34 std::shared_ptr<MMIAdapterImpl> g_mmi;
35 } // namespace
36 
37 class MMIDeviceInfoAdapterMock : public MMIDeviceInfoAdapter {
38 public:
39     MMIDeviceInfoAdapterMock() = default;
40     MOCK_METHOD0(GetId, int32_t());
41     MOCK_METHOD0(GetType, int32_t());
42     MOCK_METHOD0(GetBus, int32_t());
43     MOCK_METHOD0(GetVersion, int32_t());
44     MOCK_METHOD0(GetProduct, int32_t());
45     MOCK_METHOD0(GetVendor, int32_t());
46     MOCK_METHOD0(GetName, std::string());
47     MOCK_METHOD0(GetPhys, std::string());
48     MOCK_METHOD0(GetUniq, std::string());
49     MOCK_METHOD1(SetId, void(int32_t));
50     MOCK_METHOD1(SetType, void(int32_t));
51     MOCK_METHOD1(SetBus, void(int32_t));
52     MOCK_METHOD1(SetVersion, void(int32_t));
53     MOCK_METHOD1(SetProduct, void(int32_t));
54     MOCK_METHOD1(SetVendor, void(int32_t));
55     MOCK_METHOD1(SetName, void(std::string));
56     MOCK_METHOD1(SetPhys, void(std::string));
57     MOCK_METHOD1(SetUniq, void(std::string));
58 };
59 
60 class NWebMMIAdapterTest : public testing::Test {
61 public:
62     static void SetUpTestCase(void);
63     static void TearDownTestCase(void);
64     void SetUp();
65     void TearDown();
66 };
67 
68 class MMIListenerTest : public MMIListenerAdapter {
69 public:
70     MMIListenerTest() = default;
71     virtual ~MMIListenerTest() = default;
OnDeviceAdded(int32_t deviceId,const std::string & type)72     void OnDeviceAdded(int32_t deviceId, const std::string& type) override {};
OnDeviceRemoved(int32_t deviceId,const std::string & type)73     void OnDeviceRemoved(int32_t deviceId, const std::string& type) override {};
74 };
75 
SetUpTestCase(void)76 void NWebMMIAdapterTest::SetUpTestCase(void)
77 {
78     g_mmi = std::make_shared<MMIAdapterImpl>();
79     ASSERT_NE(g_mmi, nullptr);
80 }
81 
TearDownTestCase(void)82 void NWebMMIAdapterTest::TearDownTestCase(void) {}
83 
SetUp(void)84 void NWebMMIAdapterTest::SetUp(void) {}
85 
TearDown(void)86 void NWebMMIAdapterTest::TearDown(void) {}
87 
88 class MockMMIInputListenerAdapter : public MMIInputListenerAdapter {
89 public:
90     MockMMIInputListenerAdapter() = default;
OnInputEvent(int32_t keyCode,int32_t keyAction)91     void OnInputEvent(int32_t keyCode, int32_t keyAction) {}
92 };
93 
94 /**
95  * @tc.name: NWebMMIAdapterTest_MMIAdapterImpl_001.
96  * @tc.desc: MMI adapter unittest.
97  * @tc.type: FUNC.
98  * @tc.require:I5P001
99  */
100 HWTEST_F(NWebMMIAdapterTest, NWebMMIAdapterTest_MMIAdapterImpl_001, TestSize.Level1)
101 {
102     auto listener = std::make_shared<MMIListenerTest>();
103     int32_t ret = g_mmi->RegisterDevListener("change", listener);
104     EXPECT_EQ(ret, RESULT_OK);
105 
106     ret = g_mmi->UnregisterDevListener("change");
107     EXPECT_EQ(ret, RESULT_OK);
108 }
109 
110 /**
111  * @tc.name: NWebMMIAdapterTest_MMIAdapterImpl_002.
112  * @tc.desc: MMI adapter unittest.
113  * @tc.type: FUNC.
114  * @tc.require:I5P001
115  */
116 HWTEST_F(NWebMMIAdapterTest, NWebMMIAdapterTest_MMIAdapterImpl_002, TestSize.Level1)
117 {
118     int32_t type;
119     int32_t ret = g_mmi->GetKeyboardType(1, type);
120     EXPECT_EQ(ret, RESULT_OK);
121 }
122 
123 /**
124  * @tc.name: NWebMMIAdapterTest_MMIAdapterImpl_003.
125  * @tc.desc: MMI adapter unittest.
126  * @tc.type: FUNC.
127  * @tc.require:I5P001
128  */
129 HWTEST_F(NWebMMIAdapterTest, NWebMMIAdapterTest_MMIAdapterImpl_003, TestSize.Level1)
130 {
131     std::vector<int32_t> devList;
132     int32_t ret = g_mmi->GetDeviceIds(devList);
133     EXPECT_EQ(ret, RESULT_OK);
134 
135     std::shared_ptr<MMIDeviceInfoAdapterMock> info = std::make_shared<MMIDeviceInfoAdapterMock>();
136     EXPECT_NE(info, nullptr);
137     ret = g_mmi->GetDeviceInfo(0, info);
138     EXPECT_EQ(ret, RESULT_OK);
139     ret = g_mmi->GetDeviceInfo(0, nullptr);
140     EXPECT_NE(ret, RESULT_OK);
141 }
142 
143 /**
144  * @tc.name: NWebMMIAdapterTest_MMIAdapterImpl_004.
145  * @tc.desc: MMI adapter unittest.
146  * @tc.type: FUNC.
147  * @tc.require:I5OZZ8
148  */
149 HWTEST_F(NWebMMIAdapterTest, NWebMMIAdapterTest_MMIAdapterImpl_004, TestSize.Level1)
150 {
151     auto listener = std::make_shared<MMIListenerTest>();
152     EXPECT_NE(listener, nullptr);
153     auto listenerTest = std::make_shared<MMIListenerAdapterImpl>(listener);
154     EXPECT_NE(listenerTest, nullptr);
155     listenerTest->OnDeviceAdded(1, "add");
156     listenerTest->OnDeviceRemoved(1, "remove");
157 }
158 
159 /**
160  * @tc.name: NWebMMIAdapterTest_MMIAdapterImpl_005.
161  * @tc.desc: MMI adapter unittest.
162  * @tc.type: FUNC.
163  * @tc.require:I5OZZ8
164  */
165 HWTEST_F(NWebMMIAdapterTest, NWebMMIAdapterTest_MMIAdapterImpl_005, TestSize.Level1)
166 {
167     auto listener = std::make_shared<MMIListenerTest>();
168     int32_t ret = g_mmi->RegisterDevListener("change", nullptr);
169     EXPECT_EQ(ret, RESULT_ERROR);
170 }
171 
172 /**
173  * @tc.name: NWebMMIAdapterTest_MMIAdapterImpl_006.
174  * @tc.desc: MMI adapter unittest.
175  * @tc.type: FUNC.
176  * @tc.require:I5OZZ8
177  */
178 HWTEST_F(NWebMMIAdapterTest, NWebMMIAdapterTest_MMIAdapterImpl_006, TestSize.Level1)
179 {
180     auto mmi_adapter = OhosAdapterHelper::GetInstance().CreateMMIAdapter();
181     EXPECT_NE(mmi_adapter, nullptr);
182     auto listener = std::make_shared<MMIListenerTest>();
183     auto listenerTest = std::make_shared<MMIListenerAdapterImpl>(listener);
184     listenerTest->listener_ = nullptr;
185     listenerTest->OnDeviceAdded(1, "add");
186     listenerTest->OnDeviceRemoved(1, "remove");
187 
188     const char* code = g_mmi->KeyCodeToString(MMI::KeyEvent::KEYCODE_UNKNOWN);
189     EXPECT_NE(code, nullptr);
190     int32_t result = g_mmi->RegisterMMIInputListener(nullptr);
191     EXPECT_EQ(result, -1);
192     std::shared_ptr<MMIInputListenerAdapter> eventCallback = std::make_shared<MockMMIInputListenerAdapter>();
193     result = g_mmi->RegisterMMIInputListener(std::move(eventCallback));
194     EXPECT_NE(result, -1);
195     g_mmi->UnregisterMMIInputListener(MMI::KeyEvent::KEYCODE_UNKNOWN);
196 }
197 
198 /**
199  * @tc.name: NWebMMIAdapterTest_MMIAdapterImpl_007.
200  * @tc.desc: MMIInputListenerAdapterImpl.
201  * @tc.type: FUNC.
202  * @tc.require:I5OZZ8
203  */
204 HWTEST_F(NWebMMIAdapterTest, NWebMMIAdapterTest_MMIInputListenerAdapterImpl_007, TestSize.Level1)
205 {
206     std::shared_ptr<MMIInputListenerAdapter> listener = std::make_shared<MockMMIInputListenerAdapter>();
207     MMIInputListenerAdapterImpl listenerAdapter(listener);
208     std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
209     EXPECT_NE(keyEvent, nullptr);
210     std::shared_ptr<MMI::PointerEvent> pointerEvent = nullptr;
211     std::shared_ptr<MMI::AxisEvent> axisEvent = nullptr;
212     keyEvent->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
213     listenerAdapter.OnInputEvent(keyEvent);
214     listenerAdapter.OnInputEvent(pointerEvent);
215     listenerAdapter.OnInputEvent(axisEvent);
216 
217     keyEvent->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
218     listenerAdapter.OnInputEvent(keyEvent);
219     keyEvent->SetKeyAction(MMI::KeyEvent::KEY_ACTION_CANCEL);
220     listenerAdapter.OnInputEvent(keyEvent);
221 
222     MMIInputListenerAdapterImpl listenerAdapterImpl(nullptr);
223     listenerAdapterImpl.OnInputEvent(keyEvent);
224 }
225 } // namespace OHOS::NWeb
226