1 /*
2 * Copyright (c) 2023 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 "usb_config_desc_parser.h"
18 #include "usb_ddk_api.h"
19 #include "usb_ddk_types.h"
20
21 using namespace testing::ext;
22
23 namespace {
24 bool g_state = false;
GrantPermission(void)25 void GrantPermission(void)
26 {
27 g_state = true;
28 }
RevokePermission(void)29 void RevokePermission(void)
30 {
31 g_state = false;
32 }
33
34 class DdkPermissionTest : public testing::Test {
35 public:
36 void SetUp() override;
37 void TearDown() override;
38 };
39 } // namespace
40
41 namespace OHOS {
42 namespace ExternalDeviceManager {
43 class ExtPermissionManager {
44 static ExtPermissionManager& GetInstance();
45 bool HasPermission(std::string permissionName);
46 };
GetInstance()47 ExtPermissionManager& ExtPermissionManager::GetInstance()
48 {
49 static auto instance = new ExtPermissionManager();
50 return *instance;
51 }
52 // required permissions are not yet implemented, mock this method so that the tests may pass.
HasPermission(std::string permissionName)53 bool ExtPermissionManager::HasPermission(std::string permissionName)
54 {
55 return g_state;
56 }
57 } // namespace Security
58 } // namespace OHOS
59
SetUp()60 void DdkPermissionTest::SetUp()
61 {
62 RevokePermission();
63 int32_t ret = OH_Usb_Init();
64 EXPECT_NE(ret, 0);
65 GrantPermission();
66 ret = OH_Usb_Init();
67 EXPECT_EQ(ret, 0);
68 }
69
TearDown()70 void DdkPermissionTest::TearDown()
71 {
72 RevokePermission();
73 OH_Usb_Release();
74 GrantPermission();
75 int32_t ret = OH_Usb_GetDeviceDescriptor(0, nullptr);
76 EXPECT_EQ(ret, USB_DDK_INVALID_PARAMETER);
77 OH_Usb_Release();
78 ret = OH_Usb_GetDeviceDescriptor(0, nullptr);
79 EXPECT_EQ(ret, USB_DDK_INVALID_OPERATION);
80 }
81
82 namespace {
83 HWTEST_F(DdkPermissionTest, OH_Usb_GetDeviceDescriptor_001, TestSize.Level1)
84 {
85 int32_t ret = OH_Usb_GetDeviceDescriptor(0, nullptr);
86 EXPECT_EQ(ret, USB_DDK_INVALID_PARAMETER);
87 }
88
89 HWTEST_F(DdkPermissionTest, OH_Usb_GetDeviceDescriptor_002, TestSize.Level1)
90 {
91 RevokePermission();
92 int32_t ret = OH_Usb_GetDeviceDescriptor(0, nullptr);
93 EXPECT_EQ(ret, USB_DDK_FAILED);
94 }
95
96 HWTEST_F(DdkPermissionTest, OH_Usb_GetConfigDescriptor_001, TestSize.Level1)
97 {
98 int32_t ret = OH_Usb_GetConfigDescriptor(0, 1, nullptr);
99 EXPECT_EQ(ret, USB_DDK_INVALID_PARAMETER);
100 }
101
102 HWTEST_F(DdkPermissionTest, OH_Usb_GetConfigDescriptor_002, TestSize.Level1)
103 {
104 RevokePermission();
105 int32_t ret = OH_Usb_GetConfigDescriptor(0, 1, nullptr);
106 EXPECT_EQ(ret, USB_DDK_FAILED);
107 }
108
109 HWTEST_F(DdkPermissionTest, OH_Usb_ClaimInterface_001, TestSize.Level1)
110 {
111 int32_t ret = OH_Usb_ClaimInterface(0, 0, nullptr);
112 EXPECT_EQ(ret, USB_DDK_INVALID_PARAMETER);
113 }
114
115 HWTEST_F(DdkPermissionTest, OH_Usb_ClaimInterface_002, TestSize.Level1)
116 {
117 RevokePermission();
118 int32_t ret = OH_Usb_ClaimInterface(0, 0, nullptr);
119 EXPECT_EQ(ret, USB_DDK_FAILED);
120 }
121
122 HWTEST_F(DdkPermissionTest, OH_Usb_ReleaseInterface_001, TestSize.Level1)
123 {
124 RevokePermission();
125 int32_t ret = OH_Usb_ReleaseInterface(1);
126 EXPECT_EQ(ret, USB_DDK_FAILED);
127 }
128
129 HWTEST_F(DdkPermissionTest, OH_Usb_SelectInterfaceSetting_001, TestSize.Level1)
130 {
131 OH_Usb_Release();
132 int32_t ret = OH_Usb_SelectInterfaceSetting(0, 0);
133 EXPECT_EQ(ret, USB_DDK_INVALID_OPERATION);
134 OH_Usb_Init();
135 }
136
137 HWTEST_F(DdkPermissionTest, OH_Usb_SelectInterfaceSetting_002, TestSize.Level1)
138 {
139 RevokePermission();
140 int32_t ret = OH_Usb_SelectInterfaceSetting(0, 0);
141 EXPECT_EQ(ret, USB_DDK_FAILED);
142 }
143
144 HWTEST_F(DdkPermissionTest, OH_Usb_GetCurrentInterfaceSetting_001, TestSize.Level1)
145 {
146 int32_t ret = OH_Usb_GetCurrentInterfaceSetting(0, nullptr);
147 EXPECT_EQ(ret, USB_DDK_INVALID_PARAMETER);
148 }
149
150 HWTEST_F(DdkPermissionTest, OH_Usb_GetCurrentInterfaceSetting_002, TestSize.Level1)
151 {
152 RevokePermission();
153 int32_t ret = OH_Usb_GetCurrentInterfaceSetting(0, nullptr);
154 EXPECT_EQ(ret, USB_DDK_FAILED);
155 }
156
157 HWTEST_F(DdkPermissionTest, OH_Usb_SendControlReadRequest_001, TestSize.Level1)
158 {
159 int32_t ret = OH_Usb_SendControlReadRequest(0, nullptr, 0, nullptr, nullptr);
160 EXPECT_EQ(ret, USB_DDK_INVALID_PARAMETER);
161 }
162
163 HWTEST_F(DdkPermissionTest, OH_Usb_SendControlReadRequest_002, TestSize.Level1)
164 {
165 RevokePermission();
166 int32_t ret = OH_Usb_SendControlReadRequest(0, nullptr, 0, nullptr, nullptr);
167 EXPECT_EQ(ret, USB_DDK_FAILED);
168 }
169
170 HWTEST_F(DdkPermissionTest, OH_Usb_SendControlWriteRequest_001, TestSize.Level1)
171 {
172 int32_t ret = OH_Usb_SendControlWriteRequest(0, nullptr, 0, nullptr, 0);
173 EXPECT_EQ(ret, USB_DDK_INVALID_PARAMETER);
174 }
175
176 HWTEST_F(DdkPermissionTest, OH_Usb_SendControlWriteRequest_002, TestSize.Level1)
177 {
178 RevokePermission();
179 int32_t ret = OH_Usb_SendControlWriteRequest(0, nullptr, 0, nullptr, 0);
180 EXPECT_EQ(ret, USB_DDK_FAILED);
181 }
182
183 HWTEST_F(DdkPermissionTest, OH_Usb_SendPipeRequest_001, TestSize.Level1)
184 {
185 int32_t ret = OH_Usb_SendPipeRequest(nullptr, nullptr);
186 EXPECT_EQ(ret, USB_DDK_INVALID_PARAMETER);
187 }
188
189 HWTEST_F(DdkPermissionTest, OH_Usb_SendPipeRequest_002, TestSize.Level1)
190 {
191 RevokePermission();
192 int32_t ret = OH_Usb_SendPipeRequest(nullptr, nullptr);
193 EXPECT_EQ(ret, USB_DDK_FAILED);
194 }
195
196 HWTEST_F(DdkPermissionTest, OH_Usb_CreateDeviceMemMap_001, TestSize.Level1)
197 {
198 int32_t ret = OH_Usb_CreateDeviceMemMap(0, 100, nullptr);
199 EXPECT_EQ(ret, USB_DDK_INVALID_PARAMETER);
200 }
201
202 HWTEST_F(DdkPermissionTest, OH_Usb_CreateDeviceMemMap_002, TestSize.Level1)
203 {
204 RevokePermission();
205 int32_t ret = OH_Usb_CreateDeviceMemMap(0, 100, nullptr);
206 EXPECT_EQ(ret, USB_DDK_FAILED);
207 }
208 } // namespace