3 * Copyright 2006,2009 Free Software Foundation, Inc.
5 * This file is part of GNU Radio
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)
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.
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.
23 #include <qa_pmt_prims.h>
24 #include <cppunit/TestAssert.h>
25 #include <gruel/msg_passing.h>
33 qa_pmt_prims::test_symbols()
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);
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));
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);
51 static const int N = 2048;
52 std::vector<pmt_t> v1(N);
53 std::vector<pmt_t> v2(N);
55 // generate a bunch of symbols
56 for (int i = 0; i < N; i++){
58 snprintf(buf, sizeof(buf), "test-%d", i);
59 v1[i] = pmt_string_to_symbol(buf);
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]);
67 // generate the same symbols again
68 for (int i = 0; i < N; i++){
70 snprintf(buf, sizeof(buf), "test-%d", i);
71 v2[i] = pmt_string_to_symbol(buf);
74 // confirm that we get the same ones back
75 for (int i = 0; i < N; i++)
76 CPPUNIT_ASSERT(v1[i] == v2[i]);
80 qa_pmt_prims::test_booleans()
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);
94 qa_pmt_prims::test_integers()
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));
107 qa_pmt_prims::test_reals()
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)));
121 qa_pmt_prims::test_complexes()
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)));
136 qa_pmt_prims::test_pairs()
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");
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);
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));
156 pmt_t c3 = pmt_cons(s3, PMT_NIL);
157 pmt_t c2 = pmt_cons(s2, c3);
159 CPPUNIT_ASSERT_EQUAL(c2, pmt_cdr(c1));
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));
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);
172 qa_pmt_prims::test_vectors()
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");
181 pmt_vector_set(v1, 0, s0);
182 pmt_vector_set(v1, 1, s1);
183 pmt_vector_set(v1, 2, s2);
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));
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);
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));
198 check_tuple(size_t len, const std::vector<pmt_t> &s, pmt_t t)
200 CPPUNIT_ASSERT_EQUAL(true, pmt_is_tuple(t));
201 CPPUNIT_ASSERT_EQUAL(len, pmt_length(t));
203 for (size_t i = 0; i < len; i++)
204 CPPUNIT_ASSERT_EQUAL(s[i], pmt_tuple_ref(t, i));
209 qa_pmt_prims::test_tuples()
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;
216 s[i] = pmt_string_to_symbol(os.str());
217 pmt_vector_set(v, i, s[i]);
223 t = pmt_make_tuple();
224 check_tuple(0, s, t);
226 t = pmt_make_tuple(s[0]);
227 check_tuple(1, s, t);
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));
234 t = pmt_make_tuple(s[0], s[1]);
235 check_tuple(2, s, t);
237 t = pmt_make_tuple(s[0], s[1], s[2]);
238 check_tuple(3, s, t);
240 t = pmt_make_tuple(s[0], s[1], s[2], s[3]);
241 check_tuple(4, s, t);
243 t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4]);
244 check_tuple(5, s, t);
246 t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5]);
247 check_tuple(6, s, t);
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);
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);
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);
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);
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);
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;
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));
283 qa_pmt_prims::test_equivalence()
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);
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));
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));
306 CPPUNIT_ASSERT(!pmt_eq(list0, list1));
307 CPPUNIT_ASSERT(!pmt_eqv(list0, list1));
308 CPPUNIT_ASSERT(pmt_equal(list0, list1));
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));
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));
325 qa_pmt_prims::test_misc()
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);
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)));
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)));
349 qa_pmt_prims::test_dict()
351 pmt_t dict = pmt_make_dict();
352 CPPUNIT_ASSERT(pmt_is_dict(dict));
354 pmt_t k0 = pmt_string_to_symbol("k0");
355 pmt_t k1 = pmt_string_to_symbol("k1");
356 pmt_t k2 = pmt_string_to_symbol("k2");
357 pmt_t k3 = pmt_string_to_symbol("k3");
358 pmt_t v0 = pmt_string_to_symbol("v0");
359 pmt_t v1 = pmt_string_to_symbol("v1");
360 pmt_t v2 = pmt_string_to_symbol("v2");
361 pmt_t v3 = pmt_string_to_symbol("v3");
362 pmt_t not_found = pmt_cons(PMT_NIL, PMT_NIL);
364 CPPUNIT_ASSERT(!pmt_dict_has_key(dict, k0));
365 pmt_dict_set(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 pmt_dict_set(dict, k1, v1);
370 pmt_dict_set(dict, k2, v2);
371 CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v1));
372 pmt_dict_set(dict, k1, v3);
373 CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v3));
375 pmt_t keys = pmt_cons(k2, pmt_cons(k1, pmt_cons(k0, PMT_NIL)));
376 pmt_t vals = pmt_cons(v2, pmt_cons(v3, pmt_cons(v0, PMT_NIL)));
377 CPPUNIT_ASSERT(pmt_equal(keys, pmt_dict_keys(dict)));
378 CPPUNIT_ASSERT(pmt_equal(vals, pmt_dict_values(dict)));
382 qa_pmt_prims::test_io()
384 pmt_t k0 = pmt_string_to_symbol("k0");
385 pmt_t k1 = pmt_string_to_symbol("k1");
386 pmt_t k2 = pmt_string_to_symbol("k2");
387 pmt_t k3 = pmt_string_to_symbol("k3");
389 CPPUNIT_ASSERT_EQUAL(std::string("k0"), pmt_write_string(k0));
393 qa_pmt_prims::test_lists()
395 pmt_t s0 = pmt_intern("s0");
396 pmt_t s1 = pmt_intern("s1");
397 pmt_t s2 = pmt_intern("s2");
398 pmt_t s3 = pmt_intern("s3");
400 pmt_t l1 = pmt_list4(s0, s1, s2, s3);
401 pmt_t l2 = pmt_list3(s0, s1, s2);
402 pmt_t l3 = pmt_list_add(l2, s3);
403 CPPUNIT_ASSERT(pmt_equal(l1, l3));
406 // ------------------------------------------------------------------------
408 // class foo is used in test_any below.
409 // It can't be declared in the scope of test_any because of template
410 // namespace problems.
416 foo(double d=0, int i=0) : d_double(d), d_int(i) {}
419 bool operator==(const foo &a, const foo &b)
421 return a.d_double == b.d_double && a.d_int == b.d_int;
424 std::ostream& operator<<(std::ostream &os, const foo obj)
426 os << "<foo: " << obj.d_double << ", " << obj.d_int << ">";
431 qa_pmt_prims::test_any()
437 a0 = std::string("Hello!");
441 pmt_t p0 = pmt_make_any(a0);
442 pmt_t p1 = pmt_make_any(a1);
443 pmt_t p2 = pmt_make_any(a2);
445 CPPUNIT_ASSERT_EQUAL(std::string("Hello!"),
446 boost::any_cast<std::string>(pmt_any_ref(p0)));
448 CPPUNIT_ASSERT_EQUAL(42,
449 boost::any_cast<int>(pmt_any_ref(p1)));
451 CPPUNIT_ASSERT_EQUAL(foo(3.250, 21),
452 boost::any_cast<foo>(pmt_any_ref(p2)));
455 // ------------------------------------------------------------------------
457 class qa_pmt_msg_accepter_nop : public gruel::msg_accepter {
459 qa_pmt_msg_accepter_nop(){};
460 ~qa_pmt_msg_accepter_nop();
464 qa_pmt_msg_accepter_nop::~qa_pmt_msg_accepter_nop(){}
467 qa_pmt_prims::test_msg_accepter()
469 pmt_t sym = pmt_intern("my-symbol");
472 a0 = std::string("Hello!");
473 pmt_t p0 = pmt_make_any(a0);
475 gruel::msg_accepter_sptr ma0 = gruel::msg_accepter_sptr(new qa_pmt_msg_accepter_nop());
476 pmt_t p1 = pmt_make_msg_accepter(ma0);
478 CPPUNIT_ASSERT_EQUAL(ma0.get(), pmt_msg_accepter_ref(p1).get());
480 CPPUNIT_ASSERT_THROW(pmt_msg_accepter_ref(sym), pmt_wrong_type);
481 CPPUNIT_ASSERT_THROW(pmt_msg_accepter_ref(p0), pmt_wrong_type);
483 // just confirm interfaces on send are OK
484 gruel::send(ma0.get(), sym);
485 gruel::send(ma0, sym);
486 gruel::send(p1, sym);
490 // ------------------------------------------------------------------------
493 qa_pmt_prims::test_serialize()
495 std::stringbuf sb; // fake channel
496 pmt_t a = pmt_intern("a");
497 pmt_t b = pmt_intern("b");
498 pmt_t c = pmt_intern("c");
500 sb.str(""); // reset channel to empty
502 // write stuff to channel
504 pmt_serialize(PMT_NIL, sb);
505 pmt_serialize(pmt_intern("foobarvia"), sb);
506 pmt_serialize(pmt_from_long(123456789), sb);
507 pmt_serialize(pmt_from_long(-123456789), sb);
508 pmt_serialize(pmt_cons(PMT_NIL, PMT_NIL), sb);
509 pmt_serialize(pmt_cons(a, b), sb);
510 pmt_serialize(pmt_list1(a), sb);
511 pmt_serialize(pmt_list2(a, b), sb);
512 pmt_serialize(pmt_list3(a, b, c), sb);
513 pmt_serialize(pmt_list3(a, pmt_list3(c, b, a), c), sb);
514 pmt_serialize(PMT_T, sb);
515 pmt_serialize(PMT_F, sb);
519 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_NIL));
520 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_intern("foobarvia")));
521 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_from_long(123456789)));
522 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_from_long(-123456789)));
523 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_cons(PMT_NIL, PMT_NIL)));
524 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_cons(a, b)));
525 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list1(a)));
526 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list2(a, b)));
527 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list3(a, b, c)));
528 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list3(a, pmt_list3(c, b, a), c)));
529 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_T));
530 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_F));
532 CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_EOF)); // last item
535 // FIXME add tests for real, complex, vector, uniform-vector, dict
536 // FIXME add tests for malformed input too.
541 qa_pmt_prims::test_sets()
543 pmt_t s1 = pmt_intern("s1");
544 pmt_t s2 = pmt_intern("s2");
545 pmt_t s3 = pmt_intern("s3");
547 pmt_t l1 = pmt_list1(s1);
548 pmt_t l2 = pmt_list2(s2,s3);
549 pmt_t l3 = pmt_list3(s1,s2,s3);
551 CPPUNIT_ASSERT(pmt_is_pair(pmt_memq(s1,l1)));
552 CPPUNIT_ASSERT(pmt_is_false(pmt_memq(s3,l1)));
554 CPPUNIT_ASSERT(pmt_subsetp(l1,l3));
555 CPPUNIT_ASSERT(pmt_subsetp(l2,l3));
556 CPPUNIT_ASSERT(!pmt_subsetp(l1,l2));
557 CPPUNIT_ASSERT(!pmt_subsetp(l2,l1));
558 CPPUNIT_ASSERT(!pmt_subsetp(l3,l2));
562 qa_pmt_prims::test_sugar()
564 CPPUNIT_ASSERT(pmt_is_symbol(mp("my-symbol")));
565 CPPUNIT_ASSERT_EQUAL((long) 10, pmt_to_long(mp(10)));
566 CPPUNIT_ASSERT_EQUAL((double) 1e6, pmt_to_double(mp(1e6)));
567 CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, 3),
568 pmt_to_complex(mp(std::complex<double>(2, 3))));
570 int buf[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
571 pmt_t blob = mp(buf, sizeof(buf));
572 const void *data = pmt_blob_data(blob);
573 size_t nbytes = pmt_blob_length(blob);
574 CPPUNIT_ASSERT_EQUAL(sizeof(buf), nbytes);
575 CPPUNIT_ASSERT(memcmp(buf, data, nbytes) == 0);