Segments: Fix iterator access to underlying value

[pulseview.git] / test / data / segment.cpp

diff --git a/test/data/segment.cpp b/test/data/segment.cpp
index d1c35ee1a34aa2f8ebf94f703b9c1be5167fd3df..1a67899c952c7bd6a95378ab027bc47d6e59f6a5 100644 (file)
--- a/test/data/segment.cpp
+++ b/test/data/segment.cpp
@@ -34,7 +34,7 @@ BOOST_AUTO_TEST_SUITE(SegmentTest)
 /* --- For debugging only
 BOOST_AUTO_TEST_CASE(SmallSize8Single)
 {
-       Segment s(1, sizeof(uint8_t));
+       Segment s(0, 1, sizeof(uint8_t));
        uint32_t num_samples = 10;
 
        //----- Chunk size << pv::data::Segment::MaxChunkSize @ 8bit, added in 1 call ----//
@@ -47,17 +47,18 @@ BOOST_AUTO_TEST_CASE(SmallSize8Single)
 
        BOOST_CHECK(s.get_sample_count() == num_samples);
 
+       uint8_t *sample_data = new uint8_t[1];
        for (uint32_t i = 0; i < num_samples; i++) {
-               uint8_t* sample_data = s.get_raw_samples(i, 1);
+               s.get_raw_samples(i, 1, sample_data);
                BOOST_CHECK_EQUAL(*sample_data, i);
-               delete[] sample_data;
        }
+       delete[] sample_data;
 } */
 
 /* --- For debugging only
 BOOST_AUTO_TEST_CASE(MediumSize8Single)
 {
-       Segment s(1, sizeof(uint8_t));
+       Segment s(0, 1, sizeof(uint8_t));
        uint32_t num_samples = pv::data::Segment::MaxChunkSize;
 
        //----- Chunk size == pv::data::Segment::MaxChunkSize @ 8bit, added in 1 call ----//
@@ -70,17 +71,18 @@ BOOST_AUTO_TEST_CASE(MediumSize8Single)
 
        BOOST_CHECK(s.get_sample_count() == num_samples);
 
+       uint8_t *sample_data = new uint8_t[1];
        for (uint32_t i = 0; i < num_samples; i++) {
-               uint8_t* sample_data = s.get_raw_samples(i, 1);
+               s.get_raw_samples(i, 1, sample_data);
                BOOST_CHECK_EQUAL(*sample_data, i % 256);
-               delete[] sample_data;
        }
+       delete[] sample_data;
 } */
 
 /* --- For debugging only
 BOOST_AUTO_TEST_CASE(MaxSize8Single)
 {
-       Segment s(1, sizeof(uint8_t));
+       Segment s(0, 1, sizeof(uint8_t));
 
        // We want to see proper behavior across chunk boundaries
        uint32_t num_samples = 2*pv::data::Segment::MaxChunkSize;
@@ -95,17 +97,18 @@ BOOST_AUTO_TEST_CASE(MaxSize8Single)
 
        BOOST_CHECK(s.get_sample_count() == num_samples);
 
+       uint8_t *sample_data = new uint8_t[1];
        for (uint32_t i = 0; i < num_samples; i++) {
-               uint8_t* sample_data = s.get_raw_samples(i, 1);
+               s.get_raw_samples(i, 1, sample_data);
                BOOST_CHECK_EQUAL(*sample_data, i % 256);
-               delete[] sample_data;
        }
+       delete[] sample_data;
 } */
 
 /* --- For debugging only
 BOOST_AUTO_TEST_CASE(MediumSize24Single)
 {
-       Segment s(1, 3);
+       Segment s(0, 1, 3);
 
        // Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
        uint32_t num_samples = pv::data::Segment::MaxChunkSize / 3;
@@ -120,19 +123,20 @@ BOOST_AUTO_TEST_CASE(MediumSize24Single)
 
        BOOST_CHECK(s.get_sample_count() == num_samples);
 
+       uint8_t *sample_data = new uint8_t[3];
        for (uint32_t i = 0; i < num_samples; i++) {
-               uint8_t* sample_data = s.get_raw_samples(i, 1);
+               s.get_raw_samples(i, 1, sample_data);
                BOOST_CHECK_EQUAL(*((uint8_t*)sample_data),      3*i    % 256);
                BOOST_CHECK_EQUAL(*((uint8_t*)(sample_data+1)), (3*i+1) % 256);
                BOOST_CHECK_EQUAL(*((uint8_t*)(sample_data+2)), (3*i+2) % 256);
-               delete[] sample_data;
        }
+       delete[] sample_data;
 } */
 
 /* --- For debugging only
 BOOST_AUTO_TEST_CASE(MediumSize32Single)
 {
-       Segment s(1, sizeof(uint32_t));
+       Segment s(0, 1, sizeof(uint32_t));
 
        // Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
        uint32_t num_samples = pv::data::Segment::MaxChunkSize / sizeof(uint32_t);
@@ -147,17 +151,18 @@ BOOST_AUTO_TEST_CASE(MediumSize32Single)
 
        BOOST_CHECK(s.get_sample_count() == num_samples);
 
+       uint8_t *sample_data = new uint8_t[sizeof(uint32_t)];
        for (uint32_t i = 0; i < num_samples; i++) {
-               uint8_t* sample_data = s.get_raw_samples(i, 1);
+               s.get_raw_samples(i, 1, sample_data);
                BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
-               delete[] sample_data;
        }
+       delete[] sample_data;
 } */
 
 /* --- For debugging only
 BOOST_AUTO_TEST_CASE(MaxSize32Single)
 {
-       Segment s(1, sizeof(uint32_t));
+       Segment s(0, 1, sizeof(uint32_t));
 
        // Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
        // Also, we want to see proper behavior across chunk boundaries
@@ -173,17 +178,18 @@ BOOST_AUTO_TEST_CASE(MaxSize32Single)
 
        BOOST_CHECK(s.get_sample_count() == num_samples);
 
+       uint8_t *sample_data = new uint8_t[sizeof(uint32_t)];
        for (uint32_t i = 0; i < num_samples; i++) {
-               uint8_t* sample_data = s.get_raw_samples(i, 1);
+               s.get_raw_samples(i, 1, sample_data);
                BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
-               delete[] sample_data;
        }
+       delete[] sample_data;
 } */
 
 /* --- For debugging only
 BOOST_AUTO_TEST_CASE(MediumSize32Multi)
 {
-       Segment s(1, sizeof(uint32_t));
+       Segment s(0, 1, sizeof(uint32_t));
 
        // Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
        uint32_t num_samples = pv::data::Segment::MaxChunkSize / sizeof(uint32_t);
@@ -197,16 +203,17 @@ BOOST_AUTO_TEST_CASE(MediumSize32Multi)
 
        BOOST_CHECK(s.get_sample_count() == num_samples);
 
+       uint8_t *sample_data = new uint8_t[sizeof(uint32_t)];
        for (uint32_t i = 0; i < num_samples; i++) {
-               uint8_t* sample_data = s.get_raw_samples(i, 1);
+               s.get_raw_samples(i, 1, sample_data);
                BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
-               delete[] sample_data;
        }
+       delete[] sample_data;
 } */
 
 BOOST_AUTO_TEST_CASE(MaxSize32Multi)
 {
-       Segment s(1, sizeof(uint32_t));
+       Segment s(0, 1, sizeof(uint32_t));
 
        // Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
        uint32_t num_samples = 2*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
@@ -220,13 +227,13 @@ BOOST_AUTO_TEST_CASE(MaxSize32Multi)
 
        BOOST_CHECK(s.get_sample_count() == num_samples);
 
+       uint8_t *sample_data = new uint8_t[sizeof(uint32_t) * num_samples];
        for (uint32_t i = 0; i < num_samples; i++) {
-               uint8_t* sample_data = s.get_raw_samples(i, 1);
+               s.get_raw_samples(i, 1, sample_data);
                BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
-               delete[] sample_data;
        }
 
-       uint8_t* sample_data = s.get_raw_samples(0, num_samples);
+       s.get_raw_samples(0, num_samples, sample_data);
        for (uint32_t i = 0; i < num_samples; i++) {
                BOOST_CHECK_EQUAL(*((uint32_t*)(sample_data + i * sizeof(uint32_t))), i);
        }
@@ -235,7 +242,7 @@ BOOST_AUTO_TEST_CASE(MaxSize32Multi)
 
 BOOST_AUTO_TEST_CASE(MaxSize32MultiAtOnce)
 {
-       Segment s(1, sizeof(uint32_t));
+       Segment s(0, 1, sizeof(uint32_t));
 
        // Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
        uint32_t num_samples = 3*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
@@ -250,13 +257,13 @@ BOOST_AUTO_TEST_CASE(MaxSize32MultiAtOnce)
 
        BOOST_CHECK(s.get_sample_count() == num_samples);
 
+       uint8_t *sample_data = new uint8_t[sizeof(uint32_t) * num_samples];
        for (uint32_t i = 0; i < num_samples; i++) {
-               uint8_t* sample_data = s.get_raw_samples(i, 1);
+               s.get_raw_samples(i, 1, sample_data);
                BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
-               delete[] sample_data;
        }
 
-       uint8_t* sample_data = s.get_raw_samples(0, num_samples);
+       s.get_raw_samples(0, num_samples, sample_data);
        for (uint32_t i = 0; i < num_samples; i++) {
                BOOST_CHECK_EQUAL(*((uint32_t*)(sample_data + i * sizeof(uint32_t))), i);
        }
@@ -265,7 +272,7 @@ BOOST_AUTO_TEST_CASE(MaxSize32MultiAtOnce)
 
 BOOST_AUTO_TEST_CASE(MaxSize32MultiIterated)
 {
-       Segment s(1, sizeof(uint32_t));
+       Segment s(0, 1, sizeof(uint32_t));
 
        // Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
        uint32_t num_samples = 2*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
@@ -279,15 +286,14 @@ BOOST_AUTO_TEST_CASE(MaxSize32MultiIterated)
 
        BOOST_CHECK(s.get_sample_count() == num_samples);
 
-       pv::data::SegmentRawDataIterator* it = s.begin_raw_sample_iteration(0);
+       pv::data::SegmentDataIterator* it = s.begin_sample_iteration(0);
 
        for (uint32_t i = 0; i < num_samples; i++) {
-               uint8_t* sample_data = it->value;
-               BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
-               s.continue_raw_sample_iteration(it, 1);
+               BOOST_CHECK_EQUAL(*((uint32_t*)s.get_iterator_value(it)), i);
+               s.continue_sample_iteration(it, 1);
        }
 
-       s.end_raw_sample_iteration(it);
+       s.end_sample_iteration(it);
 }
 
 BOOST_AUTO_TEST_SUITE_END()