merge fix from dev/issue_dont_reorder_digital_data

slsReceiverSoftware/src/DataProcessor.cpp

@@ -552,8 +552,7 @@ void DataProcessor::RemoveTrailingBits(size_t &size, char *data) {
     }
 
     // update size and copy data
-    memmove(data + nAnalogDataBytes,
+    memmove(data + nAnalogDataBytes, data + nAnalogDataBytes + ctbDbitOffset,
-            data + nAnalogDataBytes + ctbDigitalDataBytes,
             ctbDigitalDataBytes + nTransceiverDataBytes);
 
     size = nAnalogDataBytes + ctbDigitalDataBytes + nTransceiverDataBytes;
@@ -575,6 +574,7 @@ void DataProcessor::Reorder(size_t &size, char *data) {
     }
 
     auto *source = (uint64_t *)(data + nAnalogDataBytes + ctbDbitOffset);
+    // TODO: leads to unaligned data
 
     const size_t numDigitalSamples = (ctbDigitalDataBytes / sizeof(uint64_t));
 
@@ -590,13 +590,6 @@ void DataProcessor::Reorder(size_t &size, char *data) {
         numBytesPerBit *
         64; // number of bytes for digital data after reordering
 
-    LOG(logDEBUG1) << "totalNumBytes: " << totalNumBytes
-                   << " nAnalogDataBytes:" << nAnalogDataBytes
-                   << " nDigitalDataBytes: " << nDigitalDataBytes
-                   << " ctbDbitOffset:" << ctbDbitOffset
-                   << " nTransceiverDataBytes:" << nTransceiverDataBytes
-                   << " size:" << size << " numsamples:" << numDigitalSamples;
-
     std::vector<uint8_t> result(totalNumBytes, 0);
     uint8_t *dest = &result[0];
 
@@ -666,8 +659,9 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
 
     // store each selected bit from all samples consecutively
     if (ctbDbitReorder) {
-        int numBitsPerDbit = numDigitalSamples; // num bits per selected digital
+        size_t numBitsPerDbit =
-                                                // Bit for all samples
+            numDigitalSamples; // num bits per selected digital
+                               // Bit for all samples
         if ((numBitsPerDbit % 8) != 0)
             numBitsPerDbit += (8 - (numDigitalSamples % 8));
         totalNumBytes = (numBitsPerDbit / 8) * ctbDbitList.size();

slsReceiverSoftware/tests/test-ArrangeDataBasedOnBitList.cpp

@@ -2,7 +2,7 @@
 // Copyright (C) 2025 Contributors to the SLS Detector Package
 /************************************************
  * @file test-ArrangeDataBasedOnBitList.cpp
- * @short test case for DataProcessor member function ArrangeDbitData,
+ * @short test case for DataProcessor rearrange functions,
  ***********************************************/
 
 #include "DataProcessor.h"
@@ -36,7 +36,7 @@ class GeneralDataTest : public GeneralData {
     int nTransceiverBytes;
 };
 
-// oke maybe just make it static
+// dummy DataProcessor class for testing
 class DataProcessorTest : public DataProcessor {
   public:
     DataProcessorTest() : DataProcessor(0){};
@@ -44,91 +44,356 @@ class DataProcessorTest : public DataProcessor {
     void ArrangeDbitData(size_t &size, char *data) {
         DataProcessor::ArrangeDbitData(size, data);
     }
-};
 
-TEST_CASE("Arrange with reorder false") {
+    void Reorder(size_t &size, char *data) {
-    DataProcessorTest dataprocessor;
+        DataProcessor::Reorder(size, data);
-
-    std::vector<int> bitlist{1, 4, 5};
-    dataprocessor.SetCtbDbitList(bitlist);
-
-    size_t num_digital_samples = 5; // size_t or uint8_t ?
-    size_t num_digital_bytes = num_digital_samples * 8;
-    size_t num_analog_bytes = 1;
-    size_t num_transceiver_bytes = 2;
-    size_t random_offset_bytes = 0;
-
-    size_t size = num_analog_bytes + num_digital_bytes + num_transceiver_bytes +
-                  random_offset_bytes;
-
-    char *data = new char[size];
-
-    char dummy_value = static_cast<char>(125);
-    memset(data, dummy_value, num_analog_bytes);
-    memset(data + num_analog_bytes, 0xFF,
-           num_digital_bytes); // all digital bits are one
-    memset(data + num_digital_bytes + num_analog_bytes, dummy_value,
-           num_transceiver_bytes);
-
-    GeneralDataTest *generaldata = new GeneralDataTest;
-    generaldata->SetNumberOfAnalogDatabytes(num_analog_bytes);
-    generaldata->SetNumberOfDigitalDatabytes(num_digital_bytes);
-    generaldata->SetNumberOfTransceiverDatabytes(num_transceiver_bytes);
-
-    dataprocessor.SetGeneralData(generaldata);
-
-    size_t new_num_digital_bytes =
-        (bitlist.size() / 8 + static_cast<size_t>(bitlist.size() % 8 != 0)) *
-        num_digital_samples;
-
-    size_t new_size =
-        num_analog_bytes + num_transceiver_bytes + new_num_digital_bytes;
-
-    char *new_data = new char[new_size];
-
-    memset(new_data, dummy_value, num_analog_bytes);
-
-    // TODO: Make test more explicit and less generic
-    size_t num_bytes_for_bitlist =
-        bitlist.size() / 8 + static_cast<size_t>(bitlist.size() % 8 != 0);
-
-    // 125 7 7 7 7 7 125 125
-    for (size_t sample = 0; sample < num_digital_samples; ++sample) {
-        if (bitlist.size() / 8 != 0) {
-            memset(new_data + sample * num_bytes_for_bitlist + num_analog_bytes,
-                   0xFF,
-                   bitlist.size() / 8); // set to 1
-        } else if (bitlist.size() % 8 != 0) {
-            memset(new_data + sample * num_bytes_for_bitlist +
-                       bitlist.size() / 8 + num_analog_bytes,
-                   static_cast<char>(pow(2, (bitlist.size() % 8)) - 1),
-                   1); // convert binary number to decimal
-        }
     }
 
-    memset(new_data + new_num_digital_bytes + num_analog_bytes, dummy_value,
+    void RemoveTrailingBits(size_t &size, char *data) {
-           num_transceiver_bytes);
+        DataProcessor::RemoveTrailingBits(size, data);
+    }
+};
 
-    dataprocessor.ArrangeDbitData(size, data);
+/**
+ * test fixture for Testing,
+ * num_analog_bytes = 1 byte has a value of 125
+ * num_transceiver_bytes = 2 both bytes have a value of 125
+ * num_digital_bytes is variable and is defined by number of samples
+ * default num sample is 5
+ * all bytes in digital data take a value of 255
+ */
+class DataProcessorTestFixture {
+  public:
+    DataProcessorTestFixture() {
+        // setup Test Fixture
+        dataprocessor = new DataProcessorTest;
+        generaldata = new GeneralDataTest;
 
-    CHECK(size == new_size);
+        // set_num_samples(num_samples);
 
-    CHECK(memcmp(data, new_data, size) == 0);
+        generaldata->SetNumberOfAnalogDatabytes(num_analog_bytes);
+        generaldata->SetNumberOfTransceiverDatabytes(num_transceiver_bytes);
+        generaldata->SetNumberOfDigitalDatabytes(num_digital_bytes +
+                                                 num_random_offset_bytes);
 
-    // Free allocated memory
+        dataprocessor->SetGeneralData(generaldata);
-    delete[] data;
+    }
-    delete[] new_data;
+
-    delete generaldata;
+    ~DataProcessorTestFixture() {
+        delete[] data;
+        delete dataprocessor;
+        delete generaldata;
+    }
+
+    size_t get_size() const {
+        return num_analog_bytes + num_digital_bytes + num_transceiver_bytes +
+               num_random_offset_bytes;
+    }
+
+    void set_num_samples(const size_t value) {
+        num_samples = value;
+        num_digital_bytes = num_samples * 8; // 64 (8 bytes) per sample
+
+        generaldata->SetNumberOfDigitalDatabytes(num_digital_bytes +
+                                                 num_random_offset_bytes);
+    }
+
+    void set_random_offset_bytes(const size_t value) {
+        num_random_offset_bytes = value;
+        generaldata->SetNumberOfDigitalDatabytes(num_digital_bytes +
+                                                 num_random_offset_bytes);
+    }
+
+    void set_data() {
+        delete[] data;
+        data = new char[get_size()];
+
+        // set testing data
+        memset(data, dummy_value, num_analog_bytes); // set to dummy value
+        memset(data + num_analog_bytes, 0,
+               num_random_offset_bytes); // set to zero
+        memset(data + num_analog_bytes + num_random_offset_bytes, 0xFF,
+               num_digital_bytes); // all digital bits are one
+        memset(data + num_digital_bytes + num_analog_bytes +
+                   num_random_offset_bytes,
+               dummy_value,
+               num_transceiver_bytes); // set to dummy value
+    }
+
+    DataProcessorTest *dataprocessor;
+    GeneralDataTest *generaldata;
+    const size_t num_analog_bytes = 1;
+    const size_t num_transceiver_bytes = 2;
+    const char dummy_value = static_cast<char>(125);
+    size_t num_digital_bytes = 40; // num_samples * 8 = 5 * 8 = 40
+    size_t num_random_offset_bytes = 0;
+    size_t num_samples = 5;
+    char *data = nullptr;
+};
+
+TEST_CASE_METHOD(DataProcessorTestFixture, "Remove Trailing Bits",
+                 "[.dataprocessor][.bitoffset]") {
+
+    const size_t num_random_offset_bytes = 3;
+    set_random_offset_bytes(num_random_offset_bytes);
+    set_data();
+
+    dataprocessor->SetCtbDbitOffset(num_random_offset_bytes);
+
+    size_t expected_size = get_size() - num_random_offset_bytes;
+
+    char *expected_data = new char[expected_size];
+    memset(expected_data, dummy_value, num_analog_bytes); // set to 125
+    memset(expected_data + num_analog_bytes, 0xFF,
+           num_digital_bytes); // set to 1
+    memset(expected_data + num_digital_bytes + num_analog_bytes, dummy_value,
+           num_transceiver_bytes); // set to 125
+
+    size_t size = get_size();
+    dataprocessor->RemoveTrailingBits(size, data);
+
+    CHECK(size == expected_size);
+
+    CHECK(memcmp(data, expected_data, expected_size) == 0);
+
+    delete[] expected_data;
 }
 
-// TEST_CASE("Arrange with reorder on") {
+// parametric test tested with num_samples = 5, num_samples = 10, num_samples =
+// 8
+TEST_CASE_METHOD(DataProcessorTestFixture, "Reorder all",
+                 "[.dataprocessor][.reorder]") {
+    // parameters: num_samples, expected_num_digital_bytes,
+    // expected_digital_part
+    auto parameters = GENERATE(
+        std::make_tuple(5, 64, std::vector<uint8_t>{0b00011111}),
+        std::make_tuple(10, 2 * 64, std::vector<uint8_t>{0xFF, 0b00000011}),
+        std::make_tuple(8, 64, std::vector<uint8_t>{0xFF}));
 
-//}
+    size_t num_samples, expected_num_digital_bytes;
+    std::vector<uint8_t> expected_digital_part;
+    std::tie(num_samples, expected_num_digital_bytes, expected_digital_part) =
+        parameters;
 
-// test case reorder on and bitoffset set
+    // set number of samples for test fixture -> create data
+    set_num_samples(num_samples);
+    set_data();
 
-// test with different samples
+    dataprocessor->SetReorder(true); // set reorder to true
 
-// test with sample number not divisable and ctbitlist not divisable
+    const size_t expected_size =
+        num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
+
+    // create expected data
+    char *expected_data = new char[expected_size];
+
+    memset(expected_data, dummy_value, num_analog_bytes); // set to 125
+    for (size_t bit = 0; bit < 64; ++bit) {
+        memcpy(expected_data + num_analog_bytes +
+                   expected_digital_part.size() * bit,
+               expected_digital_part.data(), expected_digital_part.size());
+    }
+    memset(expected_data + expected_num_digital_bytes + num_analog_bytes,
+           dummy_value,
+           num_transceiver_bytes); // set to 125
+
+    size_t size = get_size();
+    dataprocessor->Reorder(size, data); // call reorder
+
+    CHECK(size == expected_size);
+    CHECK(memcmp(data, expected_data, expected_size) == 0);
+
+    delete[] expected_data;
+}
+
+TEST_CASE_METHOD(DataProcessorTestFixture,
+                 "Reorder all and remove trailing bits",
+                 "[.dataprocessor][.reorder]") {
+
+    // set number of samples for test fixture -> create data
+    const size_t num_random_offset_bytes = 3;
+    set_random_offset_bytes(num_random_offset_bytes);
+    set_data();
+
+    dataprocessor->SetCtbDbitOffset(num_random_offset_bytes);
+    dataprocessor->SetReorder(true); // set reorder to true
+
+    const size_t expected_num_digital_bytes = 64;
+    std::vector<uint8_t> expected_digital_part{0b00011111};
+
+    const size_t expected_size =
+        num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
+
+    // create expected data
+    char *expected_data = new char[expected_size];
+
+    memset(expected_data, dummy_value, num_analog_bytes); // set to 125
+    for (size_t bit = 0; bit < 64; ++bit) {
+        memcpy(expected_data + num_analog_bytes +
+                   expected_digital_part.size() * bit,
+               expected_digital_part.data(), expected_digital_part.size());
+    }
+    memset(expected_data + expected_num_digital_bytes + num_analog_bytes,
+           dummy_value,
+           num_transceiver_bytes); // set to 125
+
+    size_t size = get_size();
+    dataprocessor->Reorder(size, data); // call reorder
+
+    CHECK(size == expected_size);
+    CHECK(memcmp(data, expected_data, expected_size) == 0);
+
+    delete[] expected_data;
+}
+
+TEST_CASE_METHOD(DataProcessorTestFixture, "Arrange bitlist with reorder false",
+                 "[.dataprocessor][.retrievebitlist]") {
+    // parameters: num_samples, bitlist, expected_num_digital_bytes,
+    // expected_digital_part
+    auto parameters = GENERATE(
+        std::make_tuple(5, std::vector<int>{1, 4, 5}, 5,
+                        std::vector<uint8_t>{0b00000111}),
+        std::make_tuple(5, std::vector<int>{1, 5, 3, 7, 8, 50, 42, 60, 39}, 10,
+                        std::vector<uint8_t>{0xFF, 0b00000001}),
+        std::make_tuple(5, std::vector<int>{1, 5, 3, 7, 8, 50, 42, 60}, 5,
+                        std::vector<uint8_t>{0xFF}));
+
+    size_t num_samples, expected_num_digital_bytes;
+    std::vector<uint8_t> expected_digital_part;
+    std::vector<int> bitlist;
+    std::tie(num_samples, bitlist, expected_num_digital_bytes,
+             expected_digital_part) = parameters;
+
+    dataprocessor->SetCtbDbitList(bitlist);
+
+    dataprocessor->SetReorder(false);
+
+    set_num_samples(num_samples);
+    set_data();
+
+    size_t expected_size =
+        num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
+
+    // create expected data
+    char *expected_data = new char[expected_size];
+
+    memset(expected_data, dummy_value, num_analog_bytes);
+
+    for (size_t sample = 0; sample < num_samples; ++sample) {
+        memcpy(expected_data + num_analog_bytes +
+                   expected_digital_part.size() * sample,
+               expected_digital_part.data(), expected_digital_part.size());
+    }
+
+    memset(expected_data + expected_num_digital_bytes + num_analog_bytes,
+           dummy_value, num_transceiver_bytes);
+
+    size_t size = get_size();
+    dataprocessor->ArrangeDbitData(size, data);
+
+    CHECK(size == expected_size);
+
+    CHECK(memcmp(data, expected_data, expected_size) == 0);
+
+    delete[] expected_data;
+}
+
+TEST_CASE_METHOD(DataProcessorTestFixture, "Arrange bitlist with reorder true",
+                 "[.dataprocessor][.retrievebitlist]") {
+    // parameters: num_samples, bitlist, expected_num_digital_bytes,
+    // expected_digital_part
+    auto parameters = GENERATE(
+        std::make_tuple(5, std::vector<int>{1, 4, 5}, 3,
+                        std::vector<uint8_t>{0b00011111}),
+        std::make_tuple(10, std::vector<int>{1, 4, 5}, 6,
+                        std::vector<uint8_t>{0xFF, 0b00000011}),
+        std::make_tuple(8, std::vector<int>{1, 5, 3, 7, 8, 50, 42, 60, 39}, 9,
+                        std::vector<uint8_t>{0xFF}));
+
+    size_t num_samples, expected_num_digital_bytes;
+    std::vector<uint8_t> expected_digital_part;
+    std::vector<int> bitlist;
+    std::tie(num_samples, bitlist, expected_num_digital_bytes,
+             expected_digital_part) = parameters;
+
+    dataprocessor->SetCtbDbitList(bitlist);
+
+    dataprocessor->SetReorder(true);
+
+    set_num_samples(num_samples);
+    set_data();
+
+    size_t expected_size =
+        num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
+
+    // create expected data
+    char *expected_data = new char[expected_size];
+
+    memset(expected_data, dummy_value, num_analog_bytes);
+
+    for (size_t sample = 0; sample < bitlist.size(); ++sample) {
+        memcpy(expected_data + num_analog_bytes +
+                   expected_digital_part.size() * sample,
+               expected_digital_part.data(), expected_digital_part.size());
+    }
+
+    memset(expected_data + expected_num_digital_bytes + num_analog_bytes,
+           dummy_value, num_transceiver_bytes);
+
+    size_t size = get_size();
+    dataprocessor->ArrangeDbitData(size, data);
+
+    CHECK(size == expected_size);
+
+    CHECK(memcmp(data, expected_data, expected_size) == 0);
+
+    delete[] expected_data;
+}
+
+TEST_CASE_METHOD(DataProcessorTestFixture,
+                 "Arrange bitlist and remove trailing bits",
+                 "[.dataprocessor][.retrievebitlist]") {
+
+    size_t num_random_offset_bytes = 3;
+    std::vector<int> bitlist{1, 4, 5};
+
+    set_random_offset_bytes(num_random_offset_bytes);
+    set_data();
+
+    dataprocessor->SetCtbDbitList(bitlist);
+
+    dataprocessor->SetReorder(false);
+
+    dataprocessor->SetCtbDbitOffset(num_random_offset_bytes);
+
+    std::vector<uint8_t> expected_digital_part{0b00000111};
+    const size_t expected_num_digital_bytes = 5;
+
+    size_t expected_size =
+        num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
+
+    // create expected data
+    char *expected_data = new char[expected_size];
+
+    memset(expected_data, dummy_value, num_analog_bytes);
+
+    for (size_t sample = 0; sample < num_samples; ++sample) {
+        memcpy(expected_data + num_analog_bytes +
+                   expected_digital_part.size() * sample,
+               expected_digital_part.data(), expected_digital_part.size());
+    }
+
+    memset(expected_data + expected_num_digital_bytes + num_analog_bytes,
+           dummy_value, num_transceiver_bytes);
+
+    size_t size = get_size();
+    dataprocessor->ArrangeDbitData(size, data);
+
+    CHECK(size == expected_size);
+
+    CHECK(memcmp(data, expected_data, expected_size) == 0);
+
+    delete[] expected_data;
+}
 
 } // namespace sls