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 #include <hwext/gtest-ext.h> 16 #include <hwext/gtest-tag.h> 17 #include <unistd.h> 18 19 #include "logging.h" 20 #include "result_demuxer.h" 21 22 using namespace testing::ext; 23 24 namespace { 25 constexpr int DATA_MAX_SIZE = 10; // set max size 10; 26 27 class ResultDemuxerTest : public ::testing::Test { 28 protected: 29 std::string path = "demux.bin"; 30 ProfilerDataRepeaterPtr repeater; 31 PluginSessionManagerPtr pluginSessionManager; 32 SetUpTestCase()33 static void SetUpTestCase() {} TearDownTestCase()34 static void TearDownTestCase() {} 35 SetUp()36 void SetUp() override 37 { 38 repeater = std::make_shared<ProfilerDataRepeater>(DATA_MAX_SIZE); 39 pluginSessionManager = std::make_shared<PluginSessionManager>(std::make_shared<PluginService>()); 40 } 41 TearDown()42 void TearDown() override {} 43 }; 44 45 /** 46 * @tc.name: server 47 * @tc.desc: Class-strengthening. 48 * @tc.type: FUNC 49 */ 50 HWTEST_F(ResultDemuxerTest, CtorDtor, TestSize.Level1) 51 { 52 auto demuxer = std::make_shared<ResultDemuxer>(repeater, pluginSessionManager); 53 EXPECT_NE(demuxer, nullptr); 54 } 55 56 /** 57 * @tc.name: server 58 * @tc.desc: set trace writer. 59 * @tc.type: FUNC 60 */ 61 HWTEST_F(ResultDemuxerTest, SetTraceWriter, TestSize.Level1) 62 { 63 auto demuxer = std::make_shared<ResultDemuxer>(repeater, pluginSessionManager); 64 ASSERT_NE(demuxer, nullptr); 65 66 demuxer->SetTraceWriter(nullptr); 67 68 auto writer = std::make_shared<TraceFileWriter>(path); 69 EXPECT_NE(writer, nullptr); 70 demuxer->SetTraceWriter(writer); 71 } 72 73 /** 74 * @tc.name: server 75 * @tc.desc: set server writer. 76 * @tc.type: FUNC 77 */ 78 HWTEST_F(ResultDemuxerTest, SetServerWriter, TestSize.Level1) 79 { 80 auto demuxer = std::make_shared<ResultDemuxer>(repeater, pluginSessionManager); 81 ASSERT_NE(demuxer, nullptr); 82 } 83 84 /** 85 * @tc.name: server 86 * @tc.desc: set take results. 87 * @tc.type: FUNC 88 */ 89 HWTEST_F(ResultDemuxerTest, StartTakeResults, TestSize.Level1) 90 { 91 auto demuxer = std::make_shared<ResultDemuxer>(repeater, pluginSessionManager); 92 ASSERT_NE(demuxer, nullptr); 93 94 auto writer = std::make_shared<TraceFileWriter>(path); 95 EXPECT_NE(writer, nullptr); 96 demuxer->SetTraceWriter(writer); 97 98 const int putCount = 20; 99 const int putDelayUs = 20 * 1000; 100 demuxer->StartTakeResults(); __anon95843a650202null101 std::thread dataProducer([=] { 102 for (int i = 0; i < putCount; i++) { 103 auto pluginData = std::make_shared<ProfilerPluginData>(); 104 ASSERT_NE(pluginData, nullptr); 105 pluginData->set_name("test-" + std::to_string(i)); 106 pluginData->set_status(i); 107 repeater->PutPluginData(pluginData); 108 HILOG_DEBUG(LOG_CORE, "put test data %d...", i); 109 usleep(putDelayUs); 110 } 111 repeater->PutPluginData(nullptr); 112 }); 113 114 HILOG_DEBUG(LOG_CORE, "waiting producer thread done..."); 115 dataProducer.join(); 116 } 117 118 /** 119 * @tc.name: server 120 * @tc.desc: stop take results. 121 * @tc.type: FUNC 122 */ 123 HWTEST_F(ResultDemuxerTest, StopTakeResults, TestSize.Level1) 124 { 125 auto demuxer = std::make_shared<ResultDemuxer>(repeater, pluginSessionManager); 126 ASSERT_NE(demuxer, nullptr); 127 128 auto writer = std::make_shared<TraceFileWriter>(path); 129 EXPECT_NE(writer, nullptr); 130 demuxer->SetTraceWriter(writer); 131 132 const int putCount = 30; 133 const int putDelayUs = 20 * 1000; 134 demuxer->StartTakeResults(); __anon95843a650302null135 std::thread dataProducer([=] { 136 for (int i = 0; i < putCount; i++) { 137 auto pluginData = std::make_shared<ProfilerPluginData>(); 138 ASSERT_NE(pluginData, nullptr); 139 pluginData->set_name("AB-" + std::to_string(i)); 140 pluginData->set_status(i); 141 142 HILOG_DEBUG(LOG_CORE, "put test data %d...", i); 143 if (!repeater->PutPluginData(pluginData)) { 144 HILOG_WARN(LOG_CORE, "put test data %d FAILED!", i); 145 break; 146 } 147 usleep(putDelayUs); 148 } 149 }); 150 151 usleep((putCount / 2) * putDelayUs); 152 demuxer->StopTakeResults(); 153 154 repeater->Close(); 155 HILOG_DEBUG(LOG_CORE, "waiting producer thread done..."); 156 dataProducer.join(); 157 } 158 } // namespace