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 <hwext/gtest-ext.h> 17 #include <hwext/gtest-tag.h> 18 19 #include "args_filter.h" 20 #include "irq_filter.h" 21 #include "slice_filter.h" 22 #include "stat_filter.h" 23 #include "ts_common.h" 24 25 using namespace testing::ext; 26 using namespace SysTuning::TraceStreamer; 27 namespace SysTuning { 28 namespace TraceStreamer { 29 class IrqFilterTest : public ::testing::Test { 30 public: SetUp()31 void SetUp() 32 { 33 streamFilters_.argsFilter_ = std::make_unique<ArgsFilter>(&traceDataCache_, &streamFilters_); 34 streamFilters_.irqFilter_ = std::make_unique<IrqFilter>(&traceDataCache_, &streamFilters_); 35 streamFilters_.sliceFilter_ = std::make_unique<SliceFilter>(&traceDataCache_, &streamFilters_); 36 streamFilters_.statFilter_ = std::make_unique<StatFilter>(&traceDataCache_, &streamFilters_); 37 streamFilters_.statFilter_ = std::make_unique<StatFilter>(&traceDataCache_, &streamFilters_); 38 } 39 TearDown()40 void TearDown() {} 41 42 public: 43 TraceStreamerFilters streamFilters_; 44 TraceDataCache traceDataCache_; 45 }; 46 47 /** 48 * @tc.name: IrqHandlerEntryTest 49 * @tc.desc: IrqHandlerEntry Normal TEST 50 * @tc.type: FUNC 51 */ 52 HWTEST_F(IrqFilterTest, IrqHandlerEntryTest, TestSize.Level1) 53 { 54 TS_LOGI("test22-1"); 55 int64_t ts1 = 100; 56 uint32_t cpu1 = 1; 57 DataIndex nameId1 = 1; 58 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); // IrqHandlerEntry 59 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 60 } 61 62 /** 63 * @tc.name: IrqHandlerEntryTestNotMatch 64 * @tc.desc: Test two interrupts, only start, no end 65 * @tc.type: FUNC 66 */ 67 HWTEST_F(IrqFilterTest, IrqHandlerEntryTestNotMatch, TestSize.Level1) 68 { 69 TS_LOGI("test22-2"); 70 int64_t ts1 = 120; 71 uint32_t cpu1 = 1; 72 DataIndex nameId1 = 1; 73 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); // IrqHandlerEntry 74 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 75 ts1 = 110; 76 uint32_t irqRet = 1; 77 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, irqRet); // IrqHandlerEntry 78 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 2); 79 // TRACE_EVENT_IRQ_HANDLER_ENTRY STAT_EVENT_DATA_LOST 80 auto eventCount = 81 traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_IRQ_HANDLER_ENTRY, STAT_EVENT_DATA_LOST); 82 EXPECT_TRUE(1 == eventCount); 83 } 84 85 /** 86 * @tc.name: IrqHandlerExitTestEmpty 87 * @tc.desc:Interrupt only ends, not starts 88 * @tc.type: FUNC 89 */ 90 HWTEST_F(IrqFilterTest, IrqHandlerExitTestEmpty, TestSize.Level1) 91 { 92 TS_LOGI("test22-3"); 93 int64_t ts1 = 100; 94 uint32_t cpu1 = 1; 95 uint32_t ret = 1; // 1 for handled, else for unhandled 96 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, ret); // IrqHandlerExit 97 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 0); 98 // TRACE_EVENT_IRQ_HANDLER_EXIT STAT_EVENT_NOTMATCH 99 auto eventCount = 100 traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_NOTMATCH); 101 EXPECT_TRUE(1 == eventCount); 102 } 103 104 /** 105 * @tc.name: IrqHandlerEnterAndExitTest 106 * @tc.desc: Interrupt normal start and end 107 * @tc.type: FUNC 108 */ 109 HWTEST_F(IrqFilterTest, IrqHandlerEnterAndExitTest, TestSize.Level1) 110 { 111 TS_LOGI("test22-4"); 112 int64_t ts1 = 100; 113 uint32_t cpu1 = 1; 114 DataIndex nameId1 = 1; 115 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); // IrqHandlerEntry 116 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 117 uint32_t irqRet = 1; // 1 for handled, else for unhandled 118 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, irqRet); // IrqHandlerExit 119 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 120 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[0] == 0); 121 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[0] == 0); 122 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().Size() == 1); 123 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().values_[0] == 124 static_cast<int64_t>(streamFilters_.irqFilter_->irqHandled_)); 125 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().names_[0] == streamFilters_.irqFilter_->irqRet_); 126 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().argset_[0] == 0); 127 } 128 129 /** 130 * @tc.name: IrqHandlerDoubleEnterAndExitTest 131 * @tc.desc: Interrupt normal test, 2 interrupts and exits 132 * @tc.type: FUNC 133 */ 134 HWTEST_F(IrqFilterTest, IrqHandlerDoubleEnterAndExitTest, TestSize.Level1) 135 { 136 TS_LOGI("test22-5"); 137 int64_t ts1 = 100; 138 uint32_t cpu1 = 1; 139 DataIndex nameId1 = 1; 140 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); // IrqHandlerEntry 141 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 142 uint32_t ret = 1; // 1 for handled, else for unhandled 143 cpu1 = 2; 144 ts1 = 150; 145 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, ret); // IrqHandlerExit 146 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 147 EXPECT_TRUE(traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_IRQ_HANDLER_EXIT, 148 STAT_EVENT_NOTMATCH) == 1); 149 cpu1 = 1; 150 ts1 = 200; 151 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, ret); // IrqHandlerExit 152 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 153 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[0] == 0); 154 } 155 156 /** 157 * @tc.name: IrqHandlerTripleEnterAndExitTest 158 * @tc.desc: Interrupt normal test, 3 interrupts and exits 159 * @tc.type: FUNC 160 */ 161 HWTEST_F(IrqFilterTest, IrqHandlerTripleEnterAndExitTest, TestSize.Level1) 162 { 163 TS_LOGI("test22-6"); 164 int64_t ts1 = 100; 165 uint32_t cpu1 = 1; 166 DataIndex nameId1 = 1; 167 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); // IrqHandlerEntry 168 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 169 uint32_t ret = 1; // 1 for handled, else for unhandled 170 ts1 = 150; 171 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, ret); // IrqHandlerExit 172 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 173 // check args 174 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[0] == 0); 175 176 ts1 = 200; 177 cpu1 = 1; 178 nameId1 = 1; 179 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); 180 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 2); 181 ret = 1; // 1 for handled, else for unhandled 182 ts1 = 250; 183 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, ret); 184 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 2); 185 // check args 186 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[1] == 1); 187 } 188 189 /** 190 * @tc.name: SoftIrqEntryTest 191 * @tc.desc: Soft interrupt normal test 192 * @tc.type: FUNC 193 */ 194 HWTEST_F(IrqFilterTest, SoftIrqEntryTest, TestSize.Level1) 195 { 196 TS_LOGI("test22-7"); 197 int64_t ts1 = 100; 198 uint32_t cpu1 = 1; 199 uint32_t vec = 1; 200 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); 201 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 202 } 203 204 /** 205 * @tc.name: SoftIrqEntryNotMatch 206 * @tc.desc: The soft interrupts do not match. The two interrupts have only the beginning and no end 207 * @tc.type: FUNC 208 */ 209 HWTEST_F(IrqFilterTest, SoftIrqEntryNotMatch, TestSize.Level1) 210 { 211 TS_LOGI("test22-8"); 212 int64_t ts1 = 100; 213 uint32_t cpu1 = 1; 214 uint32_t vec = 1; 215 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); // SoftIrqEntry 216 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 217 ts1 = 150; 218 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); // SoftIrqEntry 219 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 2); 220 EXPECT_TRUE( 221 traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_ENTRY, STAT_EVENT_DATA_LOST) == 1); 222 } 223 224 /** 225 * @tc.name: SoftIrqExitEmptyTest 226 * @tc.desc: The soft interrupt only ends without starting 227 * @tc.type: FUNC 228 */ 229 HWTEST_F(IrqFilterTest, SoftIrqExitEmptyTest, TestSize.Level1) 230 { 231 TS_LOGI("test22-9"); 232 int64_t ts1 = 100; 233 uint32_t cpu1 = 1; 234 uint32_t vec = 1; 235 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 236 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 0); 237 EXPECT_TRUE( 238 traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 239 } 240 241 /** 242 * @tc.name: SoftIrqTest 243 * @tc.desc: The soft interrupt normal test 244 * @tc.type: FUNC 245 */ 246 HWTEST_F(IrqFilterTest, SoftIrqTest, TestSize.Level1) 247 { 248 TS_LOGI("test22-10"); 249 int64_t ts1 = 100; 250 uint32_t cpu1 = 1; 251 uint32_t vec = 1; 252 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); 253 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 254 ts1 = 150; 255 uint32_t irqRet = 1; 256 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, irqRet); 257 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 258 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[0] == 0); 259 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().Size() == 1); 260 printf("%ld\n", traceDataCache_.GetConstArgSetData().values_[0]); 261 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().values_[0] == 262 static_cast<int64_t>(streamFilters_.irqFilter_->irqActionNameIds_[irqRet])); 263 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().names_[0] == streamFilters_.irqFilter_->irqRet_); 264 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().argset_[0] == 0); 265 } 266 267 /** 268 * @tc.name: SoftIrqTestWithIrqEntryAndExit 269 * @tc.desc: The soft interrupt normal test 270 * @tc.type: FUNC 271 */ 272 HWTEST_F(IrqFilterTest, SoftIrqTestWithIrqEntryAndExit, TestSize.Level1) 273 { 274 TS_LOGI("test22-11"); 275 int64_t ts1 = 100; 276 uint32_t cpu1 = 1; 277 uint32_t vec = 1; 278 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); 279 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 280 ts1 = 150; 281 cpu1 = 2; 282 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 283 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 284 EXPECT_TRUE( 285 traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 286 } 287 288 /** 289 * @tc.name: SoftIrqTestOneEntryTwoNotMatchExit 290 * @tc.desc: The soft interrupt test with onece entry and twice Not Match exit 291 * @tc.type: FUNC 292 */ 293 HWTEST_F(IrqFilterTest, SoftIrqTestOneEntryTwoNotMatchExit, TestSize.Level1) 294 { 295 TS_LOGI("test22-12"); 296 int64_t ts1 = 100; 297 uint32_t cpu1 = 1; 298 uint32_t vec = 1; 299 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); 300 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 301 ts1 = 150; 302 cpu1 = 2; 303 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 304 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 305 EXPECT_TRUE( 306 traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 307 ts1 = 200; 308 cpu1 = 3; 309 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 310 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 311 EXPECT_TRUE( 312 traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 2); 313 } 314 315 /** 316 * @tc.name: SoftIrqTestWithSingleNotMatchExit 317 * @tc.desc: The soft interrupt test with single not Match Exit 318 * @tc.type: FUNC 319 */ 320 HWTEST_F(IrqFilterTest, SoftIrqTestWithSingleNotMatchExit, TestSize.Level1) 321 { 322 TS_LOGI("test22-13"); 323 int64_t ts1 = 100; 324 uint32_t cpu1 = 1; 325 uint32_t vec = 1; 326 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); 327 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 328 ts1 = 150; 329 cpu1 = 2; 330 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 331 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 332 EXPECT_TRUE( 333 traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 334 ts1 = 200; 335 cpu1 = 1; 336 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 337 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 338 EXPECT_TRUE( 339 traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 340 } 341 } // namespace TraceStreamer 342 } // namespace SysTuning 343