git.gag.com Git - debian/gnuradio/blob - pmt/src/lib/qa_pmt_prims.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_prims.h>
  24 #include <cppunit/TestAssert.h>
  25 #include <pmt.h>
  26 #include <stdio.h>
  27 #include <sstream>
  28
  29 void
  30 qa_pmt_prims::test_symbols()
  31 {
  32   CPPUNIT_ASSERT(!pmt_is_symbol(PMT_T));
  33   CPPUNIT_ASSERT(!pmt_is_symbol(PMT_F));
  34   CPPUNIT_ASSERT_THROW(pmt_symbol_to_string(PMT_F), pmt_wrong_type);
  35
  36   pmt_t sym1 = pmt_string_to_symbol("test");
  37   CPPUNIT_ASSERT(pmt_is_symbol(sym1));
  38   CPPUNIT_ASSERT_EQUAL(std::string("test"), pmt_symbol_to_string(sym1));
  39   CPPUNIT_ASSERT(pmt_is_true(sym1));
  40   CPPUNIT_ASSERT(!pmt_is_false(sym1));
  41
  42   pmt_t sym2 = pmt_string_to_symbol("foo");
  43   pmt_t sym3 = pmt_string_to_symbol("test");
  44   CPPUNIT_ASSERT_EQUAL(sym1, sym3);
  45   CPPUNIT_ASSERT(sym1 != sym2);
  46   CPPUNIT_ASSERT(sym1 == sym3);
  47
  48   static const int N = 2048;
  49   std::vector<pmt_t> v1(N);
  50   std::vector<pmt_t> v2(N);
  51
  52   // generate a bunch of symbols
  53   for (int i = 0; i < N; i++){
  54     char buf[100];
  55     snprintf(buf, sizeof(buf), "test-%d", i);
  56     v1[i] = pmt_string_to_symbol(buf);
  57   }
  58
  59   // confirm that they are all unique
  60   for (int i = 0; i < N; i++)
  61     for (int j = i + 1; j < N; j++)
  62       CPPUNIT_ASSERT(v1[i] != v1[j]);
  63
  64   // generate the same symbols again
  65   for (int i = 0; i < N; i++){
  66     char buf[100];
  67     snprintf(buf, sizeof(buf), "test-%d", i);
  68     v2[i] = pmt_string_to_symbol(buf);
  69   }
  70
  71   // confirm that we get the same ones back
  72   for (int i = 0; i < N; i++)
  73     CPPUNIT_ASSERT(v1[i] == v2[i]);
  74 }
  75
  76 void
  77 qa_pmt_prims::test_booleans()
  78 {
  79   pmt_t sym = pmt_string_to_symbol("test");
  80   CPPUNIT_ASSERT(pmt_is_bool(PMT_T));
  81   CPPUNIT_ASSERT(pmt_is_bool(PMT_F));
  82   CPPUNIT_ASSERT(!pmt_is_bool(sym));
  83   CPPUNIT_ASSERT_EQUAL(pmt_from_bool(false), PMT_F);
  84   CPPUNIT_ASSERT_EQUAL(pmt_from_bool(true), PMT_T);
  85   CPPUNIT_ASSERT_EQUAL(false, pmt_to_bool(PMT_F));
  86   CPPUNIT_ASSERT_EQUAL(true, pmt_to_bool(PMT_T));
  87   CPPUNIT_ASSERT_THROW(pmt_to_bool(sym), pmt_wrong_type);
  88 }
  89
  90 void
  91 qa_pmt_prims::test_integers()
  92 {
  93   pmt_t p1 = pmt_from_long(1);
  94   pmt_t m1 = pmt_from_long(-1);
  95   CPPUNIT_ASSERT(!pmt_is_integer(PMT_T));
  96   CPPUNIT_ASSERT(pmt_is_integer(p1));
  97   CPPUNIT_ASSERT(pmt_is_integer(m1));
  98   CPPUNIT_ASSERT_THROW(pmt_to_long(PMT_T), pmt_wrong_type);
  99   CPPUNIT_ASSERT_EQUAL(-1L, pmt_to_long(m1));
 100   CPPUNIT_ASSERT_EQUAL(1L, pmt_to_long(p1));
 101 }
 102
 103 void
 104 qa_pmt_prims::test_reals()
 105 {
 106   pmt_t p1 = pmt_from_double(1);
 107   pmt_t m1 = pmt_from_double(-1);
 108   CPPUNIT_ASSERT(!pmt_is_real(PMT_T));
 109   CPPUNIT_ASSERT(pmt_is_real(p1));
 110   CPPUNIT_ASSERT(pmt_is_real(m1));
 111   CPPUNIT_ASSERT_THROW(pmt_to_double(PMT_T), pmt_wrong_type);
 112   CPPUNIT_ASSERT_EQUAL(-1.0, pmt_to_double(m1));
 113   CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(p1));
 114   CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(pmt_from_long(1)));
 115 }
 116
 117 void
 118 qa_pmt_prims::test_complexes()
 119 {
 120   pmt_t p1 = pmt_make_rectangular(2, -3);
 121   pmt_t m1 = pmt_make_rectangular(-3, 2);
 122   CPPUNIT_ASSERT(!pmt_is_complex(PMT_T));
 123   CPPUNIT_ASSERT(pmt_is_complex(p1));
 124   CPPUNIT_ASSERT(pmt_is_complex(m1));
 125   CPPUNIT_ASSERT_THROW(pmt_to_complex(PMT_T), pmt_wrong_type);
 126   CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt_to_complex(p1));
 127   CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt_to_complex(m1));
 128   CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt_to_complex(pmt_from_long(1)));
 129   CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt_to_complex(pmt_from_double(1.0)));
 130 }
 131
 132 void
 133 qa_pmt_prims::test_pairs()
 134 {
 135   CPPUNIT_ASSERT(pmt_is_null(PMT_NIL));
 136   CPPUNIT_ASSERT(!pmt_is_pair(PMT_NIL));
 137   pmt_t s1 = pmt_string_to_symbol("s1");
 138   pmt_t s2 = pmt_string_to_symbol("s2");
 139   pmt_t s3 = pmt_string_to_symbol("s3");
 140
 141
 142   CPPUNIT_ASSERT_EQUAL((size_t)0, pmt_length(PMT_NIL));
 143   CPPUNIT_ASSERT_THROW(pmt_length(s1), pmt_wrong_type);
 144   CPPUNIT_ASSERT_THROW(pmt_length(pmt_from_double(42)), pmt_wrong_type);
 145
 146   pmt_t c1 = pmt_cons(s1, PMT_NIL);
 147   CPPUNIT_ASSERT(pmt_is_pair(c1));
 148   CPPUNIT_ASSERT(!pmt_is_pair(s1));
 149   CPPUNIT_ASSERT_EQUAL(s1, pmt_car(c1));
 150   CPPUNIT_ASSERT_EQUAL(PMT_NIL, pmt_cdr(c1));
 151   CPPUNIT_ASSERT_EQUAL((size_t) 1, pmt_length(c1));
 152
 153   pmt_t c3 = pmt_cons(s3, PMT_NIL);
 154   pmt_t c2 = pmt_cons(s2, c3);
 155   pmt_set_cdr(c1, c2);
 156   CPPUNIT_ASSERT_EQUAL(c2, pmt_cdr(c1));
 157   pmt_set_car(c1, s3);
 158   CPPUNIT_ASSERT_EQUAL(s3, pmt_car(c1));
 159   CPPUNIT_ASSERT_EQUAL((size_t)1, pmt_length(c3));
 160   CPPUNIT_ASSERT_EQUAL((size_t)2, pmt_length(c2));
 161
 162   CPPUNIT_ASSERT_THROW(pmt_cdr(PMT_NIL), pmt_wrong_type);
 163   CPPUNIT_ASSERT_THROW(pmt_car(PMT_NIL), pmt_wrong_type);
 164   CPPUNIT_ASSERT_THROW(pmt_set_car(s1, PMT_NIL), pmt_wrong_type);
 165   CPPUNIT_ASSERT_THROW(pmt_set_cdr(s1, PMT_NIL), pmt_wrong_type);
 166 }
 167
 168 void
 169 qa_pmt_prims::test_vectors()
 170 {
 171   static const size_t N = 3;
 172   pmt_t v1 = pmt_make_vector(N, PMT_NIL);
 173   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 174   pmt_t s0 = pmt_string_to_symbol("s0");
 175   pmt_t s1 = pmt_string_to_symbol("s1");
 176   pmt_t s2 = pmt_string_to_symbol("s2");
 177
 178   pmt_vector_set(v1, 0, s0);
 179   pmt_vector_set(v1, 1, s1);
 180   pmt_vector_set(v1, 2, s2);
 181
 182   CPPUNIT_ASSERT_EQUAL(s0, pmt_vector_ref(v1, 0));
 183   CPPUNIT_ASSERT_EQUAL(s1, pmt_vector_ref(v1, 1));
 184   CPPUNIT_ASSERT_EQUAL(s2, pmt_vector_ref(v1, 2));
 185
 186   CPPUNIT_ASSERT_THROW(pmt_vector_ref(v1, N), pmt_out_of_range);
 187   CPPUNIT_ASSERT_THROW(pmt_vector_set(v1, N, PMT_NIL), pmt_out_of_range);
 188
 189   pmt_vector_fill(v1, s0);
 190   for (size_t i = 0; i < N; i++)
 191     CPPUNIT_ASSERT_EQUAL(s0, pmt_vector_ref(v1, i));
 192 }
 193
 194 void
 195 qa_pmt_prims::test_equivalence()
 196 {
 197   pmt_t s0 = pmt_string_to_symbol("s0");
 198   pmt_t s1 = pmt_string_to_symbol("s1");
 199   pmt_t s2 = pmt_string_to_symbol("s2");
 200   pmt_t list0 = pmt_cons(s0, pmt_cons(s1, pmt_cons(s2, PMT_NIL)));
 201   pmt_t list1 = pmt_cons(s0, pmt_cons(s1, pmt_cons(s2, PMT_NIL)));
 202   pmt_t i0 = pmt_from_long(42);
 203   pmt_t i1 = pmt_from_long(42);
 204   pmt_t r0 = pmt_from_double(42);
 205   pmt_t r1 = pmt_from_double(42);
 206   pmt_t r2 = pmt_from_double(43);
 207
 208   CPPUNIT_ASSERT(pmt_eq(s0, s0));
 209   CPPUNIT_ASSERT(!pmt_eq(s0, s1));
 210   CPPUNIT_ASSERT(pmt_eqv(s0, s0));
 211   CPPUNIT_ASSERT(!pmt_eqv(s0, s1));
 212
 213   CPPUNIT_ASSERT(pmt_eqv(i0, i1));
 214   CPPUNIT_ASSERT(pmt_eqv(r0, r1));
 215   CPPUNIT_ASSERT(!pmt_eqv(r0, r2));
 216   CPPUNIT_ASSERT(!pmt_eqv(i0, r0));
 217
 218   CPPUNIT_ASSERT(!pmt_eq(list0, list1));
 219   CPPUNIT_ASSERT(!pmt_eqv(list0, list1));
 220   CPPUNIT_ASSERT(pmt_equal(list0, list1));
 221
 222   pmt_t v0 = pmt_make_vector(3, s0);
 223   pmt_t v1 = pmt_make_vector(3, s0);
 224   pmt_t v2 = pmt_make_vector(4, s0);
 225   CPPUNIT_ASSERT(!pmt_eqv(v0, v1));
 226   CPPUNIT_ASSERT(pmt_equal(v0, v1));
 227   CPPUNIT_ASSERT(!pmt_equal(v0, v2));
 228
 229   pmt_vector_set(v0, 0, list0);
 230   pmt_vector_set(v0, 1, list0);
 231   pmt_vector_set(v1, 0, list1);
 232   pmt_vector_set(v1, 1, list1);
 233   CPPUNIT_ASSERT(pmt_equal(v0, v1));
 234 }
 235
 236 void
 237 qa_pmt_prims::test_misc()
 238 {
 239   pmt_t k0 = pmt_string_to_symbol("k0");
 240   pmt_t k1 = pmt_string_to_symbol("k1");
 241   pmt_t k2 = pmt_string_to_symbol("k2");
 242   pmt_t k3 = pmt_string_to_symbol("k3");
 243   pmt_t v0 = pmt_string_to_symbol("v0");
 244   pmt_t v1 = pmt_string_to_symbol("v1");
 245   pmt_t v2 = pmt_string_to_symbol("v2");
 246   pmt_t p0 = pmt_cons(k0, v0);
 247   pmt_t p1 = pmt_cons(k1, v1);
 248   pmt_t p2 = pmt_cons(k2, v2);
 249
 250   pmt_t alist = pmt_cons(p0, pmt_cons(p1, pmt_cons(p2, PMT_NIL)));
 251   CPPUNIT_ASSERT(pmt_eq(p1, pmt_assv(k1, alist)));
 252   CPPUNIT_ASSERT(pmt_eq(PMT_F, pmt_assv(k3, alist)));
 253
 254   pmt_t keys = pmt_cons(k0, pmt_cons(k1, pmt_cons(k2, PMT_NIL)));
 255   pmt_t vals = pmt_cons(v0, pmt_cons(v1, pmt_cons(v2, PMT_NIL)));
 256   CPPUNIT_ASSERT(pmt_equal(keys, pmt_map(pmt_car, alist)));
 257   CPPUNIT_ASSERT(pmt_equal(vals, pmt_map(pmt_cdr, alist)));
 258 }
 259
 260 void
 261 qa_pmt_prims::test_dict()
 262 {
 263   pmt_t dict = pmt_make_dict();
 264   CPPUNIT_ASSERT(pmt_is_dict(dict));
 265
 266   pmt_t k0 = pmt_string_to_symbol("k0");
 267   pmt_t k1 = pmt_string_to_symbol("k1");
 268   pmt_t k2 = pmt_string_to_symbol("k2");
 269   pmt_t k3 = pmt_string_to_symbol("k3");
 270   pmt_t v0 = pmt_string_to_symbol("v0");
 271   pmt_t v1 = pmt_string_to_symbol("v1");
 272   pmt_t v2 = pmt_string_to_symbol("v2");
 273   pmt_t v3 = pmt_string_to_symbol("v3");
 274   pmt_t not_found = pmt_cons(PMT_NIL, PMT_NIL);
 275
 276   CPPUNIT_ASSERT(!pmt_dict_has_key(dict, k0));
 277   pmt_dict_set(dict, k0, v0);
 278   CPPUNIT_ASSERT(pmt_dict_has_key(dict, k0));
 279   CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k0, not_found), v0));
 280   CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), not_found));
 281   pmt_dict_set(dict, k1, v1);
 282   pmt_dict_set(dict, k2, v2);
 283   CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v1));
 284   pmt_dict_set(dict, k1, v3);
 285   CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v3));
 286
 287   pmt_t keys = pmt_cons(k2, pmt_cons(k1, pmt_cons(k0, PMT_NIL)));
 288   pmt_t vals = pmt_cons(v2, pmt_cons(v3, pmt_cons(v0, PMT_NIL)));
 289   CPPUNIT_ASSERT(pmt_equal(keys, pmt_dict_keys(dict)));
 290   CPPUNIT_ASSERT(pmt_equal(vals, pmt_dict_values(dict)));
 291 }
 292
 293 void
 294 qa_pmt_prims::test_io()
 295 {
 296   pmt_t k0 = pmt_string_to_symbol("k0");
 297   pmt_t k1 = pmt_string_to_symbol("k1");
 298   pmt_t k2 = pmt_string_to_symbol("k2");
 299   pmt_t k3 = pmt_string_to_symbol("k3");
 300
 301   CPPUNIT_ASSERT_EQUAL(std::string("k0"), pmt_write_string(k0));
 302 }
 303
 304 void
 305 qa_pmt_prims::test_lists()
 306 {
 307   pmt_t s0 = pmt_intern("s0");
 308   pmt_t s1 = pmt_intern("s1");
 309   pmt_t s2 = pmt_intern("s2");
 310   pmt_t s3 = pmt_intern("s3");
 311
 312   pmt_t l1 = pmt_list4(s0, s1, s2, s3);
 313   pmt_t l2 = pmt_list3(s0, s1, s2);
 314   pmt_t l3 = pmt_list_add(l2, s3);
 315   CPPUNIT_ASSERT(pmt_equal(l1, l3));
 316 }
 317
 318 // ------------------------------------------------------------------------
 319
 320 // class foo is used in test_any below.
 321 // It can't be declared in the scope of test_any because of template
 322 // namespace problems.
 323
 324 class foo {
 325 public:
 326   double        d_double;
 327   int           d_int;
 328   foo(double d=0, int i=0) : d_double(d), d_int(i) {}
 329 };
 330
 331 bool operator==(const foo &a, const foo &b)
 332 {
 333   return a.d_double == b.d_double && a.d_int == b.d_int;
 334 }
 335
 336 std::ostream& operator<<(std::ostream &os, const foo obj)
 337 {
 338   os << "<foo: " << obj.d_double << ", " << obj.d_int << ">";
 339   return os;
 340 }
 341
 342 void
 343 qa_pmt_prims::test_any()
 344 {
 345   boost::any a0;
 346   boost::any a1;
 347   boost::any a2;
 348
 349   a0 = std::string("Hello!");
 350   a1 = 42;
 351   a2 = foo(3.250, 21);
 352
 353   pmt_t p0 = pmt_make_any(a0);
 354   pmt_t p1 = pmt_make_any(a1);
 355   pmt_t p2 = pmt_make_any(a2);
 356
 357   CPPUNIT_ASSERT_EQUAL(std::string("Hello!"),
 358                        boost::any_cast<std::string>(pmt_any_ref(p0)));
 359
 360   CPPUNIT_ASSERT_EQUAL(42,
 361                        boost::any_cast<int>(pmt_any_ref(p1)));
 362
 363   CPPUNIT_ASSERT_EQUAL(foo(3.250, 21),
 364                        boost::any_cast<foo>(pmt_any_ref(p2)));
 365 }
 366
 367 // ------------------------------------------------------------------------
 368
 369 void
 370 qa_pmt_prims::test_serialize()
 371 {
 372   std::stringbuf sb;            // fake channel
 373   pmt_t a = pmt_intern("a");
 374   pmt_t b = pmt_intern("b");
 375   pmt_t c = pmt_intern("c");
 376
 377   sb.str("");                   // reset channel to empty
 378
 379   // write stuff to channel
 380
 381   pmt_serialize(PMT_NIL, sb);
 382   pmt_serialize(pmt_intern("foobarvia"), sb);
 383   pmt_serialize(pmt_from_long(123456789), sb);
 384   pmt_serialize(pmt_from_long(-123456789), sb);
 385   pmt_serialize(pmt_cons(PMT_NIL, PMT_NIL), sb);
 386   pmt_serialize(pmt_cons(a, b), sb);
 387   pmt_serialize(pmt_list1(a), sb);
 388   pmt_serialize(pmt_list2(a, b), sb);
 389   pmt_serialize(pmt_list3(a, b, c), sb);
 390   pmt_serialize(pmt_list3(a, pmt_list3(c, b, a), c), sb);
 391   pmt_serialize(PMT_T, sb);
 392   pmt_serialize(PMT_F, sb);
 393
 394   // read it back
 395
 396   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_NIL));
 397   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_intern("foobarvia")));
 398   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_from_long(123456789)));
 399   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_from_long(-123456789)));
 400   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_cons(PMT_NIL, PMT_NIL)));
 401   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_cons(a, b)));
 402   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list1(a)));
 403   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list2(a, b)));
 404   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list3(a, b, c)));
 405   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list3(a, pmt_list3(c, b, a), c)));
 406   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_T));
 407   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_F));
 408
 409   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_EOF));      // last item
 410
 411
 412   // FIXME add tests for real, complex, vector, uniform-vector, dict
 413   // FIXME add tests for malformed input too.
 414
 415 }