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

/*
 * This file is part of the PulseView project.
 *
 * Copyright (C) 2016 Soeren Apel <soeren@apelpie.net>
 * Copyright (C) 2013 Joel Holdsworth <joel@airwebreathe.org.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <extdef.h>

#include <cstdint>

#include <boost/test/unit_test.hpp>

#include <pv/data/segment.hpp>

using pv::data::Segment;

BOOST_AUTO_TEST_SUITE(SegmentTest)


/* --- For debugging only
BOOST_AUTO_TEST_CASE(SmallSize8Single)
{
	Segment s(1, sizeof(uint8_t));
	uint32_t num_samples = 10;

	//----- Chunk size << pv::data::Segment::MaxChunkSize @ 8bit, added in 1 call ----//
	uint8_t* const data = new uint8_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);

	for (uint32_t i = 0; i < num_samples; i++) {
		uint8_t* sample_data = s.get_raw_samples(i, 1);
		BOOST_CHECK_EQUAL(*sample_data, i);
		delete[] sample_data;
	}
} */

/* --- For debugging only
BOOST_AUTO_TEST_CASE(MediumSize8Single)
{
	Segment s(1, sizeof(uint8_t));
	uint32_t num_samples = pv::data::Segment::MaxChunkSize;

	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 8bit, added in 1 call ----//
	uint8_t* const data = new uint8_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);

	for (uint32_t i = 0; i < num_samples; i++) {
		uint8_t* sample_data = s.get_raw_samples(i, 1);
		BOOST_CHECK_EQUAL(*sample_data, i % 256);
		delete[] sample_data;
	}
} */

/* --- For debugging only
BOOST_AUTO_TEST_CASE(MaxSize8Single)
{
	Segment s(1, sizeof(uint8_t));

	// We want to see proper behavior across chunk boundaries
	uint32_t num_samples = 2*pv::data::Segment::MaxChunkSize;

	//----- Chunk size >> pv::data::Segment::MaxChunkSize @ 8bit, added in 1 call ----//
	uint8_t* const data = new uint8_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);

	for (uint32_t i = 0; i < num_samples; i++) {
		uint8_t* sample_data = s.get_raw_samples(i, 1);
		BOOST_CHECK_EQUAL(*sample_data, i % 256);
		delete[] sample_data;
	}
} */

/* --- For debugging only
BOOST_AUTO_TEST_CASE(MediumSize24Single)
{
	Segment s(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;

	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 24bit, added in 1 call ----//
	uint8_t* const data = new uint8_t[num_samples * 3];
	for (uint32_t i = 0; i < num_samples * 3; i++)
		data[i] = i % 256;

	s.append_samples(data, num_samples);
	delete[] data;

	BOOST_CHECK(s.get_sample_count() == num_samples);

	for (uint32_t i = 0; i < num_samples; i++) {
		uint8_t* sample_data = s.get_raw_samples(i, 1);
		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;
	}
} */

/* --- For debugging only
BOOST_AUTO_TEST_CASE(MediumSize32Single)
{
	Segment s(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);

	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in 1 call ----//
	uint32_t* const 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);

	for (uint32_t i = 0; i < num_samples; i++) {
		uint8_t* sample_data = s.get_raw_samples(i, 1);
		BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
		delete[] sample_data;
	}
} */

/* --- For debugging only
BOOST_AUTO_TEST_CASE(MaxSize32Single)
{
	Segment s(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
	uint32_t num_samples = 2*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));

	//----- Chunk size >> pv::data::Segment::MaxChunkSize @ 32bit, added in 1 call ----//
	uint32_t* const 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);

	for (uint32_t i = 0; i < num_samples; i++) {
		uint8_t* sample_data = s.get_raw_samples(i, 1);
		BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
		delete[] sample_data;
	}
} */

/* --- For debugging only
BOOST_AUTO_TEST_CASE(MediumSize32Multi)
{
	Segment s(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);

	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in num_samples calls ----//
	uint32_t data;
	for (uint32_t i = 0; i < num_samples; i++) {
		data = i;
		s.append_samples(&data, 1);
	}

	BOOST_CHECK(s.get_sample_count() == num_samples);

	for (uint32_t i = 0; i < num_samples; i++) {
		uint8_t* sample_data = s.get_raw_samples(i, 1);
		BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
		delete[] sample_data;
	}
} */

