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