X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=test%2Fdata%2Fsegment.cpp;h=1a67899c952c7bd6a95378ab027bc47d6e59f6a5;hp=ee03a8b51033ee809b997e70e52565d893dbfaf4;hb=65c92359634f672e5f472a5214719dabc7e20883;hpb=332c6dd8ebbbd24a5efdf3761f94a48deb9d721a

diff --git a/test/data/segment.cpp b/test/data/segment.cpp
index ee03a8b5..1a67899c 100644
--- a/test/data/segment.cpp
+++ b/test/data/segment.cpp
@@ -20,7 +20,7 @@
 
 #include <extdef.h>
 
-#include <stdint.h>
+#include <cstdint>
 
 #include <boost/test/unit_test.hpp>
 
@@ -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,43 @@ 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++) {
+		s.get_raw_samples(i, 1, sample_data);
+		BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
+	}
+
+	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);
+	}
+	delete[] sample_data;
+}
+
+BOOST_AUTO_TEST_CASE(MaxSize32MultiAtOnce)
+{
+	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));
+
+	//----- Add all samples, requiring multiple chunks, in one call ----//
+	uint32_t *data = new uint32_t[num_samples];
+	for (uint32_t i = 0; i < num_samples; i++)
+		data[i] = i;
+
+	s.append_samples(data, num_samples);
+	delete[] data;
+
+	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 +272,7 @@ BOOST_AUTO_TEST_CASE(MaxSize32Multi)
 
 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));
@@ -249,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()