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 <hwext/gtest-ext.h> 17 #include <hwext/gtest-tag.h> 18 #include <fcntl.h> 19 #include <fstream> 20 #include <iostream> 21 #include <string> 22 #include <unistd.h> 23 24 #include "file.h" 25 #include "test.pb.h" 26 #include "test.pbreader.h" 27 #include "trace_streamer_selector.h" 28 29 class ProtoReader; 30 using namespace testing::ext; 31 using namespace SysTuning; 32 using namespace SysTuning::TraceStreamer; 33 using namespace SysTuning::ProtoReader; 34 namespace SysTuning { 35 namespace TraceStreamer { 36 const int32_t COUNT_01 = 100; 37 const int32_t NUMBER_01 = 100; 38 const uint64_t TV_NSEC_01 = 1000000; 39 const std::string NAME_01 = "1000"; 40 const int32_t ALLOC_EVENT_01 = 10000; 41 const int32_t NUMBER_02 = 200; 42 const uint64_t TV_NSEC_02 = 2000000; 43 const std::string NAME_02 = "2000"; 44 const std::string FREE_EVENT_02 = "20000"; 45 const int32_t ALLOC_EVENT_02 = 20000; 46 const int32_t NUMBER_03 = 300; 47 const uint64_t TV_NSEC_03 = 3000000; 48 const std::string NAME_03 = "3000"; 49 const int32_t ALLOC_EVENT_03 = 30000; 50 51 struct CoreTest { 52 int32_t number; 53 uint64_t tvNsec; 54 std::string name; 55 bool isTest; 56 ::Test_State state; 57 int32_t allocEvent; 58 std::string freeEvent; 59 }; 60 61 class ProtoReaderTest : public ::testing::Test { 62 protected: SetUpTestCase()63 static void SetUpTestCase() {} TearDownTestCase()64 static void TearDownTestCase() {} 65 AddCoreTest(::CpuInfoTest * cores,const CoreTest coreTest)66 void AddCoreTest(::CpuInfoTest *cores, const CoreTest coreTest) 67 { 68 auto test = cores->add_test(); 69 test->set_number(coreTest.number); 70 test->set_tv_nsec(coreTest.tvNsec); 71 test->set_name(coreTest.name); 72 test->set_is_test(coreTest.isTest); 73 test->set_state(coreTest.state); 74 if (coreTest.freeEvent == "") { 75 test->set_alloc_event(coreTest.allocEvent); 76 } else { 77 test->set_free_event(coreTest.freeEvent); 78 } 79 } 80 }; 81 /** 82 * @tc.name: ParserDataByPBReader 83 * @tc.desc: ParserData by pbreader 84 * @tc.type: FUNC 85 */ 86 HWTEST_F(ProtoReaderTest, ParserDataByPBReader, TestSize.Level1) 87 { 88 TS_LOGI("test33-1"); 89 TestParser testParser; 90 testParser.set_count(COUNT_01); 91 ::CpuInfoTest *cores = new ::CpuInfoTest(); 92 AddCoreTest(cores, {NUMBER_01, TV_NSEC_01, NAME_01, true, ::Test_State(0), ALLOC_EVENT_01, ""}); 93 testParser.set_allocated_cores(cores); 94 std::string str = ""; 95 testParser.SerializeToString(&str); 96 97 TestParser_Reader testParserReader(str); 98 EXPECT_EQ(COUNT_01, testParserReader.count()); 99 auto core = testParserReader.cores(); 100 CpuInfoTest_Reader cpuInfoTest(core.data_, core.size_); 101 102 auto itor = cpuInfoTest.test(); 103 Test_Reader cpuInfoReader1(itor->ToBytes()); 104 EXPECT_EQ(NUMBER_01, cpuInfoReader1.number()); 105 EXPECT_EQ(TV_NSEC_01, cpuInfoReader1.tv_nsec()); 106 EXPECT_EQ(NAME_01, cpuInfoReader1.name().ToStdString()); 107 EXPECT_TRUE(cpuInfoReader1.is_test()); 108 EXPECT_EQ(::Test_State(0), cpuInfoReader1.state()); 109 EXPECT_EQ(ALLOC_EVENT_01, cpuInfoReader1.alloc_event()); 110 } 111 112 /** 113 * @tc.name: ParserRepeatedDataByPBReader 114 * @tc.desc: ParserRepeatedData by pbreader 115 * @tc.type: FUNC 116 */ 117 HWTEST_F(ProtoReaderTest, ParserRepeatedDataByPBReader, TestSize.Level1) 118 { 119 TS_LOGI("test33-2"); 120 TestParser testParser; 121 std::string str = ""; 122 testParser.set_count(COUNT_01); 123 ::CpuInfoTest *cores = new ::CpuInfoTest(); 124 AddCoreTest(cores, {NUMBER_01, TV_NSEC_01, NAME_01, true, ::Test_State(0), ALLOC_EVENT_01, ""}); 125 AddCoreTest(cores, {NUMBER_02, TV_NSEC_02, NAME_02, false, ::Test_State(1), ALLOC_EVENT_02, ""}); 126 AddCoreTest(cores, {NUMBER_03, TV_NSEC_03, NAME_03, true, ::Test_State(0), ALLOC_EVENT_03, ""}); 127 testParser.set_allocated_cores(cores); 128 testParser.SerializeToString(&str); 129 130 TestParser_Reader testParserReader(str); 131 EXPECT_EQ(COUNT_01, testParserReader.count()); 132 auto core = testParserReader.cores(); 133 CpuInfoTest_Reader cpuInfoTest(core.data_, core.size_); 134 auto itor = cpuInfoTest.test(); 135 Test_Reader cpuInfoReader1(itor->ToBytes()); 136 EXPECT_EQ(NUMBER_01, cpuInfoReader1.number()); 137 EXPECT_EQ(TV_NSEC_01, cpuInfoReader1.tv_nsec()); 138 EXPECT_EQ(NAME_01, cpuInfoReader1.name().ToStdString()); 139 EXPECT_TRUE(cpuInfoReader1.is_test()); 140 EXPECT_EQ(::Test_State(0), cpuInfoReader1.state()); 141 EXPECT_EQ(ALLOC_EVENT_01, cpuInfoReader1.alloc_event()); 142 itor++; 143 Test_Reader cpuInfoReader2(itor->ToBytes()); 144 EXPECT_EQ(NUMBER_02, cpuInfoReader2.number()); 145 EXPECT_EQ(TV_NSEC_02, cpuInfoReader2.tv_nsec()); 146 EXPECT_EQ(NAME_02, cpuInfoReader2.name().ToStdString()); 147 EXPECT_FALSE(cpuInfoReader2.is_test()); 148 EXPECT_EQ(::Test_State(1), cpuInfoReader2.state()); 149 EXPECT_EQ(ALLOC_EVENT_02, cpuInfoReader2.alloc_event()); 150 itor++; 151 Test_Reader cpuInfoReader3(itor->ToBytes()); 152 EXPECT_EQ(NUMBER_03, cpuInfoReader3.number()); 153 EXPECT_EQ(TV_NSEC_03, cpuInfoReader3.tv_nsec()); 154 EXPECT_EQ(NAME_03, cpuInfoReader3.name().ToStdString()); 155 EXPECT_TRUE(cpuInfoReader3.is_test()); 156 EXPECT_EQ(::Test_State(0), cpuInfoReader3.state()); 157 EXPECT_EQ(ALLOC_EVENT_03, cpuInfoReader3.alloc_event()); 158 } 159 160 /** 161 * @tc.name: NoDataByPBReader 162 * @tc.desc: ParserNoData by pbreader 163 * @tc.type: FUNC 164 */ 165 HWTEST_F(ProtoReaderTest, NoDataByPBReader, TestSize.Level1) 166 { 167 TS_LOGI("test33-3"); 168 TestParser testParser; 169 std::string str = ""; 170 testParser.SerializeToString(&str); 171 172 TestParser_Reader testParserReader(str); 173 EXPECT_EQ(0, testParserReader.count()); 174 auto core = testParserReader.cores(); 175 CpuInfoTest_Reader cpuInfoTest(core.data_, core.size_); 176 177 auto itor = cpuInfoTest.test(); 178 Test_Reader cpuInfoReader1(itor->ToBytes()); 179 EXPECT_EQ(0, cpuInfoReader1.number()); 180 EXPECT_EQ(0, cpuInfoReader1.tv_nsec()); 181 EXPECT_EQ("", cpuInfoReader1.name().ToStdString()); 182 EXPECT_FALSE(cpuInfoReader1.is_test()); 183 EXPECT_EQ(::Test_State(0), cpuInfoReader1.state()); 184 EXPECT_EQ(0, cpuInfoReader1.alloc_event()); 185 } 186 187 /** 188 * @tc.name: ParserOneofForMutiDataByPBReader 189 * @tc.desc: ParserOneofForMutiData by pbreader 190 * @tc.type: FUNC 191 */ 192 HWTEST_F(ProtoReaderTest, ParserOneofForMutiDataByPBReader, TestSize.Level1) 193 { 194 TS_LOGI("test33-4"); 195 TestParser testParser; 196 std::string str = ""; 197 testParser.set_count(COUNT_01); 198 ::CpuInfoTest *cores = new ::CpuInfoTest(); 199 AddCoreTest(cores, {NUMBER_01, TV_NSEC_01, NAME_01, true, ::Test_State(0), ALLOC_EVENT_01, ""}); 200 AddCoreTest(cores, {NUMBER_02, TV_NSEC_02, NAME_02, false, ::Test_State(1), 0, FREE_EVENT_02}); 201 AddCoreTest(cores, {NUMBER_03, TV_NSEC_03, NAME_03, true, ::Test_State(0), ALLOC_EVENT_03, ""}); 202 testParser.set_allocated_cores(cores); 203 testParser.SerializeToString(&str); 204 205 TestParser_Reader testParserReader(str); 206 EXPECT_EQ(COUNT_01, testParserReader.count()); 207 auto core = testParserReader.cores(); 208 CpuInfoTest_Reader cpuInfoTest(core.data_, core.size_); 209 auto itor = cpuInfoTest.test(); 210 Test_Reader cpuInfoReader1(itor->ToBytes()); 211 EXPECT_EQ(NUMBER_01, cpuInfoReader1.number()); 212 EXPECT_EQ(TV_NSEC_01, cpuInfoReader1.tv_nsec()); 213 EXPECT_EQ(NAME_01, cpuInfoReader1.name().ToStdString()); 214 EXPECT_TRUE(cpuInfoReader1.is_test()); 215 EXPECT_EQ(::Test_State(0), cpuInfoReader1.state()); 216 EXPECT_EQ(ALLOC_EVENT_01, cpuInfoReader1.alloc_event()); 217 itor++; 218 Test_Reader cpuInfoReader2(itor->ToBytes()); 219 EXPECT_EQ(NUMBER_02, cpuInfoReader2.number()); 220 EXPECT_EQ(TV_NSEC_02, cpuInfoReader2.tv_nsec()); 221 EXPECT_EQ(NAME_02, cpuInfoReader2.name().ToStdString()); 222 EXPECT_FALSE(cpuInfoReader2.is_test()); 223 EXPECT_EQ(::Test_State(1), cpuInfoReader2.state()); 224 EXPECT_EQ(FREE_EVENT_02, cpuInfoReader2.free_event().ToStdString()); 225 itor++; 226 Test_Reader cpuInfoReader3(itor->ToBytes()); 227 EXPECT_EQ(NUMBER_03, cpuInfoReader3.number()); 228 EXPECT_EQ(TV_NSEC_03, cpuInfoReader3.tv_nsec()); 229 EXPECT_EQ(NAME_03, cpuInfoReader3.name().ToStdString()); 230 EXPECT_TRUE(cpuInfoReader3.is_test()); 231 EXPECT_EQ(::Test_State(0), cpuInfoReader3.state()); 232 EXPECT_EQ(ALLOC_EVENT_03, cpuInfoReader3.alloc_event()); 233 } 234 235 /** 236 * @tc.name: Parser One of Data For alloc event By PBReader 237 * @tc.desc: ParserOneofData by pbreader 238 * @tc.type: FUNC 239 */ 240 HWTEST_F(ProtoReaderTest, ParserOneofDataForAllocEventByPBReader, TestSize.Level1) 241 { 242 TS_LOGI("test33-5"); 243 TestParser testParser; 244 std::string str = ""; 245 testParser.set_count(COUNT_01); 246 ::CpuInfoTest *cores = new ::CpuInfoTest(); 247 AddCoreTest(cores, {NUMBER_01, TV_NSEC_01, NAME_01, true, ::Test_State(0), ALLOC_EVENT_01, ""}); 248 testParser.set_allocated_cores(cores); 249 testParser.SerializeToString(&str); 250 251 TestParser_Reader testParserReader(str); 252 EXPECT_EQ(COUNT_01, testParserReader.count()); 253 auto core = testParserReader.cores(); 254 CpuInfoTest_Reader cpuInfoTest(core.data_, core.size_); 255 auto itor = cpuInfoTest.test(); 256 Test_Reader cpuInfoReader1(itor->ToBytes()); 257 EXPECT_EQ(NUMBER_01, cpuInfoReader1.number()); 258 EXPECT_EQ(TV_NSEC_01, cpuInfoReader1.tv_nsec()); 259 EXPECT_EQ(NAME_01, cpuInfoReader1.name().ToStdString()); 260 EXPECT_TRUE(cpuInfoReader1.is_test()); 261 EXPECT_EQ(::Test_State(0), cpuInfoReader1.state()); 262 EXPECT_EQ(ALLOC_EVENT_01, cpuInfoReader1.alloc_event()); 263 } 264 265 /** 266 * @tc.name: Parser One of Data For Free event By PBReader 267 * @tc.desc: ParserOneofData by pbreader 268 * @tc.type: FUNC 269 */ 270 HWTEST_F(ProtoReaderTest, ParserOneofDataForFreeEventByPBReader, TestSize.Level1) 271 { 272 TS_LOGI("test33-6"); 273 TestParser testParser; 274 std::string str = ""; 275 testParser.set_count(COUNT_01); 276 ::CpuInfoTest *cores = new ::CpuInfoTest(); 277 AddCoreTest(cores, {NUMBER_01, TV_NSEC_01, NAME_01, true, ::Test_State(0), ALLOC_EVENT_01, ""}); 278 testParser.set_allocated_cores(cores); 279 testParser.SerializeToString(&str); 280 281 TestParser_Reader testParserReader(str); 282 EXPECT_EQ(COUNT_01, testParserReader.count()); 283 auto core = testParserReader.cores(); 284 CpuInfoTest_Reader cpuInfoTest(core.data_, core.size_); 285 auto itor = cpuInfoTest.test(); 286 Test_Reader cpuInfoReader1(itor->ToBytes()); 287 EXPECT_EQ(NUMBER_01, cpuInfoReader1.number()); 288 EXPECT_EQ(TV_NSEC_01, cpuInfoReader1.tv_nsec()); 289 EXPECT_EQ(NAME_01, cpuInfoReader1.name().ToStdString()); 290 EXPECT_TRUE(cpuInfoReader1.is_test()); 291 EXPECT_EQ(::Test_State(0), cpuInfoReader1.state()); 292 EXPECT_EQ(ALLOC_EVENT_01, cpuInfoReader1.alloc_event()); 293 } 294 295 /** 296 * @tc.name: ParserNoDataByVarInt 297 * @tc.desc: ParserNoData by VarInt 298 * @tc.type: FUNC 299 */ 300 HWTEST_F(ProtoReaderTest, ParserNoDataByVarInt, TestSize.Level1) 301 { 302 TS_LOGI("test33-7"); 303 TestParser testParser; 304 std::string str = ""; 305 testParser.SerializeToString(&str); 306 307 auto kCountFieldNumber = TestParser_Reader::kCountDataAreaNumber; 308 uint64_t count = 0; 309 auto tsTag = CreateTagVarInt(kCountFieldNumber); 310 if (str.size() > 10 && str.data()[0] == tsTag) { 311 const uint8_t *nextData = VarIntDecode(reinterpret_cast<const uint8_t *>(str.data() + 1), 312 reinterpret_cast<const uint8_t *>(str.data() + 11), &count); 313 } 314 EXPECT_EQ(0, count); 315 } 316 317 /** 318 * @tc.name: ParserDataByVarInt 319 * @tc.desc: ParserData by VarInt 320 * @tc.type: FUNC 321 */ 322 HWTEST_F(ProtoReaderTest, ParserDataByVarInt, TestSize.Level1) 323 { 324 TS_LOGI("test33-8"); 325 TestParser testParser; 326 testParser.set_count(COUNT_01); 327 ::CpuInfoTest *cores = new ::CpuInfoTest(); 328 AddCoreTest(cores, {NUMBER_01, TV_NSEC_01, NAME_01, true, ::Test_State(0), ALLOC_EVENT_01, ""}); 329 testParser.set_allocated_cores(cores); 330 std::string str = ""; 331 testParser.SerializeToString(&str); 332 333 auto kCountFieldNumber = TestParser_Reader::kCountDataAreaNumber; 334 uint64_t count2 = 0; 335 auto tsTag = CreateTagVarInt(kCountFieldNumber); 336 if (str.size() > 10 && str.data()[0] == tsTag) { 337 const uint8_t *nextData = VarIntDecode(reinterpret_cast<const uint8_t *>(str.data() + 1), 338 reinterpret_cast<const uint8_t *>(str.data() + 11), &count2); 339 } 340 EXPECT_EQ(COUNT_01, count2); 341 } 342 343 /** 344 * @tc.name: ParserDataByPBReaderBase 345 * @tc.desc: ParserData by pbreader Base 346 * @tc.type: FUNC 347 */ 348 HWTEST_F(ProtoReaderTest, ParserDataByPBReaderBase, TestSize.Level1) 349 { 350 TS_LOGI("test33-9"); 351 TestParser testParser; 352 testParser.set_count(COUNT_01); 353 ::CpuInfoTest *cores = new ::CpuInfoTest(); 354 AddCoreTest(cores, {NUMBER_01, TV_NSEC_01, NAME_01, true, ::Test_State(0), ALLOC_EVENT_01, ""}); 355 testParser.set_allocated_cores(cores); 356 std::string str = ""; 357 testParser.SerializeToString(&str); 358 359 TypedProtoReader<2> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 360 EXPECT_EQ(typedProtoTest.FindDataArea(TestParser_Reader::kCountDataAreaNumber).ToInt32(), COUNT_01); 361 auto core = typedProtoTest.FindDataArea(TestParser_Reader::kCoresDataAreaNumber).ToBytes(); 362 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(core.data_), core.size_); 363 auto typtest = typedProtoCpuInfoTest.FindDataArea(CpuInfoTest_Reader::kTestDataAreaNumber).ToBytes(); 364 TypedProtoReader<7> typedProtoTestReader(reinterpret_cast<const uint8_t *>(typtest.data_), typtest.size_); 365 EXPECT_EQ(typedProtoTestReader.FindDataArea(Test_Reader::kNumberDataAreaNumber).ToInt32(), NUMBER_01); 366 EXPECT_EQ(typedProtoTestReader.FindDataArea(Test_Reader::kTvNsecDataAreaNumber).ToUint64(), TV_NSEC_01); 367 EXPECT_EQ(typedProtoTestReader.FindDataArea(Test_Reader::kNameDataAreaNumber).ToStdString(), NAME_01); 368 EXPECT_TRUE(typedProtoTestReader.FindDataArea(Test_Reader::kIsTestDataAreaNumber).ToBool()); 369 EXPECT_EQ(::Test_State(0), typedProtoTestReader.FindDataArea(Test_Reader::kStateDataAreaNumber).ToInt32()); 370 EXPECT_EQ(ALLOC_EVENT_01, typedProtoTestReader.FindDataArea(Test_Reader::kAllocEventDataAreaNumber).ToInt32()); 371 } 372 373 /** 374 * @tc.name: ParserMutiDataByPBReaderBase 375 * @tc.desc: ParserMutiData by pbreader Base 376 * @tc.type: FUNC 377 */ 378 HWTEST_F(ProtoReaderTest, ParserMutiDataByPBReaderBase, TestSize.Level1) 379 { 380 TS_LOGI("test33-10"); 381 TestParser testParser; 382 std::string str = ""; 383 testParser.set_count(COUNT_01); 384 ::CpuInfoTest *cores = new ::CpuInfoTest(); 385 AddCoreTest(cores, {NUMBER_01, TV_NSEC_01, NAME_01, true, ::Test_State(0), ALLOC_EVENT_01, ""}); 386 AddCoreTest(cores, {NUMBER_02, TV_NSEC_02, NAME_02, false, ::Test_State(1), ALLOC_EVENT_02, ""}); 387 AddCoreTest(cores, {NUMBER_03, TV_NSEC_03, NAME_03, true, ::Test_State(0), ALLOC_EVENT_03, ""}); 388 testParser.set_allocated_cores(cores); 389 testParser.SerializeToString(&str); 390 391 TypedProtoReader<2> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 392 EXPECT_EQ(typedProtoTest.FindDataArea(TestParser_Reader::kCountDataAreaNumber).ToInt32(), COUNT_01); 393 auto core = typedProtoTest.FindDataArea(TestParser_Reader::kCoresDataAreaNumber).ToBytes(); 394 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(core.data_), core.size_); 395 auto repeate = typedProtoCpuInfoTest.GetRepeated<BytesView>(CpuInfoTest_Reader::kTestDataAreaNumber); 396 397 TypedProtoReader<7> typedProtoTestReader1(repeate->ToBytes().data_, repeate->ToBytes().size_); 398 EXPECT_EQ(NUMBER_01, typedProtoTestReader1.FindDataArea(Test_Reader::kNumberDataAreaNumber).ToInt32()); 399 EXPECT_EQ(TV_NSEC_01, typedProtoTestReader1.FindDataArea(Test_Reader::kTvNsecDataAreaNumber).ToUint64()); 400 EXPECT_EQ(NAME_01, typedProtoTestReader1.FindDataArea(Test_Reader::kNameDataAreaNumber).ToStdString()); 401 EXPECT_TRUE(typedProtoTestReader1.FindDataArea(Test_Reader::kIsTestDataAreaNumber).ToBool()); 402 EXPECT_EQ(::Test_State(0), typedProtoTestReader1.FindDataArea(Test_Reader::kStateDataAreaNumber).ToInt32()); 403 EXPECT_EQ(ALLOC_EVENT_01, typedProtoTestReader1.FindDataArea(Test_Reader::kAllocEventDataAreaNumber).ToInt32()); 404 405 repeate++; 406 TypedProtoReader<7> typedProtoTestReader2(repeate->ToBytes().data_, repeate->ToBytes().size_); 407 EXPECT_EQ(NUMBER_02, typedProtoTestReader2.FindDataArea(Test_Reader::kNumberDataAreaNumber).ToInt32()); 408 EXPECT_EQ(TV_NSEC_02, typedProtoTestReader2.FindDataArea(Test_Reader::kTvNsecDataAreaNumber).ToUint64()); 409 EXPECT_EQ(NAME_02, typedProtoTestReader2.FindDataArea(Test_Reader::kNameDataAreaNumber).ToStdString()); 410 EXPECT_FALSE(typedProtoTestReader2.FindDataArea(Test_Reader::kIsTestDataAreaNumber).ToBool()); 411 EXPECT_EQ(::Test_State(1), typedProtoTestReader2.FindDataArea(Test_Reader::kStateDataAreaNumber).ToInt32()); 412 EXPECT_EQ(ALLOC_EVENT_02, typedProtoTestReader2.FindDataArea(Test_Reader::kAllocEventDataAreaNumber).ToInt32()); 413 414 repeate++; 415 TypedProtoReader<7> typedProtoTestReader3(repeate->ToBytes().data_, repeate->ToBytes().size_); 416 EXPECT_EQ(NUMBER_03, typedProtoTestReader3.FindDataArea(Test_Reader::kNumberDataAreaNumber).ToInt32()); 417 EXPECT_EQ(TV_NSEC_03, typedProtoTestReader3.FindDataArea(Test_Reader::kTvNsecDataAreaNumber).ToUint64()); 418 EXPECT_EQ(NAME_03, typedProtoTestReader3.FindDataArea(Test_Reader::kNameDataAreaNumber).ToStdString()); 419 EXPECT_TRUE(typedProtoTestReader3.FindDataArea(Test_Reader::kIsTestDataAreaNumber).ToBool()); 420 EXPECT_EQ(::Test_State(0), typedProtoTestReader3.FindDataArea(Test_Reader::kStateDataAreaNumber).ToInt32()); 421 EXPECT_EQ(ALLOC_EVENT_03, typedProtoTestReader3.FindDataArea(Test_Reader::kAllocEventDataAreaNumber).ToInt32()); 422 } 423 424 /** 425 * @tc.name: ParserNoDataByPBReaderBase 426 * @tc.desc: ParserNoData by pbreader Base 427 * @tc.type: FUNC 428 */ 429 HWTEST_F(ProtoReaderTest, ParserNoDataByPBReaderBase, TestSize.Level1) 430 { 431 TS_LOGI("test33-11"); 432 TestParser testParser; 433 std::string str = ""; 434 testParser.SerializeToString(&str); 435 436 TypedProtoReader<2> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 437 EXPECT_EQ(0, typedProtoTest.FindDataArea(TestParser_Reader::kCountDataAreaNumber).ToInt32()); 438 auto core = typedProtoTest.FindDataArea(TestParser_Reader::kCoresDataAreaNumber).ToBytes(); 439 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(core.data_), core.size_); 440 auto typtest = typedProtoCpuInfoTest.FindDataArea(CpuInfoTest_Reader::kTestDataAreaNumber).ToBytes(); 441 TypedProtoReader<7> typedProtoTestReader(reinterpret_cast<const uint8_t *>(typtest.data_), typtest.size_); 442 EXPECT_EQ(0, typedProtoTestReader.FindDataArea(Test_Reader::kNumberDataAreaNumber).ToInt32()); 443 EXPECT_EQ(0, typedProtoTestReader.FindDataArea(Test_Reader::kTvNsecDataAreaNumber).ToUint64()); 444 EXPECT_EQ("", typedProtoTestReader.FindDataArea(Test_Reader::kNameDataAreaNumber).ToStdString()); 445 EXPECT_FALSE(typedProtoTestReader.FindDataArea(Test_Reader::kIsTestDataAreaNumber).ToBool()); 446 EXPECT_EQ(::Test_State(0), typedProtoTestReader.FindDataArea(Test_Reader::kStateDataAreaNumber).ToInt32()); 447 EXPECT_EQ(0, typedProtoTestReader.FindDataArea(Test_Reader::kAllocEventDataAreaNumber).ToInt32()); 448 } 449 450 /** 451 * @tc.name: ParserDataByGet 452 * @tc.desc: ParserData by Get 453 * @tc.type: FUNC 454 */ 455 HWTEST_F(ProtoReaderTest, ParserDataByGet, TestSize.Level1) 456 { 457 TS_LOGI("test33-12"); 458 TestParser testParser; 459 testParser.set_count(COUNT_01); 460 ::CpuInfoTest *cores = new ::CpuInfoTest(); 461 AddCoreTest(cores, {NUMBER_01, TV_NSEC_01, NAME_01, true, ::Test_State(0), ALLOC_EVENT_01, ""}); 462 testParser.set_allocated_cores(cores); 463 std::string str = ""; 464 testParser.SerializeToString(&str); 465 466 TypedProtoReader<2> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 467 EXPECT_EQ(COUNT_01, typedProtoTest.Get(TestParser_Reader::kCountDataAreaNumber).ToInt32()); 468 auto core = typedProtoTest.Get(TestParser_Reader::kCoresDataAreaNumber).ToBytes(); 469 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(core.data_), core.size_); 470 auto typtest = typedProtoCpuInfoTest.Get(CpuInfoTest_Reader::kTestDataAreaNumber).ToBytes(); 471 TypedProtoReader<7> typedProtoTestReader(reinterpret_cast<const uint8_t *>(typtest.data_), typtest.size_); 472 EXPECT_EQ(NUMBER_01, typedProtoTestReader.Get(Test_Reader::kNumberDataAreaNumber).ToInt32()); 473 EXPECT_EQ(TV_NSEC_01, typedProtoTestReader.Get(Test_Reader::kTvNsecDataAreaNumber).ToUint64()); 474 EXPECT_EQ(NAME_01, typedProtoTestReader.Get(Test_Reader::kNameDataAreaNumber).ToStdString()); 475 EXPECT_TRUE(typedProtoTestReader.Get(Test_Reader::kIsTestDataAreaNumber).ToBool()); 476 EXPECT_EQ(::Test_State(0), typedProtoTestReader.Get(Test_Reader::kStateDataAreaNumber).ToInt32()); 477 EXPECT_EQ(ALLOC_EVENT_01, typedProtoTestReader.Get(Test_Reader::kAllocEventDataAreaNumber).ToInt32()); 478 } 479 480 /** 481 * @tc.name: ParserMutiDataByGet 482 * @tc.desc: ParserMutiData by Get 483 * @tc.type: FUNC 484 */ 485 HWTEST_F(ProtoReaderTest, ParserMutiDataByGet, TestSize.Level1) 486 { 487 TS_LOGI("test33-13"); 488 TestParser testParser; 489 std::string str = ""; 490 testParser.set_count(COUNT_01); 491 ::CpuInfoTest *cores = new ::CpuInfoTest(); 492 AddCoreTest(cores, {NUMBER_01, TV_NSEC_01, NAME_01, true, ::Test_State(0), ALLOC_EVENT_01, ""}); 493 AddCoreTest(cores, {NUMBER_02, TV_NSEC_02, NAME_02, false, ::Test_State(1), ALLOC_EVENT_02, ""}); 494 AddCoreTest(cores, {NUMBER_03, TV_NSEC_03, NAME_03, true, ::Test_State(0), ALLOC_EVENT_03, ""}); 495 testParser.set_allocated_cores(cores); 496 testParser.SerializeToString(&str); 497 498 TypedProtoReader<2> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 499 EXPECT_EQ(COUNT_01, typedProtoTest.Get(TestParser_Reader::kCountDataAreaNumber).ToInt32()); 500 auto core = typedProtoTest.Get(TestParser_Reader::kCoresDataAreaNumber).ToBytes(); 501 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(core.data_), core.size_); 502 auto repeate = typedProtoCpuInfoTest.GetRepeated<BytesView>(CpuInfoTest_Reader::kTestDataAreaNumber); 503 504 TypedProtoReader<7> typedProtoTestReader1(repeate->ToBytes().data_, repeate->ToBytes().size_); 505 EXPECT_EQ(NUMBER_01, typedProtoTestReader1.Get(Test_Reader::kNumberDataAreaNumber).ToInt32()); 506 EXPECT_EQ(TV_NSEC_01, typedProtoTestReader1.Get(Test_Reader::kTvNsecDataAreaNumber).ToUint64()); 507 EXPECT_EQ(NAME_01, typedProtoTestReader1.Get(Test_Reader::kNameDataAreaNumber).ToStdString()); 508 EXPECT_TRUE(typedProtoTestReader1.Get(Test_Reader::kIsTestDataAreaNumber).ToBool()); 509 EXPECT_EQ(::Test_State(0), typedProtoTestReader1.Get(Test_Reader::kStateDataAreaNumber).ToInt32()); 510 EXPECT_EQ(ALLOC_EVENT_01, typedProtoTestReader1.Get(Test_Reader::kAllocEventDataAreaNumber).ToInt32()); 511 512 repeate++; 513 TypedProtoReader<7> typedProtoTestReader2(repeate->ToBytes().data_, repeate->ToBytes().size_); 514 EXPECT_EQ(NUMBER_02, typedProtoTestReader2.Get(Test_Reader::kNumberDataAreaNumber).ToInt32()); 515 EXPECT_EQ(TV_NSEC_02, typedProtoTestReader2.Get(Test_Reader::kTvNsecDataAreaNumber).ToUint64()); 516 EXPECT_EQ(NAME_02, typedProtoTestReader2.Get(Test_Reader::kNameDataAreaNumber).ToStdString()); 517 EXPECT_FALSE(typedProtoTestReader2.Get(Test_Reader::kIsTestDataAreaNumber).ToBool()); 518 EXPECT_EQ(::Test_State(1), typedProtoTestReader2.Get(Test_Reader::kStateDataAreaNumber).ToInt32()); 519 EXPECT_EQ(ALLOC_EVENT_02, typedProtoTestReader2.Get(Test_Reader::kAllocEventDataAreaNumber).ToInt32()); 520 521 repeate++; 522 TypedProtoReader<7> typedProtoTestReader3(repeate->ToBytes().data_, repeate->ToBytes().size_); 523 EXPECT_EQ(NUMBER_03, typedProtoTestReader3.Get(Test_Reader::kNumberDataAreaNumber).ToInt32()); 524 EXPECT_EQ(TV_NSEC_03, typedProtoTestReader3.Get(Test_Reader::kTvNsecDataAreaNumber).ToUint64()); 525 EXPECT_EQ(NAME_03, typedProtoTestReader3.Get(Test_Reader::kNameDataAreaNumber).ToStdString()); 526 EXPECT_TRUE(typedProtoTestReader3.Get(Test_Reader::kIsTestDataAreaNumber).ToBool()); 527 EXPECT_EQ(::Test_State(0), typedProtoTestReader3.Get(Test_Reader::kStateDataAreaNumber).ToInt32()); 528 EXPECT_EQ(ALLOC_EVENT_03, typedProtoTestReader3.Get(Test_Reader::kAllocEventDataAreaNumber).ToInt32()); 529 } 530 531 /** 532 * @tc.name: ParserNoDataByGet 533 * @tc.desc: ParserNoData by Get 534 * @tc.type: FUNC 535 */ 536 HWTEST_F(ProtoReaderTest, ParserNoDataByGet, TestSize.Level1) 537 { 538 TS_LOGI("test33-14"); 539 TestParser testParser; 540 std::string str = ""; 541 testParser.SerializeToString(&str); 542 543 TypedProtoReader<2> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 544 EXPECT_EQ(0, typedProtoTest.Get(TestParser_Reader::kCountDataAreaNumber).ToInt32()); 545 auto core = typedProtoTest.Get(TestParser_Reader::kCoresDataAreaNumber).ToBytes(); 546 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(core.data_), core.size_); 547 auto typtest = typedProtoCpuInfoTest.Get(CpuInfoTest_Reader::kTestDataAreaNumber).ToBytes(); 548 TypedProtoReader<7> typedProtoTestReader(reinterpret_cast<const uint8_t *>(typtest.data_), typtest.size_); 549 EXPECT_EQ(0, typedProtoTestReader.Get(Test_Reader::kNumberDataAreaNumber).ToInt32()); 550 EXPECT_EQ(0, typedProtoTestReader.Get(Test_Reader::kTvNsecDataAreaNumber).ToUint64()); 551 EXPECT_EQ("", typedProtoTestReader.Get(Test_Reader::kNameDataAreaNumber).ToStdString()); 552 EXPECT_FALSE(typedProtoTestReader.Get(Test_Reader::kIsTestDataAreaNumber).ToBool()); 553 EXPECT_EQ(::Test_State(0), typedProtoTestReader.Get(Test_Reader::kStateDataAreaNumber).ToInt32()); 554 EXPECT_EQ(0, typedProtoTestReader.Get(Test_Reader::kAllocEventDataAreaNumber).ToInt32()); 555 } 556 557 /** 558 * @tc.name: ParserPackedRepeatedInt32DataByPBReader 559 * @tc.desc: ParserPackedRepeatedInt32Data by pbreader 560 * @tc.type: FUNC 561 */ 562 HWTEST_F(ProtoReaderTest, ParserPackedRepeatedInt32DataByPBReader, TestSize.Level1) 563 { 564 TS_LOGI("test33-15"); 565 TestParser testParser; 566 const int32_t number = 1000; 567 const int32_t number1 = 1001; 568 const int32_t nameber2 = 1002; 569 const int32_t number3 = 1003; 570 std::string str = ""; 571 testParser.set_count(COUNT_01); 572 ::NumberTest *numberTest = new ::NumberTest(); 573 numberTest->add_numbertext(number); 574 numberTest->add_numbertext(number1); 575 numberTest->add_numbertext(nameber2); 576 numberTest->add_numbertext(number3); 577 testParser.set_allocated_numbertest(numberTest); 578 testParser.SerializeToString(&str); 579 bool parserError = true; 580 581 TypedProtoReader<3> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 582 EXPECT_EQ(typedProtoTest.Get(TestParser_Reader::kCountDataAreaNumber).ToInt32(), COUNT_01); 583 auto numberType = typedProtoTest.Get(TestParser_Reader::kNumberTestDataAreaNumber).ToBytes(); 584 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(numberType.data_), numberType.size_); 585 auto packedRepeate = typedProtoCpuInfoTest.GetPackedRepeated<ProtoWireType::kVarInt, int32_t>( 586 NumberTest_Reader::kNumberTextDataAreaNumber, &parserError); 587 EXPECT_EQ(number, *packedRepeate++); 588 EXPECT_EQ(number1, *packedRepeate++); 589 EXPECT_EQ(nameber2, *packedRepeate++); 590 EXPECT_EQ(number3, *packedRepeate); 591 } 592 593 /** 594 * @tc.name: ParserPackedRepeatedFixed64DataByPBReader 595 * @tc.desc: ParserPackedRepeatedFixed64Data by pbreader 596 * @tc.type: FUNC 597 */ 598 HWTEST_F(ProtoReaderTest, ParserPackedRepeatedFixed64DataByPBReader, TestSize.Level1) 599 { 600 TS_LOGI("test33-16"); 601 TestParser testParser; 602 const double number = 1000.01; 603 const double number1 = 1001.01; 604 const double nameber2 = 1002.01; 605 const double number3 = 1003.01; 606 std::string str = ""; 607 testParser.set_count(COUNT_01); 608 ::Fixed64Test *fixed64Test = new ::Fixed64Test(); 609 fixed64Test->add_fixed64numbertext(number); 610 fixed64Test->add_fixed64numbertext(number1); 611 fixed64Test->add_fixed64numbertext(nameber2); 612 fixed64Test->add_fixed64numbertext(number3); 613 testParser.set_allocated_fixed64test(fixed64Test); 614 testParser.SerializeToString(&str); 615 bool parserError = true; 616 617 TypedProtoReader<5> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 618 EXPECT_EQ(COUNT_01, typedProtoTest.Get(TestParser_Reader::kCountDataAreaNumber).ToInt32()); 619 auto fix64Type = typedProtoTest.Get(TestParser_Reader::kFixed64TestDataAreaNumber).ToBytes(); 620 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(fix64Type.data_), fix64Type.size_); 621 auto packedRepeate = typedProtoCpuInfoTest.GetPackedRepeated<ProtoWireType::kFixed64, double>( 622 Fixed64Test_Reader::kFixed64NumberTextDataAreaNumber, &parserError); 623 EXPECT_EQ(number, *packedRepeate++); 624 EXPECT_EQ(number1, *packedRepeate++); 625 EXPECT_EQ(nameber2, *packedRepeate++); 626 EXPECT_EQ(number3, *packedRepeate); 627 } 628 629 /** 630 * @tc.name: ParserPackedRepeatedFixed32DataByPBReader 631 * @tc.desc: ParserPackedRepeatedFixed32Data by pbreader 632 * @tc.type: FUNC 633 */ 634 HWTEST_F(ProtoReaderTest, ParserPackedRepeatedFixed32DataByPBReader, TestSize.Level1) 635 { 636 TS_LOGI("test33-17"); 637 TestParser testParser; 638 const float number = 1000.01; 639 const float number1 = 1001.01; 640 const float nameber2 = 1002.01; 641 const float number3 = 1003.01; 642 std::string str = ""; 643 testParser.set_count(COUNT_01); 644 ::Fixed32Test *fixed32Test = new ::Fixed32Test(); 645 fixed32Test->add_fixed32numbertext(number); 646 fixed32Test->add_fixed32numbertext(number1); 647 fixed32Test->add_fixed32numbertext(nameber2); 648 fixed32Test->add_fixed32numbertext(number3); 649 testParser.set_allocated_fixed32test(fixed32Test); 650 testParser.SerializeToString(&str); 651 bool parserError = true; 652 653 TypedProtoReader<5> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 654 EXPECT_EQ(typedProtoTest.Get(TestParser_Reader::kCountDataAreaNumber).ToInt32(), COUNT_01); 655 auto fix32Type = typedProtoTest.Get(TestParser_Reader::kFixed32TestDataAreaNumber).ToBytes(); 656 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(fix32Type.data_), fix32Type.size_); 657 auto packedRepeate = typedProtoCpuInfoTest.GetPackedRepeated<ProtoWireType::kFixed32, float>( 658 Fixed32Test_Reader::kFixed32NumberTextDataAreaNumber, &parserError); 659 EXPECT_EQ(number, *packedRepeate++); 660 EXPECT_EQ(number1, *packedRepeate++); 661 EXPECT_EQ(nameber2, *packedRepeate++); 662 EXPECT_EQ(number3, *packedRepeate); 663 } 664 665 /** 666 * @tc.name: ParserPackedRepeatedInt32OneDataByPBReader 667 * @tc.desc: ParserPackedRepeatedInt32 with one set of Data by pbreader 668 * @tc.type: FUNC 669 */ 670 HWTEST_F(ProtoReaderTest, ParserPackedRepeatedInt32OneDataByPBReader, TestSize.Level1) 671 { 672 TS_LOGI("test33-18"); 673 TestParser testParser; 674 const int32_t number = 1000; 675 std::string str = ""; 676 testParser.set_count(COUNT_01); 677 ::NumberTest *numberTest = new ::NumberTest(); 678 numberTest->add_numbertext(number); 679 testParser.set_allocated_numbertest(numberTest); 680 testParser.SerializeToString(&str); 681 bool parserError = true; 682 683 TypedProtoReader<3> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 684 EXPECT_EQ(typedProtoTest.Get(TestParser_Reader::kCountDataAreaNumber).ToInt32(), COUNT_01); 685 auto numberType = typedProtoTest.Get(TestParser_Reader::kNumberTestDataAreaNumber).ToBytes(); 686 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(numberType.data_), numberType.size_); 687 auto packedRepeate = typedProtoCpuInfoTest.GetPackedRepeated<ProtoWireType::kVarInt, int32_t>( 688 NumberTest_Reader::kNumberTextDataAreaNumber, &parserError); 689 EXPECT_EQ(number, *packedRepeate); 690 } 691 692 /** 693 * @tc.name: ParserPackedRepeatedFixed64OneDataByPBReader 694 * @tc.desc: ParserPackedRepeatedFixed64 with one set of Data by pbreader 695 * @tc.type: FUNC 696 */ 697 HWTEST_F(ProtoReaderTest, ParserPackedRepeatedFixed64OneDataByPBReader, TestSize.Level1) 698 { 699 TS_LOGI("test33-19"); 700 TestParser testParser; 701 const double number = 1000.01; 702 std::string str = ""; 703 testParser.set_count(COUNT_01); 704 ::Fixed64Test *fixed64Test = new ::Fixed64Test(); 705 fixed64Test->add_fixed64numbertext(number); 706 testParser.set_allocated_fixed64test(fixed64Test); 707 testParser.SerializeToString(&str); 708 bool parserError = true; 709 710 TypedProtoReader<5> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 711 EXPECT_EQ(typedProtoTest.Get(TestParser_Reader::kCountDataAreaNumber).ToInt32(), COUNT_01); 712 auto fix64Type = typedProtoTest.Get(TestParser_Reader::kFixed64TestDataAreaNumber).ToBytes(); 713 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(fix64Type.data_), fix64Type.size_); 714 auto packedRepeate = typedProtoCpuInfoTest.GetPackedRepeated<ProtoWireType::kFixed64, double>( 715 Fixed64Test_Reader::kFixed64NumberTextDataAreaNumber, &parserError); 716 EXPECT_EQ(number, *packedRepeate); 717 } 718 719 /** 720 * @tc.name: ParserPackedRepeatedFixed32OneDataByPBReader 721 * @tc.desc: ParserPackedRepeatedFixed32 with one set of Data by pbreader 722 * @tc.type: FUNC 723 */ 724 HWTEST_F(ProtoReaderTest, ParserPackedRepeatedFixed32OneDataByPBReader, TestSize.Level1) 725 { 726 TS_LOGI("test33-20"); 727 TestParser testParser; 728 const float number = 1000.01; 729 std::string str = ""; 730 testParser.set_count(COUNT_01); 731 ::Fixed32Test *fixed32Test = new ::Fixed32Test(); 732 fixed32Test->add_fixed32numbertext(number); 733 testParser.set_allocated_fixed32test(fixed32Test); 734 testParser.SerializeToString(&str); 735 bool parserError = true; 736 737 TypedProtoReader<5> typedProtoTest(reinterpret_cast<const uint8_t *>(str.data()), str.size()); 738 EXPECT_EQ(typedProtoTest.Get(TestParser_Reader::kCountDataAreaNumber).ToInt32(), COUNT_01); 739 auto fix32Type = typedProtoTest.Get(TestParser_Reader::kFixed32TestDataAreaNumber).ToBytes(); 740 TypedProtoReader<1> typedProtoCpuInfoTest(reinterpret_cast<const uint8_t *>(fix32Type.data_), fix32Type.size_); 741 auto packedRepeate = typedProtoCpuInfoTest.GetPackedRepeated<ProtoWireType::kFixed32, float>( 742 Fixed32Test_Reader::kFixed32NumberTextDataAreaNumber, &parserError); 743 EXPECT_EQ(number, *packedRepeate); 744 } 745 } // namespace TraceStreamer 746 } // namespace SysTuning 747