1 files changed, 229 insertions, 0 deletions
diff --git a/media/libcubeb/test/test_ring_buffer.cpp b/media/libcubeb/test/test_ring_buffer.cpp
new file mode 100644
index 0000000000..fffe1087e4
--- /dev/null
+++ b/media/libcubeb/test/test_ring_buffer.cpp
@@ -0,0 +1,229 @@
+/*
+ * Copyright © 2016 Mozilla Foundation
+ *
+ * This program is made available under an ISC-style license.  See the
+ * accompanying file LICENSE for details.
+ */
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#include "cubeb_ringbuffer.h"
+#include "gtest/gtest.h"
+#include <chrono>
+#include <iostream>
+#include <thread>
+
+/* Generate a monotonically increasing sequence of numbers. */
+template <typename T> class sequence_generator {
+public:
+  sequence_generator(size_t channels) : channels(channels) {}
+  void get(T * elements, size_t frames)
+  {
+    for (size_t i = 0; i < frames; i++) {
+      for (size_t c = 0; c < channels; c++) {
+        elements[i * channels + c] = static_cast<T>(index_);
+      }
+      index_++;
+    }
+  }
+  void rewind(size_t frames) { index_ -= frames; }
+
+private:
+  size_t index_ = 0;
+  size_t channels = 0;
+};
+
+/* Checks that a sequence is monotonically increasing. */
+template <typename T> class sequence_verifier {
+public:
+  sequence_verifier(size_t channels) : channels(channels) {}
+  void check(T * elements, size_t frames)
+  {
+    for (size_t i = 0; i < frames; i++) {
+      for (size_t c = 0; c < channels; c++) {
+        if (elements[i * channels + c] != static_cast<T>(index_)) {
+          std::cerr << "Element " << i << " is different. Expected "
+                    << static_cast<T>(index_) << ", got " << elements[i]
+                    << ". (channel count: " << channels << ")." << std::endl;
+          ASSERT_TRUE(false);
+        }
+      }
+      index_++;
+    }
+  }
+
+private:
+  size_t index_ = 0;
+  size_t channels = 0;
+};
+
+template <typename T>
+void
+test_ring(lock_free_audio_ring_buffer<T> & buf, int channels,
+          int capacity_frames)
+{
+  std::unique_ptr<T[]> seq(new T[capacity_frames * channels]);
+  sequence_generator<T> gen(channels);
+  sequence_verifier<T> checker(channels);
+
+  int iterations = 1002;
+
+  const int block_size = 128;
+
+  while (iterations--) {
+    gen.get(seq.get(), block_size);
+    int rv = buf.enqueue(seq.get(), block_size);
+    ASSERT_EQ(rv, block_size);
+    PodZero(seq.get(), block_size);
+    rv = buf.dequeue(seq.get(), block_size);
+    ASSERT_EQ(rv, block_size);
+    checker.check(seq.get(), block_size);
+  }
+}
+
+template <typename T>
+void
+test_ring_multi(lock_free_audio_ring_buffer<T> & buf, int channels,
+                int capacity_frames)
+{
+  sequence_verifier<T> checker(channels);
+  std::unique_ptr<T[]> out_buffer(new T[capacity_frames * channels]);
+
+  const int block_size = 128;
+
+  std::thread t([=, &buf] {
+    int iterations = 1002;
+    std::unique_ptr<T[]> in_buffer(new T[capacity_frames * channels]);
+    sequence_generator<T> gen(channels);
+
+    while (iterations--) {
+      std::this_thread::yield();
+      gen.get(in_buffer.get(), block_size);
+      int rv = buf.enqueue(in_buffer.get(), block_size);
+      ASSERT_TRUE(rv <= block_size);
+      if (rv != block_size) {
+        gen.rewind(block_size - rv);
+      }
+    }
+  });
+
+  int remaining = 1002;
+
+  while (remaining--) {
+    std::this_thread::yield();
+    int rv = buf.dequeue(out_buffer.get(), block_size);
+    ASSERT_TRUE(rv <= block_size);
+    checker.check(out_buffer.get(), rv);
+  }
+
+  t.join();
+}
+
+template <typename T>
+void
+basic_api_test(T & ring)
+{
+  ASSERT_EQ(ring.capacity(), 128);
+
+  ASSERT_EQ(ring.available_read(), 0);
+  ASSERT_EQ(ring.available_write(), 128);
+
+  int rv = ring.enqueue_default(63);
+
+  ASSERT_TRUE(rv == 63);
+  ASSERT_EQ(ring.available_read(), 63);
+  ASSERT_EQ(ring.available_write(), 65);
+
+  rv = ring.enqueue_default(65);
+
+  ASSERT_EQ(rv, 65);
+  ASSERT_EQ(ring.available_read(), 128);
+  ASSERT_EQ(ring.available_write(), 0);
+
+  rv = ring.dequeue(nullptr, 63);
+
+  ASSERT_EQ(ring.available_read(), 65);
+  ASSERT_EQ(ring.available_write(), 63);
+
+  rv = ring.dequeue(nullptr, 65);
+
+  ASSERT_EQ(ring.available_read(), 0);
+  ASSERT_EQ(ring.available_write(), 128);
+}
+
+void
+test_reset_api()
+{
+  const size_t ring_buffer_size = 128;
+  const size_t enqueue_size = ring_buffer_size / 2;
+
+  lock_free_queue<float> ring(ring_buffer_size);
+  std::thread t([=, &ring] {
+    std::unique_ptr<float[]> in_buffer(new float[enqueue_size]);
+    ring.enqueue(in_buffer.get(), enqueue_size);
+  });
+
+  t.join();
+
+  ring.reset_thread_ids();
+
+  // Enqueue with a different thread. We have reset the thread ID
+  // in the ring buffer, this should work.
+  std::thread t2([=, &ring] {
+    std::unique_ptr<float[]> in_buffer(new float[enqueue_size]);
+    ring.enqueue(in_buffer.get(), enqueue_size);
+  });
+
+  t2.join();
+
+  ASSERT_TRUE(true);
+}
+
+TEST(cubeb, ring_buffer)
+{
+  /* Basic API test. */
+  const int min_channels = 1;
+  const int max_channels = 10;
+  const int min_capacity = 199;
+  const int max_capacity = 1277;
+  const int capacity_increment = 27;
+
+  lock_free_queue<float> q1(128);
+  basic_api_test(q1);
+  lock_free_queue<short> q2(128);
+  basic_api_test(q2);
+
+  for (size_t channels = min_channels; channels < max_channels; channels++) {
+    lock_free_audio_ring_buffer<float> q3(channels, 128);
+    basic_api_test(q3);
+    lock_free_audio_ring_buffer<short> q4(channels, 128);
+    basic_api_test(q4);
+  }
+
+  /* Single thread testing. */
+  /* Test mono to 9.1 */
+  for (size_t channels = min_channels; channels < max_channels; channels++) {
+    /* Use non power-of-two numbers to catch edge-cases. */
+    for (size_t capacity_frames = min_capacity; capacity_frames < max_capacity;
+         capacity_frames += capacity_increment) {
+      lock_free_audio_ring_buffer<float> ring(channels, capacity_frames);
+      test_ring(ring, channels, capacity_frames);
+    }
+  }
+
+  /* Multi thread testing */
+  for (size_t channels = min_channels; channels < max_channels; channels++) {
+    /* Use non power-of-two numbers to catch edge-cases. */
+    for (size_t capacity_frames = min_capacity; capacity_frames < max_capacity;
+         capacity_frames += capacity_increment) {
+      lock_free_audio_ring_buffer<short> ring(channels, capacity_frames);
+      test_ring_multi(ring, channels, capacity_frames);
+    }
+  }
+
+  test_reset_api();
+}
+
+#undef NOMINMAX