Add tests for per-sample timestamp handling

anjaldoshi · anjaldoshi · commit 584bf8d09485 · 2026-05-01T16:56:35.000-07:00
diff --git a/Source/Processors/AudioNode/AudioNode.h b/Source/Processors/AudioNode/AudioNode.h
@@ -25,6 +25,7 @@
 #define __AUDIONODE_H_AF61F3C5__
 
 #include "../../../JuceLibraryCode/JuceHeader.h"
+#include "../../TestableExport.h"
 #include <stdio.h>
 
 #include "../Dsp/Dsp.h"
@@ -67,7 +68,7 @@ class Expander
   @see GenericProcessor, AudioEditor
 
 */
-class AudioNode : public GenericProcessor
+class TESTABLE AudioNode : public GenericProcessor
 {
 public:
     /** Constructor */
diff --git a/Tests/Processors/DataBufferTests.cpp b/Tests/Processors/DataBufferTests.cpp
@@ -41,4 +41,67 @@ TEST(DataBufferTest, CopyToAudioBuffer)
         for (int sample = 0; sample < audioBuffer.getNumSamples(); ++sample)
             EXPECT_EQ(audioBuffer.getSample(channel, sample), sample);
     }
+
+    for (int sample = 0; sample < numItems; ++sample)
+    {
+        EXPECT_EQ(timestamps[sample], sample);
+        EXPECT_EQ(eventCodes[sample], (uint64) sample);
+    }
+}
+
+TEST(DataBufferTest, CopyToAudioBufferAcrossWrap)
+{
+    constexpr int bufferSize = 11;
+    constexpr int firstWriteSize = 8;
+    constexpr int secondWriteSize = 6;
+    constexpr int firstReadSize = 5;
+
+    DataBuffer dataBuffer (1, bufferSize);
+
+    {
+        float data[firstWriteSize] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+        int64 sampleNumbers[firstWriteSize] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+        double timestamps[firstWriteSize] = { 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5 };
+        uint64 eventCodes[firstWriteSize] = { 10, 11, 12, 13, 14, 15, 16, 17 };
+
+        EXPECT_EQ (dataBuffer.addToBuffer (data, sampleNumbers, timestamps, eventCodes, firstWriteSize), firstWriteSize);
+    }
+
+    {
+        AudioBuffer<float> discardBuffer (1, firstReadSize);
+        int64 sampleNumber = -1;
+        double timestamps[firstReadSize] = { -1, -1, -1, -1, -1 };
+        uint64 eventCodes[firstReadSize] = { 0, 0, 0, 0, 0 };
+
+        EXPECT_EQ (dataBuffer.readAllFromBuffer (discardBuffer, &sampleNumber, timestamps, eventCodes, firstReadSize), firstReadSize);
+    }
+
+    {
+        float data[secondWriteSize] = { 100, 101, 102, 103, 104, 105 };
+        int64 sampleNumbers[secondWriteSize] = { 8, 9, 10, 11, 12, 13 };
+        double timestamps[secondWriteSize] = { 4.0, 4.5, 5.0, 5.5, 6.0, 6.5 };
+        uint64 eventCodes[secondWriteSize] = { 18, 19, 20, 21, 22, 23 };
+
+        EXPECT_EQ (dataBuffer.addToBuffer (data, sampleNumbers, timestamps, eventCodes, secondWriteSize), secondWriteSize);
+    }
+
+    constexpr int expectedReadSize = firstWriteSize - firstReadSize + secondWriteSize;
+    AudioBuffer<float> audioBuffer (1, expectedReadSize);
+    int64 startSampleNumber = -1;
+    double timestamps[expectedReadSize] = {};
+    uint64 eventCodes[expectedReadSize] = {};
+
+    EXPECT_EQ (dataBuffer.readAllFromBuffer (audioBuffer, &startSampleNumber, timestamps, eventCodes, expectedReadSize), expectedReadSize);
+    EXPECT_EQ (startSampleNumber, 5);
+
+    const float expectedSamples[expectedReadSize] = { 5, 6, 7, 100, 101, 102, 103, 104, 105 };
+    const double expectedTimestamps[expectedReadSize] = { 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5 };
+    const uint64 expectedEventCodes[expectedReadSize] = { 15, 16, 17, 18, 19, 20, 21, 22, 23 };
+
+    for (int sample = 0; sample < expectedReadSize; ++sample)
+    {
+        EXPECT_EQ (audioBuffer.getSample (0, sample), expectedSamples[sample]);
+        EXPECT_EQ (timestamps[sample], expectedTimestamps[sample]);
+        EXPECT_EQ (eventCodes[sample], expectedEventCodes[sample]);
+    }
 }
