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 "clock_filter.h" 20 #include "trace_data_cache.h" 21 #include "trace_streamer_filters.h" 22 23 using namespace testing::ext; 24 using namespace SysTuning::TraceStreamer; 25 namespace SysTuning { 26 namespace TraceStreamer { 27 class ClockFilterTest : public ::testing::Test { 28 public: SetUp()29 void SetUp() 30 { 31 streamFilters_.clockFilter_ = std::make_unique<ClockFilter>(&traceDataCache_, &streamFilters_); 32 } 33 TearDown()34 void TearDown() {} 35 36 public: 37 SysTuning::TraceStreamer::TraceStreamerFilters streamFilters_; 38 SysTuning::TraceStreamer::TraceDataCache traceDataCache_; 39 }; 40 41 /** 42 * @tc.name: ConvertBoottimeToMonitonicTime 43 * @tc.desc: convert Boottime to MonitonicTime 44 * @tc.type: FUNC 45 */ 46 HWTEST_F(ClockFilterTest, ConvertBoottimeToMonitonicTime, TestSize.Level1) 47 { 48 TS_LOGI("test3-1"); 49 uint64_t tsBoottime = 100; 50 uint64_t tsMonotonicTime = 200; 51 std::vector<SnapShot> snapShot0; 52 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 53 snapShot0.push_back({TS_MONOTONIC, tsMonotonicTime}); 54 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 55 56 uint64_t time1 = 150; 57 uint64_t expectTime1 = 250; 58 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time1, TS_MONOTONIC), expectTime1); 59 } 60 61 /** 62 * @tc.name: ConvertBoottimeToMonitonicTimeTwice 63 * @tc.desc: convert twice Boottime to MonitonicTime 64 * @tc.type: FUNC 65 */ 66 HWTEST_F(ClockFilterTest, ConvertBoottimeToMonitonicTimeTwice, TestSize.Level1) 67 { 68 TS_LOGI("test3-2"); 69 uint64_t tsBoottime = 100; 70 uint64_t tsMonotonicTime = 200; 71 std::vector<SnapShot> snapShot0; 72 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 73 snapShot0.push_back({TS_MONOTONIC, tsMonotonicTime}); 74 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 75 76 uint64_t time1 = 150; 77 uint64_t expectTime1 = 250; 78 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time1, TS_MONOTONIC), expectTime1); 79 uint64_t time2 = 200; 80 uint64_t expectTime2 = 300; 81 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time2, TS_MONOTONIC), expectTime2); 82 } 83 84 /** 85 * @tc.name: ConvertTimestampInvalid 86 * @tc.desc: Convert timestamp invalid 87 * @tc.type: FUNC 88 */ 89 HWTEST_F(ClockFilterTest, ConvertTimestampInvalid, TestSize.Level1) 90 { 91 TS_LOGI("test3-3"); 92 uint64_t tsBoottime = 100; 93 uint64_t tsMonotonicTime = 200; 94 std::vector<SnapShot> snapShot0; 95 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 96 snapShot0.push_back({TS_MONOTONIC, tsMonotonicTime}); 97 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 98 99 std::vector<SnapShot> snapShot1; 100 uint64_t tsBoottime2 = 200; 101 uint64_t tsMonotonicTime2 = 350; 102 snapShot1.push_back({TS_CLOCK_BOOTTIME, tsBoottime2}); 103 snapShot1.push_back({TS_MONOTONIC, tsMonotonicTime2}); 104 streamFilters_.clockFilter_->AddClockSnapshot(snapShot1); 105 uint64_t time2 = 200; 106 uint64_t expectTime2 = 200; 107 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time2, TS_CLOCK_REALTIME), expectTime2); 108 } 109 110 /** 111 * @tc.name: ConvertTimestampBoottimeToRealtime 112 * @tc.desc: convert Boottime to Realtime 113 * @tc.type: FUNC 114 */ 115 HWTEST_F(ClockFilterTest, ConvertTimestampBoottimeToRealtime, TestSize.Level1) 116 { 117 TS_LOGI("test3-4"); 118 uint64_t tsBoottime = 100; 119 uint64_t tsRealTime = 300; 120 std::vector<SnapShot> snapShot0; 121 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 122 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 123 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 124 125 std::vector<SnapShot> snapShot1; 126 uint64_t tsBoottime2 = 200; 127 uint64_t tsRealTime2 = 400; 128 snapShot1.push_back({TS_CLOCK_BOOTTIME, tsBoottime2}); 129 snapShot1.push_back({TS_CLOCK_REALTIME, tsRealTime2}); 130 streamFilters_.clockFilter_->AddClockSnapshot(snapShot1); 131 uint64_t time3 = 101; 132 uint64_t expectTime3 = 301; 133 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time3, TS_CLOCK_REALTIME), expectTime3); 134 } 135 136 /** 137 * @tc.name: ConvertBoottimeToRealtimeTwiceWithTwoSnapShot 138 * @tc.desc: convert Boottime to Realtime twice with two snapShot 139 * @tc.type: FUNC 140 */ 141 HWTEST_F(ClockFilterTest, ConvertBoottimeToRealtimeTwiceWithTwoSnapShot, TestSize.Level1) 142 { 143 TS_LOGI("test3-5"); 144 uint64_t tsBoottime = 100; 145 uint64_t tsRealTime = 300; 146 std::vector<SnapShot> snapShot0; 147 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 148 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 149 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 150 151 std::vector<SnapShot> snapShot1; 152 uint64_t tsBoottime2 = 200; 153 uint64_t tsRealTime2 = 400; 154 snapShot1.push_back({TS_CLOCK_BOOTTIME, tsBoottime2}); 155 snapShot1.push_back({TS_CLOCK_REALTIME, tsRealTime2}); 156 streamFilters_.clockFilter_->AddClockSnapshot(snapShot1); 157 uint64_t time3 = 101; 158 uint64_t expectTime3 = 301; 159 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time3, TS_CLOCK_REALTIME), expectTime3); 160 time3 = 201; 161 expectTime3 = 401; 162 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time3, TS_CLOCK_REALTIME), expectTime3); 163 } 164 165 /** 166 * @tc.name: ConvertBoottimeToRealtimeWithSingleSnapShot 167 * @tc.desc: convert Boottime to Realtime twice with single snapShot 168 * @tc.type: FUNC 169 */ 170 HWTEST_F(ClockFilterTest, ConvertBoottimeToRealtimeWithSingleSnapShot, TestSize.Level1) 171 { 172 TS_LOGI("test3-6"); 173 uint64_t tsBoottime = 100; 174 uint64_t tsRealTime = 300; 175 std::vector<SnapShot> snapShot0; 176 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 177 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 178 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 179 180 uint64_t time3 = 101; 181 uint64_t expectTime3 = 301; 182 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time3, TS_CLOCK_REALTIME), expectTime3); 183 time3 = 201; 184 expectTime3 = 401; 185 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time3, TS_CLOCK_REALTIME), expectTime3); 186 } 187 188 /** 189 * @tc.name: ConvertRealtimeToBoottime 190 * @tc.desc: convert Realtime to Boottime with single snapShot 191 * @tc.type: FUNC 192 */ 193 HWTEST_F(ClockFilterTest, ConvertRealtimeToBoottime, TestSize.Level1) 194 { 195 TS_LOGI("test3-7"); 196 uint64_t tsBoottime = 100; 197 uint64_t tsRealTime = 300; 198 std::vector<SnapShot> snapShot0; 199 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 200 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 201 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 202 uint64_t time7 = 301; 203 uint64_t expectTime7 = 101; 204 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_REALTIME, time7, TS_CLOCK_BOOTTIME), expectTime7); 205 } 206 207 /** 208 * @tc.name: ConvertRealtimeToBoottimeTwice 209 * @tc.desc: convert Realtime to Boottime twice with single snapShot 210 * @tc.type: FUNC 211 */ 212 HWTEST_F(ClockFilterTest, ConvertRealtimeToBoottimeTwice, TestSize.Level1) 213 { 214 TS_LOGI("test3-8"); 215 uint64_t tsBoottime = 100; 216 uint64_t tsRealTime = 300; 217 std::vector<SnapShot> snapShot0; 218 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 219 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 220 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 221 uint64_t time7 = 301; 222 uint64_t expectTime7 = 101; 223 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_REALTIME, time7, TS_CLOCK_BOOTTIME), expectTime7); 224 time7 = 501; 225 expectTime7 = 301; 226 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_REALTIME, time7, TS_CLOCK_BOOTTIME), expectTime7); 227 } 228 229 /** 230 * @tc.name: ConvertRealtimeToBoottimeTwiceWithTwoSnapshot 231 * @tc.desc: convert Realtime to Boottime twice with two snapShot 232 * @tc.type: FUNC 233 */ 234 HWTEST_F(ClockFilterTest, ConvertRealtimeToBoottimeTwiceWithTwoSnapshot, TestSize.Level1) 235 { 236 TS_LOGI("test3-9"); 237 uint64_t tsBoottime = 100; 238 uint64_t tsRealTime = 300; 239 std::vector<SnapShot> snapShot0; 240 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 241 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 242 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 243 244 std::vector<SnapShot> snapShot1; 245 uint64_t tsBoottime2 = 200; 246 uint64_t tsRealTime2 = 400; 247 snapShot1.push_back({TS_CLOCK_BOOTTIME, tsBoottime2}); 248 snapShot1.push_back({TS_CLOCK_REALTIME, tsRealTime2}); 249 streamFilters_.clockFilter_->AddClockSnapshot(snapShot1); 250 uint64_t time7 = 401; 251 uint64_t expectTime7 = 201; 252 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_REALTIME, time7, TS_CLOCK_BOOTTIME), expectTime7); 253 time7 = 301; 254 expectTime7 = 101; 255 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_REALTIME, time7, TS_CLOCK_BOOTTIME), expectTime7); 256 } 257 258 /** 259 * @tc.name: ConvertTimestamp 260 * @tc.desc: muti type timestamp convert 261 * @tc.type: FUNC 262 */ 263 HWTEST_F(ClockFilterTest, ConvertTimestamp, TestSize.Level1) 264 { 265 TS_LOGI("test3-10"); 266 uint64_t tsBoottime = 100; 267 uint64_t tsMonotonicTime = 200; 268 uint64_t tsRealTime = 300; 269 uint64_t tsRealTimeCoarseTime = 400; 270 std::vector<SnapShot> snapShot0; 271 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 272 snapShot0.push_back({TS_MONOTONIC, tsMonotonicTime}); 273 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 274 snapShot0.push_back({TS_CLOCK_REALTIME_COARSE, tsRealTimeCoarseTime}); 275 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 276 277 std::vector<SnapShot> snapShot1; 278 uint64_t tsBoottime2 = 200; 279 uint64_t tsMonotonicTime2 = 350; 280 uint64_t tsRealTime2 = 400; 281 uint64_t tsRealTimeCoarseTime2 = 800; 282 snapShot1.push_back({TS_CLOCK_BOOTTIME, tsBoottime2}); 283 snapShot1.push_back({TS_MONOTONIC, tsMonotonicTime2}); 284 snapShot1.push_back({TS_CLOCK_REALTIME, tsRealTime2}); 285 snapShot1.push_back({TS_CLOCK_REALTIME_COARSE, tsRealTimeCoarseTime2}); 286 streamFilters_.clockFilter_->AddClockSnapshot(snapShot1); 287 uint64_t time1 = 150; 288 uint64_t expectTime1 = 250; 289 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time1, TS_MONOTONIC), expectTime1); 290 uint64_t time2 = 200; 291 uint64_t expectTime2 = 350; 292 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time2, TS_MONOTONIC), expectTime2); 293 uint64_t time3 = 101; 294 uint64_t expectTime3 = 301; 295 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time3, TS_CLOCK_REALTIME), expectTime3); 296 uint64_t time4 = 102; 297 uint64_t expectTime4 = 402; 298 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_BOOTTIME, time4, TS_CLOCK_REALTIME_COARSE), expectTime4); 299 uint64_t time5 = 102; 300 uint64_t expectTime5 = 202; 301 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_MONOTONIC, time5, TS_CLOCK_REALTIME), expectTime5); 302 uint64_t time6 = 351; 303 uint64_t expectTime6 = 251; 304 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_REALTIME, time6, TS_MONOTONIC), expectTime6); 305 uint64_t time7 = 401; 306 uint64_t expectTime7 = 351; 307 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_CLOCK_REALTIME, time7, TS_MONOTONIC), expectTime7); 308 uint64_t time8 = 150; 309 uint64_t expectTime8 = 50; 310 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_MONOTONIC, time8, TS_CLOCK_BOOTTIME), expectTime8); 311 uint64_t time9 = 250; 312 uint64_t expectTime9 = 150; 313 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_MONOTONIC, time9, TS_CLOCK_BOOTTIME), expectTime9); 314 uint64_t time10 = 351; 315 uint64_t expectTime10 = 201; 316 EXPECT_EQ(streamFilters_.clockFilter_->Convert(TS_MONOTONIC, time10, TS_CLOCK_BOOTTIME), expectTime10); 317 } 318 319 /** 320 * @tc.name: ConvertToPrimary 321 * @tc.desc: set realtime as primary time type, and convert boottime to Primary time type 322 * @tc.type: FUNC 323 */ 324 HWTEST_F(ClockFilterTest, ConvertToPrimary, TestSize.Level1) 325 { 326 TS_LOGI("test3-11"); 327 std::vector<SnapShot> snapShot0; 328 uint64_t tsBoottime = 100; 329 uint64_t tsRealTime = 300; 330 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 331 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 332 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 333 334 std::vector<SnapShot> snapShot1; 335 uint64_t tsBoottime2 = 200; 336 uint64_t tsRealTime2 = 400; 337 snapShot1.push_back({TS_CLOCK_BOOTTIME, tsBoottime2}); 338 snapShot1.push_back({TS_CLOCK_REALTIME, tsRealTime2}); 339 streamFilters_.clockFilter_->AddClockSnapshot(snapShot1); 340 341 streamFilters_.clockFilter_->SetPrimaryClock(TS_CLOCK_REALTIME); 342 uint64_t time1 = 150; 343 uint64_t expectTime1 = 350; 344 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_BOOTTIME, time1), expectTime1); 345 } 346 347 /** 348 * @tc.name: ConvertToPrimaryTwice 349 * @tc.desc: set realtime as primary time type, and convert boottime to Primary time type twice 350 * @tc.type: FUNC 351 */ 352 HWTEST_F(ClockFilterTest, ConvertToPrimaryTwice, TestSize.Level1) 353 { 354 TS_LOGI("test3-12"); 355 std::vector<SnapShot> snapShot0; 356 uint64_t tsBoottime = 100; 357 uint64_t tsRealTime = 300; 358 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 359 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 360 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 361 362 std::vector<SnapShot> snapShot1; 363 uint64_t tsBoottime2 = 200; 364 uint64_t tsRealTime2 = 400; 365 snapShot1.push_back({TS_CLOCK_BOOTTIME, tsBoottime2}); 366 snapShot1.push_back({TS_CLOCK_REALTIME, tsRealTime2}); 367 streamFilters_.clockFilter_->AddClockSnapshot(snapShot1); 368 369 streamFilters_.clockFilter_->SetPrimaryClock(TS_CLOCK_BOOTTIME); 370 uint64_t time1 = 350; 371 uint64_t expectTime1 = 150; 372 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME, time1), expectTime1); 373 } 374 375 /** 376 * @tc.name: ConvertToPrimaryTimestampLessThanSnapShop 377 * @tc.desc: convert realtime to primary time type, and timestamp less than snapshop 378 * @tc.type: FUNC 379 */ 380 HWTEST_F(ClockFilterTest, ConvertToPrimaryTimestampLessThanSnapShop, TestSize.Level1) 381 { 382 TS_LOGI("test3-13"); 383 std::vector<SnapShot> snapShot0; 384 uint64_t tsBoottime = 100; 385 uint64_t tsRealTime = 300; 386 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 387 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 388 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 389 390 streamFilters_.clockFilter_->SetPrimaryClock(TS_CLOCK_BOOTTIME); 391 uint64_t time1 = 250; 392 uint64_t expectTime1 = 50; 393 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME, time1), expectTime1); 394 } 395 396 /** 397 * @tc.name: ConvertMonotonicTimeToPrimaryTwice 398 * @tc.desc: convert TS_MONOTONIC to primary time type with single snapshop 399 * @tc.type: FUNC 400 */ 401 HWTEST_F(ClockFilterTest, ConvertMonotonicTimeToPrimaryTwice, TestSize.Level1) 402 { 403 TS_LOGI("test3-14"); 404 std::vector<SnapShot> snapShot0; 405 uint64_t tsMonotonicTime = 200; 406 uint64_t tsRealTimeCoarseTime = 400; 407 snapShot0.push_back({TS_MONOTONIC, tsMonotonicTime}); 408 snapShot0.push_back({TS_CLOCK_REALTIME_COARSE, tsRealTimeCoarseTime}); 409 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 410 411 streamFilters_.clockFilter_->SetPrimaryClock(TS_CLOCK_REALTIME_COARSE); 412 uint64_t time1 = 250; 413 uint64_t expectTime1 = 450; 414 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_MONOTONIC, time1), expectTime1); 415 time1 = 550; 416 expectTime1 = 750; 417 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_MONOTONIC, time1), expectTime1); 418 } 419 420 /** 421 * @tc.name: ConvertToPrimaryTwiceWithTwoSnapshop 422 * @tc.desc: convert TS_MONOTONIC & TS_CLOCK_BOOTTIME to primary time type with two snapshop 423 * @tc.type: FUNC 424 */ 425 HWTEST_F(ClockFilterTest, ConvertToPrimaryTwiceWithTwoSnapshop, TestSize.Level1) 426 { 427 TS_LOGI("test3-15"); 428 std::vector<SnapShot> snapShot0; 429 uint64_t tsMonotonicTime = 200; 430 uint64_t tsRealTimeCoarseTime = 400; 431 snapShot0.push_back({TS_MONOTONIC, tsMonotonicTime}); 432 snapShot0.push_back({TS_CLOCK_REALTIME_COARSE, tsRealTimeCoarseTime}); 433 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 434 435 std::vector<SnapShot> snapShot1; 436 uint64_t tsBootTime2 = 350; 437 uint64_t tsRealTimeCoarseTime2 = 800; 438 snapShot1.push_back({TS_CLOCK_BOOTTIME, tsBootTime2}); 439 snapShot1.push_back({TS_CLOCK_REALTIME_COARSE, tsRealTimeCoarseTime2}); 440 streamFilters_.clockFilter_->AddClockSnapshot(snapShot1); 441 442 streamFilters_.clockFilter_->SetPrimaryClock(TS_CLOCK_REALTIME_COARSE); 443 444 uint64_t time1 = 250; 445 uint64_t expectTime1 = 450; 446 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_MONOTONIC, time1), expectTime1); 447 448 uint64_t time2 = 450; 449 uint64_t expectTime2 = 900; 450 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_BOOTTIME, time2), expectTime2); 451 } 452 453 /** 454 * @tc.name: MutiTimeTypeConvertWithMutiSnapshop 455 * @tc.desc: convert muti time type to primary time type with muti snapshop 456 * @tc.type: FUNC 457 */ 458 HWTEST_F(ClockFilterTest, MutiTimeTypeConvertWithMutiSnapshop, TestSize.Level1) 459 { 460 TS_LOGI("test3-16"); 461 std::vector<SnapShot> snapShot0; 462 uint64_t tsBoottime = 100; 463 uint64_t tsMonotonicTime = 200; 464 uint64_t tsRealTime = 300; 465 uint64_t tsRealTimeCoarseTime = 400; 466 snapShot0.push_back({TS_CLOCK_BOOTTIME, tsBoottime}); 467 snapShot0.push_back({TS_MONOTONIC, tsMonotonicTime}); 468 snapShot0.push_back({TS_CLOCK_REALTIME, tsRealTime}); 469 snapShot0.push_back({TS_CLOCK_REALTIME_COARSE, tsRealTimeCoarseTime}); 470 streamFilters_.clockFilter_->AddClockSnapshot(snapShot0); 471 472 std::vector<SnapShot> snapShot1; 473 uint64_t tsBoottime2 = 200; 474 uint64_t tsMonotonicTime2 = 350; 475 uint64_t tsRealTime2 = 400; 476 uint64_t tsRealTimeCoarseTime2 = 800; 477 snapShot1.push_back({TS_CLOCK_BOOTTIME, tsBoottime2}); 478 snapShot1.push_back({TS_MONOTONIC, tsMonotonicTime2}); 479 snapShot1.push_back({TS_CLOCK_REALTIME, tsRealTime2}); 480 snapShot1.push_back({TS_CLOCK_REALTIME_COARSE, tsRealTimeCoarseTime2}); 481 streamFilters_.clockFilter_->AddClockSnapshot(snapShot1); 482 483 streamFilters_.clockFilter_->SetPrimaryClock(TS_CLOCK_REALTIME); 484 uint64_t time1 = 150; 485 uint64_t expectTime1 = 350; 486 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_BOOTTIME, time1), expectTime1); 487 uint64_t time2 = 101; 488 uint64_t expectTime2 = 301; 489 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_BOOTTIME, time2), expectTime2); 490 uint64_t time3 = 101; 491 uint64_t expectTime3 = 101; 492 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME, time3), expectTime3); 493 uint64_t time4 = 351; 494 uint64_t expectTime4 = 351; 495 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME, time4), expectTime4); 496 uint64_t time5 = 350; 497 uint64_t expectTime5 = 250; 498 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME_COARSE, time5), expectTime5); 499 uint64_t time6 = 420; 500 uint64_t expectTime6 = 320; 501 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME_COARSE, time6), expectTime6); 502 uint64_t time7 = 801; 503 uint64_t expectTime7 = 401; 504 EXPECT_EQ(streamFilters_.clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME_COARSE, time7), expectTime7); 505 } 506 } // namespace TraceStreamer 507 } // namespace SysTuning 508