← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnuradio/trusty

« back to all changes in this revision

Viewing changes to pmt/src/lib/qa_pmt_unv.cc

  • Committer: Bazaar Package Importer
  • Author(s): Kamal Mostafa
  • Date: 2010-03-13 07:46:01 UTC
  • mfrom: (2.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100313074601-zjsa893a87bozyh7
Tags: 3.2.2.dfsg-1ubuntu1
https://launchpad.net/bugs/260406
* Fix build for Ubuntu lucid (LP: #260406)
  - add binary package dep for libusrp0, libusrp2-0: adduser
  - debian/rules clean: remove pre-built Qt moc files

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
}