1 /* 2 * Copyright (c) 2023-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 "gtest/gtest.h" 17 #include "iostream" 18 #include "string_ex.h" 19 #include "iservice_registry.h" 20 #include "accesstoken_kit.h" 21 #include "token_setproc.h" 22 #include "nativetoken_kit.h" 23 #include "hilog_wrapper.h" 24 #include "driver_extension_controller.h" 25 26 namespace OHOS { 27 namespace ExternalDeviceManager { 28 using namespace OHOS; 29 using namespace std; 30 using namespace testing::ext; 31 class DrvExtCtrlTest : public testing::Test { 32 public: SetUp()33 void SetUp() override 34 { 35 cout << "DrvExtCtrlTest SetUp" << endl; 36 } TearDown()37 void TearDown() override 38 { 39 cout << "DrvExtCtrlTest TearDown" << endl; 40 } 41 class TestConCb : public IDriverExtensionConnectCallback { 42 public: TestConCb()43 TestConCb() { }; OnConnectDone(const sptr<IRemoteObject> & remote,int resultCode)44 int32_t OnConnectDone(const sptr<IRemoteObject> &remote, int resultCode) override 45 { 46 cout << "ConCb OnConnectDone, "<< remote.GetRefPtr() << ", " << resultCode << endl; 47 connectCount_++; 48 return 0; 49 }; OnDisconnectDone(int resultCode)50 int32_t OnDisconnectDone(int resultCode) override 51 { 52 cout << "ConCb OnDisconnectDone, " << resultCode << endl; 53 disconnectCount_++; 54 return 0; 55 } 56 int connectCount_ = 0; 57 int disconnectCount_ = 0; 58 }; 59 }; 60 61 constexpr const char *TEST_BUNDLE_NAME = "com.usb.right"; 62 constexpr const char *TEST_ABILITY_NAME = "UsbServiceExtAbility"; 63 constexpr const char *TEST_ABILITY_NAME_ERR = "XXX"; 64 constexpr const int MAX_WAIT_FOR_CONNECT = 10; 65 66 using namespace OHOS::Security::AccessToken; 67 68 TokenInfoParams g_normalInfoInstance = { 69 .dcapsNum = 0, 70 .permsNum = 0, 71 .aclsNum = 0, 72 .dcaps = nullptr, 73 .perms = nullptr, 74 .acls = nullptr, 75 .processName = "usb_manager", 76 .aplStr = "normal", 77 }; 78 79 TokenInfoParams g_sysInfoInstance = { 80 .dcapsNum = 0, 81 .permsNum = 0, 82 .aclsNum = 0, 83 .dcaps = nullptr, 84 .perms = nullptr, 85 .acls = nullptr, 86 .processName = "usb_manager", 87 .aplStr = "system_basic", 88 }; 89 90 class AccessTokenTest { 91 public: SetTestCaseNative(TokenInfoParams * infoInstance)92 static void SetTestCaseNative(TokenInfoParams *infoInstance) 93 { 94 uint64_t tokenId = GetAccessTokenId(infoInstance); 95 int ret = SetSelfTokenID(tokenId); 96 if (ret == 0) { 97 EDM_LOGI(MODULE_EA_MGR, "SetSelfTokenID success"); 98 } else { 99 EDM_LOGE(MODULE_EA_MGR, "SetSelfTokenID fail"); 100 } 101 AccessTokenKit::ReloadNativeTokenInfo(); 102 } 103 }; 104 105 /** 106 * @tc.number: SUB_Driver_Ext_LifeCycle_0500 107 * @tc.name: DrvExtCtrlWithSATest 108 * @tc.desc: Successfully called the Start Stop interface when testing with SA permission 109 * @tc.size: MediumTest 110 * @tc.type: Function 111 */ 112 HWTEST_F(DrvExtCtrlTest, SUB_Driver_Ext_LifeCycle_0500, TestSize.Level1) 113 { 114 AccessTokenTest::SetTestCaseNative(&g_sysInfoInstance); 115 int ret = 0; 116 auto &ctrl = DriverExtensionController::GetInstance(); 117 ret = ctrl.StartDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME); 118 ASSERT_EQ(ret, 0); 119 ret = ctrl.StopDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME); 120 ASSERT_EQ(ret, 0); 121 } 122 123 /** 124 * @tc.number: SUB_Driver_Ext_LifeCycle_0600 125 * @tc.name: DrvExtCtrlWithoutSATest 126 * @tc.desc: Call to Start Stop interface failed when testing without SA permission 127 * @tc.size: MediumTest 128 * @tc.type: Function 129 */ 130 HWTEST_F(DrvExtCtrlTest, SUB_Driver_Ext_LifeCycle_0600, TestSize.Level1) 131 { 132 AccessTokenTest::SetTestCaseNative(&g_normalInfoInstance); 133 int ret = 0; 134 auto &ctrl = DriverExtensionController::GetInstance(); 135 ret = ctrl.StartDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME_ERR); 136 ASSERT_NE(ret, 0); 137 ret = ctrl.StopDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME_ERR); 138 ASSERT_NE(ret, 0); 139 } 140 141 /** 142 * @tc.number: SUB_Driver_Ext_LifeCycle_0700 143 * @tc.name: DrvExtCtrlConnectTest0 144 * @tc.desc: When testing with SA permissions, Connect&Disconnect successfully called 145 * @tc.size: MediumTest 146 * @tc.type: Function 147 */ 148 HWTEST_F(DrvExtCtrlTest, SUB_Driver_Ext_LifeCycle_0700, TestSize.Level1) 149 { 150 AccessTokenTest::SetTestCaseNative(&g_sysInfoInstance); 151 int ret = 0; 152 bool isTimeout = true; 153 auto &ctrl = DriverExtensionController::GetInstance(); 154 auto con = make_shared<TestConCb>(); 155 ret = ctrl.ConnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME, con); 156 ASSERT_EQ(ret, 0); 157 isTimeout = true; 158 for (int i = 0; i < MAX_WAIT_FOR_CONNECT; i++) { 159 sleep(1); 160 if (con->IsConnectDone()) { 161 isTimeout = false; 162 break; 163 } 164 } 165 ASSERT_EQ(con->connectCount_, 1); 166 ASSERT_EQ(isTimeout, false); 167 ret = ctrl.DisconnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME, con); 168 ASSERT_EQ(ret, 0); 169 isTimeout = true; 170 for (int i = 0; i < MAX_WAIT_FOR_CONNECT; i++) { 171 sleep(1); 172 if (!con->IsConnectDone()) { 173 isTimeout = false; 174 break; 175 } 176 } 177 ASSERT_EQ(isTimeout, false); 178 ASSERT_EQ(con->disconnectCount_, 1); 179 } 180 181 /** 182 * @tc.number: SUB_Driver_Ext_LifeCycle_0800 183 * @tc.name: DrvExtCtrlConnectTest1 184 * @tc.desc: When testing for SA permissions, an error was entered and the registration for 185 * Connect&Disconnect failed to call 186 * @tc.size: MediumTest 187 * @tc.type: Function 188 */ 189 HWTEST_F(DrvExtCtrlTest, SUB_Driver_Ext_LifeCycle_0800, TestSize.Level1) 190 { 191 AccessTokenTest::SetTestCaseNative(&g_sysInfoInstance); 192 int ret = 0; 193 bool isTimeout = true; 194 auto &ctrl = DriverExtensionController::GetInstance(); 195 auto conErr = make_shared<TestConCb>(); 196 ret = ctrl.ConnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME_ERR, conErr); 197 ASSERT_NE(ret, 0); 198 199 auto con = make_shared<TestConCb>(); 200 ret = ctrl.ConnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME, con); 201 ASSERT_EQ(ret, 0); 202 203 isTimeout = true; 204 for (int i = 0; i < MAX_WAIT_FOR_CONNECT; i++) { 205 sleep(1); 206 if (con->IsConnectDone()) { 207 isTimeout = false; 208 break; 209 } 210 } 211 ASSERT_EQ(isTimeout, false); 212 ret = ctrl.DisconnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME_ERR, con); 213 ASSERT_NE(ret, 0); 214 ret = ctrl.DisconnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME, con); 215 ASSERT_EQ(ret, 0); 216 isTimeout = true; 217 for (int i = 0; i < MAX_WAIT_FOR_CONNECT; i++) { 218 sleep(1); 219 if (!con->IsConnectDone()) { 220 isTimeout = false; 221 break; 222 } 223 } 224 ASSERT_EQ(isTimeout, false); 225 } 226 } 227 }