| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/developer/system_monitor/lib/dockyard/dockyard.h" |
| |
| #include <climits> |
| |
| #include <gtest/gtest.h> |
| |
| #include "src/developer/system_monitor/lib/dockyard/dockyard_service_impl.h" |
| #include "src/developer/system_monitor/lib/dockyard/test_sample_generator.h" |
| |
| namespace dockyard { |
| |
| namespace { |
| |
| // A server address that gets the OS to choose a free port. |
| const char kgRPCServerAddressForTest[] = "0.0.0.0:0"; |
| |
| } |
| |
| class SystemMonitorDockyardTest : public ::testing::Test { |
| public: |
| void SetUp() { |
| // Initialize to distinct values for testing. |
| EXPECT_EQ(nullptr, dockyard_.SetDockyardPathsHandler(std::bind( |
| &SystemMonitorDockyardTest::TestPathsCallback, this, |
| std::placeholders::_1, std::placeholders::_2))); |
| // Add some samples. |
| dockyard_.AddSamples(dockyard_.GetDockyardId("cpu0"), |
| {{10ULL, 8ULL}, {200ULL, 10ULL}, {300ULL, 20ULL}}); |
| dockyard_.AddSamples(dockyard_.GetDockyardId("cpu1"), {{10ULL, 3ULL}, |
| {20ULL, 4ULL}, |
| {80ULL, 5ULL}, |
| {81ULL, 50ULL}, |
| {100ULL, 10ULL}, |
| {200ULL, 100ULL}, |
| {300ULL, 80ULL}, |
| {400ULL, 100ULL}, |
| {500ULL, 50ULL}}); |
| dockyard_.AddSamples( |
| dockyard_.GetDockyardId("cpu2"), |
| { |
| {100ULL, 3ULL}, {105ULL, 4ULL}, {110ULL, 5ULL}, {115ULL, 50ULL}, |
| {120ULL, 90ULL}, {125ULL, 100ULL}, {130ULL, 80ULL}, {135ULL, 45ULL}, |
| {140ULL, 44ULL}, {150ULL, 40ULL}, {155ULL, 30ULL}, {160ULL, 12ULL}, |
| {165ULL, 10ULL}, {170ULL, 8ULL}, {175ULL, 5ULL}, {180ULL, 3ULL}, |
| {185ULL, 5ULL}, {190ULL, 15ULL}, {195ULL, 50ULL}, |
| }); |
| dockyard_.AddSamples(dockyard_.GetDockyardId("cpu3"), {{100ULL, 103ULL}, |
| {105ULL, 104ULL}, |
| {110ULL, 107ULL}, |
| {115ULL, 112ULL}, |
| {120ULL, 112ULL}, |
| {130ULL, 122ULL}, |
| {135ULL, 127ULL}, |
| {140ULL, 130ULL}, |
| {150ULL, 132ULL}, |
| {165ULL, 132ULL}, |
| {170ULL, 133ULL}, |
| {175ULL, 135ULL}, |
| {180ULL, 138ULL}, |
| {185ULL, 142ULL}, |
| {190ULL, 147ULL}, |
| {195ULL, 148ULL}}); |
| } |
| |
| // Returns whether the gRPC server is listening for Harvester connections. |
| bool IsGrpcServerActive() { |
| return !!dockyard_.grpc_server_ && dockyard_.server_thread_.joinable(); |
| } |
| |
| // TODO(fxbug.dev/37317): add further tests for paths. |
| void TestPathsCallback(const std::vector<PathInfo>& add, |
| const std::vector<uint32_t>& remove) {} |
| |
| Dockyard dockyard_; |
| }; |
| |
| namespace { |
| |
| TEST_F(SystemMonitorDockyardTest, SetsCallback) { |
| // No pending requests. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SlopeValuesMono) { |
| constexpr uint64_t SAMPLE_COUNT = 20; |
| RandomSampleGenerator gen; |
| gen.dockyard_id = dockyard_.GetDockyardId("fake0"); |
| gen.seed = 1234; |
| gen.time_style = RandomSampleGenerator::TIME_STYLE_LINEAR; |
| gen.start = 100; |
| gen.finish = 500; |
| gen.value_style = RandomSampleGenerator::VALUE_STYLE_MONO_INCREASE; |
| gen.value_min = 10; |
| gen.value_max = 100; |
| gen.sample_count = SAMPLE_COUNT / 4; |
| GenerateRandomSamples(gen, &dockyard_); |
| |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 500; |
| request.flags = StreamSetsRequest::SLOPE; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::HIGHEST_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("fake0")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(0ULL, response.lowest_value); |
| EXPECT_EQ(dockyard::SLOPE_LIMIT, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][0]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][1]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][2]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][3]); |
| EXPECT_EQ(225000ULL, response.data_sets[0][4]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][5]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SampleStreamsRequestNormal) { |
| // Add pending request. |
| SampleStreamsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 500; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu1")); |
| dockyard_.GetSampleStreams( |
| std::move(request), [](const SampleStreamsRequest& request, |
| const SampleStreamsResponse& response) { |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(4UL, response.data_sets[0].size()); |
| EXPECT_EQ(100ULL, response.data_sets[0][0].first); |
| EXPECT_EQ(10ULL, response.data_sets[0][0].second); |
| EXPECT_EQ(200ULL, response.data_sets[0][1].first); |
| EXPECT_EQ(100ULL, response.data_sets[0][1].second); |
| EXPECT_EQ(300ULL, response.data_sets[0][2].first); |
| EXPECT_EQ(80ULL, response.data_sets[0][2].second); |
| EXPECT_EQ(400ULL, response.data_sets[0][3].first); |
| EXPECT_EQ(100ULL, response.data_sets[0][3].second); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SampleStreamsRequestNearValues) { |
| // Add pending request. |
| SampleStreamsRequest request; |
| request.start_time_ns = 25; |
| request.end_time_ns = 81; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu1")); |
| dockyard_.GetSampleStreams(std::move(request), |
| [](const SampleStreamsRequest& request, |
| const SampleStreamsResponse& response) { |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(1UL, response.data_sets[0].size()); |
| EXPECT_EQ(80ULL, response.data_sets[0][0].first); |
| EXPECT_EQ(5ULL, response.data_sets[0][0].second); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SampleStreamsGenerated) { |
| constexpr uint64_t SAMPLE_COUNT = 5; |
| RandomSampleGenerator gen; |
| gen.dockyard_id = dockyard_.GetDockyardId("fake0"); |
| gen.seed = 1234; |
| gen.time_style = RandomSampleGenerator::TIME_STYLE_LINEAR; |
| gen.start = 100; |
| gen.finish = 500; |
| gen.value_style = RandomSampleGenerator::VALUE_STYLE_MONO_INCREASE; |
| gen.value_min = 10; |
| gen.value_max = 100; |
| gen.sample_count = SAMPLE_COUNT; |
| GenerateRandomSamples(gen, &dockyard_); |
| |
| // Add pending request. |
| SampleStreamsRequest request; |
| request.start_time_ns = 100; |
| // this is the exact time of the fifth sample |
| request.end_time_ns = 420; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("fake0")); |
| dockyard_.GetSampleStreams( |
| std::move(request), [](const SampleStreamsRequest& request, |
| const SampleStreamsResponse& response) { |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT - 1, response.data_sets[0].size()); |
| // Check the samples themselves. |
| std::vector<std::pair<SampleTimeNs, SampleValue>> expected = { |
| {100ULL, 10UL}, {180ULL, 28ULL}, {260ULL, 46ULL}, {340ULL, 64ULL}}; |
| int data_set_index = 0; |
| for (const auto& [timestamp, value] : expected) { |
| EXPECT_EQ(timestamp, response.data_sets[0][data_set_index].first); |
| EXPECT_EQ(value, response.data_sets[0][data_set_index].second); |
| data_set_index++; |
| } |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SampleStreamsRequestAfterSamples) { |
| // Add pending request. |
| SampleStreamsRequest request; |
| request.start_time_ns = 600; |
| request.end_time_ns = 700; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu1")); |
| dockyard_.GetSampleStreams(std::move(request), |
| [](const SampleStreamsRequest& request, |
| const SampleStreamsResponse& response) { |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(0UL, response.data_sets[0].size()); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SampleStreamsRequestBeforeSamples) { |
| // Add pending request. |
| SampleStreamsRequest request; |
| request.start_time_ns = 0; |
| request.end_time_ns = 10; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu1")); |
| dockyard_.GetSampleStreams(std::move(request), |
| [](const SampleStreamsRequest& request, |
| const SampleStreamsResponse& response) { |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(0UL, response.data_sets[0].size()); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SampleStreamsMissing) { |
| // Add pending request. |
| SampleStreamsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 500; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("does-not-exist")); |
| dockyard_.GetSampleStreams(std::move(request), |
| [](const SampleStreamsRequest& request, |
| const SampleStreamsResponse& response) { |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(0UL, response.data_sets[0].size()); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SampleStreamsRequestNormalMultiple) { |
| // Add pending request. |
| SampleStreamsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 500; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu0")); |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu1")); |
| dockyard_.GetSampleStreams( |
| std::move(request), [](const SampleStreamsRequest& request, |
| const SampleStreamsResponse& response) { |
| ASSERT_EQ(2UL, response.data_sets.size()); |
| |
| ASSERT_EQ(2UL, response.data_sets[0].size()); |
| EXPECT_EQ(200ULL, response.data_sets[0][0].first); |
| EXPECT_EQ(10ULL, response.data_sets[0][0].second); |
| EXPECT_EQ(300ULL, response.data_sets[0][1].first); |
| EXPECT_EQ(20ULL, response.data_sets[0][1].second); |
| |
| ASSERT_EQ(4UL, response.data_sets[1].size()); |
| EXPECT_EQ(10ULL, response.data_sets[1][0].second); |
| EXPECT_EQ(100ULL, response.data_sets[1][1].second); |
| EXPECT_EQ(80ULL, response.data_sets[1][2].second); |
| EXPECT_EQ(100ULL, response.data_sets[1][3].second); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SlopeCpu3Highest) { |
| constexpr uint64_t SAMPLE_COUNT = 20; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 200; |
| request.flags = StreamSetsRequest::SLOPE; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::HIGHEST_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu3")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(0ULL, response.lowest_value); |
| EXPECT_EQ(1000000ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][0]); |
| EXPECT_EQ(200000ULL, response.data_sets[0][1]); |
| EXPECT_EQ(600000ULL, response.data_sets[0][2]); |
| EXPECT_EQ(1000000ULL, response.data_sets[0][3]); |
| EXPECT_EQ(0ULL, response.data_sets[0][4]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][5]); |
| EXPECT_EQ(1000000ULL, response.data_sets[0][6]); |
| EXPECT_EQ(1000000ULL, response.data_sets[0][7]); |
| EXPECT_EQ(600000ULL, response.data_sets[0][8]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][9]); |
| EXPECT_EQ(200000ULL, response.data_sets[0][10]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][11]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][12]); |
| EXPECT_EQ(0ULL, response.data_sets[0][13]); |
| EXPECT_EQ(200000ULL, response.data_sets[0][14]); |
| EXPECT_EQ(400000ULL, response.data_sets[0][15]); |
| EXPECT_EQ(600000ULL, response.data_sets[0][16]); |
| EXPECT_EQ(800000ULL, response.data_sets[0][17]); |
| EXPECT_EQ(1000000ULL, response.data_sets[0][18]); |
| EXPECT_EQ(200000ULL, response.data_sets[0][19]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SlopeCpu3Average) { |
| constexpr uint64_t SAMPLE_COUNT = 7; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 200; |
| request.flags = StreamSetsRequest::SLOPE; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::AVERAGE_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu3")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(0ULL, response.lowest_value); |
| EXPECT_EQ(1000000ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][0]); |
| EXPECT_EQ(571428ULL, response.data_sets[0][1]); |
| EXPECT_EQ(1000000ULL, response.data_sets[0][2]); |
| EXPECT_EQ(428571ULL, response.data_sets[0][3]); |
| EXPECT_EQ(0ULL, response.data_sets[0][4]); |
| EXPECT_EQ(285714ULL, response.data_sets[0][5]); |
| EXPECT_EQ(642857ULL, response.data_sets[0][6]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, RawPastEndResponse) { |
| constexpr uint64_t SAMPLE_COUNT = 10; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 0; |
| request.end_time_ns = 1000; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::AVERAGE_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu0")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(8ULL, response.lowest_value); |
| EXPECT_EQ(20ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(8ULL, response.data_sets[0][0]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][1]); |
| EXPECT_EQ(10ULL, response.data_sets[0][2]); |
| EXPECT_EQ(20ULL, response.data_sets[0][3]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][4]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][5]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][6]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][7]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][8]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][9]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, RawSparseResponse) { |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 0; |
| request.end_time_ns = 300; |
| request.sample_count = 10; |
| request.render_style = StreamSetsRequest::AVERAGE_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu0")); |
| dockyard_.GetStreamSets( |
| std::move(request), |
| [](const StreamSetsRequest& request, const StreamSetsResponse& response) { |
| EXPECT_EQ(8ULL, response.lowest_value); |
| EXPECT_EQ(20ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(10UL, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(8ULL, response.data_sets[0][0]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][1]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][2]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][3]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][4]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][5]); |
| EXPECT_EQ(10ULL, response.data_sets[0][6]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][7]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][8]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][9]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, RawDataSetsCpu1) { |
| constexpr uint64_t SAMPLE_COUNT = 10; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 50; |
| request.end_time_ns = 450; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::AVERAGE_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu1")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(3ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(27ULL, response.data_sets[0][0]); |
| EXPECT_EQ(10ULL, response.data_sets[0][1]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][2]); |
| EXPECT_EQ(100ULL, response.data_sets[0][3]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][4]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][5]); |
| EXPECT_EQ(80ULL, response.data_sets[0][6]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][7]); |
| EXPECT_EQ(100ULL, response.data_sets[0][8]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][9]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, RawDataSetsCpu2) { |
| constexpr uint64_t SAMPLE_COUNT = 5; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 200; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::AVERAGE_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu2")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(3ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(15ULL, response.data_sets[0][0]); |
| EXPECT_EQ(78ULL, response.data_sets[0][1]); |
| EXPECT_EQ(38ULL, response.data_sets[0][2]); |
| EXPECT_EQ(8ULL, response.data_sets[0][3]); |
| EXPECT_EQ(18ULL, response.data_sets[0][4]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, RawDataSetsCpus012) { |
| constexpr uint64_t SAMPLE_COUNT = 2; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 200; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::AVERAGE_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu0")); |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu1")); |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu2")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(3ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(3UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[1].size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[2].size()); |
| // Check the samples themselves. |
| // CPU 0. |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][0]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][1]); |
| // CPU 1. |
| EXPECT_EQ(10ULL, response.data_sets[1][0]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[1][1]); |
| // CPU 2. |
| EXPECT_EQ(46ULL, response.data_sets[2][0]); |
| EXPECT_EQ(17ULL, response.data_sets[2][1]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, HighDataSetsCpus12) { |
| constexpr uint64_t SAMPLE_COUNT = 2; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 20; |
| request.end_time_ns = 150; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::HIGHEST_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu1")); |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu2")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(3ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(2UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| // CPU 1. |
| EXPECT_EQ(50ULL, response.data_sets[0][0]); |
| EXPECT_EQ(10ULL, response.data_sets[0][1]); |
| // CPU 2. |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[1][0]); |
| EXPECT_EQ(100ULL, response.data_sets[1][1]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, LowDataSetsCpus12) { |
| constexpr uint64_t SAMPLE_COUNT = 2; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 20; |
| request.end_time_ns = 150; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::LOWEST_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu1")); |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu2")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(3ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(2UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| // CPU 1. |
| EXPECT_EQ(4ULL, response.data_sets[0][0]); |
| EXPECT_EQ(10ULL, response.data_sets[0][1]); |
| // CPU 2. |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[1][0]); |
| EXPECT_EQ(3ULL, response.data_sets[1][1]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, NormalizedDataSetsCpu2) { |
| constexpr uint64_t SAMPLE_COUNT = 5; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 200; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::AVERAGE_PER_COLUMN; |
| request.flags = StreamSetsRequest::NORMALIZE; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu2")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(3ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(123711ULL, response.data_sets[0][0]); |
| EXPECT_EQ(773195ULL, response.data_sets[0][1]); |
| EXPECT_EQ(360824ULL, response.data_sets[0][2]); |
| EXPECT_EQ(51546ULL, response.data_sets[0][3]); |
| EXPECT_EQ(154639ULL, response.data_sets[0][4]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SmoothDataSetsCpu2) { |
| constexpr uint64_t SAMPLE_COUNT = 5; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 200; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::WIDE_SMOOTHING; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu2")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(3ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(47ULL, response.data_sets[0][0]); |
| EXPECT_EQ(44ULL, response.data_sets[0][1]); |
| EXPECT_EQ(42ULL, response.data_sets[0][2]); |
| EXPECT_EQ(20ULL, response.data_sets[0][3]); |
| EXPECT_EQ(13ULL, response.data_sets[0][4]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, SculptedDataSetsCpu2) { |
| constexpr uint64_t SAMPLE_COUNT = 5; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 200; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::SCULPTING; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu2")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(3ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(3ULL, response.data_sets[0][0]); |
| EXPECT_EQ(100ULL, response.data_sets[0][1]); |
| EXPECT_EQ(30ULL, response.data_sets[0][2]); |
| EXPECT_EQ(5ULL, response.data_sets[0][3]); |
| EXPECT_EQ(3ULL, response.data_sets[0][4]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, RandomSamples) { |
| constexpr uint64_t SAMPLE_COUNT = 40; |
| RandomSampleGenerator gen; |
| gen.dockyard_id = dockyard_.GetDockyardId("fake0"); |
| gen.seed = 1234; |
| gen.time_style = RandomSampleGenerator::TIME_STYLE_LINEAR; |
| gen.start = 100; |
| gen.finish = 500; |
| gen.value_style = RandomSampleGenerator::VALUE_STYLE_SINE_WAVE; |
| gen.value_min = 10; |
| gen.value_max = 100; |
| gen.sample_count = SAMPLE_COUNT; |
| GenerateRandomSamples(gen, &dockyard_); |
| |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 500; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::AVERAGE_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("fake0")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(10ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(55ULL, response.data_sets[0][0]); |
| EXPECT_EQ(99ULL, response.data_sets[0][9]); |
| EXPECT_EQ(29ULL, response.data_sets[0][19]); |
| EXPECT_EQ(29ULL, response.data_sets[0][29]); |
| EXPECT_EQ(99ULL, response.data_sets[0][39]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, NegativeSlope) { |
| // The timestamps in this fake sample stream increase by 10 in each successive |
| // Sample. The time data on the second entry of each Sample should increase by |
| // 0..10 in each successive sample. A value that is lower than the prior entry |
| // has a negative slope. E.g. the change from 10ULL to 7ULL is a downward |
| // trend (with a negative slope). |
| dockyard_.AddSamples(dockyard_.GetDockyardId("data"), {{100ULL, 5ULL}, |
| {110ULL, 10ULL}, |
| {120ULL, 7ULL}, |
| {130ULL, 15ULL}, |
| {140ULL, 16ULL}, |
| {150ULL, 25ULL}}); |
| |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 160; |
| request.flags = StreamSetsRequest::SLOPE; |
| request.sample_count = 6; |
| request.render_style = StreamSetsRequest::HIGHEST_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("data")); |
| dockyard_.GetStreamSets( |
| std::move(request), |
| [](const StreamSetsRequest& request, const StreamSetsResponse& response) { |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(request.sample_count, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][0]); |
| EXPECT_EQ(500000ULL, response.data_sets[0][1]); |
| // The Dockyard will return a level slope rather than a negative slope. |
| // The result on the next line would be a negative value if negative |
| // slopes were reported. |
| EXPECT_EQ(0ULL, response.data_sets[0][2]); |
| EXPECT_EQ(500000ULL, response.data_sets[0][3]); |
| EXPECT_EQ(100000ULL, response.data_sets[0][4]); |
| EXPECT_EQ(900000ULL, response.data_sets[0][5]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, RecentDataSetsCpus12) { |
| constexpr uint64_t SAMPLE_COUNT = 1; |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 0; |
| request.end_time_ns = ULLONG_MAX; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::RECENT; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu1")); |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("cpu2")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| EXPECT_EQ(3ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(2UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[1].size()); |
| // Check the samples themselves. |
| // CPU 1. |
| EXPECT_EQ(50ULL, response.data_sets[0][0]); |
| // CPU 2. |
| EXPECT_EQ(50ULL, response.data_sets[1][0]); |
| }); |
| |
| // Kick a process call. |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, DockyardStringToId) { |
| DockyardId apple_id = dockyard_.GetDockyardId("apple"); |
| DockyardId banana_id = dockyard_.GetDockyardId("banana"); |
| DockyardId carrot_id = dockyard_.GetDockyardId("carrot"); |
| DockyardId dog_id = dockyard_.GetDockyardId("dog"); |
| DockyardId elephant_id = dockyard_.GetDockyardId("elephant"); |
| // None of the IDs should match |
| EXPECT_NE(apple_id, banana_id); |
| EXPECT_NE(apple_id, carrot_id); |
| EXPECT_NE(apple_id, dog_id); |
| EXPECT_NE(apple_id, elephant_id); |
| EXPECT_NE(banana_id, carrot_id); |
| EXPECT_NE(banana_id, dog_id); |
| EXPECT_NE(banana_id, elephant_id); |
| EXPECT_NE(carrot_id, dog_id); |
| EXPECT_NE(carrot_id, elephant_id); |
| EXPECT_NE(dog_id, elephant_id); |
| // The same ID should be returned for an equivalent string. |
| EXPECT_EQ(apple_id, dockyard_.GetDockyardId("apple")); |
| EXPECT_EQ(banana_id, dockyard_.GetDockyardId("banana")); |
| EXPECT_EQ(carrot_id, dockyard_.GetDockyardId("carrot")); |
| EXPECT_EQ(dog_id, dockyard_.GetDockyardId("dog")); |
| EXPECT_EQ(elephant_id, dockyard_.GetDockyardId("elephant")); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, DockyardIdToString) { |
| DockyardId apple_id = dockyard_.GetDockyardId("apple"); |
| DockyardId banana_id = dockyard_.GetDockyardId("banana"); |
| DockyardId carrot_id = dockyard_.GetDockyardId("carrot"); |
| DockyardId dog_id = dockyard_.GetDockyardId("dog"); |
| DockyardId elephant_id = dockyard_.GetDockyardId("elephant"); |
| // Check that the id will give the corresponding string. |
| std::string test; |
| EXPECT_TRUE(dockyard_.GetDockyardPath(apple_id, &test)); |
| EXPECT_EQ("apple", test); |
| EXPECT_TRUE(dockyard_.GetDockyardPath(banana_id, &test)); |
| EXPECT_EQ("banana", test); |
| EXPECT_TRUE(dockyard_.GetDockyardPath(carrot_id, &test)); |
| EXPECT_EQ("carrot", test); |
| EXPECT_TRUE(dockyard_.GetDockyardPath(dog_id, &test)); |
| EXPECT_EQ("dog", test); |
| EXPECT_TRUE(dockyard_.GetDockyardPath(elephant_id, &test)); |
| EXPECT_EQ("elephant", test); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, ServerListening) { |
| // Test for: https://bugs.chromium.org/p/fuchsia/issues/detail?id=72 |
| const std::string device_name = "apple.banana.carrot.dog"; |
| |
| ConnectionRequest request; |
| request.SetDeviceName(device_name); |
| EXPECT_TRUE(dockyard_.StartCollectingFrom( |
| std::move(request), [](const dockyard::ConnectionRequest& request, |
| const dockyard::ConnectionResponse& response) { |
| EXPECT_EQ(request.RequestId(), response.RequestId()); |
| EXPECT_EQ(request.GetMessageType(), |
| dockyard::MessageType::kConnectionRequest); |
| EXPECT_EQ(response.GetMessageType(), |
| dockyard::MessageType::kResponseOk); |
| EXPECT_EQ(response.DockyardVersion(), response.HarvesterVersion()); |
| }, |
| kgRPCServerAddressForTest)); |
| |
| ConnectionRequest second_request; |
| second_request.SetDeviceName(device_name); |
| EXPECT_FALSE(dockyard_.StartCollectingFrom( |
| std::move(second_request), |
| [](const dockyard::ConnectionRequest& request, |
| const dockyard::ConnectionResponse& response) { |
| FAIL() << "Unexpected callback"; |
| }, |
| kgRPCServerAddressForTest)); |
| dockyard_.OnConnection(dockyard::MessageType::kResponseOk, |
| /*harvester_version=*/dockyard::DOCKYARD_VERSION); |
| EXPECT_TRUE(IsGrpcServerActive()); |
| dockyard_.StopCollectingFromDevice(); |
| EXPECT_FALSE(IsGrpcServerActive()); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, VersionMismatch) { |
| const std::string device_name = "apple.banana.carrot.dog"; |
| |
| ConnectionRequest request; |
| request.SetDeviceName(device_name); |
| EXPECT_TRUE(dockyard_.StartCollectingFrom( |
| std::move(request), [](const dockyard::ConnectionRequest& request, |
| const dockyard::ConnectionResponse& response) { |
| EXPECT_EQ(request.RequestId(), response.RequestId()); |
| EXPECT_EQ(request.GetMessageType(), |
| dockyard::MessageType::kConnectionRequest); |
| EXPECT_EQ(response.GetMessageType(), |
| dockyard::MessageType::kVersionMismatch); |
| EXPECT_NE(response.DockyardVersion(), response.HarvesterVersion()); |
| }, |
| kgRPCServerAddressForTest)); |
| dockyard_.OnConnection(dockyard::MessageType::kVersionMismatch, |
| /*harvester_version=*/dockyard::DOCKYARD_VERSION - 1); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, StreamRef) { |
| SampleStreamMap stream_map; |
| EXPECT_EQ(stream_map.size(), 0ULL); |
| { |
| SampleStream& ref1 = stream_map.StreamRef(11); |
| SampleStream& ref2 = stream_map.StreamRef(22); |
| // The streams should be empty. |
| EXPECT_TRUE(ref1.empty()); |
| EXPECT_TRUE(ref2.empty()); |
| ref1.emplace(0, 100ULL); |
| ref2.emplace(0, 200ULL); |
| } |
| // Requesting the stream ref caused the stream to be created. |
| EXPECT_EQ(stream_map.size(), 2ULL); |
| { |
| SampleStream& ref1 = stream_map.StreamRef(11); |
| SampleStream& ref2 = stream_map.StreamRef(22); |
| // The streams should not be empty, they should have the values above. |
| EXPECT_FALSE(ref1.empty()); |
| EXPECT_FALSE(ref2.empty()); |
| EXPECT_EQ(ref1[0], 100ULL); |
| EXPECT_EQ(ref2[0], 200ULL); |
| } |
| // Requesting the same streams reuse the existing streams. |
| EXPECT_EQ(stream_map.size(), 2ULL); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, DefaultValues) { |
| RandomSampleGenerator gen; |
| EXPECT_EQ(0u, gen.dockyard_id); |
| EXPECT_EQ(0u, gen.seed); |
| EXPECT_EQ(0u, gen.start); |
| EXPECT_EQ(100U, gen.finish); |
| EXPECT_EQ(RandomSampleGenerator::TIME_STYLE_LINEAR, gen.time_style); |
| EXPECT_EQ(RandomSampleGenerator::VALUE_STYLE_SINE_WAVE, gen.value_style); |
| EXPECT_EQ(0u, gen.value_min); |
| EXPECT_EQ(dockyard::SAMPLE_MAX_VALUE, gen.value_max); |
| EXPECT_EQ(100u, gen.sample_count); |
| |
| DiscardSamplesRequest discard; |
| EXPECT_EQ(0u, discard.start_time_ns); |
| EXPECT_EQ(dockyard::kSampleTimeInfinite, discard.end_time_ns); |
| EXPECT_EQ(0u, discard.dockyard_ids.size()); |
| |
| StreamSetsRequest request; |
| EXPECT_EQ(0u, request.start_time_ns); |
| EXPECT_EQ(0u, request.end_time_ns); |
| EXPECT_EQ(0u, request.sample_count); |
| EXPECT_EQ(StreamSetsRequest::AVERAGE_PER_COLUMN, request.render_style); |
| EXPECT_EQ(0u, request.dockyard_ids.size()); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, IgnoreSamples) { |
| { |
| constexpr uint64_t SAMPLE_COUNT = 40; |
| RandomSampleGenerator gen; |
| gen.dockyard_id = dockyard_.GetDockyardId("fake0:345:iTest"); |
| gen.seed = 1234; |
| gen.time_style = RandomSampleGenerator::TIME_STYLE_LINEAR; |
| gen.start = 100; |
| gen.finish = 500; |
| gen.value_style = RandomSampleGenerator::VALUE_STYLE_SINE_WAVE; |
| gen.value_min = 10; |
| gen.value_max = 100; |
| gen.sample_count = SAMPLE_COUNT; |
| GenerateRandomSamples(gen, &dockyard_); |
| } |
| |
| // Discard some samples. |
| IgnoreSamplesRequest ignore; |
| ignore.prefix = "fake0:"; |
| ignore.suffix = ":iTest"; |
| dockyard_.IgnoreSamples( |
| std::move(ignore), [](const dockyard::IgnoreSamplesRequest& request, |
| const dockyard::IgnoreSamplesResponse& response) { |
| EXPECT_EQ(request.RequestId(), response.RequestId()); |
| }); |
| dockyard_.ProcessRequests(); |
| |
| { |
| constexpr uint64_t SAMPLE_COUNT = 40; |
| RandomSampleGenerator gen; |
| gen.dockyard_id = dockyard_.GetDockyardId("fake0:345:iTest"); |
| gen.seed = 1234; |
| gen.time_style = RandomSampleGenerator::TIME_STYLE_LINEAR; |
| gen.start = 500; |
| gen.finish = 700; |
| gen.value_style = RandomSampleGenerator::VALUE_STYLE_SINE_WAVE; |
| gen.value_min = 10; |
| gen.value_max = 100; |
| gen.sample_count = SAMPLE_COUNT; |
| GenerateRandomSamples(gen, &dockyard_); |
| } |
| |
| // Add pending request that straddles the time when those samples were not |
| // ignored and then some time when they were ignored. |
| StreamSetsRequest request; |
| request.start_time_ns = 400; |
| request.end_time_ns = 600; |
| request.sample_count = 12; |
| request.render_style = StreamSetsRequest::AVERAGE_PER_COLUMN; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("fake0:345:iTest")); |
| dockyard_.GetStreamSets( |
| std::move(request), |
| [](const StreamSetsRequest& request, const StreamSetsResponse& response) { |
| // Check results. |
| EXPECT_EQ(request.RequestId(), response.RequestId()); |
| EXPECT_EQ(10ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| // Check the samples themselves. The samples that arrived prior to the |
| // request to ignore some samples will still be there. Samples that |
| // arrived (i.e. were generated) after the request to ignore them are |
| // ignored. |
| EXPECT_EQ(41u, response.data_sets[0][0]); |
| EXPECT_EQ(58u, response.data_sets[0][1]); |
| EXPECT_EQ(72u, response.data_sets[0][2]); |
| EXPECT_EQ(83u, response.data_sets[0][3]); |
| EXPECT_EQ(94u, response.data_sets[0][4]); |
| EXPECT_EQ(99u, response.data_sets[0][5]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][6]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][7]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][8]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][9]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][10]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][11]); |
| }); |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, Discard) { |
| constexpr uint64_t SAMPLE_COUNT = 40; |
| RandomSampleGenerator gen; |
| gen.dockyard_id = dockyard_.GetDockyardId("fake0"); |
| gen.seed = 1234; |
| gen.time_style = RandomSampleGenerator::TIME_STYLE_LINEAR; |
| gen.start = 100; |
| gen.finish = 500; |
| gen.value_style = RandomSampleGenerator::VALUE_STYLE_SINE_WAVE; |
| gen.value_min = 10; |
| gen.value_max = 100; |
| gen.sample_count = SAMPLE_COUNT; |
| GenerateRandomSamples(gen, &dockyard_); |
| |
| // Discard some samples. |
| DiscardSamplesRequest discard; |
| discard.start_time_ns = 0; |
| discard.end_time_ns = 300; |
| discard.dockyard_ids.push_back(dockyard_.GetDockyardId("fake0")); |
| dockyard_.DiscardSamples( |
| std::move(discard), [](const DiscardSamplesRequest& request, |
| const DiscardSamplesResponse& response) { |
| EXPECT_EQ(request.RequestId(), response.RequestId()); |
| }); |
| dockyard_.ProcessRequests(); |
| |
| // Add pending request. |
| StreamSetsRequest request; |
| request.start_time_ns = 100; |
| request.end_time_ns = 500; |
| request.sample_count = SAMPLE_COUNT; |
| request.render_style = StreamSetsRequest::RECENT; |
| request.dockyard_ids.push_back(dockyard_.GetDockyardId("fake0")); |
| dockyard_.GetStreamSets( |
| std::move(request), [SAMPLE_COUNT](const StreamSetsRequest& request, |
| const StreamSetsResponse& response) { |
| // Check results. |
| EXPECT_EQ(request.RequestId(), response.RequestId()); |
| EXPECT_EQ(10ULL, response.lowest_value); |
| EXPECT_EQ(100ULL, response.highest_value); |
| ASSERT_EQ(1UL, response.data_sets.size()); |
| ASSERT_EQ(SAMPLE_COUNT, response.data_sets[0].size()); |
| // Check the samples themselves. |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][0]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][9]); |
| EXPECT_EQ(dockyard::NO_DATA, response.data_sets[0][19]); |
| EXPECT_EQ(29ULL, response.data_sets[0][29]); |
| EXPECT_EQ(99ULL, response.data_sets[0][39]); |
| }); |
| dockyard_.ProcessRequests(); |
| } |
| |
| TEST_F(SystemMonitorDockyardTest, MessageTypes) { |
| #define TEST_MESSAGE_TYPES(x) \ |
| do { \ |
| dockyard::x##Request r1; \ |
| EXPECT_EQ(r1.GetMessageType(), dockyard::MessageType::k##x##Request); \ |
| } while (false) |
| |
| TEST_MESSAGE_TYPES(Connection); |
| TEST_MESSAGE_TYPES(DiscardSamples); |
| TEST_MESSAGE_TYPES(IgnoreSamples); |
| TEST_MESSAGE_TYPES(StreamSets); |
| TEST_MESSAGE_TYPES(UnignoreSamples); |
| |
| #undef TEST_MESSAGE_TYPES |
| } |
| |
| } // namespace |
| } // namespace dockyard |
