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 <fcntl.h> 17 #include <hwext/gtest-ext.h> 18 #include <hwext/gtest-tag.h> 19 #include <memory> 20 21 #include "htrace_network_parser.h" 22 #include "parser/bytrace_parser/bytrace_parser.h" 23 #include "parser/common_types.h" 24 #include "trace_streamer_selector.h" 25 26 using namespace testing::ext; 27 using namespace SysTuning::TraceStreamer; 28 29 namespace SysTuning { 30 namespace TraceStreamer { 31 class HtraceNetworkParserTest : public ::testing::Test { 32 public: SetUp()33 void SetUp() 34 { 35 stream_.InitFilter(); 36 } 37 TearDown()38 void TearDown() {} 39 40 public: 41 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 42 }; 43 44 /** 45 * @tc.name: ParseHtraceNetworkWithoutNetworkData 46 * @tc.desc: Parse a Process that does not contain any ProcessData 47 * @tc.type: FUNC 48 */ 49 HWTEST_F(HtraceNetworkParserTest, ParseHtraceNetworkWithoutNetworkData, TestSize.Level1) 50 { 51 TS_LOGI("test17-1"); 52 uint64_t ts = 100; 53 auto networkDatas = std::make_unique<NetworkDatas>(); 54 HtraceNetworkParser htraceProcessParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 55 htraceProcessParser.Parse(*networkDatas, ts); 56 auto size = stream_.traceDataCache_->GetConstNetworkData().Size(); 57 EXPECT_FALSE(size); 58 } 59 60 /** 61 * @tc.name: ParseHtraceNetworkWithNetworkData 62 * @tc.desc: Parse a Process with ProcessData 63 * @tc.type: FUNC 64 */ 65 HWTEST_F(HtraceNetworkParserTest, ParseHtraceNetworkWithNetworkData, TestSize.Level1) 66 { 67 TS_LOGI("test17-2"); 68 uint64_t ts = 100; 69 const uint64_t DURS = 1999632780; 70 const uint64_t TX = 712924; 71 const uint64_t RX = 13535014; 72 const uint64_t PACKETIN = 11431; 73 const uint64_t PACKETOUT = 7373; 74 75 auto networkDatas = std::make_unique<NetworkDatas>(); 76 NetworkSystemData* networkSystemData = new NetworkSystemData(); 77 networkSystemData->set_rx_bytes(RX); 78 networkSystemData->set_tx_bytes(TX); 79 networkSystemData->set_rx_packets(PACKETIN); 80 networkSystemData->set_tx_packets(PACKETOUT); 81 networkDatas->set_allocated_network_system_info(networkSystemData); 82 83 HtraceNetworkParser htraceNetworkParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 84 htraceNetworkParser.Parse(*networkDatas, ts); 85 htraceNetworkParser.Finish(); 86 auto size = stream_.traceDataCache_->GetConstNetworkData().Size(); 87 EXPECT_FALSE(size); 88 } 89 90 /** 91 * @tc.name: ParseHtraceNetworkWithTwoNetworkData 92 * @tc.desc: Parse a Process with ProcessData 93 * @tc.type: FUNC 94 */ 95 HWTEST_F(HtraceNetworkParserTest, ParseHtraceNetworkWithTwoNetworkData, TestSize.Level1) 96 { 97 TS_LOGI("test17-3"); 98 uint64_t ts = 100; 99 auto networkDatas = std::make_unique<NetworkDatas>(); 100 101 const uint64_t DURS_01 = 1999632781; 102 const uint64_t TX_01 = 712921; 103 const uint64_t RX_01 = 13535011; 104 const uint64_t PACKETIN_01 = 11431; 105 const uint64_t PACKETOUT_01 = 7371; 106 NetworkSystemData* networkSystemDataFirst = new NetworkSystemData(); 107 networkSystemDataFirst->set_rx_bytes(RX_01); 108 networkSystemDataFirst->set_tx_bytes(TX_01); 109 networkSystemDataFirst->set_rx_packets(PACKETIN_01); 110 networkSystemDataFirst->set_tx_packets(PACKETOUT_01); 111 networkDatas->set_allocated_network_system_info(networkSystemDataFirst); 112 HtraceNetworkParser htraceNetworkParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 113 htraceNetworkParser.Parse(*networkDatas, ts); 114 115 const uint64_t DURS_02 = 1999632782; 116 const uint64_t TX_02 = 712922; 117 const uint64_t RX_02 = 13535012; 118 const uint64_t PACKETIN_02 = 11432; 119 const uint64_t PACKETOUT_02 = 7372; 120 NetworkSystemData* networkSystemDataSecond = new NetworkSystemData(); 121 networkSystemDataSecond->set_rx_bytes(RX_02); 122 networkSystemDataSecond->set_tx_bytes(TX_02); 123 networkSystemDataSecond->set_rx_packets(PACKETIN_02); 124 networkSystemDataSecond->set_tx_packets(PACKETOUT_02); 125 networkDatas->set_allocated_network_system_info(networkSystemDataSecond); 126 htraceNetworkParser.Parse(*networkDatas, ts); 127 htraceNetworkParser.Finish(); 128 129 auto tx = stream_.traceDataCache_->GetConstNetworkData().TxDatas()[0]; 130 EXPECT_EQ(tx, TX_02); 131 auto rx = stream_.traceDataCache_->GetConstNetworkData().RxDatas()[0]; 132 EXPECT_EQ(rx, RX_02); 133 auto packetIn = stream_.traceDataCache_->GetConstNetworkData().PacketIn()[0]; 134 EXPECT_EQ(packetIn, PACKETIN_02); 135 auto packetOut = stream_.traceDataCache_->GetConstNetworkData().PacketOut()[0]; 136 EXPECT_EQ(packetOut, PACKETOUT_02); 137 } 138 139 /** 140 * @tc.name: ParseHtraceNetworkWithThreeNetworkData 141 * @tc.desc: Parse a Process with ProcessData 142 * @tc.type: FUNC 143 */ 144 HWTEST_F(HtraceNetworkParserTest, ParseHtraceNetworkWithThreeNetworkData, TestSize.Level1) 145 { 146 TS_LOGI("test17-4"); 147 uint64_t ts = 100; 148 auto networkDatas = std::make_unique<NetworkDatas>(); 149 150 const uint64_t DURS_01 = 1999632781; 151 const uint64_t TX_01 = 712921; 152 const uint64_t RX_01 = 13535011; 153 const uint64_t PACKETIN_01 = 11431; 154 const uint64_t PACKETOUT_01 = 7371; 155 NetworkSystemData* networkSystemDataFirst = new NetworkSystemData(); 156 networkSystemDataFirst->set_rx_bytes(RX_01); 157 networkSystemDataFirst->set_tx_bytes(TX_01); 158 networkSystemDataFirst->set_rx_packets(PACKETIN_01); 159 networkSystemDataFirst->set_tx_packets(PACKETOUT_01); 160 networkDatas->set_allocated_network_system_info(networkSystemDataFirst); 161 HtraceNetworkParser htraceNetworkParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 162 htraceNetworkParser.Parse(*networkDatas, ts); 163 164 const uint64_t DURS_02 = 1999632782; 165 const uint64_t TX_02 = 712922; 166 const uint64_t RX_02 = 13535012; 167 const uint64_t PACKETIN_02 = 11432; 168 const uint64_t PACKETOUT_02 = 7372; 169 NetworkSystemData* networkSystemDataSecond = new NetworkSystemData(); 170 networkSystemDataSecond->set_rx_bytes(RX_02); 171 networkSystemDataSecond->set_tx_bytes(TX_02); 172 networkSystemDataSecond->set_rx_packets(PACKETIN_02); 173 networkSystemDataSecond->set_tx_packets(PACKETOUT_02); 174 networkDatas->set_allocated_network_system_info(networkSystemDataSecond); 175 htraceNetworkParser.Parse(*networkDatas, ts); 176 177 const uint64_t DURS_03 = 1999632783; 178 const uint64_t TX_03 = 712923; 179 const uint64_t RX_03 = 13535013; 180 const uint64_t PACKETIN_03 = 11433; 181 const uint64_t PACKETOUT_03 = 7373; 182 NetworkSystemData* networkSystemDataThird = new NetworkSystemData(); 183 networkSystemDataThird->set_rx_bytes(RX_03); 184 networkSystemDataThird->set_tx_bytes(TX_03); 185 networkSystemDataThird->set_rx_packets(PACKETIN_03); 186 networkSystemDataThird->set_tx_packets(PACKETOUT_03); 187 networkDatas->set_allocated_network_system_info(networkSystemDataThird); 188 htraceNetworkParser.Parse(*networkDatas, ts); 189 htraceNetworkParser.Finish(); 190 191 auto txFirst = stream_.traceDataCache_->GetConstNetworkData().TxDatas()[0]; 192 auto txSecond = stream_.traceDataCache_->GetConstNetworkData().TxDatas()[1]; 193 EXPECT_EQ(txFirst, TX_02); 194 EXPECT_EQ(txSecond, TX_03); 195 auto rxFirst = stream_.traceDataCache_->GetConstNetworkData().RxDatas()[0]; 196 auto rxSecond = stream_.traceDataCache_->GetConstNetworkData().RxDatas()[1]; 197 EXPECT_EQ(rxFirst, RX_02); 198 EXPECT_EQ(rxSecond, RX_03); 199 auto packetInFirst = stream_.traceDataCache_->GetConstNetworkData().PacketIn()[0]; 200 auto packetInSecond = stream_.traceDataCache_->GetConstNetworkData().PacketIn()[1]; 201 EXPECT_EQ(packetInFirst, PACKETIN_02); 202 EXPECT_EQ(packetInSecond, PACKETIN_03); 203 auto packetOutFirst = stream_.traceDataCache_->GetConstNetworkData().PacketOut()[0]; 204 auto packetOutSecond = stream_.traceDataCache_->GetConstNetworkData().PacketOut()[1]; 205 EXPECT_EQ(packetOutFirst, PACKETOUT_02); 206 EXPECT_EQ(packetOutSecond, PACKETOUT_03); 207 } 208 209 /** 210 * @tc.name: ParseHtraceNetworkWithMultipleNetworkData 211 * @tc.desc: Parse a Process with ProcessData 212 * @tc.type: FUNC 213 */ 214 HWTEST_F(HtraceNetworkParserTest, ParseHtraceNetworkWithMultipleNetworkData, TestSize.Level1) 215 { 216 TS_LOGI("test17-5"); 217 uint64_t ts = 100; 218 auto networkDatas = std::make_unique<NetworkDatas>(); 219 220 const uint64_t DURS_01 = 1999632781; 221 const uint64_t TX_01 = 712921; 222 const uint64_t RX_01 = 13535011; 223 const uint64_t PACKETIN_01 = 11431; 224 const uint64_t PACKETOUT_01 = 7371; 225 NetworkSystemData* networkSystemDataFirst = new NetworkSystemData(); 226 networkSystemDataFirst->set_rx_bytes(RX_01); 227 networkSystemDataFirst->set_tx_bytes(TX_01); 228 networkSystemDataFirst->set_rx_packets(PACKETIN_01); 229 networkSystemDataFirst->set_tx_packets(PACKETOUT_01); 230 networkDatas->set_allocated_network_system_info(networkSystemDataFirst); 231 HtraceNetworkParser htraceNetworkParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 232 htraceNetworkParser.Parse(*networkDatas, ts); 233 234 const uint64_t DURS_02 = 1999632782; 235 const uint64_t TX_02 = 712922; 236 const uint64_t RX_02 = 13535012; 237 const uint64_t PACKETIN_02 = 11432; 238 const uint64_t PACKETOUT_02 = 7372; 239 NetworkSystemData* networkSystemDataSecond = new NetworkSystemData(); 240 networkSystemDataSecond->set_rx_bytes(RX_02); 241 networkSystemDataSecond->set_tx_bytes(TX_02); 242 networkSystemDataSecond->set_rx_packets(PACKETIN_02); 243 networkSystemDataSecond->set_tx_packets(PACKETOUT_02); 244 networkDatas->set_allocated_network_system_info(networkSystemDataSecond); 245 htraceNetworkParser.Parse(*networkDatas, ts); 246 247 const uint64_t DURS_03 = 1999632783; 248 const uint64_t TX_03 = 712923; 249 const uint64_t RX_03 = 13535013; 250 const uint64_t PACKETIN_03 = 11433; 251 const uint64_t PACKETOUT_03 = 7373; 252 NetworkSystemData* networkSystemDataThird = new NetworkSystemData(); 253 networkSystemDataThird->set_rx_bytes(RX_03); 254 networkSystemDataThird->set_tx_bytes(TX_03); 255 networkSystemDataThird->set_rx_packets(PACKETIN_03); 256 networkSystemDataThird->set_tx_packets(PACKETOUT_03); 257 networkDatas->set_allocated_network_system_info(networkSystemDataThird); 258 htraceNetworkParser.Parse(*networkDatas, ts); 259 260 const uint64_t DURS_04 = 1999632784; 261 const uint64_t TX_04 = 712924; 262 const uint64_t RX_04 = 13535014; 263 const uint64_t PACKETIN_04 = 11434; 264 const uint64_t PACKETOUT_04 = 7374; 265 NetworkSystemData* networkSystemDataForth = new NetworkSystemData(); 266 networkSystemDataForth->set_rx_bytes(RX_04); 267 networkSystemDataForth->set_tx_bytes(TX_04); 268 networkSystemDataForth->set_rx_packets(PACKETIN_04); 269 networkSystemDataForth->set_tx_packets(PACKETOUT_04); 270 networkDatas->set_allocated_network_system_info(networkSystemDataForth); 271 htraceNetworkParser.Parse(*networkDatas, ts); 272 htraceNetworkParser.Finish(); 273 274 auto txFirst = stream_.traceDataCache_->GetConstNetworkData().TxDatas()[0]; 275 auto txSecond = stream_.traceDataCache_->GetConstNetworkData().TxDatas()[1]; 276 auto txThird = stream_.traceDataCache_->GetConstNetworkData().TxDatas()[2]; 277 EXPECT_EQ(txFirst, TX_02); 278 EXPECT_EQ(txSecond, TX_03); 279 EXPECT_EQ(txThird, TX_04); 280 auto rxFirst = stream_.traceDataCache_->GetConstNetworkData().RxDatas()[0]; 281 auto rxSecond = stream_.traceDataCache_->GetConstNetworkData().RxDatas()[1]; 282 auto rxThird = stream_.traceDataCache_->GetConstNetworkData().RxDatas()[2]; 283 EXPECT_EQ(rxFirst, RX_02); 284 EXPECT_EQ(rxSecond, RX_03); 285 EXPECT_EQ(rxThird, RX_04); 286 auto packetInFirst = stream_.traceDataCache_->GetConstNetworkData().PacketIn()[0]; 287 auto packetInSecond = stream_.traceDataCache_->GetConstNetworkData().PacketIn()[1]; 288 auto packetInThird = stream_.traceDataCache_->GetConstNetworkData().PacketIn()[2]; 289 EXPECT_EQ(packetInFirst, PACKETIN_02); 290 EXPECT_EQ(packetInSecond, PACKETIN_03); 291 EXPECT_EQ(packetInThird, PACKETIN_04); 292 auto packetOutFirst = stream_.traceDataCache_->GetConstNetworkData().PacketOut()[0]; 293 auto packetOutSecond = stream_.traceDataCache_->GetConstNetworkData().PacketOut()[1]; 294 auto packetOutThird = stream_.traceDataCache_->GetConstNetworkData().PacketOut()[2]; 295 EXPECT_EQ(packetOutFirst, PACKETOUT_02); 296 EXPECT_EQ(packetOutSecond, PACKETOUT_03); 297 EXPECT_EQ(packetOutThird, PACKETOUT_04); 298 } 299 } // namespace TraceStreamer 300 } // namespace SysTuning