1 /*
2 * Copyright (C) 2021 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 "bluetooth_socket.h"
18 #include "bluetooth_gatt_characteristic.h"
19 #include "uuid.h"
20 #include "bluetooth_remote_device.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace Bluetooth {
26 class SocketTest : public testing::Test {
27 public:
SocketTest()28 SocketTest()
29 {}
~SocketTest()30 ~SocketTest()
31 {}
32
33 SppClientSocket *sppClientSocket_ = nullptr;
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38
39 BluetoothRemoteDevice *pbluetoothRomote_ = nullptr;
40 UUID randomUuid_;
41 UUID insecureUuid_;
42
43 SppServerSocket *server_;
44 UUID uuid_;
45 };
46
SetUpTestCase(void)47 void SocketTest::SetUpTestCase(void)
48 {}
TearDownTestCase(void)49 void SocketTest::TearDownTestCase(void)
50 {}
SetUp()51 void SocketTest::SetUp()
52 {
53 pbluetoothRomote_ = new BluetoothRemoteDevice();
54 randomUuid_ = UUID::RandomUUID();
55 sppClientSocket_ = new SppClientSocket(*pbluetoothRomote_, randomUuid_, TYPE_RFCOMM, false);
56 insecureUuid_ = UUID::FromString("00001101-0000-1000-8000-00805F9B34FB");
57
58 server_ = nullptr;
59 uuid_ = UUID::FromString("11111111-0000-1000-8000-00805F9B34FB");
60 if (!server_)
61 GTEST_LOG_(INFO) << "SocketFactory::DataListenRfcommByServiceRecord starts";
62 server_ = SocketFactory::DataListenRfcommByServiceRecord("server", uuid_);
63 }
64
TearDown()65 void SocketTest::TearDown()
66 {
67 delete pbluetoothRomote_;
68 pbluetoothRomote_ = nullptr;
69 delete sppClientSocket_;
70 sppClientSocket_ = nullptr;
71 }
72
73 /**
74 * @tc.number:Spp_UnitTest001
75 * @tc.name: Connect
76 * @tc.desc:
77 */
78 HWTEST_F(SocketTest, Spp_UnitTest_Connect, TestSize.Level1)
79 {
80 GTEST_LOG_(INFO) << "SppClientSocket::Connect starts";
81 sppClientSocket_->Connect();
82 GTEST_LOG_(INFO) << "SppClientSocket::Connect ends";
83 }
84
85 /**
86 * @tc.number:Spp_UnitTest002
87 * @tc.name: Close
88 * @tc.desc:
89 */
90 HWTEST_F(SocketTest, Spp_UnitTest_Close, TestSize.Level1)
91 {
92 GTEST_LOG_(INFO) << "SppClientSocket::Close starts";
93 sppClientSocket_->Close();
94 GTEST_LOG_(INFO) << "SppClientSocket::Close ends";
95 }
96
97 /**
98 * @tc.number:Spp_UnitTest003
99 * @tc.name: GetInputStream
100 * @tc.desc:
101 */
102 HWTEST_F(SocketTest, Spp_UnitTest_GetInputStream, TestSize.Level1)
103 {
104 int fd = 37;
105 BluetoothRemoteDevice device_;
106 SppClientSocket *pfd_SppClientSocket = new SppClientSocket(fd, device_.GetDeviceAddr());
107
108 char receive[512];
109 int DATASIZE = 1024;
110 ssize_t returnInput = 0;
111 GTEST_LOG_(INFO) << "SppClientSocket::GetInputStream starts";
112 InputStream input = pfd_SppClientSocket->GetInputStream();
113 returnInput = input.Read(receive, DATASIZE);
114 GTEST_LOG_(INFO) << "SppClientSocket::GetInputStream ends";
115 }
116
117 /**
118 * @tc.number:Spp_UnitTest004
119 * @tc.name: GetOutputStream
120 * @tc.desc:
121 */
122 HWTEST_F(SocketTest, Spp_UnitTest_GetOutputStream, TestSize.Level1)
123 {
124 GTEST_LOG_(INFO) << "SppClientSocket::GetOutputStream starts";
125 char multiChar[10] = {'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n'};
126 int fd = 37;
127 BluetoothRemoteDevice device_;
128 SppClientSocket *pfd_SppClientSocket = new SppClientSocket(fd, device_.GetDeviceAddr());
129 OutputStream output = pfd_SppClientSocket->GetOutputStream();
130 size_t returnOutput = 0;
131 returnOutput = output.Write(multiChar, 10);
132 GTEST_LOG_(INFO) << "SppClientSocket::GetOutputStream ends";
133 }
134
135 /**
136 * @tc.number:Spp_UnitTest005
137 * @tc.name: GetRemoteDevice
138 * @tc.desc:
139 */
140 HWTEST_F(SocketTest, Spp_UnitTest_GetRemoteDevice, TestSize.Level1)
141 {
142 GTEST_LOG_(INFO) << "SppClientSocket::GetRemoteDevice starts";
143 int fd = 37;
144 BluetoothRemoteDevice device_;
145 SppClientSocket *pfd_SppClientSocket = new SppClientSocket(fd, device_.GetDeviceAddr());
146 BluetoothRemoteDevice tempRemoteDevice = pfd_SppClientSocket->GetRemoteDevice();
147 GTEST_LOG_(INFO) << "SppClientSocket::GetRemoteDevice ends";
148 }
149
150 /**
151 * @tc.number:Spp_UnitTest006
152 * @tc.name: IsConnected
153 * @tc.desc:
154 */
155 HWTEST_F(SocketTest, Spp_UnitTest_IsConnected, TestSize.Level1)
156 {
157 GTEST_LOG_(INFO) << "SppClientSocket::IsConnected starts";
158 int fd = 37;
159 BluetoothRemoteDevice device_;
160 SppClientSocket *pfd_SppClientSocket = new SppClientSocket(fd, device_.GetDeviceAddr());
161 bool IsConnected = false;
162 IsConnected = pfd_SppClientSocket->IsConnected();
163 EXPECT_EQ(IsConnected, true);
164 GTEST_LOG_(INFO) << "SppClientSocket::IsConnected ends";
165 }
166
167 /**
168 * @tc.number:Spp_UnitTest007
169 * @tc.name: GetStringTag
170 * @tc.desc:
171 */
172 HWTEST_F(SocketTest, Spp_UnitTest_GetStringTag, TestSize.Level1)
173 {
174 GTEST_LOG_(INFO) << "SppServerSocket::GetStringTag starts";
175 std::string returnStr{""};
176 returnStr = server_->GetStringTag();
177 GTEST_LOG_(INFO) << "SppServerSocket::GetStringTag ends";
178 }
179
180 /**
181 * @tc.number:Spp_UnitTest008
182 * @tc.name: Accept
183 * @tc.desc:
184 */
185 HWTEST_F(SocketTest, Spp_UnitTest_Accept, TestSize.Level1)
186 {
187 GTEST_LOG_(INFO) << "SppServerSocket::Accept starts";
188
189 int SERTIMEOUT = 10;
190 std::unique_ptr<SppClientSocket> preturn_SppClientSocket = server_->Accept(SERTIMEOUT);
191 GTEST_LOG_(INFO) << "SppServerSocket::Accept ends";
192 }
193
194
195
196 } // namespace Bluetooth
197 } // namespace OHOS