[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(0, 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);

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

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

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

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

	//----- 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);

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

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

	//----- 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);

	uint8_t *sample_data = new uint8_t[3];
	for (uint32_t i = 0; i < num_samples; i++) {
		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;
} */

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

	//----- 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);

	uint8_t *sample_data = new uint8_t[sizeof(uint32_t)];
	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);
	}
	delete[] sample_data;
} */

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

	uint8_t *sample_data = new uint8_t[sizeof(uint32_t)];
	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);
	}
	delete[] sample_data;
} */

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

	//----- 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);

	uint8_t *sample_data = new uint8_t[sizeof(uint32_t)];
	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);
	}
	delete[] sample_data;
} */

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

	//----- 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);

	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++) {
		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(MaxSize32MultiIterated)
{
	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));

	//----- 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
	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
	23	#include <cstdint>
	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(0, 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	uint8_t *sample_data = new uint8_t[1];
	51	for (uint32_t i = 0; i < num_samples; i++) {
	52	s.get_raw_samples(i, 1, sample_data);
	53	BOOST_CHECK_EQUAL(*sample_data, i);
	54	}
	55	delete[] sample_data;
	56	} */
	57
	58	/* --- For debugging only
	59	BOOST_AUTO_TEST_CASE(MediumSize8Single)
	60	{
	61	Segment s(0, 1, sizeof(uint8_t));
	62	uint32_t num_samples = pv::data::Segment::MaxChunkSize;
	63
	64	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 8bit, added in 1 call ----//
	65	uint8_t* const data = new uint8_t[num_samples];
	66	for (uint32_t i = 0; i < num_samples; i++)
	67	data[i] = i;
	68
	69	s.append_samples(data, num_samples);
	70	delete[] data;
	71
	72	BOOST_CHECK(s.get_sample_count() == num_samples);
	73
	74	uint8_t *sample_data = new uint8_t[1];
	75	for (uint32_t i = 0; i < num_samples; i++) {
	76	s.get_raw_samples(i, 1, sample_data);
	77	BOOST_CHECK_EQUAL(*sample_data, i % 256);
	78	}
	79	delete[] sample_data;
	80	} */
	81
	82	/* --- For debugging only
	83	BOOST_AUTO_TEST_CASE(MaxSize8Single)
	84	{
	85	Segment s(0, 1, sizeof(uint8_t));
	86
	87	// We want to see proper behavior across chunk boundaries
	88	uint32_t num_samples = 2*pv::data::Segment::MaxChunkSize;
	89
	90	//----- Chunk size >> pv::data::Segment::MaxChunkSize @ 8bit, added in 1 call ----//
	91	uint8_t* const data = new uint8_t[num_samples];
	92	for (uint32_t i = 0; i < num_samples; i++)
	93	data[i] = i;
	94
	95	s.append_samples(data, num_samples);
	96	delete[] data;
	97
	98	BOOST_CHECK(s.get_sample_count() == num_samples);
	99
	100	uint8_t *sample_data = new uint8_t[1];
	101	for (uint32_t i = 0; i < num_samples; i++) {
	102	s.get_raw_samples(i, 1, sample_data);
	103	BOOST_CHECK_EQUAL(*sample_data, i % 256);
	104	}
	105	delete[] sample_data;
	106	} */
	107
	108	/* --- For debugging only
	109	BOOST_AUTO_TEST_CASE(MediumSize24Single)
	110	{
	111	Segment s(0, 1, 3);
	112
	113	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
	114	uint32_t num_samples = pv::data::Segment::MaxChunkSize / 3;
	115
	116	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 24bit, added in 1 call ----//
	117	uint8_t* const data = new uint8_t[num_samples * 3];
	118	for (uint32_t i = 0; i < num_samples * 3; i++)
	119	data[i] = i % 256;
	120
	121	s.append_samples(data, num_samples);
	122	delete[] data;
	123
	124	BOOST_CHECK(s.get_sample_count() == num_samples);
	125
	126	uint8_t *sample_data = new uint8_t[3];
	127	for (uint32_t i = 0; i < num_samples; i++) {
	128	s.get_raw_samples(i, 1, sample_data);
	129	BOOST_CHECK_EQUAL(((uint8_t)sample_data), 3*i % 256);
	130	BOOST_CHECK_EQUAL(((uint8_t)(sample_data+1)), (3*i+1) % 256);
	131	BOOST_CHECK_EQUAL(((uint8_t)(sample_data+2)), (3*i+2) % 256);
	132	}
	133	delete[] sample_data;
	134	} */
	135
	136	/* --- For debugging only
	137	BOOST_AUTO_TEST_CASE(MediumSize32Single)
	138	{
	139	Segment s(0, 1, sizeof(uint32_t));
	140
	141	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
	142	uint32_t num_samples = pv::data::Segment::MaxChunkSize / sizeof(uint32_t);
	143
	144	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in 1 call ----//
	145	uint32_t* const data = new uint32_t[num_samples];
	146	for (uint32_t i = 0; i < num_samples; i++)
	147	data[i] = i;
	148
	149	s.append_samples(data, num_samples);
	150	delete[] data;
	151
	152	BOOST_CHECK(s.get_sample_count() == num_samples);
	153
	154	uint8_t *sample_data = new uint8_t[sizeof(uint32_t)];
	155	for (uint32_t i = 0; i < num_samples; i++) {
	156	s.get_raw_samples(i, 1, sample_data);
	157	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
	158	}
	159	delete[] sample_data;
	160	} */
	161
	162	/* --- For debugging only
	163	BOOST_AUTO_TEST_CASE(MaxSize32Single)
	164	{
	165	Segment s(0, 1, sizeof(uint32_t));
	166
	167	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
	168	// Also, we want to see proper behavior across chunk boundaries
	169	uint32_t num_samples = 2*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
	170
	171	//----- Chunk size >> pv::data::Segment::MaxChunkSize @ 32bit, added in 1 call ----//
	172	uint32_t* const data = new uint32_t[num_samples];
	173	for (uint32_t i = 0; i < num_samples; i++)
	174	data[i] = i;
	175
	176	s.append_samples(data, num_samples);
	177	delete[] data;
	178
	179	BOOST_CHECK(s.get_sample_count() == num_samples);
	180
	181	uint8_t *sample_data = new uint8_t[sizeof(uint32_t)];
	182	for (uint32_t i = 0; i < num_samples; i++) {
	183	s.get_raw_samples(i, 1, sample_data);
	184	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
	185	}
	186	delete[] sample_data;
	187	} */
	188
	189	/* --- For debugging only
	190	BOOST_AUTO_TEST_CASE(MediumSize32Multi)
	191	{
	192	Segment s(0, 1, sizeof(uint32_t));
	193
	194	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
	195	uint32_t num_samples = pv::data::Segment::MaxChunkSize / sizeof(uint32_t);
	196
	197	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in num_samples calls ----//
	198	uint32_t data;
	199	for (uint32_t i = 0; i < num_samples; i++) {
	200	data = i;
	201	s.append_samples(&data, 1);
	202	}
	203
	204	BOOST_CHECK(s.get_sample_count() == num_samples);
	205
	206	uint8_t *sample_data = new uint8_t[sizeof(uint32_t)];
	207	for (uint32_t i = 0; i < num_samples; i++) {
	208	s.get_raw_samples(i, 1, sample_data);
	209	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
	210	}
	211	delete[] sample_data;
	212	} */
	213
	214	BOOST_AUTO_TEST_CASE(MaxSize32Multi)
	215	{
	216	Segment s(0, 1, sizeof(uint32_t));
	217
	218	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
	219	uint32_t num_samples = 2*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
	220
	221	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in num_samples calls ----//
	222	uint32_t data;
	223	for (uint32_t i = 0; i < num_samples; i++) {
	224	data = i;
	225	s.append_samples(&data, 1);
	226	}
	227
	228	BOOST_CHECK(s.get_sample_count() == num_samples);
	229
	230	uint8_t sample_data = new uint8_t[sizeof(uint32_t) num_samples];
	231	for (uint32_t i = 0; i < num_samples; i++) {
	232	s.get_raw_samples(i, 1, sample_data);
	233	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
	234	}
	235
	236	s.get_raw_samples(0, num_samples, sample_data);
	237	for (uint32_t i = 0; i < num_samples; i++) {
	238	BOOST_CHECK_EQUAL(((uint32_t)(sample_data + i * sizeof(uint32_t))), i);
	239	}
	240	delete[] sample_data;
	241	}
	242
	243	BOOST_AUTO_TEST_CASE(MaxSize32MultiAtOnce)
	244	{
	245	Segment s(0, 1, sizeof(uint32_t));
	246
	247	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
	248	uint32_t num_samples = 3*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
	249
	250	//----- Add all samples, requiring multiple chunks, in one call ----//
	251	uint32_t *data = new uint32_t[num_samples];
	252	for (uint32_t i = 0; i < num_samples; i++)
	253	data[i] = i;
	254
	255	s.append_samples(data, num_samples);
	256	delete[] data;
	257
	258	BOOST_CHECK(s.get_sample_count() == num_samples);
	259
	260	uint8_t sample_data = new uint8_t[sizeof(uint32_t) num_samples];
	261	for (uint32_t i = 0; i < num_samples; i++) {
	262	s.get_raw_samples(i, 1, sample_data);
	263	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
	264	}
	265
	266	s.get_raw_samples(0, num_samples, sample_data);
	267	for (uint32_t i = 0; i < num_samples; i++) {
	268	BOOST_CHECK_EQUAL(((uint32_t)(sample_data + i * sizeof(uint32_t))), i);
	269	}
	270	delete[] sample_data;
	271	}
	272
	273	BOOST_AUTO_TEST_CASE(MaxSize32MultiIterated)
	274	{
	275	Segment s(0, 1, sizeof(uint32_t));
	276
	277	// Chunk size is num*unit_size, so with pv::data::Segment::MaxChunkSize/unit_size, we reach the maximum size
	278	uint32_t num_samples = 2*(pv::data::Segment::MaxChunkSize / sizeof(uint32_t));
	279
	280	//----- Chunk size == pv::data::Segment::MaxChunkSize @ 32bit, added in num_samples calls ----//
	281	uint32_t data;
	282	for (uint32_t i = 0; i < num_samples; i++) {
	283	data = i;
	284	s.append_samples(&data, 1);
	285	}
	286
	287	BOOST_CHECK(s.get_sample_count() == num_samples);
	288
	289	pv::data::SegmentRawDataIterator* it = s.begin_raw_sample_iteration(0);
	290
	291	for (uint32_t i = 0; i < num_samples; i++) {
	292	uint8_t* sample_data = it->value;
	293	BOOST_CHECK_EQUAL(((uint32_t)sample_data), i);
	294	s.continue_raw_sample_iteration(it, 1);
	295	}
	296
	297	s.end_raw_sample_iteration(it);
	298	}
	299
	300	BOOST_AUTO_TEST_SUITE_END()