media/filters/memory_data_source_unittest.cc

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