#include <extdef.h>
-#include <stdint.h>
+#include <cstdint>
#include <boost/test/unit_test.hpp>
/* --- 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 ----//
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 ----//
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;
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;
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);
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
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);
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));
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);
}
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));