OLD | NEW |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 |
OLD | NEW |