1 /*
2 * Copyright (c) 2013 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 "modules/audio_processing/transient/file_utils.h"
12
13 #include <string.h>
14
15 #include <memory>
16 #include <string>
17 #include <vector>
18
19 #include "absl/strings/string_view.h"
20 #include "rtc_base/system/file_wrapper.h"
21 #include "test/gtest.h"
22 #include "test/testsupport/file_utils.h"
23
24 namespace webrtc {
25
26 static const uint8_t kPiBytesf[4] = {0xDB, 0x0F, 0x49, 0x40};
27 static const uint8_t kEBytesf[4] = {0x54, 0xF8, 0x2D, 0x40};
28 static const uint8_t kAvogadroBytesf[4] = {0x2F, 0x0C, 0xFF, 0x66};
29
30 static const uint8_t kPiBytes[8] = {0x18, 0x2D, 0x44, 0x54,
31 0xFB, 0x21, 0x09, 0x40};
32 static const uint8_t kEBytes[8] = {0x69, 0x57, 0x14, 0x8B,
33 0x0A, 0xBF, 0x05, 0x40};
34 static const uint8_t kAvogadroBytes[8] = {0xF4, 0xBC, 0xA8, 0xDF,
35 0x85, 0xE1, 0xDF, 0x44};
36
37 static const double kPi = 3.14159265358979323846;
38 static const double kE = 2.71828182845904523536;
39 static const double kAvogadro = 602214100000000000000000.0;
40
41 class TransientFileUtilsTest : public ::testing::Test {
42 protected:
TransientFileUtilsTest()43 TransientFileUtilsTest()
44 : kTestFileName(
45 test::ResourcePath("audio_processing/transient/double-utils",
46 "dat")),
47 kTestFileNamef(
48 test::ResourcePath("audio_processing/transient/float-utils",
49 "dat")) {}
50
~TransientFileUtilsTest()51 ~TransientFileUtilsTest() override { CleanupTempFiles(); }
52
CreateTempFilename(absl::string_view dir,absl::string_view prefix)53 std::string CreateTempFilename(absl::string_view dir,
54 absl::string_view prefix) {
55 std::string filename = test::TempFilename(dir, prefix);
56 temp_filenames_.push_back(filename);
57 return filename;
58 }
59
CleanupTempFiles()60 void CleanupTempFiles() {
61 for (const std::string& filename : temp_filenames_) {
62 remove(filename.c_str());
63 }
64 temp_filenames_.clear();
65 }
66
67 // This file (used in some tests) contains binary data. The data correspond to
68 // the double representation of the constants: Pi, E, and the Avogadro's
69 // Number;
70 // appended in that order.
71 const std::string kTestFileName;
72
73 // This file (used in some tests) contains binary data. The data correspond to
74 // the float representation of the constants: Pi, E, and the Avogadro's
75 // Number;
76 // appended in that order.
77 const std::string kTestFileNamef;
78
79 // List of temporary filenames created by CreateTempFilename.
80 std::vector<std::string> temp_filenames_;
81 };
82
83 #if defined(WEBRTC_IOS)
84 #define MAYBE_ConvertByteArrayToFloat DISABLED_ConvertByteArrayToFloat
85 #else
86 #define MAYBE_ConvertByteArrayToFloat ConvertByteArrayToFloat
87 #endif
TEST_F(TransientFileUtilsTest,MAYBE_ConvertByteArrayToFloat)88 TEST_F(TransientFileUtilsTest, MAYBE_ConvertByteArrayToFloat) {
89 float value = 0.0;
90
91 EXPECT_EQ(0, ConvertByteArrayToFloat(kPiBytesf, &value));
92 EXPECT_FLOAT_EQ(kPi, value);
93
94 EXPECT_EQ(0, ConvertByteArrayToFloat(kEBytesf, &value));
95 EXPECT_FLOAT_EQ(kE, value);
96
97 EXPECT_EQ(0, ConvertByteArrayToFloat(kAvogadroBytesf, &value));
98 EXPECT_FLOAT_EQ(kAvogadro, value);
99 }
100
101 #if defined(WEBRTC_IOS)
102 #define MAYBE_ConvertByteArrayToDouble DISABLED_ConvertByteArrayToDouble
103 #else
104 #define MAYBE_ConvertByteArrayToDouble ConvertByteArrayToDouble
105 #endif
TEST_F(TransientFileUtilsTest,MAYBE_ConvertByteArrayToDouble)106 TEST_F(TransientFileUtilsTest, MAYBE_ConvertByteArrayToDouble) {
107 double value = 0.0;
108
109 EXPECT_EQ(0, ConvertByteArrayToDouble(kPiBytes, &value));
110 EXPECT_DOUBLE_EQ(kPi, value);
111
112 EXPECT_EQ(0, ConvertByteArrayToDouble(kEBytes, &value));
113 EXPECT_DOUBLE_EQ(kE, value);
114
115 EXPECT_EQ(0, ConvertByteArrayToDouble(kAvogadroBytes, &value));
116 EXPECT_DOUBLE_EQ(kAvogadro, value);
117 }
118
119 #if defined(WEBRTC_IOS)
120 #define MAYBE_ConvertFloatToByteArray DISABLED_ConvertFloatToByteArray
121 #else
122 #define MAYBE_ConvertFloatToByteArray ConvertFloatToByteArray
123 #endif
TEST_F(TransientFileUtilsTest,MAYBE_ConvertFloatToByteArray)124 TEST_F(TransientFileUtilsTest, MAYBE_ConvertFloatToByteArray) {
125 std::unique_ptr<uint8_t[]> bytes(new uint8_t[4]);
126
127 EXPECT_EQ(0, ConvertFloatToByteArray(kPi, bytes.get()));
128 EXPECT_EQ(0, memcmp(bytes.get(), kPiBytesf, 4));
129
130 EXPECT_EQ(0, ConvertFloatToByteArray(kE, bytes.get()));
131 EXPECT_EQ(0, memcmp(bytes.get(), kEBytesf, 4));
132
133 EXPECT_EQ(0, ConvertFloatToByteArray(kAvogadro, bytes.get()));
134 EXPECT_EQ(0, memcmp(bytes.get(), kAvogadroBytesf, 4));
135 }
136
137 #if defined(WEBRTC_IOS)
138 #define MAYBE_ConvertDoubleToByteArray DISABLED_ConvertDoubleToByteArray
139 #else
140 #define MAYBE_ConvertDoubleToByteArray ConvertDoubleToByteArray
141 #endif
TEST_F(TransientFileUtilsTest,MAYBE_ConvertDoubleToByteArray)142 TEST_F(TransientFileUtilsTest, MAYBE_ConvertDoubleToByteArray) {
143 std::unique_ptr<uint8_t[]> bytes(new uint8_t[8]);
144
145 EXPECT_EQ(0, ConvertDoubleToByteArray(kPi, bytes.get()));
146 EXPECT_EQ(0, memcmp(bytes.get(), kPiBytes, 8));
147
148 EXPECT_EQ(0, ConvertDoubleToByteArray(kE, bytes.get()));
149 EXPECT_EQ(0, memcmp(bytes.get(), kEBytes, 8));
150
151 EXPECT_EQ(0, ConvertDoubleToByteArray(kAvogadro, bytes.get()));
152 EXPECT_EQ(0, memcmp(bytes.get(), kAvogadroBytes, 8));
153 }
154
155 #if defined(WEBRTC_IOS)
156 #define MAYBE_ReadInt16BufferFromFile DISABLED_ReadInt16BufferFromFile
157 #else
158 #define MAYBE_ReadInt16BufferFromFile ReadInt16BufferFromFile
159 #endif
TEST_F(TransientFileUtilsTest,MAYBE_ReadInt16BufferFromFile)160 TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16BufferFromFile) {
161 std::string test_filename = kTestFileName;
162
163 FileWrapper file = FileWrapper::OpenReadOnly(test_filename);
164 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
165 << kTestFileName.c_str();
166
167 const size_t kBufferLength = 12;
168 std::unique_ptr<int16_t[]> buffer(new int16_t[kBufferLength]);
169
170 EXPECT_EQ(kBufferLength,
171 ReadInt16BufferFromFile(&file, kBufferLength, buffer.get()));
172 EXPECT_EQ(22377, buffer[4]);
173 EXPECT_EQ(16389, buffer[7]);
174 EXPECT_EQ(17631, buffer[kBufferLength - 1]);
175
176 file.Rewind();
177
178 // The next test is for checking the case where there are not as much data as
179 // needed in the file, but reads to the end, and it returns the number of
180 // int16s read.
181 const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
182 buffer.reset(new int16_t[kBufferLenghtLargerThanFile]);
183 EXPECT_EQ(kBufferLength,
184 ReadInt16BufferFromFile(&file, kBufferLenghtLargerThanFile,
185 buffer.get()));
186 EXPECT_EQ(11544, buffer[0]);
187 EXPECT_EQ(22377, buffer[4]);
188 EXPECT_EQ(16389, buffer[7]);
189 EXPECT_EQ(17631, buffer[kBufferLength - 1]);
190 }
191
192 #if defined(WEBRTC_IOS)
193 #define MAYBE_ReadInt16FromFileToFloatBuffer \
194 DISABLED_ReadInt16FromFileToFloatBuffer
195 #else
196 #define MAYBE_ReadInt16FromFileToFloatBuffer ReadInt16FromFileToFloatBuffer
197 #endif
TEST_F(TransientFileUtilsTest,MAYBE_ReadInt16FromFileToFloatBuffer)198 TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16FromFileToFloatBuffer) {
199 std::string test_filename = kTestFileName;
200
201 FileWrapper file = FileWrapper::OpenReadOnly(test_filename);
202 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
203 << kTestFileName.c_str();
204
205 const size_t kBufferLength = 12;
206 std::unique_ptr<float[]> buffer(new float[kBufferLength]);
207
208 EXPECT_EQ(kBufferLength,
209 ReadInt16FromFileToFloatBuffer(&file, kBufferLength, buffer.get()));
210
211 EXPECT_DOUBLE_EQ(11544, buffer[0]);
212 EXPECT_DOUBLE_EQ(22377, buffer[4]);
213 EXPECT_DOUBLE_EQ(16389, buffer[7]);
214 EXPECT_DOUBLE_EQ(17631, buffer[kBufferLength - 1]);
215
216 file.Rewind();
217
218 // The next test is for checking the case where there are not as much data as
219 // needed in the file, but reads to the end, and it returns the number of
220 // int16s read.
221 const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
222 buffer.reset(new float[kBufferLenghtLargerThanFile]);
223 EXPECT_EQ(kBufferLength,
224 ReadInt16FromFileToFloatBuffer(&file, kBufferLenghtLargerThanFile,
225 buffer.get()));
226 EXPECT_DOUBLE_EQ(11544, buffer[0]);
227 EXPECT_DOUBLE_EQ(22377, buffer[4]);
228 EXPECT_DOUBLE_EQ(16389, buffer[7]);
229 EXPECT_DOUBLE_EQ(17631, buffer[kBufferLength - 1]);
230 }
231
232 #if defined(WEBRTC_IOS)
233 #define MAYBE_ReadInt16FromFileToDoubleBuffer \
234 DISABLED_ReadInt16FromFileToDoubleBuffer
235 #else
236 #define MAYBE_ReadInt16FromFileToDoubleBuffer ReadInt16FromFileToDoubleBuffer
237 #endif
TEST_F(TransientFileUtilsTest,MAYBE_ReadInt16FromFileToDoubleBuffer)238 TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16FromFileToDoubleBuffer) {
239 std::string test_filename = kTestFileName;
240
241 FileWrapper file = FileWrapper::OpenReadOnly(test_filename);
242 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
243 << kTestFileName.c_str();
244
245 const size_t kBufferLength = 12;
246 std::unique_ptr<double[]> buffer(new double[kBufferLength]);
247
248 EXPECT_EQ(kBufferLength, ReadInt16FromFileToDoubleBuffer(&file, kBufferLength,
249 buffer.get()));
250 EXPECT_DOUBLE_EQ(11544, buffer[0]);
251 EXPECT_DOUBLE_EQ(22377, buffer[4]);
252 EXPECT_DOUBLE_EQ(16389, buffer[7]);
253 EXPECT_DOUBLE_EQ(17631, buffer[kBufferLength - 1]);
254
255 file.Rewind();
256
257 // The next test is for checking the case where there are not as much data as
258 // needed in the file, but reads to the end, and it returns the number of
259 // int16s read.
260 const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
261 buffer.reset(new double[kBufferLenghtLargerThanFile]);
262 EXPECT_EQ(kBufferLength,
263 ReadInt16FromFileToDoubleBuffer(&file, kBufferLenghtLargerThanFile,
264 buffer.get()));
265 EXPECT_DOUBLE_EQ(11544, buffer[0]);
266 EXPECT_DOUBLE_EQ(22377, buffer[4]);
267 EXPECT_DOUBLE_EQ(16389, buffer[7]);
268 EXPECT_DOUBLE_EQ(17631, buffer[kBufferLength - 1]);
269 }
270
271 #if defined(WEBRTC_IOS)
272 #define MAYBE_ReadFloatBufferFromFile DISABLED_ReadFloatBufferFromFile
273 #else
274 #define MAYBE_ReadFloatBufferFromFile ReadFloatBufferFromFile
275 #endif
TEST_F(TransientFileUtilsTest,MAYBE_ReadFloatBufferFromFile)276 TEST_F(TransientFileUtilsTest, MAYBE_ReadFloatBufferFromFile) {
277 std::string test_filename = kTestFileNamef;
278
279 FileWrapper file = FileWrapper::OpenReadOnly(test_filename);
280 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
281 << kTestFileNamef.c_str();
282
283 const size_t kBufferLength = 3;
284 std::unique_ptr<float[]> buffer(new float[kBufferLength]);
285
286 EXPECT_EQ(kBufferLength,
287 ReadFloatBufferFromFile(&file, kBufferLength, buffer.get()));
288 EXPECT_FLOAT_EQ(kPi, buffer[0]);
289 EXPECT_FLOAT_EQ(kE, buffer[1]);
290 EXPECT_FLOAT_EQ(kAvogadro, buffer[2]);
291
292 file.Rewind();
293
294 // The next test is for checking the case where there are not as much data as
295 // needed in the file, but reads to the end, and it returns the number of
296 // doubles read.
297 const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
298 buffer.reset(new float[kBufferLenghtLargerThanFile]);
299 EXPECT_EQ(kBufferLength,
300 ReadFloatBufferFromFile(&file, kBufferLenghtLargerThanFile,
301 buffer.get()));
302 EXPECT_FLOAT_EQ(kPi, buffer[0]);
303 EXPECT_FLOAT_EQ(kE, buffer[1]);
304 EXPECT_FLOAT_EQ(kAvogadro, buffer[2]);
305 }
306
307 #if defined(WEBRTC_IOS)
308 #define MAYBE_ReadDoubleBufferFromFile DISABLED_ReadDoubleBufferFromFile
309 #else
310 #define MAYBE_ReadDoubleBufferFromFile ReadDoubleBufferFromFile
311 #endif
TEST_F(TransientFileUtilsTest,MAYBE_ReadDoubleBufferFromFile)312 TEST_F(TransientFileUtilsTest, MAYBE_ReadDoubleBufferFromFile) {
313 std::string test_filename = kTestFileName;
314
315 FileWrapper file = FileWrapper::OpenReadOnly(test_filename);
316 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
317 << kTestFileName.c_str();
318
319 const size_t kBufferLength = 3;
320 std::unique_ptr<double[]> buffer(new double[kBufferLength]);
321
322 EXPECT_EQ(kBufferLength,
323 ReadDoubleBufferFromFile(&file, kBufferLength, buffer.get()));
324 EXPECT_DOUBLE_EQ(kPi, buffer[0]);
325 EXPECT_DOUBLE_EQ(kE, buffer[1]);
326 EXPECT_DOUBLE_EQ(kAvogadro, buffer[2]);
327
328 file.Rewind();
329
330 // The next test is for checking the case where there are not as much data as
331 // needed in the file, but reads to the end, and it returns the number of
332 // doubles read.
333 const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
334 buffer.reset(new double[kBufferLenghtLargerThanFile]);
335 EXPECT_EQ(kBufferLength,
336 ReadDoubleBufferFromFile(&file, kBufferLenghtLargerThanFile,
337 buffer.get()));
338 EXPECT_DOUBLE_EQ(kPi, buffer[0]);
339 EXPECT_DOUBLE_EQ(kE, buffer[1]);
340 EXPECT_DOUBLE_EQ(kAvogadro, buffer[2]);
341 }
342
343 #if defined(WEBRTC_IOS)
344 #define MAYBE_WriteInt16BufferToFile DISABLED_WriteInt16BufferToFile
345 #else
346 #define MAYBE_WriteInt16BufferToFile WriteInt16BufferToFile
347 #endif
TEST_F(TransientFileUtilsTest,MAYBE_WriteInt16BufferToFile)348 TEST_F(TransientFileUtilsTest, MAYBE_WriteInt16BufferToFile) {
349 std::string kOutFileName =
350 CreateTempFilename(test::OutputPath(), "utils_test");
351
352 FileWrapper file = FileWrapper::OpenWriteOnly(kOutFileName);
353 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
354 << kOutFileName.c_str();
355
356 const size_t kBufferLength = 3;
357 std::unique_ptr<int16_t[]> written_buffer(new int16_t[kBufferLength]);
358 std::unique_ptr<int16_t[]> read_buffer(new int16_t[kBufferLength]);
359
360 written_buffer[0] = 1;
361 written_buffer[1] = 2;
362 written_buffer[2] = 3;
363
364 EXPECT_EQ(kBufferLength,
365 WriteInt16BufferToFile(&file, kBufferLength, written_buffer.get()));
366
367 file.Close();
368
369 file = FileWrapper::OpenReadOnly(kOutFileName);
370 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
371 << kOutFileName.c_str();
372
373 EXPECT_EQ(kBufferLength,
374 ReadInt16BufferFromFile(&file, kBufferLength, read_buffer.get()));
375 EXPECT_EQ(0, memcmp(written_buffer.get(), read_buffer.get(),
376 kBufferLength * sizeof(written_buffer[0])));
377 }
378
379 #if defined(WEBRTC_IOS)
380 #define MAYBE_WriteFloatBufferToFile DISABLED_WriteFloatBufferToFile
381 #else
382 #define MAYBE_WriteFloatBufferToFile WriteFloatBufferToFile
383 #endif
TEST_F(TransientFileUtilsTest,MAYBE_WriteFloatBufferToFile)384 TEST_F(TransientFileUtilsTest, MAYBE_WriteFloatBufferToFile) {
385 std::string kOutFileName =
386 CreateTempFilename(test::OutputPath(), "utils_test");
387
388 FileWrapper file = FileWrapper::OpenWriteOnly(kOutFileName);
389 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
390 << kOutFileName.c_str();
391
392 const size_t kBufferLength = 3;
393 std::unique_ptr<float[]> written_buffer(new float[kBufferLength]);
394 std::unique_ptr<float[]> read_buffer(new float[kBufferLength]);
395
396 written_buffer[0] = static_cast<float>(kPi);
397 written_buffer[1] = static_cast<float>(kE);
398 written_buffer[2] = static_cast<float>(kAvogadro);
399
400 EXPECT_EQ(kBufferLength,
401 WriteFloatBufferToFile(&file, kBufferLength, written_buffer.get()));
402
403 file.Close();
404
405 file = FileWrapper::OpenReadOnly(kOutFileName);
406 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
407 << kOutFileName.c_str();
408
409 EXPECT_EQ(kBufferLength,
410 ReadFloatBufferFromFile(&file, kBufferLength, read_buffer.get()));
411 EXPECT_EQ(0, memcmp(written_buffer.get(), read_buffer.get(),
412 kBufferLength * sizeof(written_buffer[0])));
413 }
414
415 #if defined(WEBRTC_IOS)
416 #define MAYBE_WriteDoubleBufferToFile DISABLED_WriteDoubleBufferToFile
417 #else
418 #define MAYBE_WriteDoubleBufferToFile WriteDoubleBufferToFile
419 #endif
TEST_F(TransientFileUtilsTest,MAYBE_WriteDoubleBufferToFile)420 TEST_F(TransientFileUtilsTest, MAYBE_WriteDoubleBufferToFile) {
421 std::string kOutFileName =
422 CreateTempFilename(test::OutputPath(), "utils_test");
423
424 FileWrapper file = FileWrapper::OpenWriteOnly(kOutFileName);
425 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
426 << kOutFileName.c_str();
427
428 const size_t kBufferLength = 3;
429 std::unique_ptr<double[]> written_buffer(new double[kBufferLength]);
430 std::unique_ptr<double[]> read_buffer(new double[kBufferLength]);
431
432 written_buffer[0] = kPi;
433 written_buffer[1] = kE;
434 written_buffer[2] = kAvogadro;
435
436 EXPECT_EQ(kBufferLength, WriteDoubleBufferToFile(&file, kBufferLength,
437 written_buffer.get()));
438
439 file.Close();
440
441 file = FileWrapper::OpenReadOnly(kOutFileName);
442 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
443 << kOutFileName.c_str();
444
445 EXPECT_EQ(kBufferLength,
446 ReadDoubleBufferFromFile(&file, kBufferLength, read_buffer.get()));
447 EXPECT_EQ(0, memcmp(written_buffer.get(), read_buffer.get(),
448 kBufferLength * sizeof(written_buffer[0])));
449 }
450
451 #if defined(WEBRTC_IOS)
452 #define MAYBE_ExpectedErrorReturnValues DISABLED_ExpectedErrorReturnValues
453 #else
454 #define MAYBE_ExpectedErrorReturnValues ExpectedErrorReturnValues
455 #endif
TEST_F(TransientFileUtilsTest,MAYBE_ExpectedErrorReturnValues)456 TEST_F(TransientFileUtilsTest, MAYBE_ExpectedErrorReturnValues) {
457 std::string test_filename = kTestFileName;
458
459 double value;
460 std::unique_ptr<int16_t[]> int16_buffer(new int16_t[1]);
461 std::unique_ptr<double[]> double_buffer(new double[1]);
462 FileWrapper file;
463
464 EXPECT_EQ(-1, ConvertByteArrayToDouble(NULL, &value));
465 EXPECT_EQ(-1, ConvertByteArrayToDouble(kPiBytes, NULL));
466
467 EXPECT_EQ(-1, ConvertDoubleToByteArray(kPi, NULL));
468
469 // Tests with file not opened.
470 EXPECT_EQ(0u, ReadInt16BufferFromFile(&file, 1, int16_buffer.get()));
471 EXPECT_EQ(0u, ReadInt16FromFileToDoubleBuffer(&file, 1, double_buffer.get()));
472 EXPECT_EQ(0u, ReadDoubleBufferFromFile(&file, 1, double_buffer.get()));
473 EXPECT_EQ(0u, WriteInt16BufferToFile(&file, 1, int16_buffer.get()));
474 EXPECT_EQ(0u, WriteDoubleBufferToFile(&file, 1, double_buffer.get()));
475
476 file = FileWrapper::OpenReadOnly(test_filename);
477 ASSERT_TRUE(file.is_open()) << "File could not be opened:\n"
478 << kTestFileName.c_str();
479
480 EXPECT_EQ(0u, ReadInt16BufferFromFile(NULL, 1, int16_buffer.get()));
481 EXPECT_EQ(0u, ReadInt16BufferFromFile(&file, 1, NULL));
482 EXPECT_EQ(0u, ReadInt16BufferFromFile(&file, 0, int16_buffer.get()));
483
484 EXPECT_EQ(0u, ReadInt16FromFileToDoubleBuffer(NULL, 1, double_buffer.get()));
485 EXPECT_EQ(0u, ReadInt16FromFileToDoubleBuffer(&file, 1, NULL));
486 EXPECT_EQ(0u, ReadInt16FromFileToDoubleBuffer(&file, 0, double_buffer.get()));
487
488 EXPECT_EQ(0u, ReadDoubleBufferFromFile(NULL, 1, double_buffer.get()));
489 EXPECT_EQ(0u, ReadDoubleBufferFromFile(&file, 1, NULL));
490 EXPECT_EQ(0u, ReadDoubleBufferFromFile(&file, 0, double_buffer.get()));
491
492 EXPECT_EQ(0u, WriteInt16BufferToFile(NULL, 1, int16_buffer.get()));
493 EXPECT_EQ(0u, WriteInt16BufferToFile(&file, 1, NULL));
494 EXPECT_EQ(0u, WriteInt16BufferToFile(&file, 0, int16_buffer.get()));
495
496 EXPECT_EQ(0u, WriteDoubleBufferToFile(NULL, 1, double_buffer.get()));
497 EXPECT_EQ(0u, WriteDoubleBufferToFile(&file, 1, NULL));
498 EXPECT_EQ(0u, WriteDoubleBufferToFile(&file, 0, double_buffer.get()));
499 }
500
501 } // namespace webrtc
502