Fold Pipeline initialization failure tests added in r150636 into PipelineTeardownTest.

media/base/pipeline_unittest.cc

 // Copyright (c) 2012 The Chromium 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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
@@ skipping 860 matching lines @@
   EXPECT_EQ(pipeline_->GetMediaTime(), seek_time);
 
   // Now that the seek is complete, verify that time updates advance the current
   // time.
   base::TimeDelta new_time = seek_time + base::TimeDelta::FromMilliseconds(100);
   audio_time_cb_.Run(new_time, new_time);
 
   EXPECT_EQ(pipeline_->GetMediaTime(), new_time);
 }
 
-TEST_F(PipelineTest, InitFailure_Demuxer) {
-  PipelineStatus expected_status = DEMUXER_ERROR_COULD_NOT_OPEN;
-  EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
-      .WillOnce(RunPipelineStatusCBWithStatus(expected_status));
-  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
-  InitializePipeline(expected_status);
-}
-
-TEST_F(PipelineTest, InitFailure_AudioDecoder) {
-  CreateAudioStream();
-  MockDemuxerStreamVector streams;
-  streams.push_back(audio_stream());
-
-  InitializeDemuxer(&streams);
-
-  PipelineStatus expected_status = PIPELINE_ERROR_DECODE;
-  scoped_refptr<DemuxerStream> stream = streams[0];
-  EXPECT_CALL(*mocks_->audio_decoder(), Initialize(stream, _, _))
-      .WillOnce(RunPipelineStatusCBWithStatus(expected_status));
-
-  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
-
-  InitializePipeline(expected_status);
-  EXPECT_FALSE(pipeline_->HasAudio());
-}
-
-TEST_F(PipelineTest, InitFailure_AudioRenderer) {
-  CreateAudioStream();
-  MockDemuxerStreamVector streams;
-  streams.push_back(audio_stream());
-
-  InitializeDemuxer(&streams);
-  InitializeAudioDecoder(audio_stream());
-
-  PipelineStatus expected_status = PIPELINE_ERROR_INITIALIZATION_FAILED;
-  EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
-      scoped_refptr<AudioDecoder>(mocks_->audio_decoder()),
-      _, _, _, _, _, _))
-      .WillOnce(RunPipelineStatusCBWithStatus(expected_status));
-
-  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
-  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
-      .WillOnce(RunClosure());
-
-  InitializePipeline(expected_status);
-  EXPECT_TRUE(pipeline_->HasAudio());
-}
-
-TEST_F(PipelineTest, InitFailure_VideoDecoder) {
-  CreateAudioStream();
-  CreateVideoStream();
-  MockDemuxerStreamVector streams;
-  streams.push_back(audio_stream());
-  streams.push_back(video_stream());
-
-  InitializeDemuxer(&streams);
-  InitializeAudioDecoder(audio_stream());
-  InitializeAudioRenderer();
-
-  PipelineStatus expected_status = PIPELINE_ERROR_DECODE;
-  scoped_refptr<DemuxerStream> stream = streams[1];
-  EXPECT_CALL(*mocks_->video_decoder(),
-              Initialize(stream, _, _))
-      .WillOnce(RunPipelineStatusCBWithStatus(expected_status));
-
-  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
-  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
-      .WillOnce(RunClosure());
-
-  InitializePipeline(expected_status);
-  EXPECT_TRUE(pipeline_->HasAudio());
-  EXPECT_FALSE(pipeline_->HasVideo());
-}
-
-TEST_F(PipelineTest, InitFailure_VideoRenderer) {
-  CreateAudioStream();
-  CreateVideoStream();
-  MockDemuxerStreamVector streams;
-  streams.push_back(audio_stream());
-  streams.push_back(video_stream());
-
-  InitializeDemuxer(&streams);
-  InitializeAudioDecoder(audio_stream());
-  InitializeAudioRenderer();
-  InitializeVideoDecoder(video_stream());
-
-  PipelineStatus expected_status = PIPELINE_ERROR_INITIALIZATION_FAILED;
-  EXPECT_CALL(*mocks_->video_renderer(), Initialize(
-        scoped_refptr<VideoDecoder>(mocks_->video_decoder()),
-        _, _, _, _, _, _, _, _))
-        .WillOnce(RunPipelineStatusCBWithStatus(expected_status));
-
-  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
-  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
-      .WillOnce(RunClosure());
-  EXPECT_CALL(*mocks_->video_renderer(), Stop(_))
-      .WillOnce(RunClosure());
-
-  InitializePipeline(expected_status);
-  EXPECT_TRUE(pipeline_->HasAudio());
-  EXPECT_TRUE(pipeline_->HasVideo());
-}
-
 class FlexibleCallbackRunner : public base::DelegateSimpleThread::Delegate {
  public:
   FlexibleCallbackRunner(base::TimeDelta delay, PipelineStatus status,
                          const PipelineStatusCB& status_cb)
       : delay_(delay),
         status_(status),
         status_cb_(status_cb) {
     if (delay_ < base::TimeDelta()) {
       status_cb_.Run(status_);
       return;
@@ skipping 36 matching lines @@
 
 // Test that different-thread, some-delay callback (the expected common case)
 // works correctly.
 TEST(PipelineStatusNotificationTest, DelayedCallback) {
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(20));
 }
 
 class PipelineTeardownTest : public PipelineTest {
  public:
   enum TeardownState {
+    kInitDemuxer,
+    kInitAudioDecoder,
+    kInitAudioRenderer,
+    kInitVideoDecoder,
+    kInitVideoRenderer,
     kPausing,
     kFlushing,
     kSeeking,
     kPrerolling,
     kStarting,
     kPlaying,
   };
 
   enum StopOrError {
     kStop,
     kError,
   };
 
-  PipelineTeardownTest() {
-    CreateAudioStream();
-    MockDemuxerStreamVector streams;
-    streams.push_back(audio_stream());
-
-    InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
-    InitializeAudioDecoder(audio_stream());
-    InitializeAudioRenderer();
-    InitializePipeline(PIPELINE_OK);
-  }
+  PipelineTeardownTest() {}
+  virtual ~PipelineTeardownTest() {}
 
   void RunTest(TeardownState state, StopOrError stop_or_error) {
-    InSequence s;
     switch (state) {
+      case kInitDemuxer:
+      case kInitAudioDecoder:
+      case kInitAudioRenderer:
+      case kInitVideoDecoder:
+      case kInitVideoRenderer:
+        DoInitialize(state, stop_or_error);
+        break;
+
       case kPausing:
       case kFlushing:
       case kSeeking:
       case kPrerolling:
-      case kStarting:
+      case kStarting: {
+        DoInitialize(state, stop_or_error);
+
+        InSequence s;
         if (stop_or_error == kStop) {
           ExpectSeekStop(state);
         } else {
           ExpectSeekError(state);
         }
         DoSeek();
         break;
+      }
 
-      case kPlaying:
+      case kPlaying: {
+        DoInitialize(state, stop_or_error);
+
+        InSequence s;
         if (stop_or_error == kStop) {
           ExpectStop();
           DoStop();
         } else {
           ExpectPlaybackError();
           DoPlaybackError();
         }
         break;
+      }
     }
   }
 
  private:
   // TODO(scherkus): We do radically different things whether teardown is
   // invoked via stop vs error. The teardown path should be the same,
   // see http://crbug.com/110228
+  void DoInitialize(TeardownState state, StopOrError stop_or_error) {
+    PipelineStatus expected_status =
+        SetInitializeExpectations(state, stop_or_error);
+
+    EXPECT_CALL(callbacks_, OnStart(expected_status));
+    pipeline_->Start(
+        mocks_->Create().Pass(),
+        base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
+        base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
+        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
+    message_loop_.RunAllPending();
+  }
+
+  PipelineStatus SetInitializeExpectations(TeardownState state,
+                                           StopOrError stop_or_error) {
+    PipelineStatus status = PIPELINE_OK;
+    base::Closure stop_cb = base::Bind(
+        &CallbackHelper::OnStop, base::Unretained(&callbacks_));
+
+    if (state == kInitDemuxer) {
+      if (stop_or_error == kStop) {
+        EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
+        EXPECT_CALL(callbacks_, OnStop());
+      } else {
+        status = DEMUXER_ERROR_COULD_NOT_OPEN;
+        EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
+            .WillOnce(RunPipelineStatusCBWithStatus(status));
+      }
+
+      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+      return status;
+    }
+
+    CreateAudioStream();
+    CreateVideoStream();
+    MockDemuxerStreamVector streams;
+    streams.push_back(audio_stream());
+    streams.push_back(video_stream());
+    InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
+
+    if (state == kInitAudioDecoder) {
+      if (stop_or_error == kStop) {
+        EXPECT_CALL(*mocks_->audio_decoder(), Initialize(_, _, _))
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
+        EXPECT_CALL(callbacks_, OnStop());
+      } else {
+        status = PIPELINE_ERROR_DECODE;
+        EXPECT_CALL(*mocks_->audio_decoder(), Initialize(_, _, _))
+            .WillOnce(RunPipelineStatusCBWithStatus(status));
+      }
+
+      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+      return status;
+    }
+
+    EXPECT_CALL(*mocks_->audio_decoder(), Initialize(_, _, _))
+        .WillOnce(RunPipelineStatusCB());
+
+    if (state == kInitAudioRenderer) {
+      if (stop_or_error == kStop) {
+        EXPECT_CALL(*mocks_->audio_renderer(), Initialize(_, _, _, _, _, _, _))
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
+        EXPECT_CALL(callbacks_, OnStop());
+      } else {
+        status = PIPELINE_ERROR_INITIALIZATION_FAILED;
+        EXPECT_CALL(*mocks_->audio_renderer(), Initialize(_, _, _, _, _, _, _))
+            .WillOnce(RunPipelineStatusCBWithStatus(status));
+      }
+
+      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+      EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+      return status;
+    }
+
+    EXPECT_CALL(*mocks_->audio_renderer(), Initialize(_, _, _, _, _, _, _))
+        .WillOnce(RunPipelineStatusCB());
+
+    if (state == kInitVideoDecoder) {
+      if (stop_or_error == kStop) {
+        EXPECT_CALL(*mocks_->video_decoder(), Initialize(_, _, _))
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
+        EXPECT_CALL(callbacks_, OnStop());
+      } else {
+        status = PIPELINE_ERROR_DECODE;
+        EXPECT_CALL(*mocks_->video_decoder(), Initialize(_, _, _))
+            .WillOnce(RunPipelineStatusCBWithStatus(status));
+      }
+
+      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+      EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+      return status;
+    }
+
+    EXPECT_CALL(*mocks_->video_decoder(), Initialize(_, _, _))
+        .WillOnce(RunPipelineStatusCB());
+
+    if (state == kInitVideoRenderer) {
+      if (stop_or_error == kStop) {
+        EXPECT_CALL(*mocks_->video_renderer(),
+                    Initialize(_, _, _, _, _, _, _, _, _))
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
+        EXPECT_CALL(callbacks_, OnStop());
+      } else {
+        status = PIPELINE_ERROR_INITIALIZATION_FAILED;
+        EXPECT_CALL(*mocks_->video_renderer(),
+                    Initialize(_, _, _, _, _, _, _, _, _))
+            .WillOnce(RunPipelineStatusCBWithStatus(status));
+      }
+
+      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+      EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+      EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
+      return status;
+    }
+
+    EXPECT_CALL(*mocks_->video_renderer(),
+                Initialize(_, _, _, _, _, _, _, _, _))
+        .WillOnce(RunPipelineStatusCB());
+
+    // If we get here it's a successful initialization.
+    EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
+    EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
+    EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
+
+    EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
+
+    EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
+        .WillOnce(RunPipelineStatusCB());
+    EXPECT_CALL(*mocks_->video_renderer(), Preroll(base::TimeDelta(), _))
+        .WillOnce(RunPipelineStatusCB());
+
+    EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
+        .WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->video_renderer(), Play(_))
+        .WillOnce(RunClosure());
+
+    return status;
+  }
+
   void ExpectSeekStop(TeardownState state) {
     base::Closure stop_cb = base::Bind(
         &CallbackHelper::OnStop, base::Unretained(&callbacks_));
 
     if (state == kPausing) {
       EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
           .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
     }
 
+    EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
+
     if (state == kFlushing) {
       EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
           .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
     }
 
+    EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
+
     if (state == kSeeking) {
       EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
           .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
     } else {
       EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
           .WillOnce(RunPipelineStatusCB());
     }
 
     if (state == kPrerolling) {
       EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
           .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
           .WillOnce(RunPipelineStatusCB());
     }
 
+    EXPECT_CALL(*mocks_->video_renderer(), Preroll(_, _))
+        .WillOnce(RunPipelineStatusCB());
+
     if (state == kStarting) {
       EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
           .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(), Play(_)).WillOnce(RunClosure());
     }
 
+    EXPECT_CALL(*mocks_->video_renderer(), Play(_)).WillOnce(RunClosure());
+
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
     ExpectStop();
   }
 
   void ExpectSeekError(TeardownState state) {
     SetSeekErrorExpectations(state);
 
     // Executed after the error is raised.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
     EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
     EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
   }
 
   void SetSeekErrorExpectations(TeardownState state) {
     if (state == kPausing) {
       EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
           .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ),
                           RunClosure()));
+      EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
       return;
     }
 
     EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
 
     if (state == kFlushing) {
       EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
           .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ),
                           RunClosure()));
