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

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2006,2009 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 <gruel/msg_passing.h>
  26 #include <cstdio>
  27 #include <cstring>
  28 #include <sstream>
  29
  30 using namespace pmt;
  31
  32 void
  33 qa_pmt_prims::test_symbols()
  34 {
  35   CPPUNIT_ASSERT(!pmt_is_symbol(PMT_T));
  36   CPPUNIT_ASSERT(!pmt_is_symbol(PMT_F));
  37   CPPUNIT_ASSERT_THROW(pmt_symbol_to_string(PMT_F), pmt_wrong_type);
  38
  39   pmt_t sym1 = pmt_string_to_symbol("test");
  40   CPPUNIT_ASSERT(pmt_is_symbol(sym1));
  41   CPPUNIT_ASSERT_EQUAL(std::string("test"), pmt_symbol_to_string(sym1));
  42   CPPUNIT_ASSERT(pmt_is_true(sym1));
  43   CPPUNIT_ASSERT(!pmt_is_false(sym1));
  44
  45   pmt_t sym2 = pmt_string_to_symbol("foo");
  46   pmt_t sym3 = pmt_string_to_symbol("test");
  47   CPPUNIT_ASSERT_EQUAL(sym1, sym3);
  48   CPPUNIT_ASSERT(sym1 != sym2);
  49   CPPUNIT_ASSERT(sym1 == sym3);
  50
  51   static const int N = 2048;
  52   std::vector<pmt_t> v1(N);
  53   std::vector<pmt_t> v2(N);
  54
  55   // generate a bunch of symbols
  56   for (int i = 0; i < N; i++){
  57     char buf[100];
  58     snprintf(buf, sizeof(buf), "test-%d", i);
  59     v1[i] = pmt_string_to_symbol(buf);
  60   }
  61
  62   // confirm that they are all unique
  63   for (int i = 0; i < N; i++)
  64     for (int j = i + 1; j < N; j++)
  65       CPPUNIT_ASSERT(v1[i] != v1[j]);
  66
  67   // generate the same symbols again
  68   for (int i = 0; i < N; i++){
  69     char buf[100];
  70     snprintf(buf, sizeof(buf), "test-%d", i);
  71     v2[i] = pmt_string_to_symbol(buf);
  72   }
  73
  74   // confirm that we get the same ones back
  75   for (int i = 0; i < N; i++)
  76     CPPUNIT_ASSERT(v1[i] == v2[i]);
  77 }
  78
  79 void
  80 qa_pmt_prims::test_booleans()
  81 {
  82   pmt_t sym = pmt_string_to_symbol("test");
  83   CPPUNIT_ASSERT(pmt_is_bool(PMT_T));
  84   CPPUNIT_ASSERT(pmt_is_bool(PMT_F));
  85   CPPUNIT_ASSERT(!pmt_is_bool(sym));
  86   CPPUNIT_ASSERT_EQUAL(pmt_from_bool(false), PMT_F);
  87   CPPUNIT_ASSERT_EQUAL(pmt_from_bool(true), PMT_T);
  88   CPPUNIT_ASSERT_EQUAL(false, pmt_to_bool(PMT_F));
  89   CPPUNIT_ASSERT_EQUAL(true, pmt_to_bool(PMT_T));
  90   CPPUNIT_ASSERT_THROW(pmt_to_bool(sym), pmt_wrong_type);
  91 }
  92
  93 void
  94 qa_pmt_prims::test_integers()
  95 {
  96   pmt_t p1 = pmt_from_long(1);
  97   pmt_t m1 = pmt_from_long(-1);
  98   CPPUNIT_ASSERT(!pmt_is_integer(PMT_T));
  99   CPPUNIT_ASSERT(pmt_is_integer(p1));
 100   CPPUNIT_ASSERT(pmt_is_integer(m1));
 101   CPPUNIT_ASSERT_THROW(pmt_to_long(PMT_T), pmt_wrong_type);
 102   CPPUNIT_ASSERT_EQUAL(-1L, pmt_to_long(m1));
 103   CPPUNIT_ASSERT_EQUAL(1L, pmt_to_long(p1));
 104 }
 105
 106 void
 107 qa_pmt_prims::test_reals()
 108 {
 109   pmt_t p1 = pmt_from_double(1);
 110   pmt_t m1 = pmt_from_double(-1);
 111   CPPUNIT_ASSERT(!pmt_is_real(PMT_T));
 112   CPPUNIT_ASSERT(pmt_is_real(p1));
 113   CPPUNIT_ASSERT(pmt_is_real(m1));
 114   CPPUNIT_ASSERT_THROW(pmt_to_double(PMT_T), pmt_wrong_type);
 115   CPPUNIT_ASSERT_EQUAL(-1.0, pmt_to_double(m1));
 116   CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(p1));
 117   CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(pmt_from_long(1)));
 118 }
 119
 120 void
 121 qa_pmt_prims::test_complexes()
 122 {
 123   pmt_t p1 = pmt_make_rectangular(2, -3);
 124   pmt_t m1 = pmt_make_rectangular(-3, 2);
 125   CPPUNIT_ASSERT(!pmt_is_complex(PMT_T));
 126   CPPUNIT_ASSERT(pmt_is_complex(p1));
 127   CPPUNIT_ASSERT(pmt_is_complex(m1));
 128   CPPUNIT_ASSERT_THROW(pmt_to_complex(PMT_T), pmt_wrong_type);
 129   CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt_to_complex(p1));
 130   CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt_to_complex(m1));
 131   CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt_to_complex(pmt_from_long(1)));
 132   CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt_to_complex(pmt_from_double(1.0)));
 133 }
 134
 135 void
 136 qa_pmt_prims::test_pairs()
 137 {
 138   CPPUNIT_ASSERT(pmt_is_null(PMT_NIL));
 139   CPPUNIT_ASSERT(!pmt_is_pair(PMT_NIL));
 140   pmt_t s1 = pmt_string_to_symbol("s1");
 141   pmt_t s2 = pmt_string_to_symbol("s2");
 142   pmt_t s3 = pmt_string_to_symbol("s3");
 143
 144
 145   CPPUNIT_ASSERT_EQUAL((size_t)0, pmt_length(PMT_NIL));
 146   CPPUNIT_ASSERT_THROW(pmt_length(s1), pmt_wrong_type);
 147   CPPUNIT_ASSERT_THROW(pmt_length(pmt_from_double(42)), pmt_wrong_type);
 148
 149   pmt_t c1 = pmt_cons(s1, PMT_NIL);
 150   CPPUNIT_ASSERT(pmt_is_pair(c1));
 151   CPPUNIT_ASSERT(!pmt_is_pair(s1));
 152   CPPUNIT_ASSERT_EQUAL(s1, pmt_car(c1));
 153   CPPUNIT_ASSERT_EQUAL(PMT_NIL, pmt_cdr(c1));
 154   CPPUNIT_ASSERT_EQUAL((size_t) 1, pmt_length(c1));
 155
 156   pmt_t c3 = pmt_cons(s3, PMT_NIL);
 157   pmt_t c2 = pmt_cons(s2, c3);
 158   pmt_set_cdr(c1, c2);
 159   CPPUNIT_ASSERT_EQUAL(c2, pmt_cdr(c1));
 160   pmt_set_car(c1, s3);
 161   CPPUNIT_ASSERT_EQUAL(s3, pmt_car(c1));
 162   CPPUNIT_ASSERT_EQUAL((size_t)1, pmt_length(c3));
 163   CPPUNIT_ASSERT_EQUAL((size_t)2, pmt_length(c2));
 164
 165   CPPUNIT_ASSERT_THROW(pmt_cdr(PMT_NIL), pmt_wrong_type);
 166   CPPUNIT_ASSERT_THROW(pmt_car(PMT_NIL), pmt_wrong_type);
 167   CPPUNIT_ASSERT_THROW(pmt_set_car(s1, PMT_NIL), pmt_wrong_type);
 168   CPPUNIT_ASSERT_THROW(pmt_set_cdr(s1, PMT_NIL), pmt_wrong_type);
 169 }
 170
 171 void
 172 qa_pmt_prims::test_vectors()
 173 {
 174   static const size_t N = 3;
 175   pmt_t v1 = pmt_make_vector(N, PMT_NIL);
 176   CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));
 177   pmt_t s0 = pmt_string_to_symbol("s0");
 178   pmt_t s1 = pmt_string_to_symbol("s1");
 179   pmt_t s2 = pmt_string_to_symbol("s2");
 180
 181   pmt_vector_set(v1, 0, s0);
 182   pmt_vector_set(v1, 1, s1);
 183   pmt_vector_set(v1, 2, s2);
 184
 185   CPPUNIT_ASSERT_EQUAL(s0, pmt_vector_ref(v1, 0));
 186   CPPUNIT_ASSERT_EQUAL(s1, pmt_vector_ref(v1, 1));
 187   CPPUNIT_ASSERT_EQUAL(s2, pmt_vector_ref(v1, 2));
 188
 189   CPPUNIT_ASSERT_THROW(pmt_vector_ref(v1, N), pmt_out_of_range);
 190   CPPUNIT_ASSERT_THROW(pmt_vector_set(v1, N, PMT_NIL), pmt_out_of_range);
 191
 192   pmt_vector_fill(v1, s0);
 193   for (size_t i = 0; i < N; i++)
 194     CPPUNIT_ASSERT_EQUAL(s0, pmt_vector_ref(v1, i));
 195 }
 196
 197 static void
 198 check_tuple(size_t len, const std::vector<pmt_t> &s, pmt_t t)
 199 {
 200   CPPUNIT_ASSERT_EQUAL(true, pmt_is_tuple(t));
 201   CPPUNIT_ASSERT_EQUAL(len, pmt_length(t));
 202
 203   for (size_t i = 0; i < len; i++)
 204     CPPUNIT_ASSERT_EQUAL(s[i], pmt_tuple_ref(t, i));
 205
 206 }
 207
 208 void
 209 qa_pmt_prims::test_tuples()
 210 {
 211   pmt_t v = pmt_make_vector(10, PMT_NIL);
 212   std::vector<pmt_t> s(10);
 213   for (size_t i = 0; i < 10; i++){
 214     std::ostringstream os;
 215     os << "s" << i;
 216     s[i] = pmt_string_to_symbol(os.str());
 217     pmt_vector_set(v, i, s[i]);
 218   }
 219
 220
 221   pmt_t t;
 222
 223   t = pmt_make_tuple();
 224   check_tuple(0, s, t);
 225
 226   t = pmt_make_tuple(s[0]);
 227   check_tuple(1, s, t);
 228
 229   CPPUNIT_ASSERT(pmt_is_vector(v));
 230   CPPUNIT_ASSERT(!pmt_is_tuple(v));
 231   CPPUNIT_ASSERT(pmt_is_tuple(t));
 232   CPPUNIT_ASSERT(!pmt_is_vector(t));
 233
 234   t = pmt_make_tuple(s[0], s[1]);
 235   check_tuple(2, s, t);
 236
 237   t = pmt_make_tuple(s[0], s[1], s[2]);
 238   check_tuple(3, s, t);
 239
 240   t = pmt_make_tuple(s[0], s[1], s[2], s[3]);
 241   check_tuple(4, s, t);
 242
 243   t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4]);
 244   check_tuple(5, s, t);
 245
 246   t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5]);
 247   check_tuple(6, s, t);
 248
 249   t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6]);
 250   check_tuple(7, s, t);
 251
 252   t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]);
 253   check_tuple(8, s, t);
 254
 255   t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8]);
 256   check_tuple(9, s, t);
 257
 258   t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]);
 259   check_tuple(10, s, t);
 260
 261   t = pmt_make_tuple(s[0], s[1], s[2]);
 262   CPPUNIT_ASSERT_THROW(pmt_tuple_ref(t, 3), pmt_out_of_range);
 263   CPPUNIT_ASSERT_THROW(pmt_vector_ref(t, 0), pmt_wrong_type);
 264   CPPUNIT_ASSERT_THROW(pmt_tuple_ref(v, 0), pmt_wrong_type);
 265
 266   t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]);
 267   pmt_t t2 = pmt_to_tuple(v);
 268   CPPUNIT_ASSERT_EQUAL(size_t(10), pmt_length(v));
 269   CPPUNIT_ASSERT(pmt_equal(t, t2));
 270   //std::cout << v << std::endl;
 271   //std::cout << t2 << std::endl;
 272
 273
 274   t = pmt_make_tuple(s[0], s[1], s[2]);
 275   pmt_t list0 = pmt_list3(s[0], s[1], s[2]);
 276   CPPUNIT_ASSERT_EQUAL(size_t(3), pmt_length(list0));
 277   t2 = pmt_to_tuple(list0);
 278   CPPUNIT_ASSERT_EQUAL(size_t(3), pmt_length(t2));
 279   CPPUNIT_ASSERT(pmt_equal(t, t2));
 280 }
 281
 282 void
 283 qa_pmt_prims::test_equivalence()
 284 {
 285   pmt_t s0 = pmt_string_to_symbol("s0");
 286   pmt_t s1 = pmt_string_to_symbol("s1");
 287   pmt_t s2 = pmt_string_to_symbol("s2");
 288   pmt_t list0 = pmt_cons(s0, pmt_cons(s1, pmt_cons(s2, PMT_NIL)));
 289   pmt_t list1 = pmt_cons(s0, pmt_cons(s1, pmt_cons(s2, PMT_NIL)));
 290   pmt_t i0 = pmt_from_long(42);
 291   pmt_t i1 = pmt_from_long(42);
 292   pmt_t r0 = pmt_from_double(42);
 293   pmt_t r1 = pmt_from_double(42);
 294   pmt_t r2 = pmt_from_double(43);
 295
 296   CPPUNIT_ASSERT(pmt_eq(s0, s0));
 297   CPPUNIT_ASSERT(!pmt_eq(s0, s1));
 298   CPPUNIT_ASSERT(pmt_eqv(s0, s0));
 299   CPPUNIT_ASSERT(!pmt_eqv(s0, s1));
 300
 301   CPPUNIT_ASSERT(pmt_eqv(i0, i1));
 302   CPPUNIT_ASSERT(pmt_eqv(r0, r1));
 303   CPPUNIT_ASSERT(!pmt_eqv(r0, r2));
 304   CPPUNIT_ASSERT(!pmt_eqv(i0, r0));
 305
 306   CPPUNIT_ASSERT(!pmt_eq(list0, list1));
 307   CPPUNIT_ASSERT(!pmt_eqv(list0, list1));
 308   CPPUNIT_ASSERT(pmt_equal(list0, list1));
 309
 310   pmt_t v0 = pmt_make_vector(3, s0);
 311   pmt_t v1 = pmt_make_vector(3, s0);
 312   pmt_t v2 = pmt_make_vector(4, s0);
 313   CPPUNIT_ASSERT(!pmt_eqv(v0, v1));
 314   CPPUNIT_ASSERT(pmt_equal(v0, v1));
 315   CPPUNIT_ASSERT(!pmt_equal(v0, v2));
 316
 317   pmt_vector_set(v0, 0, list0);
 318   pmt_vector_set(v0, 1, list0);
 319   pmt_vector_set(v1, 0, list1);
 320   pmt_vector_set(v1, 1, list1);
 321   CPPUNIT_ASSERT(pmt_equal(v0, v1));
 322 }
 323
 324 void
 325 qa_pmt_prims::test_misc()
 326 {
 327   pmt_t k0 = pmt_string_to_symbol("k0");
 328   pmt_t k1 = pmt_string_to_symbol("k1");
 329   pmt_t k2 = pmt_string_to_symbol("k2");
 330   pmt_t k3 = pmt_string_to_symbol("k3");
 331   pmt_t v0 = pmt_string_to_symbol("v0");
 332   pmt_t v1 = pmt_string_to_symbol("v1");
 333   pmt_t v2 = pmt_string_to_symbol("v2");
 334   pmt_t p0 = pmt_cons(k0, v0);
 335   pmt_t p1 = pmt_cons(k1, v1);
 336   pmt_t p2 = pmt_cons(k2, v2);
 337
 338   pmt_t alist = pmt_cons(p0, pmt_cons(p1, pmt_cons(p2, PMT_NIL)));
 339   CPPUNIT_ASSERT(pmt_eq(p1, pmt_assv(k1, alist)));
 340   CPPUNIT_ASSERT(pmt_eq(PMT_F, pmt_assv(k3, alist)));
 341
 342   pmt_t keys = pmt_cons(k0, pmt_cons(k1, pmt_cons(k2, PMT_NIL)));
 343   pmt_t vals = pmt_cons(v0, pmt_cons(v1, pmt_cons(v2, PMT_NIL)));
 344   CPPUNIT_ASSERT(pmt_equal(keys, pmt_map(pmt_car, alist)));
 345   CPPUNIT_ASSERT(pmt_equal(vals, pmt_map(pmt_cdr, alist)));
 346 }
 347
 348 void
 349 qa_pmt_prims::test_dict()
 350 {
 351   pmt_t dict = pmt_make_dict();
 352   CPPUNIT_ASSERT(pmt_is_dict(dict));
 353
 354   pmt_t k0 = mp("k0");
 355   pmt_t k1 = mp("k1");
 356   pmt_t k2 = mp("k2");
 357   pmt_t k3 = mp("k3");
 358   pmt_t v0 = mp("v0");
 359   pmt_t v1 = mp("v1");
 360   pmt_t v2 = mp("v2");
 361   pmt_t v3 = mp("v3");
 362   pmt_t not_found = pmt_cons(PMT_NIL, PMT_NIL);
 363
 364   CPPUNIT_ASSERT(!pmt_dict_has_key(dict, k0));
 365   dict = pmt_dict_add(dict, k0, v0);
 366   CPPUNIT_ASSERT(pmt_dict_has_key(dict, k0));
 367   CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k0, not_found), v0));
 368   CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), not_found));
 369   dict = pmt_dict_add(dict, k1, v1);
 370   dict = pmt_dict_add(dict, k2, v2);
 371   CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v1));
 372   dict = pmt_dict_add(dict, k1, v3);
 373   CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v3));
 374
 375   pmt_t keys = pmt_list3(k1, k2, k0);
 376   pmt_t vals = pmt_list3(v3, v2, v0);
 377   //std::cout << "pmt_dict_keys:   " << pmt_dict_keys(dict) << std::endl;
 378   //std::cout << "pmt_dict_values: " << pmt_dict_values(dict) << std::endl;
 379   CPPUNIT_ASSERT(pmt_equal(keys, pmt_dict_keys(dict)));
 380   CPPUNIT_ASSERT(pmt_equal(vals, pmt_dict_values(dict)));
 381 }
 382
 383 void
 384 qa_pmt_prims::test_io()
 385 {
 386   pmt_t k0 = pmt_string_to_symbol("k0");
 387   pmt_t k1 = pmt_string_to_symbol("k1");
 388   pmt_t k2 = pmt_string_to_symbol("k2");
 389   pmt_t k3 = pmt_string_to_symbol("k3");
 390
 391   CPPUNIT_ASSERT_EQUAL(std::string("k0"), pmt_write_string(k0));
 392 }
 393
 394 void
 395 qa_pmt_prims::test_lists()
 396 {
 397   pmt_t s0 = pmt_intern("s0");
 398   pmt_t s1 = pmt_intern("s1");
 399   pmt_t s2 = pmt_intern("s2");
 400   pmt_t s3 = pmt_intern("s3");
 401
 402   pmt_t l1 = pmt_list4(s0, s1, s2, s3);
 403   pmt_t l2 = pmt_list3(s0, s1, s2);
 404   pmt_t l3 = pmt_list_add(l2, s3);
 405   CPPUNIT_ASSERT(pmt_equal(l1, l3));
 406 }
 407
 408 // ------------------------------------------------------------------------
 409
 410 // class foo is used in test_any below.
 411 // It can't be declared in the scope of test_any because of template
 412 // namespace problems.
 413
 414 class foo {
 415 public:
 416   double        d_double;
 417   int           d_int;
 418   foo(double d=0, int i=0) : d_double(d), d_int(i) {}
 419 };
 420
 421 bool operator==(const foo &a, const foo &b)
 422 {
 423   return a.d_double == b.d_double && a.d_int == b.d_int;
 424 }
 425
 426 std::ostream& operator<<(std::ostream &os, const foo obj)
 427 {
 428   os << "<foo: " << obj.d_double << ", " << obj.d_int << ">";
 429   return os;
 430 }
 431
 432 void
 433 qa_pmt_prims::test_any()
 434 {
 435   boost::any a0;
 436   boost::any a1;
 437   boost::any a2;
 438
 439   a0 = std::string("Hello!");
 440   a1 = 42;
 441   a2 = foo(3.250, 21);
 442
 443   pmt_t p0 = pmt_make_any(a0);
 444   pmt_t p1 = pmt_make_any(a1);
 445   pmt_t p2 = pmt_make_any(a2);
 446
 447   CPPUNIT_ASSERT_EQUAL(std::string("Hello!"),
 448                        boost::any_cast<std::string>(pmt_any_ref(p0)));
 449
 450   CPPUNIT_ASSERT_EQUAL(42,
 451                        boost::any_cast<int>(pmt_any_ref(p1)));
 452
 453   CPPUNIT_ASSERT_EQUAL(foo(3.250, 21),
 454                        boost::any_cast<foo>(pmt_any_ref(p2)));
 455 }
 456
 457 // ------------------------------------------------------------------------
 458
 459 class qa_pmt_msg_accepter_nop : public gruel::msg_accepter {
 460 public:
 461   qa_pmt_msg_accepter_nop(){};
 462   ~qa_pmt_msg_accepter_nop();
 463   void post(pmt_t){};
 464 };
 465
 466 qa_pmt_msg_accepter_nop::~qa_pmt_msg_accepter_nop(){}
 467
 468 void
 469 qa_pmt_prims::test_msg_accepter()
 470 {
 471   pmt_t sym = pmt_intern("my-symbol");
 472
 473   boost::any a0;
 474   a0 = std::string("Hello!");
 475   pmt_t p0 = pmt_make_any(a0);
 476
 477   gruel::msg_accepter_sptr ma0 = gruel::msg_accepter_sptr(new qa_pmt_msg_accepter_nop());
 478   pmt_t p1 = pmt_make_msg_accepter(ma0);
 479
 480   CPPUNIT_ASSERT_EQUAL(ma0.get(), pmt_msg_accepter_ref(p1).get());
 481
 482   CPPUNIT_ASSERT_THROW(pmt_msg_accepter_ref(sym), pmt_wrong_type);
 483   CPPUNIT_ASSERT_THROW(pmt_msg_accepter_ref(p0),  pmt_wrong_type);
 484
 485   // just confirm interfaces on send are OK
 486   gruel::send(ma0.get(), sym);
 487   gruel::send(ma0, sym);
 488   gruel::send(p1, sym);
 489
 490 }
 491
 492 // ------------------------------------------------------------------------
 493
 494 void
 495 qa_pmt_prims::test_serialize()
 496 {
 497   std::stringbuf sb;            // fake channel
 498   pmt_t a = pmt_intern("a");
 499   pmt_t b = pmt_intern("b");
 500   pmt_t c = pmt_intern("c");
 501
 502   sb.str("");                   // reset channel to empty
 503
 504   // write stuff to channel
 505
 506   pmt_serialize(PMT_NIL, sb);
 507   pmt_serialize(pmt_intern("foobarvia"), sb);
 508   pmt_serialize(pmt_from_long(123456789), sb);
 509   pmt_serialize(pmt_from_long(-123456789), sb);
 510   pmt_serialize(pmt_cons(PMT_NIL, PMT_NIL), sb);
 511   pmt_serialize(pmt_cons(a, b), sb);
 512   pmt_serialize(pmt_list1(a), sb);
 513   pmt_serialize(pmt_list2(a, b), sb);
 514   pmt_serialize(pmt_list3(a, b, c), sb);
 515   pmt_serialize(pmt_list3(a, pmt_list3(c, b, a), c), sb);
 516   pmt_serialize(PMT_T, sb);
 517   pmt_serialize(PMT_F, sb);
 518
 519   // read it back
 520
 521   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_NIL));
 522   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_intern("foobarvia")));
 523   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_from_long(123456789)));
 524   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_from_long(-123456789)));
 525   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_cons(PMT_NIL, PMT_NIL)));
 526   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_cons(a, b)));
 527   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list1(a)));
 528   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list2(a, b)));
 529   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list3(a, b, c)));
 530   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list3(a, pmt_list3(c, b, a), c)));
 531   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_T));
 532   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_F));
 533
 534   CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_EOF));      // last item
 535
 536
 537   // FIXME add tests for real, complex, vector, uniform-vector, dict
 538   // FIXME add tests for malformed input too.
 539
 540 }
 541
 542 void
 543 qa_pmt_prims::test_sets()
 544 {
 545   pmt_t s1 = pmt_intern("s1");
 546   pmt_t s2 = pmt_intern("s2");
 547   pmt_t s3 = pmt_intern("s3");
 548
 549   pmt_t l1 = pmt_list1(s1);
 550   pmt_t l2 = pmt_list2(s2,s3);
 551   pmt_t l3 = pmt_list3(s1,s2,s3);
 552
 553   CPPUNIT_ASSERT(pmt_is_pair(pmt_memq(s1,l1)));
 554   CPPUNIT_ASSERT(pmt_is_false(pmt_memq(s3,l1)));
 555
 556   CPPUNIT_ASSERT(pmt_subsetp(l1,l3));
 557   CPPUNIT_ASSERT(pmt_subsetp(l2,l3));
 558   CPPUNIT_ASSERT(!pmt_subsetp(l1,l2));
 559   CPPUNIT_ASSERT(!pmt_subsetp(l2,l1));
 560   CPPUNIT_ASSERT(!pmt_subsetp(l3,l2));
 561 }
 562
 563 void
 564 qa_pmt_prims::test_sugar()
 565 {
 566   CPPUNIT_ASSERT(pmt_is_symbol(mp("my-symbol")));
 567   CPPUNIT_ASSERT_EQUAL((long) 10, pmt_to_long(mp(10)));
 568   CPPUNIT_ASSERT_EQUAL((double) 1e6, pmt_to_double(mp(1e6)));
 569   CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, 3),
 570                        pmt_to_complex(mp(std::complex<double>(2, 3))));
 571
 572   int buf[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 573   pmt_t blob = mp(buf, sizeof(buf));
 574   const void *data = pmt_blob_data(blob);
 575   size_t nbytes = pmt_blob_length(blob);
 576   CPPUNIT_ASSERT_EQUAL(sizeof(buf), nbytes);
 577   CPPUNIT_ASSERT(memcmp(buf, data, nbytes) == 0);
 578 }