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::SegmentDataIterator* it = s.begin_sample_iteration(0);
 290
 291         for (uint32_t i = 0; i < num_samples; i++) {
 292                 BOOST_CHECK_EQUAL(*((uint32_t*)s.get_iterator_value(it)), i);
 293                 s.continue_sample_iteration(it, 1);
 294         }
 295
 296         s.end_sample_iteration(it);
 297 }
 298
 299 BOOST_AUTO_TEST_SUITE_END()