+      EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
       return;
     }
 
     EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
 
     if (state == kSeeking) {
       EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
           .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_READ));
       return;
     }
 
     EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
         .WillOnce(RunPipelineStatusCB());
 
     if (state == kPrerolling) {
       EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
           .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_READ));
       return;
     }
 
     EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
         .WillOnce(RunPipelineStatusCB());
+    EXPECT_CALL(*mocks_->video_renderer(), Preroll(_, _))
+        .WillOnce(RunPipelineStatusCB());
 
     if (state == kStarting) {
       EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
           .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ),
                           RunClosure()));
+      EXPECT_CALL(*mocks_->video_renderer(), Play(_)).WillOnce(RunClosure());
       return;
     }
 
     NOTREACHED() << "Unexpected TeardownState: " << state;
   }
 
   void ExpectStop() {
     // TODO(scherkus): Don't pause+flush, see http://crbug.com/110228
     EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
     EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
     EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
     EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
 
     EXPECT_CALL(callbacks_, OnStop());
   }
 
   void ExpectPlaybackError() {
     // TODO(scherkus): Don't pause+flush, see http://crbug.com/110228
     EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
     EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
     EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
     EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
 
     EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
   }
 
   void DoSeek() {
     pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
         &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
   }
 
   void DoStop() {
     pipeline_->Stop(base::Bind(
         &CallbackHelper::OnStop, base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
   }
 
   void DoPlaybackError() {
     pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
     message_loop_.RunAllPending();
   }
 
   DISALLOW_COPY_AND_ASSIGN(PipelineTeardownTest);
 };
 
 #define INSTANTIATE_TEARDOWN_TEST(stop_or_error, state) \
     TEST_F(PipelineTeardownTest, stop_or_error##_##state) { \
       RunTest(k##state, k##stop_or_error); \
     }
 
+INSTANTIATE_TEARDOWN_TEST(Stop, InitDemuxer);
+INSTANTIATE_TEARDOWN_TEST(Stop, InitAudioDecoder);
+INSTANTIATE_TEARDOWN_TEST(Stop, InitAudioRenderer);
+INSTANTIATE_TEARDOWN_TEST(Stop, InitVideoDecoder);
+INSTANTIATE_TEARDOWN_TEST(Stop, InitVideoRenderer);
 INSTANTIATE_TEARDOWN_TEST(Stop, Pausing);
 INSTANTIATE_TEARDOWN_TEST(Stop, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Stop, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Stop, Prerolling);
 INSTANTIATE_TEARDOWN_TEST(Stop, Starting);
 INSTANTIATE_TEARDOWN_TEST(Stop, Playing);
 
+INSTANTIATE_TEARDOWN_TEST(Error, InitDemuxer);
+INSTANTIATE_TEARDOWN_TEST(Error, InitAudioDecoder);
+INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
+INSTANTIATE_TEARDOWN_TEST(Error, InitVideoDecoder);
+INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, Pausing);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Prerolling);
 INSTANTIATE_TEARDOWN_TEST(Error, Starting);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 }  // namespace media