1 /* 2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. 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 <fcntl.h> 17 #include <hwext/gtest-ext.h> 18 #include <hwext/gtest-tag.h> 19 #include <string> 20 21 #define private public 22 #include "hidump_parser/pbreader_hidump_parser.h" 23 #include "hidump_plugin_result.pb.h" 24 #include "hidump_plugin_result.pbreader.h" 25 #include "parser/ptreader_parser/ptreader_parser.h" 26 #include "parser/common_types.h" 27 #include "trace_streamer_selector.h" 28 29 using namespace testing::ext; 30 using namespace SysTuning::TraceStreamer; 31 32 namespace SysTuning { 33 namespace TraceStreamer { 34 class HidumpParserTest : public ::testing::Test { 35 public: SetUp()36 void SetUp() 37 { 38 stream_.InitFilter(); 39 } 40 TearDown()41 void TearDown() 42 { 43 if (access(dbPath_.c_str(), F_OK) == 0) { 44 remove(dbPath_.c_str()); 45 } 46 } 47 48 public: 49 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 50 const std::string dbPath_ = "../../../data/resource/out.db"; 51 }; 52 53 /** 54 * @tc.name: ParseEmptyHidumpInfo 55 * @tc.desc: Parse an empty HidumpInfo 56 * @tc.type: FUNC 57 */ 58 HWTEST_F(HidumpParserTest, ParseEmptyHidumpInfo, TestSize.Level1) 59 { 60 TS_LOGI("test7-1"); 61 HidumpInfo hidumpInfo; 62 PbreaderHidumpParser htraceHidumpParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 63 std::string hidumpDatas = ""; 64 hidumpInfo.SerializeToString(&hidumpDatas); 65 ProtoReader::BytesView hidumpInfoData(reinterpret_cast<const uint8_t *>(hidumpDatas.data()), hidumpDatas.size()); 66 htraceHidumpParser.Parse(hidumpInfoData); 67 auto size = stream_.traceDataCache_->GetConstHidumpData().Size(); 68 EXPECT_EQ(0, size); 69 } 70 71 /** 72 * @tc.name: ParseLegalHidumpInfo 73 * @tc.desc: Parse a legal HidumpInfo 74 * @tc.type: FUNC 75 */ 76 HWTEST_F(HidumpParserTest, ParseLegalHidumpInfo, TestSize.Level1) 77 { 78 TS_LOGI("test7-2"); 79 const uint32_t FPS = 120; 80 const uint32_t TV_SEC = 16326755; 81 const uint32_t TV_NSEC = 39656070; 82 83 FpsData_TimeSpec timeSpec; 84 timeSpec.set_tv_nsec(TV_NSEC); 85 timeSpec.set_tv_sec(TV_SEC); 86 87 HidumpInfo *hidumpInfo = new HidumpInfo(); 88 auto fpsData = hidumpInfo->add_fps_event(); 89 fpsData->set_fps(FPS); 90 fpsData->set_allocated_time(&timeSpec); 91 92 PbreaderHidumpParser htraceHidumpParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 93 std::string hidumpDatas = ""; 94 hidumpInfo->SerializeToString(&hidumpDatas); 95 ProtoReader::BytesView hidumpInfoData(reinterpret_cast<const uint8_t *>(hidumpDatas.data()), hidumpDatas.size()); 96 htraceHidumpParser.Parse(hidumpInfoData); 97 98 auto Fps = stream_.traceDataCache_->GetConstHidumpData().Fpss()[0]; 99 EXPECT_EQ(FPS, Fps); 100 auto TimeSpec = stream_.traceDataCache_->GetConstHidumpData().TimeStampData()[0]; 101 EXPECT_EQ((TV_NSEC + TV_SEC * SEC_TO_NS), TimeSpec); 102 auto Size = stream_.traceDataCache_->GetConstHidumpData().Size(); 103 EXPECT_EQ(1, Size); 104 } 105 106 /** 107 * @tc.name: ParseMultipleReasonableHidumpInfo 108 * @tc.desc: parse multiple reasonable HidumpInfo 109 * @tc.type: FUNC 110 */ 111 HWTEST_F(HidumpParserTest, ParseMultipleReasonableHidumpInfo, TestSize.Level1) 112 { 113 TS_LOGI("test7-3"); 114 const uint32_t FPS_00 = 120; 115 const uint32_t TV_SEC_00 = 1632675525; 116 const uint32_t TV_NSEC_00 = 996560700; 117 FpsData_TimeSpec timeSpecFirst; 118 timeSpecFirst.set_tv_nsec(TV_NSEC_00); 119 timeSpecFirst.set_tv_sec(TV_SEC_00); 120 121 const uint32_t FPS_01 = 60; 122 const uint32_t TV_SEC_01 = 1632675525; 123 const uint32_t TV_NSEC_01 = 996560700; 124 FpsData_TimeSpec timeSpecSecond; 125 timeSpecSecond.set_tv_nsec(TV_NSEC_01); 126 timeSpecSecond.set_tv_sec(TV_SEC_01); 127 128 const uint32_t FPS_02 = 90; 129 const uint32_t TV_SEC_02 = 1632688888; 130 const uint32_t TV_NSEC_02 = 996588888; 131 FpsData_TimeSpec timeSpecThird; 132 timeSpecThird.set_tv_nsec(TV_NSEC_02); 133 timeSpecThird.set_tv_sec(TV_SEC_02); 134 135 HidumpInfo *hidumpInfo = new HidumpInfo(); 136 auto fpsDataFirst = hidumpInfo->add_fps_event(); 137 fpsDataFirst->set_fps(FPS_00); 138 fpsDataFirst->set_allocated_time(&timeSpecFirst); 139 140 auto fpsDataSecond = hidumpInfo->add_fps_event(); 141 fpsDataSecond->set_fps(FPS_01); 142 fpsDataSecond->set_allocated_time(&timeSpecSecond); 143 144 auto fpsDataThird = hidumpInfo->add_fps_event(); 145 fpsDataThird->set_fps(FPS_02); 146 fpsDataThird->set_allocated_time(&timeSpecThird); 147 148 PbreaderHidumpParser htraceHidumpParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 149 std::string hidumpDatas = ""; 150 hidumpInfo->SerializeToString(&hidumpDatas); 151 ProtoReader::BytesView hidumpInfoData(reinterpret_cast<const uint8_t *>(hidumpDatas.data()), hidumpDatas.size()); 152 htraceHidumpParser.Parse(hidumpInfoData); 153 154 auto Fps_00 = stream_.traceDataCache_->GetConstHidumpData().Fpss()[0]; 155 auto Fps_01 = stream_.traceDataCache_->GetConstHidumpData().Fpss()[1]; 156 auto Fps_02 = stream_.traceDataCache_->GetConstHidumpData().Fpss()[2]; 157 EXPECT_EQ(FPS_00, Fps_00); 158 EXPECT_EQ(FPS_01, Fps_01); 159 EXPECT_EQ(FPS_02, Fps_02); 160 161 auto TimeSpec_00 = stream_.traceDataCache_->GetConstHidumpData().TimeStampData()[0]; 162 auto TimeSpec_01 = stream_.traceDataCache_->GetConstHidumpData().TimeStampData()[1]; 163 auto TimeSpec_02 = stream_.traceDataCache_->GetConstHidumpData().TimeStampData()[2]; 164 EXPECT_EQ((TV_NSEC_00 + TV_SEC_00 * SEC_TO_NS), TimeSpec_00); 165 EXPECT_EQ((TV_NSEC_01 + TV_SEC_01 * SEC_TO_NS), TimeSpec_01); 166 EXPECT_EQ((TV_NSEC_02 + TV_SEC_02 * SEC_TO_NS), TimeSpec_02); 167 168 auto Size = stream_.traceDataCache_->GetConstHidumpData().Size(); 169 EXPECT_EQ(3, Size); 170 } 171 } // namespace TraceStreamer 172 } // namespace SysTuning 173