1 /*
2  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #include "rtc_base/swap_queue.h"
12 
13 #include <cstdint>
14 #include <vector>
15 
16 #include "test/gtest.h"
17 
18 namespace webrtc {
19 
20 namespace {
21 
22 // Test parameter for the basic sample based SwapQueue Tests.
23 const size_t kChunkSize = 3;
24 
25 // Queue item verification function for the vector test.
LengthVerifierFunction(const std::vector<int> & v)26 bool LengthVerifierFunction(const std::vector<int>& v) {
27   return v.size() == kChunkSize;
28 }
29 
30 // Queue item verifier for the vector test.
31 class LengthVerifierFunctor {
32  public:
LengthVerifierFunctor(size_t length)33   explicit LengthVerifierFunctor(size_t length) : length_(length) {}
34 
operator ()(const std::vector<int> & v) const35   bool operator()(const std::vector<int>& v) const {
36     return v.size() == length_;
37   }
38 
39  private:
40   size_t length_;
41 };
42 
43 }  // anonymous namespace
44 
TEST(SwapQueueTest,BasicOperation)45 TEST(SwapQueueTest, BasicOperation) {
46   std::vector<int> i(kChunkSize, 0);
47   SwapQueue<std::vector<int>> queue(2, i);
48 
49   EXPECT_TRUE(queue.Insert(&i));
50   EXPECT_EQ(i.size(), kChunkSize);
51   EXPECT_TRUE(queue.Insert(&i));
52   EXPECT_EQ(i.size(), kChunkSize);
53   EXPECT_TRUE(queue.Remove(&i));
54   EXPECT_EQ(i.size(), kChunkSize);
55   EXPECT_TRUE(queue.Remove(&i));
56   EXPECT_EQ(i.size(), kChunkSize);
57 }
58 
TEST(SwapQueueTest,FullQueue)59 TEST(SwapQueueTest, FullQueue) {
60   SwapQueue<int> queue(2);
61 
62   // Fill the queue.
63   int i = 0;
64   EXPECT_TRUE(queue.Insert(&i));
65   i = 1;
66   EXPECT_TRUE(queue.Insert(&i));
67 
68   // Ensure that the value is not swapped when doing an Insert
69   // on a full queue.
70   i = 2;
71   EXPECT_FALSE(queue.Insert(&i));
72   EXPECT_EQ(i, 2);
73 
74   // Ensure that the Insert didn't overwrite anything in the queue.
75   EXPECT_TRUE(queue.Remove(&i));
76   EXPECT_EQ(i, 0);
77   EXPECT_TRUE(queue.Remove(&i));
78   EXPECT_EQ(i, 1);
79 }
80 
TEST(SwapQueueTest,EmptyQueue)81 TEST(SwapQueueTest, EmptyQueue) {
82   SwapQueue<int> queue(2);
83   int i = 0;
84   EXPECT_FALSE(queue.Remove(&i));
85   EXPECT_TRUE(queue.Insert(&i));
86   EXPECT_TRUE(queue.Remove(&i));
87   EXPECT_FALSE(queue.Remove(&i));
88 }
89 
TEST(SwapQueueTest,Clear)90 TEST(SwapQueueTest, Clear) {
91   SwapQueue<int> queue(2);
92   int i = 0;
93 
94   // Fill the queue.
95   EXPECT_TRUE(queue.Insert(&i));
96   EXPECT_TRUE(queue.Insert(&i));
97 
98   // Ensure full queue.
99   EXPECT_FALSE(queue.Insert(&i));
100 
101   // Empty the queue.
102   queue.Clear();
103 
104   // Ensure that the queue is empty
105   EXPECT_FALSE(queue.Remove(&i));
106 
107   // Ensure that the queue is no longer full.
108   EXPECT_TRUE(queue.Insert(&i));
109 }
110 
TEST(SwapQueueTest,SuccessfulItemVerifyFunction)111 TEST(SwapQueueTest, SuccessfulItemVerifyFunction) {
112   std::vector<int> template_element(kChunkSize);
113   SwapQueue<std::vector<int>,
114             SwapQueueItemVerifier<std::vector<int>, LengthVerifierFunction>>
115       queue(2, template_element);
116   std::vector<int> valid_chunk(kChunkSize, 0);
117 
118   EXPECT_TRUE(queue.Insert(&valid_chunk));
119   EXPECT_EQ(valid_chunk.size(), kChunkSize);
120   EXPECT_TRUE(queue.Remove(&valid_chunk));
121   EXPECT_EQ(valid_chunk.size(), kChunkSize);
122 }
123 
TEST(SwapQueueTest,SuccessfulItemVerifyFunctor)124 TEST(SwapQueueTest, SuccessfulItemVerifyFunctor) {
125   std::vector<int> template_element(kChunkSize);
126   LengthVerifierFunctor verifier(kChunkSize);
127   SwapQueue<std::vector<int>, LengthVerifierFunctor> queue(2, template_element,
128                                                            verifier);
129   std::vector<int> valid_chunk(kChunkSize, 0);
130 
131   EXPECT_TRUE(queue.Insert(&valid_chunk));
132   EXPECT_EQ(valid_chunk.size(), kChunkSize);
133   EXPECT_TRUE(queue.Remove(&valid_chunk));
134   EXPECT_EQ(valid_chunk.size(), kChunkSize);
135 }
136 
137 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
TEST(SwapQueueDeathTest,UnsuccessfulItemVerifyFunctor)138 TEST(SwapQueueDeathTest, UnsuccessfulItemVerifyFunctor) {
139   // Queue item verifier for the test.
140   auto minus_2_verifier = [](const int& i) { return i > -2; };
141   SwapQueue<int, decltype(minus_2_verifier)> queue(2, minus_2_verifier);
142 
143   int valid_value = 1;
144   int invalid_value = -4;
145   EXPECT_TRUE(queue.Insert(&valid_value));
146   EXPECT_TRUE(queue.Remove(&valid_value));
147   bool result;
148   EXPECT_DEATH(result = queue.Insert(&invalid_value), "");
149 }
150 
TEST(SwapQueueDeathTest,UnSuccessfulItemVerifyInsert)151 TEST(SwapQueueDeathTest, UnSuccessfulItemVerifyInsert) {
152   std::vector<int> template_element(kChunkSize);
153   SwapQueue<std::vector<int>,
154             SwapQueueItemVerifier<std::vector<int>, &LengthVerifierFunction>>
155       queue(2, template_element);
156   std::vector<int> invalid_chunk(kChunkSize - 1, 0);
157   bool result;
158   EXPECT_DEATH(result = queue.Insert(&invalid_chunk), "");
159 }
160 
TEST(SwapQueueDeathTest,UnSuccessfulItemVerifyRemove)161 TEST(SwapQueueDeathTest, UnSuccessfulItemVerifyRemove) {
162   std::vector<int> template_element(kChunkSize);
163   SwapQueue<std::vector<int>,
164             SwapQueueItemVerifier<std::vector<int>, &LengthVerifierFunction>>
165       queue(2, template_element);
166   std::vector<int> invalid_chunk(kChunkSize - 1, 0);
167   std::vector<int> valid_chunk(kChunkSize, 0);
168   EXPECT_TRUE(queue.Insert(&valid_chunk));
169   EXPECT_EQ(valid_chunk.size(), kChunkSize);
170   bool result;
171   EXPECT_DEATH(result = queue.Remove(&invalid_chunk), "");
172 }
173 #endif
174 
TEST(SwapQueueTest,VectorContentTest)175 TEST(SwapQueueTest, VectorContentTest) {
176   const size_t kQueueSize = 10;
177   const size_t kFrameLength = 160;
178   const size_t kDataLength = kQueueSize * kFrameLength;
179   std::vector<int16_t> buffer_reader(kFrameLength, 0);
180   std::vector<int16_t> buffer_writer(kFrameLength, 0);
181   SwapQueue<std::vector<int16_t>> queue(kQueueSize,
182                                         std::vector<int16_t>(kFrameLength));
183   std::vector<int16_t> samples(kDataLength);
184 
185   for (size_t k = 0; k < kDataLength; k++) {
186     samples[k] = k % 9;
187   }
188 
189   for (size_t k = 0; k < kQueueSize; k++) {
190     buffer_writer.clear();
191     buffer_writer.insert(buffer_writer.end(), &samples[0] + k * kFrameLength,
192                          &samples[0] + (k + 1) * kFrameLength);
193 
194     EXPECT_TRUE(queue.Insert(&buffer_writer));
195   }
196 
197   for (size_t k = 0; k < kQueueSize; k++) {
198     EXPECT_TRUE(queue.Remove(&buffer_reader));
199 
200     for (size_t j = 0; j < buffer_reader.size(); j++) {
201       EXPECT_EQ(buffer_reader[j], samples[k * kFrameLength + j]);
202     }
203   }
204 }
205 
TEST(SwapQueueTest,ZeroSlotQueue)206 TEST(SwapQueueTest, ZeroSlotQueue) {
207   SwapQueue<int> queue(0);
208   int i = 42;
209   EXPECT_FALSE(queue.Insert(&i));
210   EXPECT_FALSE(queue.Remove(&i));
211   EXPECT_EQ(i, 42);
212 }
213 
TEST(SwapQueueTest,OneSlotQueue)214 TEST(SwapQueueTest, OneSlotQueue) {
215   SwapQueue<int> queue(1);
216   int i = 42;
217   EXPECT_TRUE(queue.Insert(&i));
218   i = 43;
219   EXPECT_FALSE(queue.Insert(&i));
220   EXPECT_EQ(i, 43);
221   EXPECT_TRUE(queue.Remove(&i));
222   EXPECT_EQ(i, 42);
223   EXPECT_FALSE(queue.Remove(&i));
224 }
225 
226 }  // namespace webrtc
227