src/media/cast/logging/logging_impl_unittest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include <stdint.h>
   6
   7 #include <vector>
   8
   9 #include "base/rand_util.h"
  10 #include "base/test/simple_test_tick_clock.h"
  11 #include "base/time/tick_clock.h"
  12 #include "base/time/time.h"
  13 #include "media/cast/logging/logging_defines.h"
  14 #include "media/cast/logging/logging_impl.h"
  15 #include "media/cast/logging/simple_event_subscriber.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace media {
  19 namespace cast {
  20
  21 // Insert frame duration- one second.
  22 const int64 kIntervalTime1S = 1;
  23 // Test frame rate goal - 30fps.
  24 const int kFrameIntervalMs = 33;
  25
  26 static const int64 kStartMillisecond = INT64_C(12345678900000);
  27
  28 class LoggingImplTest : public ::testing::Test {
  29  protected:
  30   LoggingImplTest() {
  31     testing_clock_.Advance(
  32         base::TimeDelta::FromMilliseconds(kStartMillisecond));
  33     logging_.AddRawEventSubscriber(&event_subscriber_);
  34   }
  35
  36   virtual ~LoggingImplTest() {
  37     logging_.RemoveRawEventSubscriber(&event_subscriber_);
  38   }
  39
  40   LoggingImpl logging_;
  41   base::SimpleTestTickClock testing_clock_;
  42   SimpleEventSubscriber event_subscriber_;
  43
  44   DISALLOW_COPY_AND_ASSIGN(LoggingImplTest);
  45 };
  46
  47 TEST_F(LoggingImplTest, BasicFrameLogging) {
  48   base::TimeTicks start_time = testing_clock_.NowTicks();
  49   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
  50   uint32 rtp_timestamp = 0;
  51   uint32 frame_id = 0;
  52   base::TimeTicks now;
  53   do {
  54     now = testing_clock_.NowTicks();
  55     logging_.InsertFrameEvent(
  56         now, kAudioFrameCaptureBegin, rtp_timestamp, frame_id);
  57     testing_clock_.Advance(
  58         base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
  59     rtp_timestamp += kFrameIntervalMs * 90;
  60     ++frame_id;
  61     time_interval = now - start_time;
  62   }  while (time_interval.InSeconds() < kIntervalTime1S);
  63
  64   // Get logging data.
  65   std::vector<FrameEvent> frame_events;
  66   event_subscriber_.GetFrameEventsAndReset(&frame_events);
  67   // Size of vector should be equal to the number of events logged,
  68   // which equals to number of frames in this case.
  69   EXPECT_EQ(frame_id, frame_events.size());
  70 }
  71
  72 TEST_F(LoggingImplTest, FrameLoggingWithSize) {
  73   // Average packet size.
  74   const int kBaseFrameSizeBytes = 25000;
  75   const int kRandomSizeInterval = 100;
  76   base::TimeTicks start_time = testing_clock_.NowTicks();
  77   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
  78   uint32 rtp_timestamp = 0;
  79   uint32 frame_id = 0;
  80   size_t sum_size = 0;
  81   int target_bitrate = 1234;
  82   do {
  83     int size = kBaseFrameSizeBytes +
  84         base::RandInt(-kRandomSizeInterval, kRandomSizeInterval);
  85     sum_size += static_cast<size_t>(size);
  86     logging_.InsertEncodedFrameEvent(testing_clock_.NowTicks(),
  87                                      kVideoFrameEncoded, rtp_timestamp,
  88                                      frame_id, size, true, target_bitrate);
  89     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
  90     rtp_timestamp += kFrameIntervalMs * 90;
  91     ++frame_id;
  92     time_interval = testing_clock_.NowTicks() - start_time;
  93   } while (time_interval.InSeconds() < kIntervalTime1S);
  94   // Get logging data.
  95   std::vector<FrameEvent> frame_events;
  96   event_subscriber_.GetFrameEventsAndReset(&frame_events);
  97   // Size of vector should be equal to the number of events logged, which
  98   // equals to number of frames in this case.
  99   EXPECT_EQ(frame_id, frame_events.size());
 100 }
 101
 102 TEST_F(LoggingImplTest, FrameLoggingWithDelay) {
 103   // Average packet size.
 104   const int kPlayoutDelayMs = 50;
 105   const int kRandomSizeInterval = 20;
 106   base::TimeTicks start_time = testing_clock_.NowTicks();
 107   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
 108   uint32 rtp_timestamp = 0;
 109   uint32 frame_id = 0;
 110   do {
 111     int delay = kPlayoutDelayMs +
 112                 base::RandInt(-kRandomSizeInterval, kRandomSizeInterval);
 113     logging_.InsertFrameEventWithDelay(
 114         testing_clock_.NowTicks(),
 115         kAudioFrameCaptureBegin,
 116         rtp_timestamp,
 117         frame_id,
 118         base::TimeDelta::FromMilliseconds(delay));
 119     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
 120     rtp_timestamp += kFrameIntervalMs * 90;
 121     ++frame_id;
 122     time_interval = testing_clock_.NowTicks() - start_time;
 123   } while (time_interval.InSeconds() < kIntervalTime1S);
 124   // Get logging data.
 125   std::vector<FrameEvent> frame_events;
 126   event_subscriber_.GetFrameEventsAndReset(&frame_events);
 127   // Size of vector should be equal to the number of frames logged.
 128   EXPECT_EQ(frame_id, frame_events.size());
 129 }
 130
 131 TEST_F(LoggingImplTest, MultipleEventFrameLogging) {
 132   base::TimeTicks start_time = testing_clock_.NowTicks();
 133   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
 134   uint32 rtp_timestamp = 0u;
 135   uint32 frame_id = 0u;
 136   uint32 num_events = 0u;
 137   do {
 138     logging_.InsertFrameEvent(testing_clock_.NowTicks(),
 139                               kAudioFrameCaptureBegin,
 140                               rtp_timestamp,
 141                               frame_id);
 142     ++num_events;
 143     if (frame_id % 2) {
 144       logging_.InsertEncodedFrameEvent(testing_clock_.NowTicks(),
 145                                        kAudioFrameEncoded, rtp_timestamp,
 146                                        frame_id, 1500, true, 0);
 147     } else if (frame_id % 3) {
 148       logging_.InsertFrameEvent(testing_clock_.NowTicks(), kVideoFrameDecoded,
 149                                  rtp_timestamp, frame_id);
 150     } else {
 151       logging_.InsertFrameEventWithDelay(
 152           testing_clock_.NowTicks(), kVideoRenderDelay, rtp_timestamp, frame_id,
 153           base::TimeDelta::FromMilliseconds(20));
 154     }
 155     ++num_events;
 156
 157     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
 158     rtp_timestamp += kFrameIntervalMs * 90;
 159     ++frame_id;
 160     time_interval = testing_clock_.NowTicks() - start_time;
 161   } while (time_interval.InSeconds() < kIntervalTime1S);
 162   // Get logging data.
 163   std::vector<FrameEvent> frame_events;
 164   event_subscriber_.GetFrameEventsAndReset(&frame_events);
 165   // Size of vector should be equal to the number of frames logged.
 166   EXPECT_EQ(num_events, frame_events.size());
 167   // Multiple events captured per frame.
 168 }
 169
 170 TEST_F(LoggingImplTest, PacketLogging) {
 171   const int kNumPacketsPerFrame = 10;
 172   const int kBaseSize = 2500;
 173   const int kSizeInterval = 100;
 174   base::TimeTicks start_time = testing_clock_.NowTicks();
 175   base::TimeTicks latest_time;
 176   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
 177   RtpTimestamp rtp_timestamp = 0;
 178   int frame_id = 0;
 179   int num_packets = 0;
 180   int sum_size = 0u;
 181   do {
 182     for (int i = 0; i < kNumPacketsPerFrame; ++i) {
 183       int size = kBaseSize + base::RandInt(-kSizeInterval, kSizeInterval);
 184       sum_size += size;
 185       latest_time = testing_clock_.NowTicks();
 186       ++num_packets;
 187       logging_.InsertPacketEvent(latest_time,
 188                                   kDuplicateVideoPacketReceived,
 189                                   rtp_timestamp,
 190                                   frame_id,
 191                                   i,
 192                                   kNumPacketsPerFrame,
 193                                   size);
 194     }
 195     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
 196     rtp_timestamp += kFrameIntervalMs * 90;
 197     ++frame_id;
 198     time_interval = testing_clock_.NowTicks() - start_time;
 199   } while (time_interval.InSeconds() < kIntervalTime1S);
 200   // Get logging data.
 201   std::vector<PacketEvent> packet_events;
 202   event_subscriber_.GetPacketEventsAndReset(&packet_events);
 203   // Size of vector should be equal to the number of packets logged.
 204   EXPECT_EQ(num_packets, static_cast<int>(packet_events.size()));
 205 }
 206
 207 TEST_F(LoggingImplTest, MultipleRawEventSubscribers) {
 208   SimpleEventSubscriber event_subscriber_2;
 209
 210   // Now logging_ has two subscribers.
 211   logging_.AddRawEventSubscriber(&event_subscriber_2);
 212
 213   logging_.InsertFrameEvent(testing_clock_.NowTicks(),
 214                             kAudioFrameCaptureBegin,
 215                             /*rtp_timestamp*/ 0u,
 216                             /*frame_id*/ 0u);
 217
 218   std::vector<FrameEvent> frame_events;
 219   event_subscriber_.GetFrameEventsAndReset(&frame_events);
 220   EXPECT_EQ(1u, frame_events.size());
 221   frame_events.clear();
 222   event_subscriber_2.GetFrameEventsAndReset(&frame_events);
 223   EXPECT_EQ(1u, frame_events.size());
 224
 225   logging_.RemoveRawEventSubscriber(&event_subscriber_2);
 226 }
 227
 228 }  // namespace cast
 229 }  // namespace media