media/filters/memory_data_source_unittest.cc

   1 // Copyright 2016 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 "media/filters/memory_data_source.h"
   6
   7 #include <memory>
   8
   9 #include "base/bind.h"
  10 #include "base/macros.h"
  11 #include "base/rand_util.h"
  12 #include "testing/gmock/include/gmock/gmock.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace media {
  16
  17 class MemoryDataSourceTest : public ::testing::Test {
  18  public:
  19   MemoryDataSourceTest() = default;
  20
  21  protected:
  22   void Initialize(size_t size) {
  23     data_.assign(size, 0);
  24     base::RandBytes(data_.data(), size);
  25     memory_data_source_.reset(new MemoryDataSource(data_.data(), size));
  26     EXPECT_EQ(size, GetSize());
  27   }
  28
  29   // Reads |size| bytes starting from |position|, expects |expected_read_size|
  30   // bytes to be read and checks the read data. Expects error when
  31   // |expected_read_size| is DataSource::kReadError.
  32   void ReadAndExpect(int64_t position, int size, int expected_read_size) {
  33     std::vector<uint8_t> data(size < 0 ? 0 : size, 0);
  34
  35     EXPECT_CALL(*this, ReadCB(expected_read_size));
  36     memory_data_source_->Read(
  37         position, size, data.data(),
  38         base::Bind(&MemoryDataSourceTest::ReadCB, base::Unretained(this)));
  39
  40     if (expected_read_size != DataSource::kReadError) {
  41       EXPECT_EQ(
  42           0, memcmp(data_.data() + position, data.data(), expected_read_size));
  43     }
  44   }
  45
  46   size_t GetSize() {
  47     int64_t size = 0;
  48     EXPECT_TRUE(memory_data_source_->GetSize(&size));
  49     EXPECT_GE(size, 0);
  50     return size;
  51   }
  52
  53   void Stop() { memory_data_source_->Stop(); }
  54
  55   MOCK_METHOD1(ReadCB, void(int size));
  56
  57  private:
  58   std::vector<uint8_t> data_;
  59   std::unique_ptr<MemoryDataSource> memory_data_source_;
  60
  61   DISALLOW_COPY_AND_ASSIGN(MemoryDataSourceTest);
  62 };
  63
  64 TEST_F(MemoryDataSourceTest, EmptySource) {
  65   Initialize(0);
  66   ReadAndExpect(0, 0, 0);
  67 }
  68
  69 TEST_F(MemoryDataSourceTest, ReadData) {
  70   Initialize(128);
  71   ReadAndExpect(0, 0, 0);
  72   ReadAndExpect(0, 128, 128);
  73   ReadAndExpect(12, 64, 64);
  74   ReadAndExpect(128, 0, 0);
  75 }
  76
  77 TEST_F(MemoryDataSourceTest, ReadData_InvalidPosition) {
  78   Initialize(128);
  79   ReadAndExpect(-7, 64, DataSource::kReadError);
  80   ReadAndExpect(129, 64, DataSource::kReadError);
  81 }
  82
  83 TEST_F(MemoryDataSourceTest, ReadData_InvalidSize) {
  84   Initialize(128);
  85   ReadAndExpect(0, -12, DataSource::kReadError);
  86 }
  87
  88 TEST_F(MemoryDataSourceTest, ReadData_PartialRead) {
  89   Initialize(128);
  90   ReadAndExpect(0, 129, 128);
  91   ReadAndExpect(96, 100, 32);
  92 }
  93
  94 // All ReadData() will fail after Stop().
  95 TEST_F(MemoryDataSourceTest, Stop) {
  96   Initialize(128);
  97   ReadAndExpect(12, 64, 64);
  98   Stop();
  99   ReadAndExpect(12, 64, DataSource::kReadError);
 100 }
 101
 102 // ReadData() doesn't affect GetSize().
 103 TEST_F(MemoryDataSourceTest, GetSize) {
 104   Initialize(128);
 105   ReadAndExpect(12, 64, 64);
 106   EXPECT_EQ(128u, GetSize());
 107   ReadAndExpect(-7, 64, DataSource::kReadError);
 108   EXPECT_EQ(128u, GetSize());
 109 }
 110
 111 }  // namespace media