git.gag.com Git - debian/gnuradio/blob - pmt/src/lib/qa_pmt_unv.cc

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2006 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GNU Radio
   6  *
   7  * GNU Radio 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 3, or (at your option)
  10  * any later version.
  11  *
  12  * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #include <qa_pmt_unv.h>
  24 #include <cppunit/TestAssert.h>
  25 #include <pmt.h>
  26 #include <stdio.h>
  27
  28 void
  29 qa_pmt_unv::test_u8vector()
  30 {
  31   static const size_t N = 3;
  32   pmt_t v1 = pmt_make_u8vector(N, 0);
  33   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
  34   uint8_t s0 = uint8_t(10);
  35   uint8_t s1 = uint8_t(20);
  36   uint8_t s2 = uint8_t(30);
  37
  38   pmt_u8vector_set(v1, 0, s0);
  39   pmt_u8vector_set(v1, 1, s1);
  40   pmt_u8vector_set(v1, 2, s2);
  41
  42   CPPUNIT_ASSERT_EQUAL(s0, pmt_u8vector_ref(v1, 0));
  43   CPPUNIT_ASSERT_EQUAL(s1, pmt_u8vector_ref(v1, 1));
  44   CPPUNIT_ASSERT_EQUAL(s2, pmt_u8vector_ref(v1, 2));
  45
  46   CPPUNIT_ASSERT_THROW(pmt_u8vector_ref(v1, N), pmt_out_of_range);
  47   CPPUNIT_ASSERT_THROW(pmt_u8vector_set(v1, N, uint8_t(0)), pmt_out_of_range);
  48
  49   size_t        len;
  50   const uint8_t *rd = pmt_u8vector_elements(v1, len);
  51   CPPUNIT_ASSERT_EQUAL(len, N);
  52   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
  53   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
  54   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
  55
  56   uint8_t *wr = pmt_u8vector_writable_elements(v1, len);
  57   CPPUNIT_ASSERT_EQUAL(len, N);
  58   wr[0] = uint8_t(0);
  59   CPPUNIT_ASSERT_EQUAL(uint8_t(0), wr[0]);
  60   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
  61   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
  62 }
  63 void
  64 qa_pmt_unv::test_s8vector()
  65 {
  66   static const size_t N = 3;
  67   pmt_t v1 = pmt_make_s8vector(N, 0);
  68   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
  69   int8_t s0 = int8_t(10);
  70   int8_t s1 = int8_t(20);
  71   int8_t s2 = int8_t(30);
  72
  73   pmt_s8vector_set(v1, 0, s0);
  74   pmt_s8vector_set(v1, 1, s1);
  75   pmt_s8vector_set(v1, 2, s2);
  76
  77   CPPUNIT_ASSERT_EQUAL(s0, pmt_s8vector_ref(v1, 0));
  78   CPPUNIT_ASSERT_EQUAL(s1, pmt_s8vector_ref(v1, 1));
  79   CPPUNIT_ASSERT_EQUAL(s2, pmt_s8vector_ref(v1, 2));
  80
  81   CPPUNIT_ASSERT_THROW(pmt_s8vector_ref(v1, N), pmt_out_of_range);
  82   CPPUNIT_ASSERT_THROW(pmt_s8vector_set(v1, N, int8_t(0)), pmt_out_of_range);
  83
  84   size_t        len;
  85   const int8_t *rd = pmt_s8vector_elements(v1, len);
  86   CPPUNIT_ASSERT_EQUAL(len, N);
  87   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
  88   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
  89   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
  90
  91   int8_t *wr = pmt_s8vector_writable_elements(v1, len);
  92   CPPUNIT_ASSERT_EQUAL(len, N);
  93   wr[0] = int8_t(0);
  94   CPPUNIT_ASSERT_EQUAL(int8_t(0), wr[0]);
  95   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
  96   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
  97 }
  98 void
  99 qa_pmt_unv::test_u16vector()
 100 {
 101   static const size_t N = 3;
 102   pmt_t v1 = pmt_make_u16vector(N, 0);
 103   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 104   uint16_t s0 = uint16_t(10);
 105   uint16_t s1 = uint16_t(20);
 106   uint16_t s2 = uint16_t(30);
 107
 108   pmt_u16vector_set(v1, 0, s0);
 109   pmt_u16vector_set(v1, 1, s1);
 110   pmt_u16vector_set(v1, 2, s2);
 111
 112   CPPUNIT_ASSERT_EQUAL(s0, pmt_u16vector_ref(v1, 0));
 113   CPPUNIT_ASSERT_EQUAL(s1, pmt_u16vector_ref(v1, 1));
 114   CPPUNIT_ASSERT_EQUAL(s2, pmt_u16vector_ref(v1, 2));
 115
 116   CPPUNIT_ASSERT_THROW(pmt_u16vector_ref(v1, N), pmt_out_of_range);
 117   CPPUNIT_ASSERT_THROW(pmt_u16vector_set(v1, N, uint16_t(0)), pmt_out_of_range);
 118
 119   size_t        len;
 120   const uint16_t *rd = pmt_u16vector_elements(v1, len);
 121   CPPUNIT_ASSERT_EQUAL(len, N);
 122   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
 123   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
 124   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
 125
 126   uint16_t *wr = pmt_u16vector_writable_elements(v1, len);
 127   CPPUNIT_ASSERT_EQUAL(len, N);
 128   wr[0] = uint16_t(0);
 129   CPPUNIT_ASSERT_EQUAL(uint16_t(0), wr[0]);
 130   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
 131   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
 132 }
 133 void
 134 qa_pmt_unv::test_s16vector()
 135 {
 136   static const size_t N = 3;
 137   pmt_t v1 = pmt_make_s16vector(N, 0);
 138   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 139   int16_t s0 = int16_t(10);
 140   int16_t s1 = int16_t(20);
 141   int16_t s2 = int16_t(30);
 142
 143   pmt_s16vector_set(v1, 0, s0);
 144   pmt_s16vector_set(v1, 1, s1);
 145   pmt_s16vector_set(v1, 2, s2);
 146
 147   CPPUNIT_ASSERT_EQUAL(s0, pmt_s16vector_ref(v1, 0));
 148   CPPUNIT_ASSERT_EQUAL(s1, pmt_s16vector_ref(v1, 1));
 149   CPPUNIT_ASSERT_EQUAL(s2, pmt_s16vector_ref(v1, 2));
 150
 151   CPPUNIT_ASSERT_THROW(pmt_s16vector_ref(v1, N), pmt_out_of_range);
 152   CPPUNIT_ASSERT_THROW(pmt_s16vector_set(v1, N, int16_t(0)), pmt_out_of_range);
 153
 154   size_t        len;
 155   const int16_t *rd = pmt_s16vector_elements(v1, len);
 156   CPPUNIT_ASSERT_EQUAL(len, N);
 157   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
 158   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
 159   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
 160
 161   int16_t *wr = pmt_s16vector_writable_elements(v1, len);
 162   CPPUNIT_ASSERT_EQUAL(len, N);
 163   wr[0] = int16_t(0);
 164   CPPUNIT_ASSERT_EQUAL(int16_t(0), wr[0]);
 165   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
 166   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
 167 }
 168 void
 169 qa_pmt_unv::test_u32vector()
 170 {
 171   static const size_t N = 3;
 172   pmt_t v1 = pmt_make_u32vector(N, 0);
 173   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 174   uint32_t s0 = uint32_t(10);
 175   uint32_t s1 = uint32_t(20);
 176   uint32_t s2 = uint32_t(30);
 177
 178   pmt_u32vector_set(v1, 0, s0);
 179   pmt_u32vector_set(v1, 1, s1);
 180   pmt_u32vector_set(v1, 2, s2);
 181
 182   CPPUNIT_ASSERT_EQUAL(s0, pmt_u32vector_ref(v1, 0));
 183   CPPUNIT_ASSERT_EQUAL(s1, pmt_u32vector_ref(v1, 1));
 184   CPPUNIT_ASSERT_EQUAL(s2, pmt_u32vector_ref(v1, 2));
 185
 186   CPPUNIT_ASSERT_THROW(pmt_u32vector_ref(v1, N), pmt_out_of_range);
 187   CPPUNIT_ASSERT_THROW(pmt_u32vector_set(v1, N, uint32_t(0)), pmt_out_of_range);
 188
 189   size_t        len;
 190   const uint32_t *rd = pmt_u32vector_elements(v1, len);
 191   CPPUNIT_ASSERT_EQUAL(len, N);
 192   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
 193   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
 194   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
 195
 196   uint32_t *wr = pmt_u32vector_writable_elements(v1, len);
 197   CPPUNIT_ASSERT_EQUAL(len, N);
 198   wr[0] = uint32_t(0);
 199   CPPUNIT_ASSERT_EQUAL(uint32_t(0), wr[0]);
 200   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
 201   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
 202 }
 203 void
 204 qa_pmt_unv::test_s32vector()
 205 {
 206   static const size_t N = 3;
 207   pmt_t v1 = pmt_make_s32vector(N, 0);
 208   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 209   int32_t s0 = int32_t(10);
 210   int32_t s1 = int32_t(20);
 211   int32_t s2 = int32_t(30);
 212
 213   pmt_s32vector_set(v1, 0, s0);
 214   pmt_s32vector_set(v1, 1, s1);
 215   pmt_s32vector_set(v1, 2, s2);
 216
 217   CPPUNIT_ASSERT_EQUAL(s0, pmt_s32vector_ref(v1, 0));
 218   CPPUNIT_ASSERT_EQUAL(s1, pmt_s32vector_ref(v1, 1));
 219   CPPUNIT_ASSERT_EQUAL(s2, pmt_s32vector_ref(v1, 2));
 220
 221   CPPUNIT_ASSERT_THROW(pmt_s32vector_ref(v1, N), pmt_out_of_range);
 222   CPPUNIT_ASSERT_THROW(pmt_s32vector_set(v1, N, int32_t(0)), pmt_out_of_range);
 223
 224   size_t        len;
 225   const int32_t *rd = pmt_s32vector_elements(v1, len);
 226   CPPUNIT_ASSERT_EQUAL(len, N);
 227   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
 228   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
 229   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
 230
 231   int32_t *wr = pmt_s32vector_writable_elements(v1, len);
 232   CPPUNIT_ASSERT_EQUAL(len, N);
 233   wr[0] = int32_t(0);
 234   CPPUNIT_ASSERT_EQUAL(int32_t(0), wr[0]);
 235   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
 236   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
 237 }
 238 void
 239 qa_pmt_unv::test_u64vector()
 240 {
 241   static const size_t N = 3;
 242   pmt_t v1 = pmt_make_u64vector(N, 0);
 243   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 244   uint64_t s0 = uint64_t(10);
 245   uint64_t s1 = uint64_t(20);
 246   uint64_t s2 = uint64_t(30);
 247
 248   pmt_u64vector_set(v1, 0, s0);
 249   pmt_u64vector_set(v1, 1, s1);
 250   pmt_u64vector_set(v1, 2, s2);
 251
 252   CPPUNIT_ASSERT_EQUAL(s0, pmt_u64vector_ref(v1, 0));
 253   CPPUNIT_ASSERT_EQUAL(s1, pmt_u64vector_ref(v1, 1));
 254   CPPUNIT_ASSERT_EQUAL(s2, pmt_u64vector_ref(v1, 2));
 255
 256   CPPUNIT_ASSERT_THROW(pmt_u64vector_ref(v1, N), pmt_out_of_range);
 257   CPPUNIT_ASSERT_THROW(pmt_u64vector_set(v1, N, uint64_t(0)), pmt_out_of_range);
 258
 259   size_t        len;
 260   const uint64_t *rd = pmt_u64vector_elements(v1, len);
 261   CPPUNIT_ASSERT_EQUAL(len, N);
 262   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
 263   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
 264   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
 265
 266   uint64_t *wr = pmt_u64vector_writable_elements(v1, len);
 267   CPPUNIT_ASSERT_EQUAL(len, N);
 268   wr[0] = uint64_t(0);
 269   CPPUNIT_ASSERT_EQUAL(uint64_t(0), wr[0]);
 270   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
 271   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
 272 }
 273 void
 274 qa_pmt_unv::test_s64vector()
 275 {
 276   static const size_t N = 3;
 277   pmt_t v1 = pmt_make_s64vector(N, 0);
 278   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 279   int64_t s0 = int64_t(10);
 280   int64_t s1 = int64_t(20);
 281   int64_t s2 = int64_t(30);
 282
 283   pmt_s64vector_set(v1, 0, s0);
 284   pmt_s64vector_set(v1, 1, s1);
 285   pmt_s64vector_set(v1, 2, s2);
 286
 287   CPPUNIT_ASSERT_EQUAL(s0, pmt_s64vector_ref(v1, 0));
 288   CPPUNIT_ASSERT_EQUAL(s1, pmt_s64vector_ref(v1, 1));
 289   CPPUNIT_ASSERT_EQUAL(s2, pmt_s64vector_ref(v1, 2));
 290
 291   CPPUNIT_ASSERT_THROW(pmt_s64vector_ref(v1, N), pmt_out_of_range);
 292   CPPUNIT_ASSERT_THROW(pmt_s64vector_set(v1, N, int64_t(0)), pmt_out_of_range);
 293
 294   size_t        len;
 295   const int64_t *rd = pmt_s64vector_elements(v1, len);
 296   CPPUNIT_ASSERT_EQUAL(len, N);
 297   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
 298   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
 299   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
 300
 301   int64_t *wr = pmt_s64vector_writable_elements(v1, len);
 302   CPPUNIT_ASSERT_EQUAL(len, N);
 303   wr[0] = int64_t(0);
 304   CPPUNIT_ASSERT_EQUAL(int64_t(0), wr[0]);
 305   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
 306   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
 307 }
 308 void
 309 qa_pmt_unv::test_f32vector()
 310 {
 311   static const size_t N = 3;
 312   pmt_t v1 = pmt_make_f32vector(N, 0);
 313   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 314   float s0 = float(10);
 315   float s1 = float(20);
 316   float s2 = float(30);
 317
 318   pmt_f32vector_set(v1, 0, s0);
 319   pmt_f32vector_set(v1, 1, s1);
 320   pmt_f32vector_set(v1, 2, s2);
 321
 322   CPPUNIT_ASSERT_EQUAL(s0, pmt_f32vector_ref(v1, 0));
 323   CPPUNIT_ASSERT_EQUAL(s1, pmt_f32vector_ref(v1, 1));
 324   CPPUNIT_ASSERT_EQUAL(s2, pmt_f32vector_ref(v1, 2));
 325
 326   CPPUNIT_ASSERT_THROW(pmt_f32vector_ref(v1, N), pmt_out_of_range);
 327   CPPUNIT_ASSERT_THROW(pmt_f32vector_set(v1, N, float(0)), pmt_out_of_range);
 328
 329   size_t        len;
 330   const float *rd = pmt_f32vector_elements(v1, len);
 331   CPPUNIT_ASSERT_EQUAL(len, N);
 332   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
 333   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
 334   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
 335
 336   float *wr = pmt_f32vector_writable_elements(v1, len);
 337   CPPUNIT_ASSERT_EQUAL(len, N);
 338   wr[0] = float(0);
 339   CPPUNIT_ASSERT_EQUAL(float(0), wr[0]);
 340   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
 341   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
 342 }
 343 void
 344 qa_pmt_unv::test_f64vector()
 345 {
 346   static const size_t N = 3;
 347   pmt_t v1 = pmt_make_f64vector(N, 0);
 348   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 349   double s0 = double(10);
 350   double s1 = double(20);
 351   double s2 = double(30);
 352
 353   pmt_f64vector_set(v1, 0, s0);
 354   pmt_f64vector_set(v1, 1, s1);
 355   pmt_f64vector_set(v1, 2, s2);
 356
 357   CPPUNIT_ASSERT_EQUAL(s0, pmt_f64vector_ref(v1, 0));
 358   CPPUNIT_ASSERT_EQUAL(s1, pmt_f64vector_ref(v1, 1));
 359   CPPUNIT_ASSERT_EQUAL(s2, pmt_f64vector_ref(v1, 2));
 360
 361   CPPUNIT_ASSERT_THROW(pmt_f64vector_ref(v1, N), pmt_out_of_range);
 362   CPPUNIT_ASSERT_THROW(pmt_f64vector_set(v1, N, double(0)), pmt_out_of_range);
 363
 364   size_t        len;
 365   const double *rd = pmt_f64vector_elements(v1, len);
 366   CPPUNIT_ASSERT_EQUAL(len, N);
 367   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
 368   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
 369   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
 370
 371   double *wr = pmt_f64vector_writable_elements(v1, len);
 372   CPPUNIT_ASSERT_EQUAL(len, N);
 373   wr[0] = double(0);
 374   CPPUNIT_ASSERT_EQUAL(double(0), wr[0]);
 375   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
 376   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
 377 }
 378 void
 379 qa_pmt_unv::test_c32vector()
 380 {
 381   static const size_t N = 3;
 382   pmt_t v1 = pmt_make_c32vector(N, 0);
 383   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 384   std::complex<float> s0 = std::complex<float>(10);
 385   std::complex<float> s1 = std::complex<float>(20);
 386   std::complex<float> s2 = std::complex<float>(30);
 387
 388   pmt_c32vector_set(v1, 0, s0);
 389   pmt_c32vector_set(v1, 1, s1);
 390   pmt_c32vector_set(v1, 2, s2);
 391
 392   CPPUNIT_ASSERT_EQUAL(s0, pmt_c32vector_ref(v1, 0));
 393   CPPUNIT_ASSERT_EQUAL(s1, pmt_c32vector_ref(v1, 1));
 394   CPPUNIT_ASSERT_EQUAL(s2, pmt_c32vector_ref(v1, 2));
 395
 396   CPPUNIT_ASSERT_THROW(pmt_c32vector_ref(v1, N), pmt_out_of_range);
 397   CPPUNIT_ASSERT_THROW(pmt_c32vector_set(v1, N, std::complex<float>(0)), pmt_out_of_range);
 398
 399   size_t        len;
 400   const std::complex<float> *rd = pmt_c32vector_elements(v1, len);
 401   CPPUNIT_ASSERT_EQUAL(len, N);
 402   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
 403   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
 404   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
 405
 406   std::complex<float> *wr = pmt_c32vector_writable_elements(v1, len);
 407   CPPUNIT_ASSERT_EQUAL(len, N);
 408   wr[0] = std::complex<float>(0);
 409   CPPUNIT_ASSERT_EQUAL(std::complex<float>(0), wr[0]);
 410   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
 411   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
 412 }
 413 void
 414 qa_pmt_unv::test_c64vector()
 415 {
 416   static const size_t N = 3;
 417   pmt_t v1 = pmt_make_c64vector(N, 0);
 418   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 419   std::complex<double> s0 = std::complex<double>(10);
 420   std::complex<double> s1 = std::complex<double>(20);
 421   std::complex<double> s2 = std::complex<double>(30);
 422
 423   pmt_c64vector_set(v1, 0, s0);
 424   pmt_c64vector_set(v1, 1, s1);
 425   pmt_c64vector_set(v1, 2, s2);
 426
 427   CPPUNIT_ASSERT_EQUAL(s0, pmt_c64vector_ref(v1, 0));
 428   CPPUNIT_ASSERT_EQUAL(s1, pmt_c64vector_ref(v1, 1));
 429   CPPUNIT_ASSERT_EQUAL(s2, pmt_c64vector_ref(v1, 2));
 430
 431   CPPUNIT_ASSERT_THROW(pmt_c64vector_ref(v1, N), pmt_out_of_range);
 432   CPPUNIT_ASSERT_THROW(pmt_c64vector_set(v1, N, std::complex<double>(0)), pmt_out_of_range);
 433
 434   size_t        len;
 435   const std::complex<double> *rd = pmt_c64vector_elements(v1, len);
 436   CPPUNIT_ASSERT_EQUAL(len, N);
 437   CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
 438   CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
 439   CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
 440
 441   std::complex<double> *wr = pmt_c64vector_writable_elements(v1, len);
 442   CPPUNIT_ASSERT_EQUAL(len, N);
 443   wr[0] = std::complex<double>(0);
 444   CPPUNIT_ASSERT_EQUAL(std::complex<double>(0), wr[0]);
 445   CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
 446   CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
 447 }