BOOST_AUTO_TEST_CASE(MaxSize32Multi)
{
	Segment s(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));

	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in num_samples calls ----//
	uint32_t data;
	for (uint32_t i = 0; i < num_samples; i++) {
		data = i;
		s.append_samples(&data, 1);
	}

	BOOST_CHECK(s.get_sample_count() == num_samples);

	for (uint32_t i = 0; i < num_samples; i++) {
		uint8_t* sample_data = s.get_raw_samples(i, 1);
		BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
		delete[] sample_data;
	}

	uint8_t* sample_data = s.get_raw_samples(0, num_samples);
	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(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);

	for (uint32_t i = 0; i < num_samples; i++) {
		uint8_t* sample_data = s.get_raw_samples(i, 1);
		BOOST_CHECK_EQUAL(*((uint32_t*)sample_data), i);
		delete[] sample_data;
	}

	uint8_t* sample_data = s.get_raw_samples(0, num_samples);
	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(MaxSize32MultiIterated)
{
	Segment s(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));

	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in num_samples calls ----//
	uint32_t data;
	for (uint32_t i = 0; i < num_samples; i++) {
		data = i;
		s.append_samples(&data, 1);
	}

	BOOST_CHECK(s.get_sample_count() == num_samples);

	pv::data::SegmentRawDataIterator* it = s.begin_raw_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);
	}

	s.end_raw_sample_iteration(it);
}

