inputfile: Increase chunk size from 16KB to 4MB.
[pulseview.git] / test / data / segment.cpp
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()