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 "common_audio/ring_buffer.h"
12
13 #include <stdlib.h>
14 #include <time.h>
15
16 #include <algorithm>
17 #include <memory>
18
19 #include "test/gtest.h"
20
21 namespace webrtc {
22
23 struct FreeBufferDeleter {
operator ()webrtc::FreeBufferDeleter24 inline void operator()(void* ptr) const {
25 WebRtc_FreeBuffer(ptr);
26 }
27 };
28 typedef std::unique_ptr<RingBuffer, FreeBufferDeleter> scoped_ring_buffer;
29
AssertElementEq(int expected,int actual)30 static void AssertElementEq(int expected, int actual) {
31 ASSERT_EQ(expected, actual);
32 }
33
SetIncrementingData(int * data,int num_elements,int starting_value)34 static int SetIncrementingData(int* data, int num_elements,
35 int starting_value) {
36 for (int i = 0; i < num_elements; i++) {
37 data[i] = starting_value++;
38 }
39 return starting_value;
40 }
41
CheckIncrementingData(int * data,int num_elements,int starting_value)42 static int CheckIncrementingData(int* data, int num_elements,
43 int starting_value) {
44 for (int i = 0; i < num_elements; i++) {
45 AssertElementEq(starting_value++, data[i]);
46 }
47 return starting_value;
48 }
49
50 // We use ASSERTs in this test to avoid obscuring the seed in the case of a
51 // failure.
RandomStressTest(int ** data_ptr)52 static void RandomStressTest(int** data_ptr) {
53 const int kNumTests = 10;
54 const int kNumOps = 1000;
55 const int kMaxBufferSize = 1000;
56
57 unsigned int seed = time(nullptr);
58 printf("seed=%u\n", seed);
59 srand(seed);
60 for (int i = 0; i < kNumTests; i++) {
61 // rand_r is not supported on many platforms, so rand is used.
62 const int buffer_size = std::max(rand() % kMaxBufferSize, 1); // NOLINT
63 std::unique_ptr<int[]> write_data(new int[buffer_size]);
64 std::unique_ptr<int[]> read_data(new int[buffer_size]);
65 scoped_ring_buffer buffer(WebRtc_CreateBuffer(buffer_size, sizeof(int)));
66 ASSERT_TRUE(buffer.get() != nullptr);
67 WebRtc_InitBuffer(buffer.get());
68 int buffer_consumed = 0;
69 int write_element = 0;
70 int read_element = 0;
71 for (int j = 0; j < kNumOps; j++) {
72 const bool write = rand() % 2 == 0 ? true : false; // NOLINT
73 const int num_elements = rand() % buffer_size; // NOLINT
74 if (write) {
75 const int buffer_available = buffer_size - buffer_consumed;
76 ASSERT_EQ(static_cast<size_t>(buffer_available),
77 WebRtc_available_write(buffer.get()));
78 const int expected_elements = std::min(num_elements, buffer_available);
79 write_element = SetIncrementingData(write_data.get(), expected_elements,
80 write_element);
81 ASSERT_EQ(static_cast<size_t>(expected_elements),
82 WebRtc_WriteBuffer(buffer.get(), write_data.get(),
83 num_elements));
84 buffer_consumed = std::min(buffer_consumed + expected_elements,
85 buffer_size);
86 } else {
87 const int expected_elements = std::min(num_elements,
88 buffer_consumed);
89 ASSERT_EQ(static_cast<size_t>(buffer_consumed),
90 WebRtc_available_read(buffer.get()));
91 ASSERT_EQ(static_cast<size_t>(expected_elements),
92 WebRtc_ReadBuffer(buffer.get(),
93 reinterpret_cast<void**>(data_ptr),
94 read_data.get(),
95 num_elements));
96 int* check_ptr = read_data.get();
97 if (data_ptr) {
98 check_ptr = *data_ptr;
99 }
100 read_element = CheckIncrementingData(check_ptr, expected_elements,
101 read_element);
102 buffer_consumed = std::max(buffer_consumed - expected_elements, 0);
103 }
104 }
105 }
106 }
107
TEST(RingBufferTest,RandomStressTest)108 TEST(RingBufferTest, RandomStressTest) {
109 int* data_ptr = nullptr;
110 RandomStressTest(&data_ptr);
111 }
112
TEST(RingBufferTest,RandomStressTestWithNullPtr)113 TEST(RingBufferTest, RandomStressTestWithNullPtr) {
114 RandomStressTest(nullptr);
115 }
116
TEST(RingBufferTest,PassingNulltoReadBufferForcesMemcpy)117 TEST(RingBufferTest, PassingNulltoReadBufferForcesMemcpy) {
118 const size_t kDataSize = 2;
119 int write_data[kDataSize];
120 int read_data[kDataSize];
121 int* data_ptr;
122
123 scoped_ring_buffer buffer(WebRtc_CreateBuffer(kDataSize, sizeof(int)));
124 ASSERT_TRUE(buffer.get() != nullptr);
125 WebRtc_InitBuffer(buffer.get());
126
127 SetIncrementingData(write_data, kDataSize, 0);
128 EXPECT_EQ(kDataSize, WebRtc_WriteBuffer(buffer.get(), write_data, kDataSize));
129 SetIncrementingData(read_data, kDataSize, kDataSize);
130 EXPECT_EQ(kDataSize, WebRtc_ReadBuffer(buffer.get(),
131 reinterpret_cast<void**>(&data_ptr), read_data, kDataSize));
132 // Copying was not necessary, so |read_data| has not been updated.
133 CheckIncrementingData(data_ptr, kDataSize, 0);
134 CheckIncrementingData(read_data, kDataSize, kDataSize);
135
136 EXPECT_EQ(kDataSize, WebRtc_WriteBuffer(buffer.get(), write_data, kDataSize));
137 EXPECT_EQ(kDataSize,
138 WebRtc_ReadBuffer(buffer.get(), nullptr, read_data, kDataSize));
139 // Passing null forces a memcpy, so |read_data| is now updated.
140 CheckIncrementingData(read_data, kDataSize, 0);
141 }
142
TEST(RingBufferTest,CreateHandlesErrors)143 TEST(RingBufferTest, CreateHandlesErrors) {
144 EXPECT_TRUE(WebRtc_CreateBuffer(0, 1) == nullptr);
145 EXPECT_TRUE(WebRtc_CreateBuffer(1, 0) == nullptr);
146 RingBuffer* buffer = WebRtc_CreateBuffer(1, 1);
147 EXPECT_TRUE(buffer != nullptr);
148 WebRtc_FreeBuffer(buffer);
149 }
150
151 } // namespace webrtc
152