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 #include <climits> 16 #include <gtest/gtest.h> 17 #include <iostream> 18 #include <unistd.h> 19 20 #include "file_util.h" 21 #include "parameter_ex.h" 22 #include "trace_collector.h" 23 #include "trace_flow_controller.h" 24 #include "trace_state_machine.h" 25 26 using namespace testing::ext; 27 using namespace OHOS::HiviewDFX; 28 using namespace OHOS::HiviewDFX::UCollectUtil; 29 using namespace OHOS::HiviewDFX::UCollect; 30 31 class TraceCollectorTest : public testing::Test { 32 public: SetUp()33 void SetUp() override {}; TearDown()34 void TearDown() override {}; SetUpTestCase()35 static void SetUpTestCase() {}; TearDownTestCase()36 static void TearDownTestCase() 37 { 38 bool isBetaVersion = Parameter::IsBetaVersion(); 39 bool isUCollectionSwitchOn = Parameter::IsUCollectionSwitchOn(); 40 bool isTraceCollectionSwitchOn = Parameter::IsTraceCollectionSwitchOn(); 41 bool isFrozeSwitchOn = Parameter::GetBoolean("persist.hiview.freeze_detector", false); 42 if (!isBetaVersion && !isFrozeSwitchOn && !isUCollectionSwitchOn && !isTraceCollectionSwitchOn) { 43 return; 44 } 45 46 if (isTraceCollectionSwitchOn) { 47 std::cout << "recover to hitrace CommonDropState" << std::endl; 48 TraceStateMachine::GetInstance().SetTraceSwitchDevOn(); 49 } else { 50 TraceStateMachine::GetInstance().SetTraceSwitchFreezeOn(); 51 std::cout << "recover to hitrace CommonState" << std::endl; 52 } 53 TraceStateMachine::GetInstance().InitOrUpdateState(); 54 } 55 }; 56 57 /** 58 * @tc.name: TraceCollectorTest001 59 * @tc.desc: used to test TraceCollector for xpower dump 60 * @tc.type: FUNC 61 */ 62 HWTEST_F(TraceCollectorTest, TraceCollectorTest001, TestSize.Level1) 63 { 64 UCollect::TraceCaller caller = UCollect::TraceCaller::XPOWER; 65 std::shared_ptr<TraceCollector> collector = TraceCollector::Create(); 66 CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTrace(caller); 67 ASSERT_EQ(resultDumpTrace.retCode, UCollect::UcError::PERMISSION_CHECK_FAILED); 68 69 UCollect::TeleModule module = UCollect::TeleModule::XPOWER; 70 CollectResult<std::vector<std::string>> resultDumpTrace1 = collector->DumpTraceWithFilter(module, {}, 0, 0); 71 ASSERT_EQ(resultDumpTrace1.retCode, UCollect::UcError::PERMISSION_CHECK_FAILED); 72 setuid(1201); // hiview uid 73 TraceStateMachine::GetInstance().InitOrUpdateState(); // init to close state 74 TraceStateMachine::GetInstance().SetTraceSwitchFreezeOn(); 75 TraceStateMachine::GetInstance().InitOrUpdateState(); // trans to common state 76 sleep(2); 77 auto resultDumpTrace2 = collector->DumpTrace(caller); 78 ASSERT_EQ(resultDumpTrace2.retCode, UCollect::UcError::SUCCESS); 79 ASSERT_GE(resultDumpTrace2.data.size(), 0); 80 std::vector<std::string> items = resultDumpTrace2.data; 81 std::cout << "collect DumpTrace result size : " << items.size() << std::endl; 82 for (auto it = items.begin(); it != items.end(); it++) { 83 std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl; 84 } 85 TraceStateMachine::GetInstance().SetTraceSwitchFreezeOff(); 86 TraceStateMachine::GetInstance().InitOrUpdateState(); 87 auto resultDumpTrace3 = collector->DumpTrace(caller); 88 ASSERT_EQ(resultDumpTrace3.retCode, UCollect::UcError::TRACE_STATE_ERROR); 89 } 90 91 /** 92 * @tc.name: TraceCollectorTest002 93 * @tc.desc: used to test TraceCollector for xperf dump 94 * @tc.type: FUNC 95 */ 96 HWTEST_F(TraceCollectorTest, TraceCollectorTest002, TestSize.Level1) 97 { 98 setuid(1201); // hiview uid 99 UCollect::TraceCaller caller = UCollect::TraceCaller::XPERF; 100 std::shared_ptr<TraceCollector> collector = TraceCollector::Create(); 101 TraceStateMachine::GetInstance().InitOrUpdateState(); //init to close state 102 103 // open ucollection switch dump success 104 TraceStateMachine::GetInstance().SetTraceSwitchUcOn(); 105 auto ret = TraceStateMachine::GetInstance().InitOrUpdateState(); 106 ASSERT_TRUE(ret.IsSuccess()); 107 sleep(2); 108 109 //trans to common state, assert dump success 110 auto resultDumpTrace = collector->DumpTrace(caller); 111 ASSERT_EQ(resultDumpTrace.retCode, UCollect::UcError::SUCCESS); 112 ASSERT_GE(resultDumpTrace.data.size(), 0); 113 std::vector<std::string> items = resultDumpTrace.data; 114 std::cout << "collect DumpTrace result size : " << items.size() << std::endl; 115 for (auto it = items.begin(); it != items.end(); it++) { 116 std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl; 117 } 118 TraceStateMachine::GetInstance().SetTraceSwitchDevOn(); 119 auto ret1 = TraceStateMachine::GetInstance().InitOrUpdateState(); 120 ASSERT_TRUE(ret1.IsSuccess()); 121 sleep(2); 122 123 //trans to common drop state, assert dump fail 124 auto resultDumpTrace2 = collector->DumpTrace(caller); 125 ASSERT_EQ(resultDumpTrace2.retCode, UCollect::UcError::TRACE_STATE_ERROR); 126 TraceStateMachine::GetInstance().SetTraceSwitchDevOff(); 127 auto ret2 = TraceStateMachine::GetInstance().InitOrUpdateState(); 128 ASSERT_TRUE(ret2.IsSuccess()); 129 sleep(2); 130 131 // trans to common state 132 auto resultDumpTrace3 = collector->DumpTrace(caller); 133 ASSERT_EQ(resultDumpTrace3.retCode, UCollect::UcError::SUCCESS); 134 TraceStateMachine::GetInstance().SetTraceSwitchUcOff(); 135 auto ret3 = TraceStateMachine::GetInstance().InitOrUpdateState(); 136 ASSERT_TRUE(ret3.IsSuccess()); 137 sleep(2); 138 139 // trans to close state 140 auto resultDumpTrace4 = collector->DumpTrace(caller); 141 ASSERT_EQ(resultDumpTrace4.retCode, UCollect::UcError::TRACE_STATE_ERROR); 142 } 143 144 /** 145 * @tc.name: TraceCollectorTest003 146 * @tc.desc: used to test TraceCollector for other dump 147 * @tc.type: FUNC 148 */ 149 HWTEST_F(TraceCollectorTest, TraceCollectorTest003, TestSize.Level1) 150 { 151 setuid(1201); // hiview uid 152 UCollect::TraceCaller caller = UCollect::TraceCaller::OTHER; 153 std::shared_ptr<TraceCollector> collector = TraceCollector::Create(); 154 TraceStateMachine::GetInstance().InitOrUpdateState(); // init to close state 155 TraceStateMachine::GetInstance().SetTraceSwitchFreezeOn(); 156 TraceStateMachine::GetInstance().InitOrUpdateState(); // trans to common state 157 sleep(2); 158 auto resultDumpTrace2 = collector->DumpTrace(caller); 159 ASSERT_EQ(resultDumpTrace2.retCode, UCollect::UcError::SUCCESS); 160 ASSERT_GE(resultDumpTrace2.data.size(), 0); 161 string traceName = resultDumpTrace2.data[0]; 162 ASSERT_FALSE(traceName.empty()); 163 ASSERT_NE(traceName.find(CallerName::OTHER), string::npos); 164 std::vector<std::string> items = resultDumpTrace2.data; 165 std::cout << "collect DumpTrace result size : " << items.size() << std::endl; 166 for (auto it = items.begin(); it != items.end(); it++) { 167 std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl; 168 } 169 TraceStateMachine::GetInstance().SetTraceSwitchFreezeOff(); 170 TraceStateMachine::GetInstance().InitOrUpdateState(); 171 auto resultDumpTrace3 = collector->DumpTrace(caller); 172 ASSERT_EQ(resultDumpTrace3.retCode, UCollect::UcError::TRACE_STATE_ERROR); 173 } 174 175 /** 176 * @tc.name: TraceCollectorTest004 177 * @tc.desc: used to test TraceCollector for other dump 178 * @tc.type: FUNC 179 */ 180 HWTEST_F(TraceCollectorTest, TraceCollectorTest004, TestSize.Level1) 181 { 182 setuid(1201); // hiview uid 183 UCollect::TraceCaller caller = UCollect::TraceCaller::SCREEN; 184 std::shared_ptr<TraceCollector> collector = TraceCollector::Create(); 185 TraceStateMachine::GetInstance().InitOrUpdateState(); // init to close state 186 TraceStateMachine::GetInstance().SetTraceSwitchFreezeOn(); 187 TraceStateMachine::GetInstance().InitOrUpdateState(); // trans to common state 188 sleep(2); 189 auto resultDumpTrace2 = collector->DumpTrace(caller); 190 ASSERT_EQ(resultDumpTrace2.retCode, UCollect::UcError::SUCCESS); 191 ASSERT_GE(resultDumpTrace2.data.size(), 0); 192 string traceName = resultDumpTrace2.data[0]; 193 ASSERT_FALSE(traceName.empty()); 194 ASSERT_NE(traceName.find(CallerName::SCREEN), string::npos); 195 std::vector<std::string> items = resultDumpTrace2.data; 196 std::cout << "collect DumpTrace result size : " << items.size() << std::endl; 197 for (auto it = items.begin(); it != items.end(); it++) { 198 std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl; 199 } 200 TraceStateMachine::GetInstance().SetTraceSwitchFreezeOff(); 201 TraceStateMachine::GetInstance().InitOrUpdateState(); 202 auto resultDumpTrace3 = collector->DumpTrace(caller); 203 ASSERT_EQ(resultDumpTrace3.retCode, UCollect::UcError::TRACE_STATE_ERROR); 204 } 205 206 /** 207 * @tc.name: TraceCollectorTest005 208 * @tc.desc: used to test TraceCollector for other dump 209 * @tc.type: FUNC 210 */ 211 HWTEST_F(TraceCollectorTest, TraceCollectorTest005, TestSize.Level1) { 212 setuid(1201); // hiview uid 213 UCollect::TeleModule module = UCollect::TeleModule::XPOWER; 214 std::shared_ptr<TraceCollector> collector = TraceCollector::Create(); 215 TraceFlowController(BusinessName::TELEMETRY).ClearTelemetryData(); 216 TraceStateMachine::GetInstance().OpenTelemetryTrace(""); 217 CollectResult<std::vector<std::string>> resultDumpTrace1 = collector->DumpTraceWithFilter(module, {}, 0, 0); 218 ASSERT_EQ(resultDumpTrace1.retCode, UCollect::UcError::TRACE_DUMP_OVER_FLOW); 219 220 int64_t beginTime = 100; 221 std::map<std::string, int64_t> flowControlQuotas { 222 {CallerName::XPERF, 100000000 }, 223 {CallerName::XPOWER, 120000000}, 224 {"Total", 180000000} 225 }; 226 auto ret = TraceFlowController(BusinessName::TELEMETRY).InitTelemetryData("id", beginTime, 227 flowControlQuotas); 228 ASSERT_EQ(ret, TelemetryRet::SUCCESS); 229 sleep(1); 230 231 CollectResult<std::vector<std::string>> resultDumpTrace2 = collector->DumpTraceWithFilter(module, {}, 0, 0); 232 ASSERT_EQ(resultDumpTrace2.retCode, UCollect::UcError::SUCCESS); 233 TraceFlowController(BusinessName::TELEMETRY).ClearTelemetryData(); 234 TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_TELEMETRY); 235 236 sleep(1); 237 CollectResult<std::vector<std::string>> resultDumpTrace3 = collector->DumpTraceWithFilter(module, {}, 0, 0); 238 ASSERT_EQ(resultDumpTrace3.retCode, UCollect::UcError::TRACE_STATE_ERROR); 239 }