Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(175)

Side by Side Diff: webrtc/common_audio/swap_queue_unittest.cc

Issue 1398473004: Changed queue implementation to the proposed vector-based solution. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@lock_unittest_CL
Patch Set: Made the copy assignment operator thread safe Created 5 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
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 "webrtc/common_audio/swap_queue.h"
12
13 #include <vector>
14
15 #include "testing/gtest/include/gtest/gtest.h"
16
17 namespace webrtc {
18
19 namespace {
20
21 // Test parameter for the basic sample based SwapQueue Tests.
22 const size_t kChunkSize = 3;
23
24 // Queue item verification function for the vector test.
25 bool LengthVerifierFunction(const std::vector<int>& v) {
26 return v.size() == kChunkSize;
27 }
28
29 // Queue item verifier for the vector test.
30 class LengthVerifierFunctor {
31 public:
32 explicit LengthVerifierFunctor(size_t length) : length_(length) {}
33
34 bool operator()(const std::vector<int>& v) const {
35 return v.size() == length_;
36 }
37
38 private:
39 size_t length_;
40 };
41
42 } // anonymous namespace
43
44 TEST(SwapQueueTest, BasicOperation) {
45 std::vector<int> i(kChunkSize, 0);
46 SwapQueue<std::vector<int>> queue(2, i);
47
48 EXPECT_TRUE(queue.Insert(&i));
49 EXPECT_EQ(i.size(), kChunkSize);
50 EXPECT_TRUE(queue.Insert(&i));
51 EXPECT_EQ(i.size(), kChunkSize);
52 EXPECT_TRUE(queue.Remove(&i));
53 EXPECT_EQ(i.size(), kChunkSize);
54 EXPECT_TRUE(queue.Remove(&i));
55 EXPECT_EQ(i.size(), kChunkSize);
56 }
57
58 TEST(SwapQueueTest, FullQueue) {
59 SwapQueue<int> queue(2);
60
61 // Fill the queue.
62 int i = 0;
63 EXPECT_TRUE(queue.Insert(&i));
64 i = 1;
65 EXPECT_TRUE(queue.Insert(&i));
66
67 // Ensure that the value is not swapped when doing an Insert
68 // on a full queue.
69 i = 2;
70 EXPECT_FALSE(queue.Insert(&i));
71 EXPECT_EQ(i, 2);
72
73 // Ensure that the Insert didn't overwrite anything in the queue.
74 EXPECT_TRUE(queue.Remove(&i));
75 EXPECT_EQ(i, 0);
76 EXPECT_TRUE(queue.Remove(&i));
77 EXPECT_EQ(i, 1);
78 }
79
80 TEST(SwapQueueTest, EmptyQueue) {
81 SwapQueue<int> queue(2);
82 int i = 0;
83 EXPECT_FALSE(queue.Remove(&i));
84 EXPECT_TRUE(queue.Insert(&i));
85 EXPECT_TRUE(queue.Remove(&i));
86 EXPECT_FALSE(queue.Remove(&i));
87 }
88
89 TEST(SwapQueueTest, Clear) {
90 SwapQueue<int> queue(2);
91 int i = 0;
92
93 // Fill the queue.
94 EXPECT_TRUE(queue.Insert(&i));
95 EXPECT_TRUE(queue.Insert(&i));
96
97 // Ensure full queue.
98 EXPECT_FALSE(queue.Insert(&i));
99
100 // Empty the queue.
101 queue.Clear();
102
103 // Ensure that the queue is empty
104 EXPECT_FALSE(queue.Remove(&i));
105
106 // Ensure that the queue is no longer full.
107 EXPECT_TRUE(queue.Insert(&i));
108 }
109
110 TEST(SwapQueueTest, SuccessfulItemVerifyFunction) {
111 std::vector<int> template_element(kChunkSize);
112 SwapQueue<std::vector<int>,
113 SwapQueueItemVerifier<std::vector<int>, LengthVerifierFunction>>
114 queue(2, template_element);
115 std::vector<int> valid_chunk(kChunkSize, 0);
116
117 EXPECT_TRUE(queue.Insert(&valid_chunk));
118 EXPECT_EQ(valid_chunk.size(), kChunkSize);
119 EXPECT_TRUE(queue.Remove(&valid_chunk));
120 EXPECT_EQ(valid_chunk.size(), kChunkSize);
121 }
122
123 TEST(SwapQueueTest, SuccessfulItemVerifyFunctor) {
124 std::vector<int> template_element(kChunkSize);
125 LengthVerifierFunctor verifier(kChunkSize);
126 SwapQueue<std::vector<int>, LengthVerifierFunctor> queue(2, verifier,
127 template_element);
128 std::vector<int> valid_chunk(kChunkSize, 0);
129
130 EXPECT_TRUE(queue.Insert(&valid_chunk));
131 EXPECT_EQ(valid_chunk.size(), kChunkSize);
132 EXPECT_TRUE(queue.Remove(&valid_chunk));
133 EXPECT_EQ(valid_chunk.size(), kChunkSize);
134 }
135
136 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
137 TEST(SwapQueueTest, UnsuccessfulItemVerifyFunctor) {
138 // Queue item verifier for the test.
139 auto minus_2_verifier = [](const int& i) {
140 return i > -2;
141 } SwapQueue<int, decltype(minus_2_verifier)> queue(2, minus_2_verifier);
142
143 IntVerifier verifier(-2);
144 SwapQueue<int, IntVerifier> queue(2, verifier);
145
146 int valid_value = 1;
147 int invalid_value = -4;
148 EXPECT_TRUE(queue.Insert(&valid_value));
149 EXPECT_TRUE(queue.Remove(&valid_value));
150 bool result;
151 EXPECT_DEATH(result = queue.Insert(&invalid_value), "");
152 }
153
154 TEST(SwapQueueTest, UnSuccessfulItemVerifyInsert) {
155 std::vector<int> template_element(kChunkSize);
156 SwapQueue<std::vector<int>,
157 SwapQueueItemVerifier<std::vector<int>, &LengthVerifierFunction>>
158 queue(2, template_element);
159 std::vector<int> invalid_chunk(kChunkSize - 1, 0);
160 bool result;
161 EXPECT_DEATH(result = queue.Insert(&invalid_chunk), "");
162 }
163
164 TEST(SwapQueueTest, UnSuccessfulItemVerifyRemove) {
165 std::vector<int> template_element(kChunkSize);
166 SwapQueue<std::vector<int>,
167 SwapQueueItemVerifier<std::vector<int>, &LengthVerifierFunction>>
168 queue(2, template_element);
169 std::vector<int> invalid_chunk(kChunkSize - 1, 0);
170 std::vector<int> valid_chunk(kChunkSize, 0);
171 EXPECT_TRUE(queue.Insert(&valid_chunk));
172 EXPECT_EQ(valid_chunk.size(), kChunkSize);
173 bool result;
174 EXPECT_DEATH(result = queue.Remove(&invalid_chunk), "");
175 }
176 #endif
177
178 TEST(SwapQueueTest, VectorContentTest) {
179 const size_t kQueueSize = 10;
180 const size_t kFrameLength = 160;
181 const size_t kDataLength = kQueueSize * kFrameLength;
182 std::vector<int16_t> buffer_reader(kFrameLength, 0);
183 std::vector<int16_t> buffer_writer(kFrameLength, 0);
184 SwapQueue<std::vector<int16_t>> queue(kQueueSize,
185 std::vector<int16_t>(kFrameLength));
186 std::vector<int16_t> samples(kDataLength);
187
188 for (size_t k = 0; k < kDataLength; k++) {
189 samples[k] = k % 9;
190 }
191
192 for (size_t k = 0; k < kQueueSize; k++) {
193 buffer_writer.clear();
194 buffer_writer.insert(buffer_writer.end(), &samples[0] + k * kFrameLength,
195 &samples[0] + (k + 1) * kFrameLength);
196
197 EXPECT_TRUE(queue.Insert(&buffer_writer));
198 }
199
200 for (size_t k = 0; k < kQueueSize; k++) {
201 EXPECT_TRUE(queue.Remove(&buffer_reader));
202
203 for (size_t j = 0; j < buffer_reader.size(); j++) {
204 EXPECT_EQ(buffer_reader[j], samples[k * kFrameLength + j]);
205 }
206 }
207 }
208
209 TEST(SwapQueueTest, ZeroSlotQueue) {
210 SwapQueue<int> queue(0);
211 int i = 42;
212 EXPECT_FALSE(queue.Insert(&i));
213 EXPECT_FALSE(queue.Remove(&i));
214 EXPECT_EQ(i, 42);
215 }
216
217 TEST(SwapQueueTest, OneSlotQueue) {
218 SwapQueue<int> queue(1);
219 int i = 42;
220 EXPECT_TRUE(queue.Insert(&i));
221 i = 43;
222 EXPECT_FALSE(queue.Insert(&i));
223 EXPECT_EQ(i, 43);
224 EXPECT_TRUE(queue.Remove(&i));
225 EXPECT_EQ(i, 42);
226 EXPECT_FALSE(queue.Remove(&i));
227 }
228
229 TEST(SwapQueueTest, BasicCopy) {
230 SwapQueue<int> queue1(2);
231 SwapQueue<int> queue2(3);
232
233 // Fill queue1.
234 int i = 0;
235 EXPECT_TRUE(queue1.Insert(&i));
236 i = 1;
237 EXPECT_TRUE(queue1.Insert(&i));
238
239 // Verify empty queue 2.
240 EXPECT_FALSE(queue2.Remove(&i));
241
242 // Copy queue content.
243 queue2 = queue1;
244
245 // Verify queue content.
246 EXPECT_TRUE(queue2.Remove(&i));
247 EXPECT_EQ(i, 0);
248 EXPECT_TRUE(queue2.Remove(&i));
249 EXPECT_EQ(i, 1);
250 }
251
252 TEST(SwapQueueTest, AdvancedCopy) {
253 const size_t kQueueSize = 10;
254 const size_t kFrameLength = 160;
255 const size_t kDataLength = kQueueSize * kFrameLength;
256 std::vector<int16_t> buffer_reader(kFrameLength, 0);
257 std::vector<int16_t> buffer_writer(kFrameLength, 0);
258 SwapQueue<std::vector<int16_t>> queue1(kQueueSize,
259 std::vector<int16_t>(kFrameLength));
260 SwapQueue<std::vector<int16_t>> queue2(kQueueSize,
261 std::vector<int16_t>(kFrameLength));
262 std::vector<int16_t> samples(kDataLength);
263
264 for (size_t k = 0; k < kDataLength; k++) {
265 samples[k] = k % 9;
266 }
267
268 for (size_t k = 0; k < kQueueSize; k++) {
269 buffer_writer.clear();
270 buffer_writer.insert(buffer_writer.end(), &samples[0] + k * kFrameLength,
271 &samples[0] + (k + 1) * kFrameLength);
272
273 EXPECT_TRUE(queue1.Insert(&buffer_writer));
274 }
275
276 // Verify empty queue 2.
277 EXPECT_FALSE(queue2.Remove(&buffer_reader));
278
279 // Copy queue content.
280 queue2 = queue1;
281
282 for (size_t k = 0; k < kQueueSize; k++) {
283 EXPECT_TRUE(queue2.Remove(&buffer_reader));
284
285 for (size_t j = 0; j < buffer_reader.size(); j++) {
286 EXPECT_EQ(buffer_reader[j], samples[k * kFrameLength + j]);
287 }
288 }
289 }
290
291 } // namespace webrtc
OLDNEW
« webrtc/common_audio/swap_queue.h ('K') | « webrtc/common_audio/swap_queue.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698