media/base/test_helpers.h

   1 // Copyright (c) 2012 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 #ifndef MEDIA_BASE_TEST_HELPERS_H_
   6 #define MEDIA_BASE_TEST_HELPERS_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/callback.h"
  10 #include "media/base/channel_layout.h"
  11 #include "media/base/pipeline_status.h"
  12 #include "media/base/sample_format.h"
  13 #include "media/base/video_decoder_config.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "ui/gfx/size.h"
  16
  17 namespace base {
  18 class MessageLoop;
  19 class TimeDelta;
  20 }
  21
  22 namespace media {
  23
  24 class AudioBuffer;
  25 class DecoderBuffer;
  26
  27 // Return a callback that expects to be run once.
  28 base::Closure NewExpectedClosure();
  29 PipelineStatusCB NewExpectedStatusCB(PipelineStatus status);
  30
  31 // Helper class for running a message loop until a callback has run. Useful for
  32 // testing classes that run on more than a single thread.
  33 //
  34 // Events are intended for single use and cannot be reset.
  35 class WaitableMessageLoopEvent {
  36  public:
  37   WaitableMessageLoopEvent();
  38   ~WaitableMessageLoopEvent();
  39
  40   // Returns a thread-safe closure that will signal |this| when executed.
  41   base::Closure GetClosure();
  42   PipelineStatusCB GetPipelineStatusCB();
  43
  44   // Runs the current message loop until |this| has been signaled.
  45   //
  46   // Fails the test if the timeout is reached.
  47   void RunAndWait();
  48
  49   // Runs the current message loop until |this| has been signaled and asserts
  50   // that the |expected| status was received.
  51   //
  52   // Fails the test if the timeout is reached.
  53   void RunAndWaitForStatus(PipelineStatus expected);
  54
  55  private:
  56   void OnCallback(PipelineStatus status);
  57   void OnTimeout();
  58
  59   base::MessageLoop* message_loop_;
  60   bool signaled_;
  61   PipelineStatus status_;
  62
  63   DISALLOW_COPY_AND_ASSIGN(WaitableMessageLoopEvent);
  64 };
  65
  66 // Provides pre-canned VideoDecoderConfig. These types are used for tests that
  67 // don't care about detailed parameters of the config.
  68 class TestVideoConfig {
  69  public:
  70   // Returns a configuration that is invalid.
  71   static VideoDecoderConfig Invalid();
  72
  73   static VideoDecoderConfig Normal();
  74   static VideoDecoderConfig NormalEncrypted();
  75
  76   // Returns a configuration that is larger in dimensions than Normal().
  77   static VideoDecoderConfig Large();
  78   static VideoDecoderConfig LargeEncrypted();
  79
  80   // Returns coded size for Normal and Large config.
  81   static gfx::Size NormalCodedSize();
  82   static gfx::Size LargeCodedSize();
  83
  84  private:
  85   DISALLOW_IMPLICIT_CONSTRUCTORS(TestVideoConfig);
  86 };
  87
  88 // Create an AudioBuffer containing |frames| frames of data, where each sample
  89 // is of type T.
  90 //
  91 // For interleaved formats, each frame will have the data from |channels|
  92 // channels interleaved. |start| and |increment| are used to specify the values
  93 // for the samples. Since this is interleaved data, channel 0 data will be:
  94 //   |start|
  95 //   |start| + |channels| * |increment|
  96 //   |start| + 2 * |channels| * |increment|, and so on.
  97 // Data for subsequent channels is similar. No check is done that |format|
  98 // requires data to be of type T, but it is verified that |format| is an
  99 // interleaved format.
 100 //
 101 // For planar formats, there will be a block for each of |channel| channels.
 102 // |start| and |increment| are used to specify the values for the samples, which
 103 // are created in channel order. Since this is planar data, channel 0 data will
 104 // be:
 105 //   |start|
 106 //   |start| + |increment|
 107 //   |start| + 2 * |increment|, and so on.
 108 // Data for channel 1 will follow where channel 0 ends. Subsequent channels are
 109 // similar. No check is done that |format| requires data to be of type T, but it
 110 // is verified that |format| is a planar format.
 111 //
 112 // |start_time| will be used as the start time for the samples. |duration| is
 113 // the duration.
 114 template <class T>
 115 scoped_refptr<AudioBuffer> MakeAudioBuffer(SampleFormat format,
 116                                            ChannelLayout channel_layout,
 117                                            int channel_count,
 118                                            int sample_rate,
 119                                            T start,
 120                                            T increment,
 121                                            int frames,
 122                                            base::TimeDelta timestamp,
 123                                            base::TimeDelta duration);
 124
 125 // Create a fake video DecoderBuffer for testing purpose. The buffer contains
 126 // part of video decoder config info embedded so that the testing code can do
 127 // some sanity check.
 128 scoped_refptr<DecoderBuffer> CreateFakeVideoBufferForTest(
 129     const VideoDecoderConfig& config,
 130     base::TimeDelta timestamp,
 131     base::TimeDelta duration);
 132
 133 // Verify if a fake video DecoderBuffer is valid.
 134 bool VerifyFakeVideoBufferForTest(const scoped_refptr<DecoderBuffer>& buffer,
 135                                   const VideoDecoderConfig& config);
 136
 137 }  // namespace media
 138
 139 #endif  // MEDIA_BASE_TEST_HELPERS_H_