diff --git a/Tests/Processors/RecordNodeTests.cpp b/Tests/Processors/RecordNodeTests.cpp
@@ -56,8 +56,8 @@ class RecordNodeTests :  public testing::Test {
         return inputBuffer;
     }
 
-    void writeBlock(AudioBuffer<float> &buffer, TTLEvent* maybeTtlEvent = nullptr) {
-        auto outBuffer = tester->processBlock(processor, buffer, maybeTtlEvent);
+    void writeBlock(AudioBuffer<float> &buffer, TTLEvent* maybeTtlEvent = nullptr, const double* sampleTimestamps = nullptr) {
+        auto outBuffer = tester->processBlock(processor, buffer, maybeTtlEvent, sampleTimestamps);
         // Assert the buffer hasn't changed after process()
         ASSERT_EQ(outBuffer.getNumSamples(), buffer.getNumSamples());
         ASSERT_EQ(outBuffer.getNumChannels(), buffer.getNumChannels());
@@ -179,6 +179,55 @@ class RecordNodeTests :  public testing::Test {
         *output = loadNpyFileBinaryFullpath(npyFilePath.string());
     }
 
+    template <typename T>
+    std::vector<T> parseNpyPayload(const std::vector<char>& binary) {
+        if (binary.size() < static_cast<size_t>(10)) {
+            ADD_FAILURE() << "NPY payload is too small to contain a valid header";
+            return {};
+        }
+
+        const uint16_t headerLength = static_cast<uint8_t>(binary[8])
+                                      | (static_cast<uint16_t>(static_cast<uint8_t>(binary[9])) << 8);
+        const size_t payloadOffset = 10 + headerLength;
+
+        if (payloadOffset > binary.size()) {
+            ADD_FAILURE() << "NPY payload header exceeds file size";
+            return {};
+        }
+
+        if (((binary.size() - payloadOffset) % sizeof(T)) != static_cast<size_t>(0)) {
+            ADD_FAILURE() << "NPY payload size is not aligned to element size";
+            return {};
+        }
+
+        std::vector<T> values((binary.size() - payloadOffset) / sizeof(T));
+
+        if (!values.empty()) {
+            memcpy(values.data(), binary.data() + payloadOffset, values.size() * sizeof(T));
+        }
+
+        return values;
+    }
+
+    template <typename T>
+    std::vector<T> loadNpyData(const std::string& basename) {
+        bool success = false;
+        std::vector<char> binary;
+        loadNpyFileBinary(basename, &binary, &success);
+
+        if (!success) {
+            ADD_FAILURE() << "Failed to load NPY file: " << basename;
+            return {};
+        }
+
+        return parseNpyPayload<T>(binary);
+    }
+
+    template <typename T>
+    std::vector<T> loadNpyDataFullpath(const std::filesystem::path& path) {
+        return parseNpyPayload<T>(loadNpyFileBinaryFullpath(path.string()));
+    }
+
 
     void compareBinaryFilesHex(const std::string& filename, const std::vector<char> binData, const std::string& expectedBinDataHex) {
         std::vector<char> expectedBinData;
@@ -223,6 +272,32 @@ class RecordNodeTests :  public testing::Test {
     float sampleRate = 1.0;
 };
 
+class HardwareSynced_RecordNodeTests : public RecordNodeTests {
+protected:
+    void SetUp() override {
+        sampleRate = 100.0f;
+        numChannels = 8;
+        tester = std::make_unique<ProcessorTester>(TestSourceNodeBuilder
+                                                   (FakeSourceNodeParams{
+            numChannels,
+            sampleRate,
+            bitVolts,
+            1,
+            0,
+            true
+        }));
+
+        parentRecordingDir = std::filesystem::temp_directory_path() / "record_node_hardware_sync_tests";
+        if (std::filesystem::exists(parentRecordingDir)) {
+            std::filesystem::remove_all(parentRecordingDir);
+        }
+        std::filesystem::create_directory(parentRecordingDir);
+
+        tester->setRecordingParentDirectory(parentRecordingDir.string());
+        processor = tester->createProcessor<RecordNode>(Plugin::Processor::RECORD_NODE);
+    }
+};
+
 TEST_F(RecordNodeTests, TestInputOutput_Continuous_Single) {
     int numSamples = 100;
     tester->startAcquisition(true);
@@ -421,6 +496,32 @@ TEST_F(RecordNodeTests, Test_PersistsSampleNumbersAndTimestamps) {
     compareBinaryFilesHex("timestamps.npy", timeStampsBin, expectedTimeStampsHex);
 }
 
+TEST_F(HardwareSynced_RecordNodeTests, Test_PersistsPerSampleHardwareTimestamps) {
+    tester->startAcquisition(true);
+
+    const int numSamples = 5;
+    auto firstBuffer = createBuffer(1000.0f, 20.0f, numChannels, numSamples);
+    std::vector<double> firstTimestamps { 10.000, 10.011, 10.021, 10.034, 10.048 };
+    writeBlock(firstBuffer, nullptr, firstTimestamps.data());
+
+    auto secondBuffer = createBuffer(2000.0f, 20.0f, numChannels, numSamples);
+    std::vector<double> secondTimestamps { 10.061, 10.073, 10.084, 10.098, 10.113 };
+    writeBlock(secondBuffer, nullptr, secondTimestamps.data());
+
+    tester->stopAcquisition();
+
+    auto persistedTimestamps = loadNpyData<double>("timestamps.npy");
+
+    std::vector<double> expectedTimestamps = firstTimestamps;
+    expectedTimestamps.insert(expectedTimestamps.end(), secondTimestamps.begin(), secondTimestamps.end());
+
+    ASSERT_EQ(persistedTimestamps.size(), expectedTimestamps.size());
+
+    for (size_t index = 0; index < expectedTimestamps.size(); ++index) {
+        EXPECT_DOUBLE_EQ(persistedTimestamps[index], expectedTimestamps[index]);
+    }
+}
+
 TEST_F(RecordNodeTests, Test_PersistsStructureOeBin) {
     tester->startAcquisition(true);
 
@@ -530,6 +631,37 @@ TEST_F(RecordNodeTests, Test_PersistsEvents) {
     compareBinaryFilesHex("full_words.npy", fullWordsBin, expectedFullWordsHex);
 }
 
+TEST_F(HardwareSynced_RecordNodeTests, Test_PersistsHardwareEventTimestampFromBlockArray) {
+    processor->setRecordEvents(true);
+    processor->updateSettings();
+
+    tester->startAcquisition(true);
+
+    const int numSamples = 5;
+    auto streamId = processor->getDataStreams()[0]->getStreamId();
+    auto eventChannels = tester->getSourceNodeDataStream(streamId)->getEventChannels();
+    ASSERT_GE(eventChannels.size(), 1);
+
+    TTLEventPtr eventPtr = TTLEvent::createTTLEvent(
+        eventChannels[0],
+        1,
+        2,
+        true);
+
+    auto inputBuffer = createBuffer(1000.0f, 20.0f, numChannels, numSamples);
+    std::vector<double> blockTimestamps { 20.000, 20.031, 20.047, 20.062, 20.081 };
+    writeBlock(inputBuffer, eventPtr.get(), blockTimestamps.data());
+
+    tester->stopAcquisition();
+
+    std::filesystem::path timestampPath;
+    ASSERT_TRUE(eventsPathFor("timestamps.npy", &timestampPath));
+    auto eventTimestamps = loadNpyDataFullpath<double>(timestampPath);
+
+    ASSERT_EQ(eventTimestamps.size(), static_cast<size_t>(1));
+    EXPECT_DOUBLE_EQ(eventTimestamps[0], blockTimestamps[1]);
+}
+
 // ============================================================================
 // SEQUENTIAL BLOCK FILE BATCH WRITE TESTS
 // ============================================================================
diff --git a/Tests/TestHelpers/Processors/FakeSourceNode.cpp b/Tests/TestHelpers/Processors/FakeSourceNode.cpp
@@ -20,7 +20,8 @@ void FakeSourceNode::updateSettings()
                 "FakeSourceNode" + String (i),
                 "description",
                 "identifier",
-                params.sampleRate
+                params.sampleRate,
+                params.generatesTimestamps
             };
 
             cachedDataStreams.add (new DataStream (settings));
diff --git a/Tests/TestHelpers/Processors/FakeSourceNode.h b/Tests/TestHelpers/Processors/FakeSourceNode.h
@@ -12,6 +12,7 @@ struct FakeSourceNodeParams
     float bitVolts = 1.0f;
     int streams = 1;
     uint32_t metadataSizeBytes = 0;
+    bool generatesTimestamps = false;
 };
 
 class TESTABLE FakeSourceNode : public GenericProcessor
diff --git a/Tests/TestHelpers/include/TestFixtures.h b/Tests/TestHelpers/include/TestFixtures.h
@@ -230,27 +230,43 @@ class ProcessorTester
     AudioBuffer<float> processBlock (
         GenericProcessor* processor,
         const AudioBuffer<float>& buffer,
-        TTLEvent* maybeTtlEvent = nullptr)
+        TTLEvent* maybeTtlEvent = nullptr,
+        const double* sampleTimestamps = nullptr)
     {
         auto audioProcessor = (AudioProcessor*) processor;
         auto dataStreams = processor->getDataStreams();
+        auto* sourceProcessor = getSourceNode();
 
         MidiBuffer eventBuffer;
         for (const auto* datastream : dataStreams)
         {
             HeapBlock<char> data;
             auto streamId = datastream->getStreamId();
+            double startTimestamp = sampleTimestamps != nullptr ? sampleTimestamps[0] : 0.0;
             size_t dataSize = SystemEvent::fillTimestampAndSamplesData (
                 data,
-                processor,
+                sourceProcessor,
                 streamId,
                 currentSampleIndex,
-                // NOTE: this timestamp is actually ignored in the current implementation?
-                0,
+                startTimestamp,
                 buffer.getNumSamples(),
                 0);
             eventBuffer.addEvent (data, dataSize, 0);
 
+            if (sampleTimestamps != nullptr)
+            {
+                HeapBlock<char> timestampData;
+                size_t timestampDataSize = SystemEvent::fillTimestampArrayData (
+                    timestampData,
+                    sourceProcessor,
+                    streamId,
+                    currentSampleIndex,
+                    sampleTimestamps,
+                    buffer.getNumSamples(),
+                    0);
+                eventBuffer.addEvent (timestampData, timestampDataSize, 0);
+            }
+
             if (maybeTtlEvent != nullptr)
             {
                 size_t ttlSize = maybeTtlEvent->getChannelInfo()->getDataSize() + maybeTtlEvent->getChannelInfo()->getTotalEventMetadataSize() + EVENT_BASE_SIZE;
