Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(493)

Side by Side Diff: media/cast/logging/logging_impl_unittest.cc

Issue 145873007: Cast: Added missing DCHECKs to ThreadChecker calls and minor cleanup. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebase Created 6 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « media/cast/audio_receiver/audio_receiver.cc ('k') | media/cast/logging/logging_raw_unittest.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include <vector> 5 #include <vector>
6 6
7 #include "base/rand_util.h" 7 #include "base/rand_util.h"
8 #include "base/test/simple_test_tick_clock.h" 8 #include "base/test/simple_test_tick_clock.h"
9 #include "base/time/tick_clock.h" 9 #include "base/time/tick_clock.h"
10 #include "base/time/time.h" 10 #include "base/time/time.h"
(...skipping 18 matching lines...) Expand all
29 LoggingImplTest() { 29 LoggingImplTest() {
30 // Enable all logging types. 30 // Enable all logging types.
31 config_.enable_raw_data_collection = true; 31 config_.enable_raw_data_collection = true;
32 config_.enable_stats_data_collection = true; 32 config_.enable_stats_data_collection = true;
33 config_.enable_tracing = true; 33 config_.enable_tracing = true;
34 34
35 testing_clock_.Advance( 35 testing_clock_.Advance(
36 base::TimeDelta::FromMilliseconds(kStartMillisecond)); 36 base::TimeDelta::FromMilliseconds(kStartMillisecond));
37 task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_); 37 task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_);
38 logging_.reset(new LoggingImpl(task_runner_, config_)); 38 logging_.reset(new LoggingImpl(task_runner_, config_));
39 event_subscriber_.reset(new SimpleEventSubscriber(task_runner_)); 39 logging_->AddRawEventSubscriber(&event_subscriber_);
40 logging_->AddRawEventSubscriber(event_subscriber_.get());
41 } 40 }
42 41
43 virtual ~LoggingImplTest() { 42 virtual ~LoggingImplTest() {
44 logging_->RemoveRawEventSubscriber(event_subscriber_.get()); 43 logging_->RemoveRawEventSubscriber(&event_subscriber_);
45 } 44 }
46 45
47 CastLoggingConfig config_; 46 CastLoggingConfig config_;
48 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; 47 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
49 scoped_ptr<LoggingImpl> logging_; 48 scoped_ptr<LoggingImpl> logging_;
50 base::SimpleTestTickClock testing_clock_; 49 base::SimpleTestTickClock testing_clock_;
51 scoped_ptr<SimpleEventSubscriber> event_subscriber_; 50 SimpleEventSubscriber event_subscriber_;
52 51
53 DISALLOW_COPY_AND_ASSIGN(LoggingImplTest); 52 DISALLOW_COPY_AND_ASSIGN(LoggingImplTest);
54 }; 53 };
55 54
56 TEST_F(LoggingImplTest, BasicFrameLogging) { 55 TEST_F(LoggingImplTest, BasicFrameLogging) {
57 base::TimeTicks start_time = testing_clock_.NowTicks(); 56 base::TimeTicks start_time = testing_clock_.NowTicks();
58 base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time; 57 base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
59 uint32 rtp_timestamp = 0; 58 uint32 rtp_timestamp = 0;
60 uint32 frame_id = 0; 59 uint32 frame_id = 0;
61 base::TimeTicks now; 60 base::TimeTicks now;
62 do { 61 do {
63 now = testing_clock_.NowTicks(); 62 now = testing_clock_.NowTicks();
64 logging_->InsertFrameEvent(now, kAudioFrameCaptured, rtp_timestamp, 63 logging_->InsertFrameEvent(now, kAudioFrameCaptured, rtp_timestamp,
65 frame_id); 64 frame_id);
66 testing_clock_.Advance( 65 testing_clock_.Advance(
67 base::TimeDelta::FromMilliseconds(kFrameIntervalMs)); 66 base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
68 rtp_timestamp += kFrameIntervalMs * 90; 67 rtp_timestamp += kFrameIntervalMs * 90;
69 ++frame_id; 68 ++frame_id;
70 time_interval = now - start_time; 69 time_interval = now - start_time;
71 } while (time_interval.InSeconds() < kIntervalTime1S); 70 } while (time_interval.InSeconds() < kIntervalTime1S);
72 base::TimeTicks end_time = now; 71 base::TimeTicks end_time = now;
73 72
74 // Get logging data. 73 // Get logging data.
75 std::vector<FrameEvent> frame_events; 74 std::vector<FrameEvent> frame_events;
76 event_subscriber_->GetFrameEventsAndReset(&frame_events); 75 event_subscriber_.GetFrameEventsAndReset(&frame_events);
77 // Size of vector should be equal to the number of events logged, 76 // Size of vector should be equal to the number of events logged,
78 // which equals to number of frames in this case. 77 // which equals to number of frames in this case.
79 EXPECT_EQ(frame_id, frame_events.size()); 78 EXPECT_EQ(frame_id, frame_events.size());
80 // Verify stats. 79 // Verify stats.
81 FrameStatsMap frame_stats = logging_->GetFrameStatsData(); 80 FrameStatsMap frame_stats = logging_->GetFrameStatsData();
82 // Size of stats equals the number of events. 81 // Size of stats equals the number of events.
83 EXPECT_EQ(1u, frame_stats.size()); 82 EXPECT_EQ(1u, frame_stats.size());
84 FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured); 83 FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured);
85 EXPECT_TRUE(it != frame_stats.end()); 84 EXPECT_TRUE(it != frame_stats.end());
86 EXPECT_EQ(0, it->second.max_delay.InMilliseconds()); 85 EXPECT_EQ(0, it->second.max_delay.InMilliseconds());
(...skipping 21 matching lines...) Expand all
108 logging_->InsertFrameEventWithSize(testing_clock_.NowTicks(), 107 logging_->InsertFrameEventWithSize(testing_clock_.NowTicks(),
109 kAudioFrameCaptured, rtp_timestamp, 108 kAudioFrameCaptured, rtp_timestamp,
110 frame_id, size); 109 frame_id, size);
111 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs)); 110 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
112 rtp_timestamp += kFrameIntervalMs * 90; 111 rtp_timestamp += kFrameIntervalMs * 90;
113 ++frame_id; 112 ++frame_id;
114 time_interval = testing_clock_.NowTicks() - start_time; 113 time_interval = testing_clock_.NowTicks() - start_time;
115 } while (time_interval.InSeconds() < kIntervalTime1S); 114 } while (time_interval.InSeconds() < kIntervalTime1S);
116 // Get logging data. 115 // Get logging data.
117 std::vector<FrameEvent> frame_events; 116 std::vector<FrameEvent> frame_events;
118 event_subscriber_->GetFrameEventsAndReset(&frame_events); 117 event_subscriber_.GetFrameEventsAndReset(&frame_events);
119 // Size of vector should be equal to the number of events logged, which 118 // Size of vector should be equal to the number of events logged, which
120 // equals to number of frames in this case. 119 // equals to number of frames in this case.
121 EXPECT_EQ(frame_id, frame_events.size()); 120 EXPECT_EQ(frame_id, frame_events.size());
122 // Verify stats. 121 // Verify stats.
123 FrameStatsMap frame_stats = logging_->GetFrameStatsData(); 122 FrameStatsMap frame_stats = logging_->GetFrameStatsData();
124 // Size of stats equals the number of events. 123 // Size of stats equals the number of events.
125 EXPECT_EQ(1u, frame_stats.size()); 124 EXPECT_EQ(1u, frame_stats.size());
126 FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured); 125 FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured);
127 EXPECT_TRUE(it != frame_stats.end()); 126 EXPECT_TRUE(it != frame_stats.end());
128 EXPECT_EQ(0, it->second.max_delay.InMilliseconds()); 127 EXPECT_EQ(0, it->second.max_delay.InMilliseconds());
(...skipping 16 matching lines...) Expand all
145 logging_->InsertFrameEventWithDelay( 144 logging_->InsertFrameEventWithDelay(
146 testing_clock_.NowTicks(), kAudioFrameCaptured, rtp_timestamp, frame_id, 145 testing_clock_.NowTicks(), kAudioFrameCaptured, rtp_timestamp, frame_id,
147 base::TimeDelta::FromMilliseconds(delay)); 146 base::TimeDelta::FromMilliseconds(delay));
148 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs)); 147 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
149 rtp_timestamp += kFrameIntervalMs * 90; 148 rtp_timestamp += kFrameIntervalMs * 90;
150 ++frame_id; 149 ++frame_id;
151 time_interval = testing_clock_.NowTicks() - start_time; 150 time_interval = testing_clock_.NowTicks() - start_time;
152 } while (time_interval.InSeconds() < kIntervalTime1S); 151 } while (time_interval.InSeconds() < kIntervalTime1S);
153 // Get logging data. 152 // Get logging data.
154 std::vector<FrameEvent> frame_events; 153 std::vector<FrameEvent> frame_events;
155 event_subscriber_->GetFrameEventsAndReset(&frame_events); 154 event_subscriber_.GetFrameEventsAndReset(&frame_events);
156 // Size of vector should be equal to the number of frames logged. 155 // Size of vector should be equal to the number of frames logged.
157 EXPECT_EQ(frame_id, frame_events.size()); 156 EXPECT_EQ(frame_id, frame_events.size());
158 // Verify stats. 157 // Verify stats.
159 FrameStatsMap frame_stats = logging_->GetFrameStatsData(); 158 FrameStatsMap frame_stats = logging_->GetFrameStatsData();
160 // Size of stats equals the number of events. 159 // Size of stats equals the number of events.
161 EXPECT_EQ(1u, frame_stats.size()); 160 EXPECT_EQ(1u, frame_stats.size());
162 FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured); 161 FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured);
163 EXPECT_TRUE(it != frame_stats.end()); 162 EXPECT_TRUE(it != frame_stats.end());
164 EXPECT_GE(kPlayoutDelayMs + kRandomSizeInterval, 163 EXPECT_GE(kPlayoutDelayMs + kRandomSizeInterval,
165 it->second.max_delay.InMilliseconds()); 164 it->second.max_delay.InMilliseconds());
(...skipping 25 matching lines...) Expand all
191 } 190 }
192 ++num_events; 191 ++num_events;
193 192
194 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs)); 193 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
195 rtp_timestamp += kFrameIntervalMs * 90; 194 rtp_timestamp += kFrameIntervalMs * 90;
196 ++frame_id; 195 ++frame_id;
197 time_interval = testing_clock_.NowTicks() - start_time; 196 time_interval = testing_clock_.NowTicks() - start_time;
198 } while (time_interval.InSeconds() < kIntervalTime1S); 197 } while (time_interval.InSeconds() < kIntervalTime1S);
199 // Get logging data. 198 // Get logging data.
200 std::vector<FrameEvent> frame_events; 199 std::vector<FrameEvent> frame_events;
201 event_subscriber_->GetFrameEventsAndReset(&frame_events); 200 event_subscriber_.GetFrameEventsAndReset(&frame_events);
202 // Size of vector should be equal to the number of frames logged. 201 // Size of vector should be equal to the number of frames logged.
203 EXPECT_EQ(num_events, frame_events.size()); 202 EXPECT_EQ(num_events, frame_events.size());
204 // Multiple events captured per frame. 203 // Multiple events captured per frame.
205 } 204 }
206 205
207 TEST_F(LoggingImplTest, PacketLogging) { 206 TEST_F(LoggingImplTest, PacketLogging) {
208 const int kNumPacketsPerFrame = 10; 207 const int kNumPacketsPerFrame = 10;
209 const int kBaseSize = 2500; 208 const int kBaseSize = 2500;
210 const int kSizeInterval = 100; 209 const int kSizeInterval = 100;
211 base::TimeTicks start_time = testing_clock_.NowTicks(); 210 base::TimeTicks start_time = testing_clock_.NowTicks();
212 base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time; 211 base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
213 uint32 rtp_timestamp = 0; 212 uint32 rtp_timestamp = 0;
214 uint32 frame_id = 0; 213 uint32 frame_id = 0;
215 do { 214 do {
216 for (int i = 0; i < kNumPacketsPerFrame; ++i) { 215 for (int i = 0; i < kNumPacketsPerFrame; ++i) {
217 int size = kBaseSize + base::RandInt(-kSizeInterval, kSizeInterval); 216 int size = kBaseSize + base::RandInt(-kSizeInterval, kSizeInterval);
218 logging_->InsertPacketEvent(testing_clock_.NowTicks(), kPacketSentToPacer, 217 logging_->InsertPacketEvent(testing_clock_.NowTicks(), kPacketSentToPacer,
219 rtp_timestamp, frame_id, i, 218 rtp_timestamp, frame_id, i,
220 kNumPacketsPerFrame, size); 219 kNumPacketsPerFrame, size);
221 } 220 }
222 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs)); 221 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
223 rtp_timestamp += kFrameIntervalMs * 90; 222 rtp_timestamp += kFrameIntervalMs * 90;
224 ++frame_id; 223 ++frame_id;
225 time_interval = testing_clock_.NowTicks() - start_time; 224 time_interval = testing_clock_.NowTicks() - start_time;
226 } while (time_interval.InSeconds() < kIntervalTime1S); 225 } while (time_interval.InSeconds() < kIntervalTime1S);
227 // Get logging data. 226 // Get logging data.
228 std::vector<PacketEvent> packet_events; 227 std::vector<PacketEvent> packet_events;
229 event_subscriber_->GetPacketEventsAndReset(&packet_events); 228 event_subscriber_.GetPacketEventsAndReset(&packet_events);
230 // Size of vector should be equal to the number of packets logged. 229 // Size of vector should be equal to the number of packets logged.
231 EXPECT_EQ(frame_id * kNumPacketsPerFrame, packet_events.size()); 230 EXPECT_EQ(frame_id * kNumPacketsPerFrame, packet_events.size());
232 // Verify stats. 231 // Verify stats.
233 PacketStatsMap stats_map = logging_->GetPacketStatsData(); 232 PacketStatsMap stats_map = logging_->GetPacketStatsData();
234 // Size of stats equals the number of events. 233 // Size of stats equals the number of events.
235 EXPECT_EQ(1u, stats_map.size()); 234 EXPECT_EQ(1u, stats_map.size());
236 PacketStatsMap::const_iterator it = stats_map.find(kPacketSentToPacer); 235 PacketStatsMap::const_iterator it = stats_map.find(kPacketSentToPacer);
237 EXPECT_TRUE(it != stats_map.end()); 236 EXPECT_TRUE(it != stats_map.end());
238 } 237 }
239 238
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
280 max_value = value; 279 max_value = value;
281 } else if (min_value > value) { 280 } else if (min_value > value) {
282 min_value = value; 281 min_value = value;
283 } else if (max_value < value) { 282 } else if (max_value < value) {
284 max_value = value; 283 max_value = value;
285 } 284 }
286 } 285 }
287 286
288 // Size of generic event vector = number of generic events logged. 287 // Size of generic event vector = number of generic events logged.
289 std::vector<GenericEvent> generic_events; 288 std::vector<GenericEvent> generic_events;
290 event_subscriber_->GetGenericEventsAndReset(&generic_events); 289 event_subscriber_.GetGenericEventsAndReset(&generic_events);
291 EXPECT_EQ(num_events, generic_events.size()); 290 EXPECT_EQ(num_events, generic_events.size());
292 291
293 // Verify each type of event has expected number of events logged. 292 // Verify each type of event has expected number of events logged.
294 uint32 rtt_event_count = 0u; 293 uint32 rtt_event_count = 0u;
295 uint32 packet_loss_event_count = 0u; 294 uint32 packet_loss_event_count = 0u;
296 uint32 jitter_event_count = 0u; 295 uint32 jitter_event_count = 0u;
297 for (std::vector<GenericEvent>::iterator it = generic_events.begin(); 296 for (std::vector<GenericEvent>::iterator it = generic_events.begin();
298 it != generic_events.end(); ++it) { 297 it != generic_events.end(); ++it) {
299 if (it->type == kRttMs) { 298 if (it->type == kRttMs) {
300 ++rtt_event_count; 299 ++rtt_event_count;
(...skipping 18 matching lines...) Expand all
319 EXPECT_EQ(sumsq_value_pl, sit->second.sum_squared); 318 EXPECT_EQ(sumsq_value_pl, sit->second.sum_squared);
320 EXPECT_LE(min_value, sit->second.min); 319 EXPECT_LE(min_value, sit->second.min);
321 EXPECT_GE(max_value, sit->second.max); 320 EXPECT_GE(max_value, sit->second.max);
322 sit = stats_map.find(kJitterMs); 321 sit = stats_map.find(kJitterMs);
323 EXPECT_EQ(sumsq_value_jitter, sit->second.sum_squared); 322 EXPECT_EQ(sumsq_value_jitter, sit->second.sum_squared);
324 EXPECT_LE(min_value, sit->second.min); 323 EXPECT_LE(min_value, sit->second.min);
325 EXPECT_GE(max_value, sit->second.max); 324 EXPECT_GE(max_value, sit->second.max);
326 } 325 }
327 326
328 TEST_F(LoggingImplTest, MultipleRawEventSubscribers) { 327 TEST_F(LoggingImplTest, MultipleRawEventSubscribers) {
329 SimpleEventSubscriber event_subscriber_2(task_runner_); 328 SimpleEventSubscriber event_subscriber_2;
330 329
331 // Now logging_ has two subscribers. 330 // Now logging_ has two subscribers.
332 logging_->AddRawEventSubscriber(&event_subscriber_2); 331 logging_->AddRawEventSubscriber(&event_subscriber_2);
333 332
334 logging_->InsertFrameEvent(testing_clock_.NowTicks(), kAudioFrameCaptured, 333 logging_->InsertFrameEvent(testing_clock_.NowTicks(), kAudioFrameCaptured,
335 /*rtp_timestamp*/ 0u, 334 /*rtp_timestamp*/ 0u,
336 /*frame_id*/ 0u); 335 /*frame_id*/ 0u);
337 336
338 std::vector<FrameEvent> frame_events; 337 std::vector<FrameEvent> frame_events;
339 event_subscriber_->GetFrameEventsAndReset(&frame_events); 338 event_subscriber_.GetFrameEventsAndReset(&frame_events);
340 EXPECT_EQ(1u, frame_events.size()); 339 EXPECT_EQ(1u, frame_events.size());
341 frame_events.clear(); 340 frame_events.clear();
342 event_subscriber_2.GetFrameEventsAndReset(&frame_events); 341 event_subscriber_2.GetFrameEventsAndReset(&frame_events);
343 EXPECT_EQ(1u, frame_events.size()); 342 EXPECT_EQ(1u, frame_events.size());
344 343
345 logging_->RemoveRawEventSubscriber(&event_subscriber_2); 344 logging_->RemoveRawEventSubscriber(&event_subscriber_2);
346 } 345 }
347 346
348 } // namespace cast 347 } // namespace cast
349 } // namespace media 348 } // namespace media
OLDNEW
« no previous file with comments | « media/cast/audio_receiver/audio_receiver.cc ('k') | media/cast/logging/logging_raw_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698