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 "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 HWTEST_F(DrvExtCtrlTest, DrvExtCtrlWithSATest, TestSize.Level1) 106 { 107 AccessTokenTest::SetTestCaseNative(&g_sysInfoInstance); 108 int ret = 0; 109 auto &ctrl = DriverExtensionController::GetInstance(); 110 ret = ctrl.StartDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME); 111 ASSERT_EQ(ret, 0); 112 ret = ctrl.StopDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME); 113 ASSERT_EQ(ret, 0); 114 } 115 116 HWTEST_F(DrvExtCtrlTest, DrvExtCtrlWithoutSATest, TestSize.Level1) 117 { 118 AccessTokenTest::SetTestCaseNative(&g_normalInfoInstance); 119 int ret = 0; 120 auto &ctrl = DriverExtensionController::GetInstance(); 121 ret = ctrl.StartDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME_ERR); 122 ASSERT_NE(ret, 0); 123 ret = ctrl.StopDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME_ERR); 124 ASSERT_NE(ret, 0); 125 } 126 127 128 HWTEST_F(DrvExtCtrlTest, DrvExtCtrlConnectTest0, TestSize.Level1) 129 { 130 AccessTokenTest::SetTestCaseNative(&g_sysInfoInstance); 131 int ret = 0; 132 bool isTimeout = true; 133 auto &ctrl = DriverExtensionController::GetInstance(); 134 auto con = make_shared<TestConCb>(); 135 ret = ctrl.ConnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME, con); 136 ASSERT_EQ(ret, 0); 137 isTimeout = true; 138 for (int i = 0; i < MAX_WAIT_FOR_CONNECT; i++) { 139 sleep(1); 140 if (con->IsConnectDone()) { 141 isTimeout = false; 142 break; 143 } 144 } 145 ASSERT_EQ(con->connectCount_, 1); 146 ASSERT_EQ(isTimeout, false); 147 ret = ctrl.DisconnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME, con); 148 ASSERT_EQ(ret, 0); 149 isTimeout = true; 150 for (int i = 0; i < MAX_WAIT_FOR_CONNECT; i++) { 151 sleep(1); 152 if (!con->IsConnectDone()) { 153 isTimeout = false; 154 break; 155 } 156 } 157 ASSERT_EQ(isTimeout, false); 158 ASSERT_EQ(con->disconnectCount_, 1); 159 } 160 161 HWTEST_F(DrvExtCtrlTest, DrvExtCtrlConnectTest1, TestSize.Level1) 162 { 163 AccessTokenTest::SetTestCaseNative(&g_sysInfoInstance); 164 int ret = 0; 165 bool isTimeout = true; 166 auto &ctrl = DriverExtensionController::GetInstance(); 167 auto conErr = make_shared<TestConCb>(); 168 ret = ctrl.ConnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME_ERR, conErr); 169 ASSERT_NE(ret, 0); 170 171 auto con = make_shared<TestConCb>(); 172 ret = ctrl.ConnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME, con); 173 ASSERT_EQ(ret, 0); 174 175 isTimeout = true; 176 for (int i = 0; i < MAX_WAIT_FOR_CONNECT; i++) { 177 sleep(1); 178 if (con->IsConnectDone()) { 179 isTimeout = false; 180 break; 181 } 182 } 183 ASSERT_EQ(isTimeout, false); 184 ret = ctrl.DisconnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME_ERR, con); 185 ASSERT_NE(ret, 0); 186 ret = ctrl.DisconnectDriverExtension(TEST_BUNDLE_NAME, TEST_ABILITY_NAME, con); 187 ASSERT_EQ(ret, 0); 188 isTimeout = true; 189 for (int i = 0; i < MAX_WAIT_FOR_CONNECT; i++) { 190 sleep(1); 191 if (!con->IsConnectDone()) { 192 isTimeout = false; 193 break; 194 } 195 } 196 ASSERT_EQ(isTimeout, false); 197 } 198 } 199 }