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 <gtest/gtest.h>
17 #include <securec.h>
18 #include "softbus_error_code.h"
19 #include "softbus_def.h"
20 #include "softbus_adapter_mem.h"
21 #include "trans_client_proxy.h"
22
23 using namespace std;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 class TransClientProxyGitpidTest : public testing::Test {
28 public:
TransClientProxyGitpidTest()29 TransClientProxyGitpidTest() {}
~TransClientProxyGitpidTest()30 ~TransClientProxyGitpidTest() {}
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
SetUp()33 void SetUp() override {}
TearDown()34 void TearDown() override {}
35 };
36
SetUpTestCase(void)37 void TransClientProxyGitpidTest::SetUpTestCase(void) {}
TearDownTestCase(void)38 void TransClientProxyGitpidTest::TearDownTestCase(void) {}
39
40 /**
41 * @tc.name: ClientIpcOnChannelOpenedTest001
42 * @tc.desc: ClientIpcOnChannelOpened test
43 * @tc.type: FUNC
44 * @tc.require:
45 */
46 HWTEST_F(TransClientProxyGitpidTest, ClientIpcOnChannelOpenedTest001, TestSize.Level1)
47 {
48 const char *pkgName = "testName";
49 const char *sessionName = "testName";
50 int32_t pid = getpid();
51
52 ChannelInfo *channel = static_cast<ChannelInfo *>(SoftBusCalloc(sizeof(ChannelInfo)));
53 ASSERT_TRUE(channel != nullptr);
54
55 int32_t ret = ClientIpcOnChannelOpened(pkgName, sessionName, channel, pid);
56 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
57 SoftBusFree(channel);
58 }
59
60 /**
61 * @tc.name: ClientIpcOnChannelBindTest001
62 * @tc.desc: ClientIpcOnChannelBind test
63 * @tc.type: FUNC
64 * @tc.require:
65 */
66 HWTEST_F(TransClientProxyGitpidTest, ClientIpcOnChannelBindTest001, TestSize.Level1)
67 {
68 ChannelMsg *data = static_cast<ChannelMsg *>(SoftBusCalloc(sizeof(ChannelMsg)));
69 ASSERT_TRUE(data != nullptr);
70 data->msgPid = getpid();
71
72 int32_t ret = ClientIpcOnChannelBind(data);
73 EXPECT_EQ(SOFTBUS_OK, ret);
74 SoftBusFree(data);
75 }
76
77 /**
78 * @tc.name: ClientIpcOnChannelOpenFailedTest001
79 * @tc.desc: ClientIpcOnChannelOpenFailed test
80 * @tc.type: FUNC
81 * @tc.require:
82 */
83 HWTEST_F(TransClientProxyGitpidTest, ClientIpcOnChannelOpenFailedTest001, TestSize.Level1)
84 {
85 const char *pkgName = "testName";
86 ChannelMsg *data = static_cast<ChannelMsg *>(SoftBusCalloc(sizeof(ChannelMsg)));
87 ASSERT_TRUE(data != nullptr);
88 data->msgPid = getpid();
89 int32_t errCode = 0;
90 data->msgPkgName = pkgName;
91
92 int32_t ret = ClientIpcOnChannelOpenFailed(data, errCode);
93 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
94 SoftBusFree(data);
95 }
96
97 /**
98 * @tc.name: ClientIpcOnChannelLinkDownTest001
99 * @tc.desc: ClientIpcOnChannelLinkDown test
100 * @tc.type: FUNC
101 * @tc.require:
102 */
103 HWTEST_F(TransClientProxyGitpidTest, ClientIpcOnChannelLinkDownTest001, TestSize.Level1)
104 {
105 const char *pkgName = "testName";
106 ChannelMsg *data = static_cast<ChannelMsg *>(SoftBusCalloc(sizeof(ChannelMsg)));
107 ASSERT_TRUE(data != nullptr);
108 data->msgPid = getpid();
109 data->msgPkgName = pkgName;
110 const char *networkId = "1111"; // test value
111 const char *peerIp = "1111"; // test value
112 int32_t routeType = 1;
113
114 int32_t ret = ClientIpcOnChannelLinkDown(data, networkId, peerIp, routeType);
115 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
116 SoftBusFree(data);
117 }
118
119 /**
120 * @tc.name: ClientIpcOnChannelClosedTest001
121 * @tc.desc: ClientIpcOnChannelClosed test
122 * @tc.type: FUNC
123 * @tc.require:
124 */
125 HWTEST_F(TransClientProxyGitpidTest, ClientIpcOnChannelClosedTest001, TestSize.Level1)
126 {
127 const char *pkgName = "testName";
128 ChannelMsg *data = static_cast<ChannelMsg *>(SoftBusCalloc(sizeof(ChannelMsg)));
129 ASSERT_TRUE(data != nullptr);
130
131 data->msgPid = getpid();
132 data->msgPkgName = pkgName;
133
134 int32_t ret = ClientIpcOnChannelClosed(data);
135 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
136 SoftBusFree(data);
137 }
138
139 /**
140 * @tc.name: ClientIpcSetChannelInfoTest001
141 * @tc.desc: ClientIpcSetChannelInfon test
142 * @tc.type: FUNC
143 * @tc.require:
144 */
145 HWTEST_F(TransClientProxyGitpidTest, ClientIpcSetChannelInfoTest001, TestSize.Level1)
146 {
147 const char *pkgName = "testName";
148 const char *sessionName = "testName";
149 int32_t pid = getpid();
150 int32_t sessionId = 1;
151
152 TransInfo *transInfo = static_cast<TransInfo *>(SoftBusCalloc(sizeof(TransInfo)));
153 ASSERT_TRUE(transInfo != nullptr);
154
155 int32_t ret = ClientIpcSetChannelInfo(pkgName, sessionName, sessionId, transInfo, pid);
156 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
157 SoftBusFree(transInfo);
158 }
159
160 /**
161 * @tc.name: ClientIpcOnChannelMsgReceivedTest001
162 * @tc.desc: ClientIpcOnChannelMsgReceived test
163 * @tc.type: FUNC
164 * @tc.require:
165 */
166 HWTEST_F(TransClientProxyGitpidTest, ClientIpcOnChannelMsgReceivedTest001, TestSize.Level1)
167 {
168 const char *pkgName = "testName";
169 ChannelMsg *data = static_cast<ChannelMsg *>(SoftBusCalloc(sizeof(ChannelMsg)));
170 ASSERT_TRUE(data != nullptr);
171 TransReceiveData *receiveData = static_cast<TransReceiveData *>(SoftBusCalloc(sizeof(TransReceiveData)));
172 ASSERT_TRUE(receiveData != nullptr);
173
174 data->msgPid = getpid();
175 data->msgPkgName = pkgName;
176
177 int32_t ret = ClientIpcOnChannelMsgReceived(data, receiveData);
178 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
179 SoftBusFree(data);
180 SoftBusFree(receiveData);
181 }
182 }