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 #include "asset_recv_callback_proxy.h"
16
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 #include "asset_obj.h"
21 #include "asset_recv_callback_mock.h"
22 #include "dfs_error.h"
23 #include "message_parcel_mock.h"
24
25 namespace OHOS::Storage::DistributedFile::Test {
26 using namespace OHOS::FileManagement;
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace std;
30
31 class AssetRecvCallbackProxyTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 public:
38 static inline shared_ptr<AssetRecvCallbackProxy> proxy_ = nullptr;
39 static inline sptr<IAssetRecvCallbackMock> mock_ = nullptr;
40 static inline shared_ptr<MessageParcelMock> messageParcelMock_ = nullptr;
41 };
42
SetUpTestCase(void)43 void AssetRecvCallbackProxyTest::SetUpTestCase(void)
44 {
45 GTEST_LOG_(INFO) << "SetUpTestCase";
46 mock_ = sptr(new IAssetRecvCallbackMock());
47 proxy_ = make_shared<AssetRecvCallbackProxy>(mock_);
48 messageParcelMock_ = make_shared<MessageParcelMock>();
49 MessageParcelMock::messageParcel = messageParcelMock_;
50 }
51
TearDownTestCase(void)52 void AssetRecvCallbackProxyTest::TearDownTestCase(void)
53 {
54 GTEST_LOG_(INFO) << "TearDownTestCase";
55 mock_ = nullptr;
56 proxy_ = nullptr;
57 MessageParcelMock::messageParcel = nullptr;
58 messageParcelMock_ = nullptr;
59 }
60
SetUp(void)61 void AssetRecvCallbackProxyTest::SetUp(void)
62 {
63 GTEST_LOG_(INFO) << "SetUp";
64 }
65
TearDown(void)66 void AssetRecvCallbackProxyTest::TearDown(void)
67 {
68 GTEST_LOG_(INFO) << "TearDown";
69 }
70
71 /**
72 * @tc.name: AssetRecvCallbackProxy_OnStart_0100
73 * @tc.desc: The execution of the OnStart failed.
74 * @tc.type: FUNC
75 * @tc.require: I7TDJK
76 */
77 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnStart_0100, TestSize.Level1)
78 {
79 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0100 Start";
80 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
81 ASSERT_NE(proxy_, nullptr);
82 auto ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
83 EXPECT_EQ(ret, E_BROKEN_IPC);
84
85 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
86 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
87 ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
88 EXPECT_EQ(ret, E_INVAL_ARG);
89
90 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
91 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
92 ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
93 EXPECT_EQ(ret, E_INVAL_ARG);
94
95 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
96 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
97 .WillOnce(Return(false));
98 ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
99 EXPECT_EQ(ret, E_INVAL_ARG);
100
101 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
102 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
103 .WillOnce(Return(true)).WillOnce(Return(false));
104 ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
105 EXPECT_EQ(ret, E_INVAL_ARG);
106 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0100 End";
107 }
108
109 /**
110 * @tc.name: AssetRecvCallbackProxy_OnStart_0200
111 * @tc.desc: The execution of the OnStart failed.
112 * @tc.type: FUNC
113 * @tc.require: I7TDJK
114 */
115 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnStart_0200, TestSize.Level1)
116 {
117 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0200 Start";
118 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
119 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
120 .WillOnce(Return(true)).WillOnce(Return(true));
121 auto testProxy = make_shared<AssetRecvCallbackProxy>(nullptr);
122 auto ret = testProxy->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
123 EXPECT_EQ(ret, E_BROKEN_IPC);
124
125 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
126 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
127 .WillOnce(Return(true)).WillOnce(Return(true));
128 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
129 ASSERT_NE(proxy_, nullptr);
130 ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
131 EXPECT_EQ(ret, E_BROKEN_IPC);
132 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0200 End";
133 }
134
135 /**
136 * @tc.name: AssetRecvCallbackProxy_OnStart_0300
137 * @tc.desc: The execution of the OnStart success.
138 * @tc.type: FUNC
139 * @tc.require: I7TDJK
140 */
141 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnStart_0300, TestSize.Level1)
142 {
143 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0300 Start";
144 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
145 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
146 .WillOnce(Return(true)).WillOnce(Return(true));
147 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
148 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_OK));
149 ASSERT_NE(proxy_, nullptr);
150 auto ret = proxy_->OnStart("srcNetworkId", "dstNetworkId", "sessionId", "bundleName");
151 EXPECT_EQ(ret, E_OK);
152 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnStart_0300 End";
153 }
154
155 /**
156 * @tc.name: AssetRecvCallbackProxy_OnFinished_0100
157 * @tc.desc: The execution of the OnFinished failed.
158 * @tc.type: FUNC
159 * @tc.require: I7TDJK
160 */
161 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnFinished_0100, TestSize.Level1)
162 {
163 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0100 Start";
164 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
165 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
166 ASSERT_NE(proxy_, nullptr);
167 auto ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
168 EXPECT_EQ(ret, E_BROKEN_IPC);
169
170 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
171 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
172 ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
173 EXPECT_EQ(ret, E_INVAL_ARG);
174
175 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
176 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
177 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(false));
178 ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
179 EXPECT_EQ(ret, E_INVAL_ARG);
180
181 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
182 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
183 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
184 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
185 ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
186 EXPECT_EQ(ret, E_INVAL_ARG);
187 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0100 End";
188 }
189
190 /**
191 * @tc.name: AssetRecvCallbackProxy_OnFinished_0200
192 * @tc.desc: The execution of the OnFinished failed.
193 * @tc.type: FUNC
194 * @tc.require: I7TDJK
195 */
196 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnFinished_0200, TestSize.Level1)
197 {
198 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0200 Start";
199 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
200 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
201 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
202 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
203 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
204 auto testProxy = make_shared<AssetRecvCallbackProxy>(nullptr);
205 auto ret = testProxy->OnFinished("srcNetworkId", assetObj, 0);
206 EXPECT_EQ(ret, E_BROKEN_IPC);
207
208 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
209 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
210 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
211 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
212 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
213 ASSERT_NE(proxy_, nullptr);
214 ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
215 EXPECT_EQ(ret, E_BROKEN_IPC);
216 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0200 End";
217 }
218
219 /**
220 * @tc.name: AssetRecvCallbackProxy_OnFinished_0300
221 * @tc.desc: The execution of the OnFinished success.
222 * @tc.type: FUNC
223 * @tc.require: I7TDJK
224 */
225 HWTEST_F(AssetRecvCallbackProxyTest, AssetRecvCallbackProxy_OnFinished_0300, TestSize.Level1)
226 {
227 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0300 Start";
228 sptr<AssetObj> assetObj (new (std::nothrow) AssetObj());
229 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
230 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
231 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
232 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
233 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
234 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_OK));
235 ASSERT_NE(proxy_, nullptr);
236 auto ret = proxy_->OnFinished("srcNetworkId", assetObj, 0);
237 EXPECT_EQ(ret, E_OK);
238 GTEST_LOG_(INFO) << "AssetRecvCallbackProxy_OnFinished_0300 End";
239 }
240 }