BOOST_AUTO_TEST_SUITE_END()
Commit	Line	Data
332c6dd8 SA	1	/*
	2	* This file is part of the PulseView project.
	3	*
	4	* Copyright (C) 2016 Soeren Apel <soeren@apelpie.net>
	5	* Copyright (C) 2013 Joel Holdsworth <joel@airwebreathe.org.uk>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
	21	#include <extdef.h>
	22
eb8269e3	23	#include <cstdint>
332c6dd8 SA	24
	25	#include <boost/test/unit_test.hpp>
	26
	27	#include <pv/data/segment.hpp>
	28
	29	using pv::data::Segment;
	30
	31	BOOST_AUTO_TEST_SUITE(SegmentTest)
	32
	33
	34	/* --- For debugging only
	35	BOOST_AUTO_TEST_CASE(SmallSize8Single)
	36	{
	37	Segment s(1, sizeof(uint8_t));
	38	uint32_t num_samples = 10;
	39
	40	//----- Chunk size << pv::data::Segment::MaxChunkSize @ 8bit, added in 1 call ----//
	41	uint8_t* const data = new uint8_t[num_samples];
	42	for (uint32_t i = 0; i < num_samples; i++)
	43	data[i] = i;
	44
	45	s.append_samples(data, num_samples);
	46	delete[] data;
	47
	48	BOOST_CHECK(s.get_sample_count() == num_samples);
	49
	50	for (uint32_t i = 0; i < num_samples; i++) {
	51	uint8_t* sample_data = s.get_raw_samples(i, 1);
	52	BOOST_CHECK_EQUAL(*sample_data, i);
	53	delete[] sample_data;
	54	}
	55	} */
	56
	57	/* --- For debugging only
	58	BOOST_AUTO_TEST_CASE(MediumSize8Single)
	59	{
	60	Segment s(1, sizeof(uint8_t));
	61	uint32_t num_samples = pv::data::Segment::MaxChunkSize;
	62
	63	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 8bit, added in 1 call ----//
	64	uint8_t* const data = new uint8_t[num_samples];
	65	for (uint32_t i = 0; i < num_samples; i++)
	66	data[i] = i;
	67
	68	s.append_samples(data, num_samples);
	69	delete[] data;
	70
	71	BOOST_CHECK(s.get_sample_count() == num_samples);
	72
	73	for (uint32_t i = 0; i < num_samples; i++) {
	74	uint8_t* sample_data = s.get_raw_samples(i, 1);
	75	BOOST_CHECK_EQUAL(*sample_data, i % 256);
	76	delete[] sample_data;
	77	}
	78	} */
	79
	80	/* --- For debugging only
	81	BOOST_AUTO_TEST_CASE(MaxSize8Single)
	82	{
	83	Segment s(1, sizeof(uint8_t));
	84
	85	// We want to see proper behavior across chunk boundaries
	86	uint32_t num_samples = 2*pv::data::Segment::MaxChunkSize;
	87
88	//----- Chunk size >> pv::data::Segment::MaxChunkSize @ 8bit, added in 1 call ----//
89	uint8_t* const data = new uint8_t[num_samples];
90	for (uint32_t i = 0; i < num_samples; i++)
91	data[i] = i;
92
93	s.append_samples(data, num_samples);
94	delete[] data;
95
96	BOOST_CHECK(s.get_sample_count() == num_samples);
97
98	for (uint32_t i = 0; i < num_samples; i++) {
99	uint8_t* sample_data = s.get_raw_samples(i, 1);
100	BOOST_CHECK_EQUAL(*sample_data, i % 256);
101	delete[] sample_data;
102	}
103	} */
104
105	/* --- For debugging only
106	BOOST_AUTO_TEST_CASE(MediumSize24Single)
107	{
108	Segment s(1, 3);
109
110	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
111	uint32_t num_samples = pv::data::Segment::MaxChunkSize / 3;
112
113	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 24bit, added in 1 call ----//
114	uint8_t* const data = new uint8_t[num_samples * 3];
115	for (uint32_t i = 0; i < num_samples * 3; i++)
116	data[i] = i % 256;
117
118	s.append_samples(data, num_samples);
119	delete[] data;
120
121	BOOST_CHECK(s.get_sample_count() == num_samples);
122
123	for (uint32_t i = 0; i < num_samples; i++) {
124	uint8_t* sample_data = s.get_raw_samples(i, 1);
125	BOOST_CHECK_EQUAL(((uint8_t)sample_data), 3*i % 256);
126	BOOST_CHECK_EQUAL(((uint8_t)(sample_data+1)), (3*i+1) % 256);
127	BOOST_CHECK_EQUAL(((uint8_t)(sample_data+2)), (3*i+2) % 256);
128	delete[] sample_data;
129	}
130	} */
131
132	/* --- For debugging only
133	BOOST_AUTO_TEST_CASE(MediumSize32Single)
134	{
135	Segment s(1, sizeof(uint32_t));
136
137	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
138	uint32_t num_samples = pv::data::Segment::MaxChunkSize / sizeof(uint32_t);
139
140	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in 1 call ----//
141	uint32_t* const data = new uint32_t[num_samples];
142	for (uint32_t i = 0; i < num_samples; i++)
143	data[i] = i;
144
145	s.append_samples(data, num_samples);
146	delete[] data;
147
148	BOOST_CHECK(s.get_sample_count() == num_samples);
149
150	for (uint32_t i = 0; i < num_samples; i++) {
151	uint8_t* sample_data = s.get_raw_samples(i, 1);
152	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
153	delete[] sample_data;
154	}
155	} */
156
157	/* --- For debugging only
158	BOOST_AUTO_TEST_CASE(MaxSize32Single)
159	{
160	Segment s(1, sizeof(uint32_t));
161
162	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
163	// Also, we want to see proper behavior across chunk boundaries
164	uint32_t num_samples = 2*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
165
166	//----- Chunk size >> pv::data::Segment::MaxChunkSize @ 32bit, added in 1 call ----//
167	uint32_t* const data = new uint32_t[num_samples];
168	for (uint32_t i = 0; i < num_samples; i++)
169	data[i] = i;
170
171	s.append_samples(data, num_samples);
172	delete[] data;
173
174	BOOST_CHECK(s.get_sample_count() == num_samples);
175
176	for (uint32_t i = 0; i < num_samples; i++) {
177	uint8_t* sample_data = s.get_raw_samples(i, 1);
178	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
179	delete[] sample_data;
180	}
181	} */
182
183	/* --- For debugging only
184	BOOST_AUTO_TEST_CASE(MediumSize32Multi)
185	{
186	Segment s(1, sizeof(uint32_t));
187
188	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
189	uint32_t num_samples = pv::data::Segment::MaxChunkSize / sizeof(uint32_t);
190
191	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in num_samples calls ----//
192	uint32_t data;
193	for (uint32_t i = 0; i < num_samples; i++) {
194	data = i;
195	s.append_samples(&data, 1);
196	}
197
198	BOOST_CHECK(s.get_sample_count() == num_samples);
199
200	for (uint32_t i = 0; i < num_samples; i++) {
201	uint8_t* sample_data = s.get_raw_samples(i, 1);
202	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
203	delete[] sample_data;
204	}
205	} */
206
207	BOOST_AUTO_TEST_CASE(MaxSize32Multi)
208	{
209	Segment s(1, sizeof(uint32_t));
210
211	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
212	uint32_t num_samples = 2*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
213
214	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in num_samples calls ----//
215	uint32_t data;
216	for (uint32_t i = 0; i < num_samples; i++) {
217	data = i;
218	s.append_samples(&data, 1);
219	}
220
221	BOOST_CHECK(s.get_sample_count() == num_samples);
222
223	for (uint32_t i = 0; i < num_samples; i++) {
224	uint8_t* sample_data = s.get_raw_samples(i, 1);
225	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
226	delete[] sample_data;
227	}
228
229	uint8_t* sample_data = s.get_raw_samples(0, num_samples);
207ae8f6 SA	230	for (uint32_t i = 0; i < num_samples; i++) {
	231	BOOST_CHECK_EQUAL(((uint32_t)(sample_data + i * sizeof(uint32_t))), i);
	232	}
	233	delete[] sample_data;
	234	}
	235
	236	BOOST_AUTO_TEST_CASE(MaxSize32MultiAtOnce)
	237	{
	238	Segment s(1, sizeof(uint32_t));
	239
	240	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
	241	uint32_t num_samples = 3*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
	242
	243	//----- Add all samples, requiring multiple chunks, in one call ----//
	244	uint32_t *data = new uint32_t[num_samples];
	245	for (uint32_t i = 0; i < num_samples; i++)
	246	data[i] = i;
	247
	248	s.append_samples(data, num_samples);
	249	delete[] data;
	250
	251	BOOST_CHECK(s.get_sample_count() == num_samples);
	252
	253	for (uint32_t i = 0; i < num_samples; i++) {
	254	uint8_t* sample_data = s.get_raw_samples(i, 1);
	255	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
	256	delete[] sample_data;
	257	}
	258
	259	uint8_t* sample_data = s.get_raw_samples(0, num_samples);
332c6dd8 SA	260	for (uint32_t i = 0; i < num_samples; i++) {
	261	BOOST_CHECK_EQUAL(((uint32_t)(sample_data + i * sizeof(uint32_t))), i);
	262	}
	263	delete[] sample_data;
	264	}
	265
	266	BOOST_AUTO_TEST_CASE(MaxSize32MultiIterated)
	267	{
	268	Segment s(1, sizeof(uint32_t));
	269
	270	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
	271	uint32_t num_samples = 2*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
	272
	273	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in num_samples calls ----//
	274	uint32_t data;
	275	for (uint32_t i = 0; i < num_samples; i++) {
	276	data = i;
	277	s.append_samples(&data, 1);
	278	}
	279
	280	BOOST_CHECK(s.get_sample_count() == num_samples);
	281
	282	pv::data::SegmentRawDataIterator* it = s.begin_raw_sample_iteration(0);
	283
	284	for (uint32_t i = 0; i < num_samples; i++) {
	285	uint8_t* sample_data = it->value;
	286	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
	287	s.continue_raw_sample_iteration(it, 1);
	288	}
	289
	290	s.end_raw_sample_iteration(it);
	291	}
	292
	293	BOOST_AUTO_TEST_SUITE_END()