1 /*
2 * Copyright (c) 2022-2023 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 #include <vector>
18
19 #include "devicestatus_callback_stub.h"
20 #include "devicestatus_define.h"
21 #include "on_screen_data.h"
22 #include "on_screen_manager.h"
23 #include "stationary_manager.h"
24
25 #include "accesstoken_kit.h"
26 #include "nativetoken_kit.h"
27 #include "token_setproc.h"
28
29 #undef LOG_TAG
30 #define LOG_TAG "DeviceStatusClientTest"
31
32 namespace OHOS {
33 namespace Msdp {
34 namespace DeviceStatus {
35 using namespace testing::ext;
36 using namespace Security::AccessToken;
37 namespace {
38 constexpr float DOUBLEPIMAX = 6.3F;
39 constexpr int32_t RET_NO_SUPPORT = 801;
40 uint64_t tokenId_ = 0;
41 const char *PERMISSION_GET_PAGE_CONTENT = "ohos.permission.GET_SCREEN_CONTENT";
42 const char *PERMISSION_SEND_CONTROL_EVENT = "ohos.permission.SIMULATE_USER_INPUT";
43 }
44
45 class DeviceStatusClientTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp();
50 void TearDown();
51 class DeviceStatusClientTestCallback : public DeviceStatusCallbackStub {
52 public:
DeviceStatusClientTestCallback()53 DeviceStatusClientTestCallback() {};
~DeviceStatusClientTestCallback()54 virtual ~DeviceStatusClientTestCallback() {};
55 virtual void OnDeviceStatusChanged(const Data& devicestatusData);
56 };
57 };
58
SetUp()59 void DeviceStatusClientTest::SetUp() {}
60
TearDown()61 void DeviceStatusClientTest::TearDown() {}
62
SetUpTestCase()63 void DeviceStatusClientTest::SetUpTestCase()
64 {
65 const char **perms = new (std::nothrow) const char *[2];
66 const char **acls = new (std::nothrow) const char *[2];
67 if (perms == nullptr || acls == nullptr) {
68 return;
69 }
70 perms[0] = PERMISSION_GET_PAGE_CONTENT;
71 perms[1] = PERMISSION_SEND_CONTROL_EVENT;
72 acls[0] = PERMISSION_GET_PAGE_CONTENT;
73 acls[1] = PERMISSION_SEND_CONTROL_EVENT;
74 TokenInfoParams infoInstance = {
75 .dcapsNum = 0,
76 .permsNum = 2,
77 .aclsNum = 2,
78 .dcaps = nullptr,
79 .perms = perms,
80 .acls = acls,
81 .processName = "DeviceStatusClientTest",
82 .aplStr = "system_core",
83 };
84 tokenId_ = GetAccessTokenId(&infoInstance);
85 ASSERT_EQ(SetSelfTokenID(tokenId_), 0);
86 AccessTokenKit::ReloadNativeTokenInfo();
87 }
88
TearDownTestCase()89 void DeviceStatusClientTest::TearDownTestCase()
90 {
91 int32_t ret = AccessTokenKit::DeleteToken(tokenId_);
92 if (ret != RET_OK) {
93 FI_HILOGE("failed to remove permission");
94 return;
95 }
96 }
97
OnDeviceStatusChanged(const Data & devicestatusData)98 void DeviceStatusClientTest::DeviceStatusClientTestCallback::OnDeviceStatusChanged(const
99 Data& devicestatusData)
100 {
101 GTEST_LOG_(INFO) << "DeviceStatusClientTestCallback type: " << devicestatusData.type;
102 GTEST_LOG_(INFO) << "DeviceStatusClientTestCallback value: " << devicestatusData.value;
103 EXPECT_TRUE(devicestatusData.type == Type::TYPE_VERTICAL_POSITION &&
104 devicestatusData.value >= OnChangedValue::VALUE_INVALID &&
105 devicestatusData.value <= OnChangedValue::VALUE_EXIT) << "DeviceStatusClientTestCallback failed";
106 }
107
108 /**
109 * @tc.name: DeviceStatusCallbackTest001
110 * @tc.desc: test devicestatus callback in proxy
111 * @tc.type: FUNC
112 */
113 HWTEST_F(DeviceStatusClientTest, DeviceStatusCallbackTest001, TestSize.Level0)
114 {
115 CALL_TEST_DEBUG;
116 sptr<IRemoteDevStaCallback> cb = new (std::nothrow) DeviceStatusClientTestCallback();
117 ASSERT_NE(cb, nullptr);
118 StationaryManager& stationaryMgr = StationaryManager::GetInstance();
119 ReportLatencyNs latency = ReportLatencyNs::Latency_INVALID;
120 ActivityEvent activityEvent = ActivityEvent::EVENT_INVALID;
121 int32_t result = stationaryMgr.SubscribeCallback(Type::TYPE_VERTICAL_POSITION, activityEvent, latency, cb);
122 ASSERT_EQ(result, RET_OK);
123 result = stationaryMgr.UnsubscribeCallback(Type::TYPE_VERTICAL_POSITION, activityEvent, cb);
124 ASSERT_EQ(result, RET_OK);
125
126 result = stationaryMgr.SubscribeCallback(Type::TYPE_INVALID, activityEvent, latency, cb);
127 ASSERT_EQ(result, RET_OK);
128 result = stationaryMgr.UnsubscribeCallback(Type::TYPE_INVALID, activityEvent, cb);
129 ASSERT_EQ(result, RET_OK);
130
131 result = stationaryMgr.SubscribeCallback(Type::TYPE_ABSOLUTE_STILL, activityEvent, latency, cb);
132 ASSERT_EQ(result, RET_OK);
133 result = stationaryMgr.UnsubscribeCallback(Type::TYPE_ABSOLUTE_STILL, activityEvent, cb);
134 ASSERT_EQ(result, RET_OK);
135
136 result = stationaryMgr.SubscribeCallback(Type::TYPE_HORIZONTAL_POSITION, activityEvent, latency, cb);
137 ASSERT_EQ(result, RET_OK);
138 result = stationaryMgr.UnsubscribeCallback(Type::TYPE_HORIZONTAL_POSITION, activityEvent, cb);
139 ASSERT_EQ(result, RET_OK);
140
141 result = stationaryMgr.SubscribeCallback(Type::TYPE_LID_OPEN, activityEvent, latency, cb);
142 ASSERT_EQ(result, RET_OK);
143 result = stationaryMgr.UnsubscribeCallback(Type::TYPE_LID_OPEN, activityEvent, cb);
144 ASSERT_EQ(result, RET_OK);
145
146 result = stationaryMgr.SubscribeCallback(Type::TYPE_MAX, activityEvent, latency, cb);
147 ASSERT_EQ(result, RET_OK);
148 result = stationaryMgr.UnsubscribeCallback(Type::TYPE_MAX, activityEvent, cb);
149 ASSERT_EQ(result, RET_OK);
150 }
151
152 /**
153 * @tc.name: GetDeviceStatusDataTest001
154 * @tc.desc: test get devicestatus data in proxy
155 * @tc.type: FUNC
156 */
157 HWTEST_F(DeviceStatusClientTest, GetDeviceStatusDataTest001, TestSize.Level0)
158 {
159 CALL_TEST_DEBUG;
160 StationaryManager& stationaryMgr = StationaryManager::GetInstance();
161 OnChangedValue invalidValue = OnChangedValue::VALUE_INVALID;
162 OnChangedValue exitValue = OnChangedValue::VALUE_EXIT;
163
164 Type type = Type::TYPE_ABSOLUTE_STILL;
165 Data data = stationaryMgr.GetDeviceStatusData(type);
166 EXPECT_TRUE(data.type == type && data.value >= invalidValue && data.value <= exitValue);
167
168 type = Type::TYPE_VERTICAL_POSITION;
169 data = stationaryMgr.GetDeviceStatusData(type);
170 EXPECT_TRUE(data.type == type && data.value >= invalidValue && data.value <= exitValue);
171
172 type = Type::TYPE_HORIZONTAL_POSITION;
173 data = stationaryMgr.GetDeviceStatusData(type);
174 EXPECT_TRUE(data.type == type && data.value >= invalidValue && data.value <= exitValue);
175
176 type = Type::TYPE_LID_OPEN;
177 data = stationaryMgr.GetDeviceStatusData(type);
178 EXPECT_TRUE(data.type == type && data.value >= invalidValue && data.value <= exitValue);
179
180 type = Type::TYPE_INVALID;
181 data = stationaryMgr.GetDeviceStatusData(type);
182 EXPECT_TRUE(data.type == type && data.value >= invalidValue && data.value <= exitValue);
183
184 type = static_cast<Type>(10);
185 data = stationaryMgr.GetDeviceStatusData(type);
186 EXPECT_TRUE(data.type == type && data.value >= invalidValue && data.value <= exitValue);
187 }
188
189 /**
190 * @tc.name: GetDevicePostureDataSync001
191 * @tc.desc: test GetDevicePostureDataSync in proxy
192 * @tc.type: FUNC
193 */
194 HWTEST_F(DeviceStatusClientTest, GetDevicePostureDataSyncTest001, TestSize.Level0)
195 {
196 CALL_TEST_DEBUG;
197 StationaryManager& stationaryMgr = StationaryManager::GetInstance();
198 DevicePostureData data;
199 int32_t ret = stationaryMgr.GetDevicePostureDataSync(data);
200 EXPECT_TRUE(ret == RET_OK || ret == RET_NO_SUPPORT);
201 EXPECT_TRUE(data.rollRad >= 0 && data.rollRad <= DOUBLEPIMAX && data.pitchRad >= 0 &&
202 data.pitchRad <= DOUBLEPIMAX && data.yawRad >= 0 && data.yawRad <= DOUBLEPIMAX);
203 ret = stationaryMgr.GetDevicePostureDataSync(data);
204 EXPECT_TRUE(ret == RET_OK || ret == RET_NO_SUPPORT);
205 EXPECT_TRUE(data.rollRad >= 0 && data.rollRad <= DOUBLEPIMAX && data.pitchRad >= 0 &&
206 data.pitchRad <= DOUBLEPIMAX && data.yawRad >= 0 && data.yawRad <= DOUBLEPIMAX);
207 ret = stationaryMgr.GetDevicePostureDataSync(data);
208 EXPECT_TRUE(ret == RET_OK || ret == RET_NO_SUPPORT);
209 EXPECT_TRUE(data.rollRad >= 0 && data.rollRad <= DOUBLEPIMAX && data.pitchRad >= 0 &&
210 data.pitchRad <= DOUBLEPIMAX && data.yawRad >= 0 && data.yawRad <= DOUBLEPIMAX);
211 }
212
213 /**
214 * @tc.name: GetPageContent001
215 * @tc.desc: test GetPageContent001
216 * @tc.type: FUNC
217 */
218 HWTEST_F(DeviceStatusClientTest, GetPageContent001, TestSize.Level0)
219 {
220 CALL_TEST_DEBUG;
221 OnScreen::ContentOption option;
222 option.contentUnderstand = true;
223 option.pageLink = true;
224 option.textOnly = true;
225 OnScreen::PageContent pageContent;
226 int32_t ret = OnScreen::OnScreenManager::GetInstance().GetPageContent(option, pageContent);
227 if (ret != RET_OK) {
228 std::cout << "ret:" << ret << std::endl;
229 } else {
230 std::cout << "windowId:" << pageContent.windowId << std::endl;
231 std::cout << "bundleName:" << pageContent.bundleName << std::endl;
232 std::cout << "title:" << pageContent.title << std::endl;
233 std::cout << "content:" << pageContent.content << std::endl;
234 std::cout << "pageLink:" << pageContent.pageLink << std::endl;
235 std::cout << "paragraphs:" << std::endl;
236 for (auto i = 0; i < pageContent.paragraphs.size(); i++) {
237 std::cout << "------pagegragh " << i << "---------" << std::endl;
238 std::cout << "hookid: "<< pageContent.paragraphs[i].hookId << std::endl;
239 std::cout << "title: "<< pageContent.paragraphs[i].title << std::endl;
240 std::cout << "content: "<< pageContent.paragraphs[i].content << std::endl;
241 }
242 std::cout << "--------------------------" << std::endl;
243 std::cout << "ret:" << ret << std::endl;
244 }
245 EXPECT_TRUE(ret >= RET_ERR);
246 }
247
248 /**
249 * @tc.name: GetPageContent001
250 * @tc.desc: test GetPageContent001
251 * @tc.type: FUNC
252 */
253 HWTEST_F(DeviceStatusClientTest, SendControlEvent, TestSize.Level0)
254 {
255 CALL_TEST_DEBUG;
256 OnScreen::ControlEvent event;
257 event.eventType = OnScreen::EventType::END;
258 int32_t ret = OnScreen::OnScreenManager::GetInstance().SendControlEvent(event);
259 EXPECT_TRUE(ret >= RET_ERR);
260 }
261 } // namespace DeviceStatus
262 } // namespace Msdp
263 } // namespace OHOS
264