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 "iremote_object_mocker.h" 17 #include "session_ipc_interface_code.h" 18 #include "session_proxy.h" 19 #include "ws_common.h" 20 #include <gtest/gtest.h> 21 22 using namespace testing; 23 using namespace testing::ext; 24 25 namespace OHOS { 26 namespace Rosen { 27 class SessionProxyImmersiveTest : public testing::Test { 28 public: SessionProxyImmersiveTest()29 SessionProxyImmersiveTest() {} ~SessionProxyImmersiveTest()30 ~SessionProxyImmersiveTest() {} 31 }; 32 33 namespace { 34 /** 35 * @tc.name: GetAllAvoidAreasOnlyOne 36 * @tc.desc: get one system avoid area 37 * @tc.type: FUNC 38 */ 39 HWTEST_F(SessionProxyImmersiveTest, GetAllAvoidAreasOnlyOne, Function | SmallTest | Level2) 40 { 41 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAllAvoidAreasOnlyOne start"; 42 auto remoteObj = sptr<RemoteObjectMocker>::MakeSptr(); 43 EXPECT_CALL(*remoteObj, SendRequest(_, _, _, _)).WillOnce(Invoke( __anon55b9194e0202(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) 44 [](uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) -> int { 45 reply.WriteUint32(static_cast<uint32_t>(1)); // avoidArea num 46 reply.WriteUint32(static_cast<uint32_t>(AvoidAreaType::TYPE_SYSTEM)); 47 AvoidArea tmpArea; 48 tmpArea.topRect_ = {0, 0, 1200, 127}; 49 reply.WriteParcelable(&tmpArea); 50 reply.WriteUint32(0); // error code 51 return 0; 52 } 53 )); 54 55 auto sProxy = sptr<SessionProxy>::MakeSptr(remoteObj); 56 std::map<AvoidAreaType, AvoidArea> avoidAreas; 57 WSError ret = sProxy->GetAllAvoidAreas(avoidAreas); 58 59 ASSERT_EQ(ret, WSError::WS_OK); 60 ASSERT_EQ(1, avoidAreas.size()); 61 auto itrFind = avoidAreas.find(AvoidAreaType::TYPE_SYSTEM); 62 ASSERT_TRUE(itrFind != avoidAreas.end()); 63 ASSERT_EQ(itrFind->second.topRect_.posX_, 0); 64 ASSERT_EQ(itrFind->second.topRect_.posY_, 0); 65 ASSERT_EQ(itrFind->second.topRect_.width_, 1200); 66 ASSERT_EQ(itrFind->second.topRect_.height_, 127); 67 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAllAvoidAreasOnlyOne end"; 68 } 69 70 /** 71 * @tc.name: GetAllAvoidAreasRemoteErrorPara 72 * @tc.desc: remote func return error code 1003 73 * @tc.type: FUNC 74 */ 75 HWTEST_F(SessionProxyImmersiveTest, GetAllAvoidAreasRemoteErrorPara, Function | SmallTest | Level2) 76 { 77 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAllAvoidAreasRemoteErrorPara start"; 78 auto remoteObj = sptr<RemoteObjectMocker>::MakeSptr(); 79 EXPECT_CALL(*remoteObj, SendRequest(_, _, _, _)).WillOnce(Return(1003)); 80 81 auto sProxy = sptr<SessionProxy>::MakeSptr(remoteObj); 82 std::map<AvoidAreaType, AvoidArea> avoidAreas; 83 WSError ret = sProxy->GetAllAvoidAreas(avoidAreas); 84 85 ASSERT_EQ(ret, WSError::WS_ERROR_IPC_FAILED); 86 ASSERT_TRUE(avoidAreas.empty()); 87 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAllAvoidAreasRemoteErrorPara end"; 88 } 89 90 /** 91 * @tc.name: GetAllAvoidAreasEmpty 92 * @tc.desc: remote func return no avoid area 93 * @tc.type: FUNC 94 */ 95 HWTEST_F(SessionProxyImmersiveTest, GetAllAvoidAreasEmpty, Function | SmallTest | Level2) 96 { 97 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAllAvoidAreasEmpty start"; 98 auto remoteObj = sptr<RemoteObjectMocker>::MakeSptr(); 99 EXPECT_CALL(*remoteObj, SendRequest(_, _, _, _)).WillOnce(Invoke( __anon55b9194e0302(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) 100 [](uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) -> int { 101 reply.WriteUint32(0); // avoidArea num 102 reply.WriteUint32(0); // error code 103 return 0; 104 } 105 )); 106 107 auto sProxy = sptr<SessionProxy>::MakeSptr(remoteObj); 108 std::map<AvoidAreaType, AvoidArea> avoidAreas; 109 WSError ret = sProxy->GetAllAvoidAreas(avoidAreas); 110 111 ASSERT_EQ(ret, WSError::WS_OK); 112 ASSERT_TRUE(avoidAreas.empty()); 113 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAllAvoidAreasEmpty end"; 114 } 115 116 /** 117 * @tc.name: GetAllAvoidAreasWithInvalidAreaType 118 * @tc.desc: remote func return invalid area type 119 * @tc.type: FUNC 120 */ 121 HWTEST_F(SessionProxyImmersiveTest, GetAllAvoidAreasWithInvalidAreaType, Function | SmallTest | Level2) 122 { 123 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAllAvoidAreasWithInvalidAreaType start"; 124 auto remoteObj = sptr<RemoteObjectMocker>::MakeSptr(); 125 EXPECT_CALL(*remoteObj, SendRequest(_, _, _, _)).WillOnce(Invoke( __anon55b9194e0402(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) 126 [](uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) -> int { 127 reply.WriteUint32(1); // avoidArea num 128 reply.WriteUint32(1111); // invalid areaType 129 AvoidArea tmpArea; 130 tmpArea.topRect_ = {0, 0, 1200, 127}; 131 reply.WriteParcelable(&tmpArea); 132 reply.WriteUint32(0); // error code 133 return 0; 134 } 135 )); 136 137 auto sProxy = sptr<SessionProxy>::MakeSptr(remoteObj); 138 std::map<AvoidAreaType, AvoidArea> avoidAreas; 139 WSError ret = sProxy->GetAllAvoidAreas(avoidAreas); 140 141 ASSERT_EQ(ret, WSError::WS_ERROR_IPC_FAILED); 142 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAllAvoidAreasWithInvalidAreaType end"; 143 } 144 145 /** 146 * @tc.name: GetAllAvoidAreasWithInvalidArea 147 * @tc.desc: remote func return invalid area type 148 * @tc.type: FUNC 149 */ 150 HWTEST_F(SessionProxyImmersiveTest, GetAllAvoidAreasWithInvalidArea, Function | SmallTest | Level2) 151 { 152 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAllAvoidAreasWithInvalidArea start"; 153 auto remoteObj = sptr<RemoteObjectMocker>::MakeSptr(); 154 EXPECT_CALL(*remoteObj, SendRequest(_, _, _, _)).WillOnce(Invoke( __anon55b9194e0502(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) 155 [](uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) -> int { 156 reply.WriteUint32(1); // avoidArea num 157 reply.WriteUint32(static_cast<uint32_t>(AvoidAreaType::TYPE_SYSTEM)); 158 reply.WriteUint32(2234); // invalid area 159 reply.WriteUint32(0); // error code 160 return 0; 161 } 162 )); 163 164 auto sProxy = sptr<SessionProxy>::MakeSptr(remoteObj); 165 std::map<AvoidAreaType, AvoidArea> avoidAreas; 166 WSError ret = sProxy->GetAllAvoidAreas(avoidAreas); 167 168 ASSERT_EQ(ret, WSError::WS_ERROR_IPC_FAILED); 169 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAllAvoidAreasWithInvalidArea end"; 170 } 171 172 /** 173 * @tc.name: GetAvoidAreaByTypeWithRemoteNull 174 * @tc.desc: remote obj is nullptr 175 * @tc.type: FUNC 176 */ 177 HWTEST_F(SessionProxyImmersiveTest, GetAvoidAreaByTypeWithRemoteNull, Function | SmallTest | Level2) 178 { 179 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAvoidAreaByTypeWithRemoteNull start"; 180 auto sProxy = sptr<SessionProxy>::MakeSptr(nullptr); 181 AvoidArea ret = sProxy->GetAvoidAreaByType(AvoidAreaType::TYPE_SYSTEM); 182 ASSERT_TRUE(ret.isEmptyAvoidArea()); 183 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAvoidAreaByTypeWithRemoteNull end"; 184 } 185 186 /** 187 * @tc.name: GetAvoidAreaByTypeWithRemoteErr 188 * @tc.desc: remote func return error code 189 * @tc.type: FUNC 190 */ 191 HWTEST_F(SessionProxyImmersiveTest, GetAvoidAreaByTypeWithRemoteErr, Function | SmallTest | Level2) 192 { 193 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAvoidAreaByTypeWithRemoteErr start"; 194 auto remoteObj = sptr<RemoteObjectMocker>::MakeSptr(); 195 EXPECT_CALL(*remoteObj, SendRequest(_, _, _, _)).WillOnce(Return(1003)); 196 197 auto sProxy = sptr<SessionProxy>::MakeSptr(remoteObj); 198 AvoidArea ret = sProxy->GetAvoidAreaByType(AvoidAreaType::TYPE_SYSTEM); 199 ASSERT_TRUE(ret.isEmptyAvoidArea()); 200 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAvoidAreaByTypeWithRemoteErr end"; 201 } 202 203 /** 204 * @tc.name: GetAvoidAreaByTypeWithAreaInvalid 205 * @tc.desc: remote func return invalid avoid area 206 * @tc.type: FUNC 207 */ 208 HWTEST_F(SessionProxyImmersiveTest, GetAvoidAreaByTypeWithAreaInvalid, Function | SmallTest | Level2) 209 { 210 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAvoidAreaByTypeWithAreaInvalid start"; 211 auto remoteObj = sptr<RemoteObjectMocker>::MakeSptr(); 212 EXPECT_CALL(*remoteObj, SendRequest(_, _, _, _)).WillOnce(Invoke( __anon55b9194e0602(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) 213 [](uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) -> int { 214 reply.WriteUint32(2234); // invalid area 215 return 0; 216 } 217 )); 218 219 auto sProxy = sptr<SessionProxy>::MakeSptr(remoteObj); 220 AvoidArea ret = sProxy->GetAvoidAreaByType(AvoidAreaType::TYPE_SYSTEM); 221 ASSERT_TRUE(ret.isEmptyAvoidArea()); 222 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAvoidAreaByTypeWithAreaInvalid end"; 223 } 224 225 /** 226 * @tc.name: GetAvoidAreaByTypeWithAreaNormal 227 * @tc.desc: normal function 228 * @tc.type: FUNC 229 */ 230 HWTEST_F(SessionProxyImmersiveTest, GetAvoidAreaByTypeWithAreaNormal, Function | SmallTest | Level2) 231 { 232 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAvoidAreaByTypeWithAreaNormal start"; 233 auto remoteObj = sptr<RemoteObjectMocker>::MakeSptr(); 234 EXPECT_CALL(*remoteObj, SendRequest(_, _, _, _)).WillOnce(Invoke( __anon55b9194e0702(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) 235 [](uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) -> int { 236 AvoidArea tmpArea; 237 tmpArea.topRect_ = {0, 0, 1200, 127}; 238 reply.WriteParcelable(&tmpArea); 239 return 0; 240 } 241 )); 242 243 auto sProxy = sptr<SessionProxy>::MakeSptr(remoteObj); 244 AvoidArea ret = sProxy->GetAvoidAreaByType(AvoidAreaType::TYPE_SYSTEM); 245 ASSERT_EQ(ret.topRect_.posX_, 0); 246 ASSERT_EQ(ret.topRect_.posY_, 0); 247 ASSERT_EQ(ret.topRect_.width_, 1200); 248 ASSERT_EQ(ret.topRect_.height_, 127); 249 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAvoidAreaByTypeWithAreaNormal end"; 250 } 251 252 /** 253 * @tc.name: GetAvoidAreaByTypeEmpty 254 * @tc.desc: normal function 255 * @tc.type: FUNC 256 */ 257 HWTEST_F(SessionProxyImmersiveTest, GetAvoidAreaByTypeEmpty, Function | SmallTest | Level2) 258 { 259 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAvoidAreaByTypeEmpty start"; 260 auto remoteObj = sptr<RemoteObjectMocker>::MakeSptr(); 261 auto sProxy = sptr<SessionProxy>::MakeSptr(remoteObj); 262 AvoidArea res = sProxy->GetAvoidAreaByType(AvoidAreaType::TYPE_SYSTEM); 263 AvoidArea area; 264 ASSERT_EQ(res, area); 265 GTEST_LOG_(INFO) << "SessionProxyImmersiveTest::GetAvoidAreaByTypeEmpty end"; 266 } 267 } // namespace 268 } // namespace Rosen 269 } // namespace OHOS 270