blob: 3862d850fa43f4c45faa3ff4e8410948fe073cbd [file] [log] [blame]
peah48407f72015-11-09 13:24:501/*
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
Mirko Bonadei92ea95e2017-09-15 04:47:3111#include "rtc_base/swap_queue.h"
peah48407f72015-11-09 13:24:5012
Yves Gerey3e707812018-11-28 15:47:4913#include <cstdint>
peah48407f72015-11-09 13:24:5014#include <vector>
15
Mirko Bonadei92ea95e2017-09-15 04:47:3116#include "test/gtest.h"
peah48407f72015-11-09 13:24:5017
18namespace webrtc {
19
20namespace {
21
22// Test parameter for the basic sample based SwapQueue Tests.
23const size_t kChunkSize = 3;
24
25// Queue item verification function for the vector test.
26bool LengthVerifierFunction(const std::vector<int>& v) {
27 return v.size() == kChunkSize;
28}
29
30// Queue item verifier for the vector test.
31class LengthVerifierFunctor {
32 public:
33 explicit LengthVerifierFunctor(size_t length) : length_(length) {}
34
35 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
45TEST(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
59TEST(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
81TEST(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
90TEST(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
111TEST(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
124TEST(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)
Tommia5e07cc2020-05-26 19:40:37138TEST(SwapQueueDeathTest, UnsuccessfulItemVerifyFunctor) {
peah48407f72015-11-09 13:24:50139 // 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
Tommia5e07cc2020-05-26 19:40:37151TEST(SwapQueueDeathTest, UnSuccessfulItemVerifyInsert) {
peah48407f72015-11-09 13:24:50152 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
Tommia5e07cc2020-05-26 19:40:37161TEST(SwapQueueDeathTest, UnSuccessfulItemVerifyRemove) {
peah48407f72015-11-09 13:24:50162 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
175TEST(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
206TEST(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
214TEST(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