dom/media/gtest/TestMediaQueue.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include <gtest/gtest.h>
   6
   7 #include "MediaData.h"
   8 #include "MediaQueue.h"
   9
  10 using namespace mozilla;
  11 using mozilla::media::TimeUnit;
  12
  13 MediaData* CreateDataRawPtr(int64_t aStartTime, int64_t aEndTime) {
  14   const TimeUnit startTime = TimeUnit::FromMicroseconds(aStartTime);
  15   const TimeUnit endTime = TimeUnit::FromMicroseconds(aEndTime);
  16   return new NullData(0, startTime, endTime - startTime);
  17 }
  18
  19 already_AddRefed<MediaData> CreateData(int64_t aStartTime, int64_t aEndTime) {
  20   RefPtr<MediaData> data = CreateDataRawPtr(aStartTime, aEndTime);
  21   return data.forget();
  22 }
  23
  24 // Used to avoid the compile error `comparison of integers of different signs`
  25 // when comparing 'const unsigned long' and 'const int'.
  26 #define EXPECT_EQUAL_SIZE_T(lhs, rhs) EXPECT_EQ(size_t(lhs), size_t(rhs))
  27
  28 TEST(MediaQueue, BasicPopOperations)
  29 {
  30   MediaQueue<MediaData> queue;
  31   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 0);
  32
  33   // Test only one element
  34   const RefPtr<MediaData> data = CreateDataRawPtr(0, 10);
  35   queue.Push(data.get());
  36   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 1);
  37
  38   RefPtr<MediaData> rv = queue.PopFront();
  39   EXPECT_EQ(rv, data);
  40
  41   queue.Push(data.get());
  42   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 1);
  43
  44   rv = queue.PopBack();
  45   EXPECT_EQ(rv, data);
  46   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 0);
  47
  48   // Test multiple elements
  49   const RefPtr<MediaData> data1 = CreateDataRawPtr(0, 10);
  50   const RefPtr<MediaData> data2 = CreateDataRawPtr(11, 20);
  51   const RefPtr<MediaData> data3 = CreateDataRawPtr(21, 30);
  52   queue.Push(data1.get());
  53   queue.Push(data2.get());
  54   queue.Push(data3.get());
  55   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 3);
  56
  57   rv = queue.PopFront();
  58   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 2);
  59   EXPECT_EQ(rv, data1);
  60
  61   rv = queue.PopBack();
  62   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 1);
  63   EXPECT_EQ(rv, data3);
  64
  65   rv = queue.PopBack();
  66   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 0);
  67   EXPECT_EQ(rv, data2);
  68 }
  69
  70 TEST(MediaQueue, BasicPeekOperations)
  71 {
  72   MediaQueue<MediaData> queue;
  73   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 0);
  74
  75   // Test only one element
  76   const RefPtr<MediaData> data1 = CreateDataRawPtr(0, 10);
  77   queue.Push(data1.get());
  78   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 1);
  79
  80   RefPtr<MediaData> rv = queue.PeekFront();
  81   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 1);
  82   EXPECT_EQ(rv, data1);
  83
  84   rv = queue.PeekBack();
  85   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 1);
  86   EXPECT_EQ(rv, data1);
  87
  88   // Test multiple elements
  89   const RefPtr<MediaData> data2 = CreateDataRawPtr(11, 20);
  90   const RefPtr<MediaData> data3 = CreateDataRawPtr(21, 30);
  91   queue.Push(data2.get());
  92   queue.Push(data3.get());
  93   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 3);
  94
  95   rv = queue.PeekFront();
  96   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 3);
  97   EXPECT_EQ(rv, data1);
  98
  99   rv = queue.PeekBack();
 100   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 3);
 101   EXPECT_EQ(rv, data3);
 102 }
 103
 104 TEST(MediaQueue, FinishQueue)
 105 {
 106   MediaQueue<MediaData> queue;
 107   EXPECT_FALSE(queue.IsFinished());
 108
 109   queue.Finish();
 110   EXPECT_TRUE(queue.IsFinished());
 111 }
 112
 113 TEST(MediaQueue, EndOfStream)
 114 {
 115   MediaQueue<MediaData> queue;
 116   EXPECT_FALSE(queue.IsFinished());
 117
 118   queue.Push(CreateData(0, 10));
 119   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 1);
 120
 121   queue.Finish();
 122   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 1);
 123   EXPECT_TRUE(queue.IsFinished());
 124   EXPECT_FALSE(queue.AtEndOfStream());
 125
 126   RefPtr<MediaData> rv = queue.PopFront();
 127   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 0);
 128   EXPECT_TRUE(queue.IsFinished());
 129   EXPECT_TRUE(queue.AtEndOfStream());
 130 }
 131
 132 TEST(MediaQueue, QueueDuration)
 133 {
 134   MediaQueue<MediaData> queue;
 135   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 0);
 136
 137   queue.Push(CreateData(0, 10));
 138   queue.Push(CreateData(11, 20));
 139   queue.Push(CreateData(21, 30));
 140   EXPECT_EQUAL_SIZE_T(queue.GetSize(), 3);
 141
 142   const int64_t rv = queue.Duration();
 143   EXPECT_EQ(rv, 30);
 144 }
 145
 146 TEST(MediaQueue, CallGetElementAfterOnSingleElement)
 147 {
 148   MediaQueue<MediaData> queue;
 149   queue.Push(CreateData(0, 10));
 150
 151   // Target time is earlier than data's end time
 152   TimeUnit targetTime = TimeUnit::FromMicroseconds(5);
 153   nsTArray<RefPtr<MediaData>> foundResult;
 154   queue.GetElementsAfter(targetTime, &foundResult);
 155   EXPECT_EQUAL_SIZE_T(foundResult.Length(), 1);
 156   EXPECT_TRUE(foundResult[0]->GetEndTime() > targetTime);
 157
 158   // Target time is later than data's end time
 159   targetTime = TimeUnit::FromMicroseconds(15);
 160   nsTArray<RefPtr<MediaData>> emptyResult;
 161   queue.GetElementsAfter(targetTime, &emptyResult);
 162   EXPECT_TRUE(emptyResult.IsEmpty());
 163 }
 164
 165 TEST(MediaQueue, CallGetElementAfterOnMultipleElements)
 166 {
 167   MediaQueue<MediaData> queue;
 168   queue.Push(CreateData(0, 10));
 169   queue.Push(CreateData(11, 20));
 170   queue.Push(CreateData(21, 30));
 171   queue.Push(CreateData(31, 40));
 172   queue.Push(CreateData(41, 50));
 173
 174   // Should find [21,30], [31,40] and [41,50]
 175   TimeUnit targetTime = TimeUnit::FromMicroseconds(25);
 176   nsTArray<RefPtr<MediaData>> foundResult;
 177   queue.GetElementsAfter(targetTime, &foundResult);
 178   EXPECT_EQUAL_SIZE_T(foundResult.Length(), 3);
 179   for (const auto& data : foundResult) {
 180     EXPECT_TRUE(data->GetEndTime() > targetTime);
 181   }
 182
 183   // Should find [31,40] and [41,50]
 184   targetTime = TimeUnit::FromMicroseconds(30);
 185   foundResult.Clear();
 186   queue.GetElementsAfter(targetTime, &foundResult);
 187   EXPECT_EQUAL_SIZE_T(foundResult.Length(), 2);
 188   for (const auto& data : foundResult) {
 189     EXPECT_TRUE(data->GetEndTime() > targetTime);
 190   }
 191
 192   // Should find no data.
 193   targetTime = TimeUnit::FromMicroseconds(60);
 194   nsTArray<RefPtr<MediaData>> emptyResult;
 195   queue.GetElementsAfter(targetTime, &emptyResult);
 196   EXPECT_TRUE(emptyResult.IsEmpty());
 197 }
 198
 199 #undef EXPECT_EQUAL_SIZE_T