react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

package/common/cpp/audioapi/utils/ThreadPool.hpp

@@ -1,8 +1,10 @@
 #pragma once
-#include <thread>
-#include <vector>
 #include <functional>
+#include <memory>
+#include <thread>
+#include <utility>
 #include <variant>
+#include <vector>
 
 #include <audioapi/utils/MoveOnlyFunction.hpp>
 #include <audioapi/utils/SpscChannel.hpp>
@@ -17,32 +19,78 @@ namespace audioapi {
 /// @note IMPORTANT: ThreadPool is not thread-safe and events should be scheduled from a single thread only.
 class ThreadPool {
   struct StopEvent {};
-  struct TaskEvent { audioapi::move_only_function<void()> task; };
+  struct TaskEvent {
+    audioapi::move_only_function<void()> task;
+  };
   using Event = std::variant<TaskEvent, StopEvent>;
 
-  using Sender = channels::spsc::Sender<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>;
-  using Receiver = channels::spsc::Receiver<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>;
-public:
+  struct Cntrl {
+    std::atomic<bool> waitingForTasks{false};
+    std::atomic<size_t> tasksScheduled{0};
+  };
+
+  using Sender = channels::spsc::Sender<
+      Event,
+      channels::spsc::OverflowStrategy::WAIT_ON_FULL,
+      channels::spsc::WaitStrategy::ATOMIC_WAIT>;
+  using Receiver = channels::spsc::Receiver<
+      Event,
+      channels::spsc::OverflowStrategy::WAIT_ON_FULL,
+      channels::spsc::WaitStrategy::ATOMIC_WAIT>;
+
+ public:
   /// @brief Construct a new ThreadPool
   /// @param numThreads The number of worker threads to create
   /// @param loadBalancerQueueSize The size of the load balancer's queue
   /// @param workerQueueSize The size of each worker thread's queue
-  ThreadPool(size_t numThreads, size_t loadBalancerQueueSize = 32, size_t workerQueueSize = 32) {
-    auto [sender, receiver] = channels::spsc::channel<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>(loadBalancerQueueSize);
+  explicit ThreadPool(
+      size_t numThreads,
+      size_t loadBalancerQueueSize = 32,
+      size_t workerQueueSize = 32) {
+    auto [sender, receiver] = channels::spsc::channel<
+        Event,
+        channels::spsc::OverflowStrategy::WAIT_ON_FULL,
+        channels::spsc::WaitStrategy::ATOMIC_WAIT>(loadBalancerQueueSize);
     loadBalancerSender = std::move(sender);
     std::vector<Sender> workerSenders;
     workerSenders.reserve(numThreads);
     for (size_t i = 0; i < numThreads; ++i) {
-      auto [workerSender, workerReceiver] = channels::spsc::channel<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>(workerQueueSize);
+      auto [workerSender, workerReceiver] = channels::spsc::channel<
+          Event,
+          channels::spsc::OverflowStrategy::WAIT_ON_FULL,
+          channels::spsc::WaitStrategy::ATOMIC_WAIT>(workerQueueSize);
       workers.emplace_back(&ThreadPool::workerThreadFunc, this, std::move(workerReceiver));
       workerSenders.emplace_back(std::move(workerSender));
     }
-    loadBalancerThread = std::thread(&ThreadPool::loadBalancerThreadFunc, this, std::move(receiver), std::move(workerSenders));
+    loadBalancerThread = std::thread(
+        &ThreadPool::loadBalancerThreadFunc, this, std::move(receiver), std::move(workerSenders));
+    controlBlock_ = std::make_unique<Cntrl>();
+  }
+  ThreadPool(const ThreadPool &) = delete;
+  ThreadPool &operator=(const ThreadPool &) = delete;
+  ThreadPool(ThreadPool &&other)
+      : loadBalancerThread(std::move(other.loadBalancerThread)),
+        workers(std::move(other.workers)),
+        loadBalancerSender(std::move(other.loadBalancerSender)),
+        controlBlock_(std::move(other.controlBlock_)) {}
+  ThreadPool &operator=(ThreadPool &&other) {
+    if (this != &other) {
+      loadBalancerThread = std::move(other.loadBalancerThread);
+      workers = std::move(other.workers);
+      loadBalancerSender = std::move(other.loadBalancerSender);
+      controlBlock_ = std::move(other.controlBlock_);
+      other.movedFrom_ = true;
+    }
+    return *this;
   }
+
   ~ThreadPool() {
+    if (movedFrom_) {
+      return;
+    }
     loadBalancerSender.send(StopEvent{});
     loadBalancerThread.join();
-    for (auto& worker : workers) {
+    for (auto &worker : workers) {
       worker.join();
     }
   }
@@ -57,18 +105,54 @@ public:
   /// @note The task should not throw exceptions, as they will not be caught.
   /// @note The task should end at some point, otherwise the thread pool will never be able to shut down.
   /// @note IMPORTANT: This function is not thread-safe and should be called from a single thread only.
-  template<typename Func, typename ... Args, typename = std::enable_if_t<std::is_invocable_r_v<void, Func, Args...>>>
-  void schedule(Func &&task, Args &&... args) noexcept {
-    auto boundTask = [f = std::forward<Func>(task), ...capturedArgs = std::forward<Args>(args)]() mutable {
+  template <
+      typename Func,
+      typename... Args,
+      typename = std::enable_if_t<std::is_invocable_r_v<void, Func, Args...>>>
+  void schedule(Func &&task, Args &&...args) noexcept {
+    controlBlock_->tasksScheduled.fetch_add(1, std::memory_order_release);
+
+    /// We know that lifetime of each worker thus spsc thus lambda is strongly bounded by ThreadPool lifetime
+    /// so we can safely capture control block pointer unsafely here
+    Cntrl *cntrl = controlBlock_.get();
+    auto boundTask = [cntrl,
+                      f = std::forward<Func>(task),
+                      ... capturedArgs = std::forward<Args>(args)]() mutable {
       f(std::forward<Args>(capturedArgs)...);
+      size_t left = cntrl->tasksScheduled.fetch_sub(1, std::memory_order_acq_rel) - 1;
+      if (left == 0) {
+        cntrl->waitingForTasks.store(false, std::memory_order_release);
+        cntrl->waitingForTasks.notify_one();
+      }
     };
     loadBalancerSender.send(TaskEvent{audioapi::move_only_function<void()>(std::move(boundTask))});
   }
 
-private:
+  /// @brief Waits for all scheduled tasks to complete
+  void wait() {
+    /// This logic might seem incorrect at first glance
+    /// Main principle for this is that there is only one thread scheduling tasks
+    /// If he is waiting for the tasks he CANNOT schedule new tasks so we can assume partial
+    /// synchronization here.
+    /// We first store true so if any task finishes at this moment he will flip it
+    /// Then we check if there are any tasks scheduled
+    /// If there are none we can return immediately
+    /// If there are some we wait until the last task flips the flag to false
+    controlBlock_->waitingForTasks.store(true, std::memory_order_release);
+    if (controlBlock_->tasksScheduled.load(std::memory_order_acquire) == 0) {
+      controlBlock_->waitingForTasks.store(false, std::memory_order_release);
+      return;
+    }
+    controlBlock_->waitingForTasks.wait(true, std::memory_order_acquire);
+    return;
+  }
+
+ private:
   std::thread loadBalancerThread;
   std::vector<std::thread> workers;
   Sender loadBalancerSender;
+  std::unique_ptr<Cntrl> controlBlock_;
+  bool movedFrom_ = false;
 
   void workerThreadFunc(Receiver &&receiver) {
     Receiver localReceiver = std::move(receiver);
@@ -77,9 +161,9 @@ private:
       /// We use [[unlikely]] and [[likely]] attributes to help the compiler optimize the branching.
       /// we expect most of the time to receive TaskEvent, and rarely StopEvent.
       /// and whenever we receive StopEvent we can burn some cycles as it will not be expected to execute fast.
-      if (std::holds_alternative<StopEvent>(event)) [[ unlikely ]] {
+      if (std::holds_alternative<StopEvent>(event)) [[unlikely]] {
         break;
-      } else if (std::holds_alternative<TaskEvent>(event)) [[ likely ]] {
+      } else if (std::holds_alternative<TaskEvent>(event)) [[likely]] {
         std::get<TaskEvent>(event).task();
       }
     }
@@ -94,15 +178,15 @@ private:
       /// We use [[unlikely]] and [[likely]] attributes to help the compiler optimize the branching.
       /// we expect most of the time to receive TaskEvent, and rarely StopEvent.
       /// and whenever we receive StopEvent we can burn some cycles as it will not be expected to execute fast.
-      if (std::holds_alternative<StopEvent>(event)) [[ unlikely ]] {
+      if (std::holds_alternative<StopEvent>(event)) [[unlikely]] {
         // Propagate stop event to all workers
         for (size_t i = 0; i < localWorkerSenders.size(); ++i) {
           localWorkerSenders[i].send(StopEvent{});
         }
         break;
-      } else if (std::holds_alternative<TaskEvent>(event)) [[ likely ]] {
+      } else if (std::holds_alternative<TaskEvent>(event)) [[likely]] {
         // Dispatch task to the next worker in round-robin fashion
-        auto& taskEvent = std::get<TaskEvent>(event);
+        auto &taskEvent = std::get<TaskEvent>(event);
         localWorkerSenders[nextWorker].send(std::move(taskEvent));
         nextWorker = (nextWorker + 1) % localWorkerSenders.size();
       }

package/common/cpp/audioapi/utils/UnitConversion.h

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace audioapi {
+
+static constexpr double KB_IN_BYTES = 1024.0;
+static constexpr double MB_IN_BYTES = KB_IN_BYTES * 1024.0;
+static constexpr double GB_IN_BYTES = MB_IN_BYTES * 1024.0;
+
+} // namespace audioapi

package/common/cpp/test/CMakeLists.txt

@@ -12,41 +12,39 @@ FetchContent_Declare(
   googletest
   URL https://github.com/google/googletest/archive/3983f67e32fb3e9294487b9d4f9586efa6e5d088.zip
 )
+
 # For Windows: Prevent overriding the parent project's compiler/linker settings
 set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 FetchContent_MakeAvailable(googletest)
 
 enable_testing()
 
+set(REACT_NATIVE_AUDIO_API_DIR "${ROOT}/node_modules/react-native-audio-api")
+
 file(GLOB_RECURSE RNAUDIOAPI_SRC
   CONFIGURE_DEPENDS
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/*.cpp"
-  "${ROOT}/node_modules/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/*.cpp"
 )
 
 # exclude HostObjects from tests
 list(FILTER RNAUDIOAPI_SRC EXCLUDE REGEX ".*/audioapi/HostObjects/.*\\.cpp$")
+# exclude worklet nodes
+list(FILTER RNAUDIOAPI_SRC EXCLUDE REGEX ".*/Worklet.*Node\\.cpp$")
 
 list(REMOVE_ITEM RNAUDIOAPI_SRC
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.cpp"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.h"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/core/AudioContext.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp"
 )
 
 file(GLOB_RECURSE RNAUDIOAPI_LIBS
   CONFIGURE_DEPENDS
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/*.c"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/*.h"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/*.c"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/*.h"
 )
 
 list(REMOVE_ITEM RNAUDIOAPI_LIBS
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.c"
-  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.c"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.c"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.c"
 )
 
 add_library(rnaudioapi STATIC ${RNAUDIOAPI_SRC})
@@ -57,6 +55,8 @@ target_include_directories(rnaudioapi PUBLIC
   ${JSI_DIR}
   "${REACT_NATIVE_DIR}/ReactCommon"
   "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
+  ${gtest_SOURCE_DIR}/include
+  ${gmock_SOURCE_DIR}/include
 )
 
 target_include_directories(rnaudioapi_libs PUBLIC
@@ -73,9 +73,9 @@ add_executable(
   ${test_src}
 )
 
-add_compile_definitions(AUDIO_API_TEST_SUITE)
 add_compile_definitions(RN_AUDIO_API_ENABLE_WORKLETS=0)
 add_compile_definitions(RN_AUDIO_API_TEST=1)
+add_compile_definitions(RN_AUDIO_API_FFMPEG_DISABLED=1)
 
 target_link_libraries(tests
   rnaudioapi

package/common/cpp/test/src/AudioParamTest.cpp

@@ -3,12 +3,14 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+#include <vector>
 
 using namespace audioapi;
 
 class AudioParamTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 
@@ -119,8 +121,7 @@ TEST_F(AudioParamTest, SetTargetAtTime) {
 TEST_F(AudioParamTest, SetValueCurveAtTime) {
   AudioParam param = AudioParam(0.0, 0.0, 1.0, context.get());
   param.setValue(0.5);
-  auto curve = std::make_shared<std::vector<float>>(
-      std::vector<float>{0.1, 0.4, 0.2, 0.8, 0.5});
+  auto curve = std::make_shared<std::vector<float>>(std::vector<float>{0.1, 0.4, 0.2, 0.8, 0.5});
   param.setValueCurveAtTime(curve, curve->size(), 0.1, 0.2);
   // 5 elements over 0.2s => each element is 0.04s apart
 

package/common/cpp/test/src/AudioScheduledSourceTest.cpp

@@ -0,0 +1,113 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/utils/AudioBus.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+
+using namespace audioapi;
+static constexpr int SAMPLE_RATE = 44100;
+static constexpr int RENDER_QUANTUM = 128;
+static constexpr double RENDER_QUANTUM_TIME = static_cast<double>(RENDER_QUANTUM) / SAMPLE_RATE;
+
+class AudioScheduledSourceTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * SAMPLE_RATE, SAMPLE_RATE, eventRegistry, RuntimeRegistry{});
+  }
+};
+
+class TestableAudioScheduledSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit TestableAudioScheduledSourceNode(BaseAudioContext *context)
+      : AudioScheduledSourceNode(context) {
+    isInitialized_ = true;
+  }
+
+  void updatePlaybackInfo(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess,
+      size_t &startOffset,
+      size_t &nonSilentFramesToProcess) {
+    AudioScheduledSourceNode::updatePlaybackInfo(
+        processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
+  }
+
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus> &, int) override {
+    return nullptr;
+  }
+
+  PlaybackState getPlaybackState() const {
+    return playbackState_;
+  }
+
+  void playFrames(int frames) {
+    size_t startOffset = 0;
+    size_t nonSilentFramesToProcess = 0;
+    auto processingBus = std::make_shared<AudioBus>(128, 2, static_cast<float>(SAMPLE_RATE));
+    updatePlaybackInfo(processingBus, frames, startOffset, nonSilentFramesToProcess);
+    context_->getDestination()->renderAudio(processingBus, frames);
+  }
+};
+
+TEST_F(AudioScheduledSourceTest, IsUnscheduledStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  EXPECT_EQ(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::UNSCHEDULED);
+
+  sourceNode.start(RENDER_QUANTUM_TIME);
+  EXPECT_NE(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::UNSCHEDULED);
+}
+
+TEST_F(AudioScheduledSourceTest, IsScheduledStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(RENDER_QUANTUM_TIME);
+  EXPECT_EQ(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+
+  sourceNode.playFrames(RENDER_QUANTUM);
+  EXPECT_EQ(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+
+  sourceNode.playFrames(1);
+  EXPECT_NE(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+}
+
+TEST_F(AudioScheduledSourceTest, IsPlayingStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(0);
+  sourceNode.stop(RENDER_QUANTUM_TIME);
+
+  sourceNode.playFrames(RENDER_QUANTUM);
+  EXPECT_EQ(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::PLAYING);
+
+  sourceNode.playFrames(1);
+  EXPECT_NE(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::PLAYING);
+}
+
+TEST_F(AudioScheduledSourceTest, IsStopScheduledStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(0);
+  sourceNode.stop(RENDER_QUANTUM_TIME);
+  sourceNode.playFrames(1); // start playing
+  sourceNode.playFrames(RENDER_QUANTUM);
+  EXPECT_EQ(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::STOP_SCHEDULED);
+
+  sourceNode.playFrames(1);
+  EXPECT_NE(sourceNode.getPlaybackState(), AudioScheduledSourceNode::PlaybackState::STOP_SCHEDULED);
+}
+
+TEST_F(AudioScheduledSourceTest, IsFinishedStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(0);
+  sourceNode.stop(RENDER_QUANTUM_TIME);
+  sourceNode.playFrames(1); // start playing
+
+  sourceNode.playFrames(RENDER_QUANTUM);
+  sourceNode.playFrames(1);
+  EXPECT_TRUE(sourceNode.isFinished());
+}

package/common/cpp/test/src/ConstantSourceTest.cpp

@@ -5,12 +5,13 @@
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 using namespace audioapi;
 
 class ConstantSourceTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 
@@ -23,8 +24,7 @@ class ConstantSourceTest : public ::testing::Test {
 
 class TestableConstantSourceNode : public ConstantSourceNode {
  public:
-  explicit TestableConstantSourceNode(BaseAudioContext *context)
-      : ConstantSourceNode(context) {}
+  explicit TestableConstantSourceNode(BaseAudioContext *context) : ConstantSourceNode(context) {}
 
   void setOffsetParam(float value) {
     getOffsetParam()->setValue(value);
@@ -45,10 +45,8 @@ TEST_F(ConstantSourceTest, ConstantSourceCanBeCreated) {
 TEST_F(ConstantSourceTest, ConstantSourceOutputsConstantValue) {
   static constexpr int FRAMES_TO_PROCESS = 4;
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
-  auto constantSource =
-      std::make_shared<TestableConstantSourceNode>(context.get());
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  auto constantSource = std::make_shared<TestableConstantSourceNode>(context.get());
   constantSource->start(context->getCurrentTime());
   auto resultBus = constantSource->processNode(bus, FRAMES_TO_PROCESS);
 

package/common/cpp/test/src/DelayTest.cpp

@@ -0,0 +1,108 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/DelayNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+
+using namespace audioapi;
+
+class DelayTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+  static constexpr int sampleRate = 44100;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+};
+
+class TestableDelayNode : public DelayNode {
+ public:
+  explicit TestableDelayNode(BaseAudioContext *context) : DelayNode(context, 1) {}
+
+  void setDelayTimeParam(float value) {
+    getDelayTimeParam()->setValue(value);
+  }
+
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return DelayNode::processNode(processingBus, framesToProcess);
+  }
+};
+
+TEST_F(DelayTest, DelayCanBeCreated) {
+  auto delay = context->createDelay(1.0f);
+  ASSERT_NE(delay, nullptr);
+}
+
+TEST_F(DelayTest, DelayWithZeroDelayOutputsInputSignal) {
+  static constexpr float DELAY_TIME = 0.0f;
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  auto delayNode = std::make_shared<TestableDelayNode>(context.get());
+  delayNode->setDelayTimeParam(DELAY_TIME);
+
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    bus->getChannel(0)->getData()[i] = i + 1;
+  }
+
+  auto resultBus = delayNode->processNode(bus, FRAMES_TO_PROCESS);
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_FLOAT_EQ((*resultBus->getChannel(0))[i], static_cast<float>(i + 1));
+  }
+}
+
+TEST_F(DelayTest, DelayAppliesTimeShiftCorrectly) {
+  float DELAY_TIME = (128.0 / context->getSampleRate()) * 0.5;
+  static constexpr int FRAMES_TO_PROCESS = 128;
+  auto delayNode = std::make_shared<TestableDelayNode>(context.get());
+  delayNode->setDelayTimeParam(DELAY_TIME);
+
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    bus->getChannel(0)->getData()[i] = i + 1;
+  }
+
+  auto resultBus = delayNode->processNode(bus, FRAMES_TO_PROCESS);
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    if (i < FRAMES_TO_PROCESS / 2) { // First 64 samples should be zero due to delay
+      EXPECT_FLOAT_EQ((*resultBus->getChannel(0))[i], 0.0f);
+    } else {
+      EXPECT_FLOAT_EQ(
+          (*resultBus->getChannel(0))[i],
+          static_cast<float>(
+              i + 1 - FRAMES_TO_PROCESS / 2)); // Last 64 samples should be 1st part of bus
+    }
+  }
+}
+
+TEST_F(DelayTest, DelayHandlesTailCorrectly) {
+  float DELAY_TIME = (128.0 / context->getSampleRate()) * 0.5;
+  static constexpr int FRAMES_TO_PROCESS = 128;
+  auto delayNode = std::make_shared<TestableDelayNode>(context.get());
+  delayNode->setDelayTimeParam(DELAY_TIME);
+
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    bus->getChannel(0)->getData()[i] = i + 1;
+  }
+
+  delayNode->processNode(bus, FRAMES_TO_PROCESS);
+  auto resultBus = delayNode->processNode(bus, FRAMES_TO_PROCESS);
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    if (i < FRAMES_TO_PROCESS / 2) { // First 64 samples should be 2nd part of bus
+      EXPECT_FLOAT_EQ(
+          (*resultBus->getChannel(0))[i], static_cast<float>(i + 1 + FRAMES_TO_PROCESS / 2));
+    } else {
+      EXPECT_FLOAT_EQ((*resultBus->getChannel(0))[i],
+                      0.0f); // Last 64 samples should be zero
+    }
+  }
+}

package/common/cpp/test/src/GainTest.cpp

@@ -5,12 +5,13 @@
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
 
 using namespace audioapi;
 
 class GainTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 
@@ -47,8 +48,7 @@ TEST_F(GainTest, GainModulatesVolumeCorrectly) {
   auto gainNode = std::make_shared<TestableGainNode>(context.get());
   gainNode->setGainParam(GAIN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
   for (size_t i = 0; i < bus->getSize(); ++i) {
     bus->getChannel(0)->getData()[i] = i + 1;
   }
@@ -65,8 +65,7 @@ TEST_F(GainTest, GainModulatesVolumeCorrectlyMultiChannel) {
   auto gainNode = std::make_shared<TestableGainNode>(context.get());
   gainNode->setGainParam(GAIN_VALUE);
 
-  auto bus =
-      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
   for (size_t i = 0; i < bus->getSize(); ++i) {
     bus->getChannel(0)->getData()[i] = i + 1;
     bus->getChannel(1)->getData()[i] = -i - 1;