src/test/run-pass/reflect-visit-data.rs

   1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // xfail-fast
  12
  13 #[feature(managed_boxes)];
  14
  15 use std::cell::RefCell;
  16 use std::libc::c_void;
  17 use std::ptr;
  18 use std::mem;
  19 use std::unstable::intrinsics::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Disr, Opaque};
  20 use std::unstable::raw::Vec;
  21
  22 #[doc = "High-level interfaces to `std::unstable::intrinsics::visit_ty` reflection system."]
  23
  24 /// Trait for visitor that wishes to reflect on data.
  25 trait movable_ptr {
  26     fn move_ptr(&mut self, adjustment: |*c_void| -> *c_void);
  27 }
  28
  29 /// Helper function for alignment calculation.
  30 #[inline(always)]
  31 fn align(size: uint, align: uint) -> uint {
  32     ((size + align) - 1u) & !(align - 1u)
  33 }
  34
  35 struct ptr_visit_adaptor<V>(Inner<V>);
  36
  37 impl<V:TyVisitor + movable_ptr> ptr_visit_adaptor<V> {
  38     fn inner<'a>(&'a mut self) -> &'a mut V {
  39         let ptr_visit_adaptor(ref mut i) = *self;
  40         &mut i.inner
  41     }
  42 }
  43
  44 impl<V:TyVisitor + movable_ptr> ptr_visit_adaptor<V> {
  45
  46     #[inline(always)]
  47     pub fn bump(&mut self, sz: uint) {
  48       self.inner().move_ptr(|p| ((p as uint) + sz) as *c_void)
  49     }
  50
  51     #[inline(always)]
  52     pub fn align(&mut self, a: uint) {
  53       self.inner().move_ptr(|p| align(p as uint, a) as *c_void)
  54     }
  55
  56     #[inline(always)]
  57     pub fn align_to<T>(&mut self) {
  58         self.align(mem::min_align_of::<T>());
  59     }
  60
  61     #[inline(always)]
  62     pub fn bump_past<T>(&mut self) {
  63         self.bump(mem::size_of::<T>());
  64     }
  65
  66 }
  67
  68 impl<V:TyVisitor + movable_ptr> TyVisitor for ptr_visit_adaptor<V> {
  69
  70     fn visit_bot(&mut self) -> bool {
  71         self.align_to::<()>();
  72         if ! self.inner().visit_bot() { return false; }
  73         self.bump_past::<()>();
  74         true
  75     }
  76
  77     fn visit_nil(&mut self) -> bool {
  78         self.align_to::<()>();
  79         if ! self.inner().visit_nil() { return false; }
  80         self.bump_past::<()>();
  81         true
  82     }
  83
  84     fn visit_bool(&mut self) -> bool {
  85         self.align_to::<bool>();
  86         if ! self.inner().visit_bool() { return false; }
  87         self.bump_past::<bool>();
  88         true
  89     }
  90
  91     fn visit_int(&mut self) -> bool {
  92         self.align_to::<int>();
  93         if ! self.inner().visit_int() { return false; }
  94         self.bump_past::<int>();
  95         true
  96     }
  97
  98     fn visit_i8(&mut self) -> bool {
  99         self.align_to::<i8>();
 100         if ! self.inner().visit_i8() { return false; }
 101         self.bump_past::<i8>();
 102         true
 103     }
 104
 105     fn visit_i16(&mut self) -> bool {
 106         self.align_to::<i16>();
 107         if ! self.inner().visit_i16() { return false; }
 108         self.bump_past::<i16>();
 109         true
 110     }
 111
 112     fn visit_i32(&mut self) -> bool {
 113         self.align_to::<i32>();
 114         if ! self.inner().visit_i32() { return false; }
 115         self.bump_past::<i32>();
 116         true
 117     }
 118
 119     fn visit_i64(&mut self) -> bool {
 120         self.align_to::<i64>();
 121         if ! self.inner().visit_i64() { return false; }
 122         self.bump_past::<i64>();
 123         true
 124     }
 125
 126     fn visit_uint(&mut self) -> bool {
 127         self.align_to::<uint>();
 128         if ! self.inner().visit_uint() { return false; }
 129         self.bump_past::<uint>();
 130         true
 131     }
 132
 133     fn visit_u8(&mut self) -> bool {
 134         self.align_to::<u8>();
 135         if ! self.inner().visit_u8() { return false; }
 136         self.bump_past::<u8>();
 137         true
 138     }
 139
 140     fn visit_u16(&mut self) -> bool {
 141         self.align_to::<u16>();
 142         if ! self.inner().visit_u16() { return false; }
 143         self.bump_past::<u16>();
 144         true
 145     }
 146
 147     fn visit_u32(&mut self) -> bool {
 148         self.align_to::<u32>();
 149         if ! self.inner().visit_u32() { return false; }
 150         self.bump_past::<u32>();
 151         true
 152     }
 153
 154     fn visit_u64(&mut self) -> bool {
 155         self.align_to::<u64>();
 156         if ! self.inner().visit_u64() { return false; }
 157         self.bump_past::<u64>();
 158         true
 159     }
 160
 161     fn visit_f32(&mut self) -> bool {
 162         self.align_to::<f32>();
 163         if ! self.inner().visit_f32() { return false; }
 164         self.bump_past::<f32>();
 165         true
 166     }
 167
 168     fn visit_f64(&mut self) -> bool {
 169         self.align_to::<f64>();
 170         if ! self.inner().visit_f64() { return false; }
 171         self.bump_past::<f64>();
 172         true
 173     }
 174
 175     fn visit_char(&mut self) -> bool {
 176         self.align_to::<char>();
 177         if ! self.inner().visit_char() { return false; }
 178         self.bump_past::<char>();
 179         true
 180     }
 181
 182     fn visit_estr_box(&mut self) -> bool {
 183         true
 184     }
 185
 186     fn visit_estr_uniq(&mut self) -> bool {
 187         self.align_to::<~str>();
 188         if ! self.inner().visit_estr_uniq() { return false; }
 189         self.bump_past::<~str>();
 190         true
 191     }
 192
 193     fn visit_estr_slice(&mut self) -> bool {
 194         self.align_to::<&'static str>();
 195         if ! self.inner().visit_estr_slice() { return false; }
 196         self.bump_past::<&'static str>();
 197         true
 198     }
 199
 200     fn visit_estr_fixed(&mut self, n: uint,
 201                         sz: uint,
 202                         align: uint) -> bool {
 203         self.align(align);
 204         if ! self.inner().visit_estr_fixed(n, sz, align) { return false; }
 205         self.bump(sz);
 206         true
 207     }
 208
 209     fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
 210         self.align_to::<@u8>();
 211         if ! self.inner().visit_box(mtbl, inner) { return false; }
 212         self.bump_past::<@u8>();
 213         true
 214     }
 215
 216     fn visit_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
 217         self.align_to::<~u8>();
 218         if ! self.inner().visit_uniq(mtbl, inner) { return false; }
 219         self.bump_past::<~u8>();
 220         true
 221     }
 222
 223     fn visit_ptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
 224         self.align_to::<*u8>();
 225         if ! self.inner().visit_ptr(mtbl, inner) { return false; }
 226         self.bump_past::<*u8>();
 227         true
 228     }
 229
 230     fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
 231         self.align_to::<&'static u8>();
 232         if ! self.inner().visit_rptr(mtbl, inner) { return false; }
 233         self.bump_past::<&'static u8>();
 234         true
 235     }
 236
 237     fn visit_unboxed_vec(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
 238         self.align_to::<Vec<()>>();
 239         // FIXME (#3732): Inner really has to move its own pointers on this one.
 240         // or else possibly we could have some weird interface wherein we
 241         // read-off a word from inner's pointers, but the read-word has to
 242         // always be the same in all sub-pointers? Dubious.
 243         if ! self.inner().visit_vec(mtbl, inner) { return false; }
 244         true
 245     }
 246
 247     fn visit_vec(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
 248         self.align_to::<~[u8]>();
 249         if ! self.inner().visit_vec(mtbl, inner) { return false; }
 250         self.bump_past::<~[u8]>();
 251         true
 252     }
 253
 254     fn visit_evec_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
 255         self.align_to::<@[u8]>();
 256         if ! self.inner().visit_evec_box(mtbl, inner) { return false; }
 257         self.bump_past::<@[u8]>();
 258         true
 259     }
 260
 261     fn visit_evec_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
 262         self.align_to::<~[u8]>();
 263         if ! self.inner().visit_evec_uniq(mtbl, inner) { return false; }
 264         self.bump_past::<~[u8]>();
 265         true
 266     }
 267
 268     fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
 269         self.align_to::<&'static [u8]>();
 270         if ! self.inner().visit_evec_slice(mtbl, inner) { return false; }
 271         self.bump_past::<&'static [u8]>();
 272         true
 273     }
 274
 275     fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
 276                         mtbl: uint, inner: *TyDesc) -> bool {
 277         self.align(align);
 278         if ! self.inner().visit_evec_fixed(n, sz, align, mtbl, inner) {
 279             return false;
 280         }
 281         self.bump(sz);
 282         true
 283     }
 284
 285     fn visit_enter_rec(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
 286         self.align(align);
 287         if ! self.inner().visit_enter_rec(n_fields, sz, align) { return false; }
 288         true
 289     }
 290
 291     fn visit_rec_field(&mut self, i: uint, name: &str,
 292                        mtbl: uint, inner: *TyDesc) -> bool {
 293         if ! self.inner().visit_rec_field(i, name, mtbl, inner) { return false; }
 294         true
 295     }
 296
 297     fn visit_leave_rec(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
 298         if ! self.inner().visit_leave_rec(n_fields, sz, align) { return false; }
 299         true
 300     }
 301
 302     fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,
 303                          align: uint) -> bool {
 304         self.align(align);
 305         if ! self.inner().visit_enter_class(name, named_fields, n_fields, sz, align) {
 306             return false;
 307         }
 308         true
 309     }
 310
 311     fn visit_class_field(&mut self, i: uint, name: &str, named: bool,
 312                          mtbl: uint, inner: *TyDesc) -> bool {
 313         if ! self.inner().visit_class_field(i, name, named, mtbl, inner) {
 314             return false;
 315         }
 316         true
 317     }
 318
 319     fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,
 320                          align: uint) -> bool {
 321         if ! self.inner().visit_leave_class(name, named_fields, n_fields, sz, align) {
 322             return false;
 323         }
 324         true
 325     }
 326
 327     fn visit_enter_tup(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
 328         self.align(align);
 329         if ! self.inner().visit_enter_tup(n_fields, sz, align) { return false; }
 330         true
 331     }
 332
 333     fn visit_tup_field(&mut self, i: uint, inner: *TyDesc) -> bool {
 334         if ! self.inner().visit_tup_field(i, inner) { return false; }
 335         true
 336     }
 337
 338     fn visit_leave_tup(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
 339         if ! self.inner().visit_leave_tup(n_fields, sz, align) { return false; }
 340         true
 341     }
 342
 343     fn visit_enter_fn(&mut self, purity: uint, proto: uint,
 344                       n_inputs: uint, retstyle: uint) -> bool {
 345         if ! self.inner().visit_enter_fn(purity, proto, n_inputs, retstyle) {
 346             return false
 347         }
 348         true
 349     }
 350
 351     fn visit_fn_input(&mut self, i: uint, mode: uint, inner: *TyDesc) -> bool {
 352         if ! self.inner().visit_fn_input(i, mode, inner) { return false; }
 353         true
 354     }
 355
 356     fn visit_fn_output(&mut self, retstyle: uint, variadic: bool, inner: *TyDesc) -> bool {
 357         if ! self.inner().visit_fn_output(retstyle, variadic, inner) { return false; }
 358         true
 359     }
 360
 361     fn visit_leave_fn(&mut self, purity: uint, proto: uint,
 362                       n_inputs: uint, retstyle: uint) -> bool {
 363         if ! self.inner().visit_leave_fn(purity, proto, n_inputs, retstyle) {
 364             return false;
 365         }
 366         true
 367     }
 368
 369     fn visit_enter_enum(&mut self, n_variants: uint,
 370                         get_disr: extern unsafe fn(ptr: *Opaque) -> Disr,
 371                         sz: uint, align: uint)
 372                      -> bool {
 373         self.align(align);
 374         if ! self.inner().visit_enter_enum(n_variants, get_disr, sz, align) { return false; }
 375         true
 376     }
 377
 378     fn visit_enter_enum_variant(&mut self, variant: uint,
 379                                 disr_val: Disr,
 380                                 n_fields: uint,
 381                                 name: &str) -> bool {
 382         if ! self.inner().visit_enter_enum_variant(variant, disr_val,
 383                                                  n_fields, name) {
 384             return false;
 385         }
 386         true
 387     }
 388
 389     fn visit_enum_variant_field(&mut self, i: uint, offset: uint, inner: *TyDesc) -> bool {
 390         if ! self.inner().visit_enum_variant_field(i, offset, inner) { return false; }
 391         true
 392     }
 393
 394     fn visit_leave_enum_variant(&mut self, variant: uint,
 395                                 disr_val: Disr,
 396                                 n_fields: uint,
 397                                 name: &str) -> bool {
 398         if ! self.inner().visit_leave_enum_variant(variant, disr_val,
 399                                                  n_fields, name) {
 400             return false;
 401         }
 402         true
 403     }
 404
 405     fn visit_leave_enum(&mut self, n_variants: uint,
 406                         get_disr: extern unsafe fn(ptr: *Opaque) -> Disr,
 407                         sz: uint, align: uint)
 408                      -> bool {
 409         if ! self.inner().visit_leave_enum(n_variants, get_disr, sz, align) { return false; }
 410         true
 411     }
 412
 413     fn visit_trait(&mut self, name: &str) -> bool {
 414         self.align_to::<@TyVisitor>();
 415         if ! self.inner().visit_trait(name) { return false; }
 416         self.bump_past::<@TyVisitor>();
 417         true
 418     }
 419
 420     fn visit_param(&mut self, i: uint) -> bool {
 421         if ! self.inner().visit_param(i) { return false; }
 422         true
 423     }
 424
 425     fn visit_self(&mut self) -> bool {
 426         self.align_to::<&'static u8>();
 427         if ! self.inner().visit_self() { return false; }
 428         self.align_to::<&'static u8>();
 429         true
 430     }
 431
 432     fn visit_type(&mut self) -> bool {
 433         if ! self.inner().visit_type() { return false; }
 434         true
 435     }
 436 }
 437
 438 struct my_visitor(@RefCell<Stuff>);
 439
 440 #[deriving(Clone)]
 441 struct Stuff {
 442     ptr1: *c_void,
 443     ptr2: *c_void,
 444     vals: ~[~str]
 445 }
 446
 447 impl my_visitor {
 448     pub fn get<T:Clone>(&mut self, f: |T|) {
 449         unsafe {
 450             let my_visitor(s) = *self;
 451             f((*((*s).get().ptr1 as *T)).clone());
 452         }
 453     }
 454
 455     pub fn visit_inner(&mut self, inner: *TyDesc) -> bool {
 456         unsafe {
 457             let my_visitor(s) = *self;
 458             let u = my_visitor(s);
 459             let mut v = ptr_visit_adaptor::<my_visitor>(Inner {inner: u});
 460             visit_tydesc(inner, &mut v as &mut TyVisitor);
 461             true
 462         }
 463     }
 464 }
 465
 466 struct Inner<V> { inner: V }
 467
 468 impl movable_ptr for my_visitor {
 469     fn move_ptr(&mut self, adjustment: |*c_void| -> *c_void) {
 470         let my_visitor(s) = *self;
 471         let mut this = s.borrow_mut();
 472         this.get().ptr1 = adjustment(this.get().ptr1);
 473         this.get().ptr2 = adjustment(this.get().ptr2);
 474     }
 475 }
 476
 477 impl TyVisitor for my_visitor {
 478
 479     fn visit_bot(&mut self) -> bool { true }
 480     fn visit_nil(&mut self) -> bool { true }
 481     fn visit_bool(&mut self) -> bool {
 482         self.get::<bool>(|b| {
 483             let my_visitor(s) = *self;
 484             let mut this = s.borrow_mut();
 485             this.get().vals.push(b.to_str());
 486         });
 487         true
 488     }
 489     fn visit_int(&mut self) -> bool {
 490         self.get::<int>(|i| {
 491             let my_visitor(s) = *self;
 492             let mut this = s.borrow_mut();
 493             this.get().vals.push(i.to_str());
 494         });
 495         true
 496     }
 497     fn visit_i8(&mut self) -> bool { true }
 498     fn visit_i16(&mut self) -> bool { true }
 499     fn visit_i32(&mut self) -> bool { true }
 500     fn visit_i64(&mut self) -> bool { true }
 501
 502     fn visit_uint(&mut self) -> bool { true }
 503     fn visit_u8(&mut self) -> bool { true }
 504     fn visit_u16(&mut self) -> bool { true }
 505     fn visit_u32(&mut self) -> bool { true }
 506     fn visit_u64(&mut self) -> bool { true }
 507
 508     fn visit_f32(&mut self) -> bool { true }
 509     fn visit_f64(&mut self) -> bool { true }
 510
 511     fn visit_char(&mut self) -> bool { true }
 512
 513     fn visit_estr_box(&mut self) -> bool { true }
 514     fn visit_estr_uniq(&mut self) -> bool { true }
 515     fn visit_estr_slice(&mut self) -> bool { true }
 516     fn visit_estr_fixed(&mut self, _n: uint, _sz: uint,
 517                         _align: uint) -> bool { true }
 518
 519     fn visit_box(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
 520     fn visit_uniq(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
 521     fn visit_ptr(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
 522     fn visit_rptr(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
 523
 524     fn visit_vec(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
 525     fn visit_unboxed_vec(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
 526     fn visit_evec_box(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
 527     fn visit_evec_uniq(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
 528     fn visit_evec_slice(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
 529     fn visit_evec_fixed(&mut self, _n: uint, _sz: uint, _align: uint,
 530                         _mtbl: uint, _inner: *TyDesc) -> bool { true }
 531
 532     fn visit_enter_rec(&mut self, _n_fields: uint,
 533                        _sz: uint, _align: uint) -> bool { true }
 534     fn visit_rec_field(&mut self, _i: uint, _name: &str,
 535                        _mtbl: uint, inner: *TyDesc) -> bool {
 536         error!("rec field!");
 537         self.visit_inner(inner)
 538     }
 539     fn visit_leave_rec(&mut self, _n_fields: uint,
 540                        _sz: uint, _align: uint) -> bool { true }
 541
 542     fn visit_enter_class(&mut self, _name: &str, _named_fields: bool, _n_fields: uint,
 543                          _sz: uint, _align: uint) -> bool { true }
 544     fn visit_class_field(&mut self, _i: uint, _name: &str, _named: bool,
 545                          _mtbl: uint, inner: *TyDesc) -> bool {
 546         self.visit_inner(inner)
 547     }
 548     fn visit_leave_class(&mut self, _name: &str, _named_fields: bool, _n_fields: uint,
 549                          _sz: uint, _align: uint) -> bool { true }
 550
 551     fn visit_enter_tup(&mut self, _n_fields: uint,
 552                        _sz: uint, _align: uint) -> bool { true }
 553     fn visit_tup_field(&mut self, _i: uint, inner: *TyDesc) -> bool {
 554         error!("tup field!");
 555         self.visit_inner(inner)
 556     }
 557     fn visit_leave_tup(&mut self, _n_fields: uint,
 558                        _sz: uint, _align: uint) -> bool { true }
 559
 560     fn visit_enter_enum(&mut self, _n_variants: uint,
 561                         _get_disr: extern unsafe fn(ptr: *Opaque) -> Disr,
 562                         _sz: uint, _align: uint) -> bool {
 563         // FIXME (#3732): this needs to rewind between enum variants, or something.
 564         true
 565     }
 566     fn visit_enter_enum_variant(&mut self, _variant: uint,
 567                                 _disr_val: Disr,
 568                                 _n_fields: uint,
 569                                 _name: &str) -> bool { true }
 570     fn visit_enum_variant_field(&mut self, _i: uint, _offset: uint, inner: *TyDesc) -> bool {
 571         self.visit_inner(inner)
 572     }
 573     fn visit_leave_enum_variant(&mut self, _variant: uint,
 574                                 _disr_val: Disr,
 575                                 _n_fields: uint,
 576                                 _name: &str) -> bool { true }
 577     fn visit_leave_enum(&mut self, _n_variants: uint,
 578                         _get_disr: extern unsafe fn(ptr: *Opaque) -> Disr,
 579                         _sz: uint, _align: uint) -> bool { true }
 580
 581     fn visit_enter_fn(&mut self, _purity: uint, _proto: uint,
 582                       _n_inputs: uint, _retstyle: uint) -> bool { true }
 583     fn visit_fn_input(&mut self, _i: uint, _mode: uint, _inner: *TyDesc) -> bool {
 584         true
 585     }
 586     fn visit_fn_output(&mut self, _retstyle: uint, _variadic: bool, _inner: *TyDesc) -> bool {
 587         true
 588     }
 589     fn visit_leave_fn(&mut self, _purity: uint, _proto: uint,
 590                       _n_inputs: uint, _retstyle: uint) -> bool { true }
 591
 592
 593     fn visit_trait(&mut self, _name: &str) -> bool { true }
 594     fn visit_param(&mut self, _i: uint) -> bool { true }
 595     fn visit_self(&mut self) -> bool { true }
 596     fn visit_type(&mut self) -> bool { true }
 597 }
 598
 599 fn get_tydesc_for<T>(_t: T) -> *TyDesc {
 600     unsafe {
 601         get_tydesc::<T>()
 602     }
 603 }
 604
 605 struct Triple { x: int, y: int, z: int }
 606
 607 pub fn main() {
 608     unsafe {
 609         let r = (1,2,3,true,false, Triple {x:5,y:4,z:3}, (12,));
 610         let p = ptr::to_unsafe_ptr(&r) as *c_void;
 611         let u = my_visitor(@RefCell::new(Stuff {ptr1: p,
 612                                                 ptr2: p,
 613                                                 vals: ~[]}));
 614         let mut v = ptr_visit_adaptor(Inner {inner: u});
 615         let td = get_tydesc_for(r);
 616         error!("tydesc sz: {}, align: {}",
 617                (*td).size, (*td).align);
 618         visit_tydesc(td, &mut v as &mut TyVisitor);
 619
 620         let my_visitor(m) = u;
 621         let mut ub = m.borrow_mut();
 622         let r = ub.get().vals.clone();
 623         for s in r.iter() {
 624             println!("val: {}", *s);
 625         }
 626         error!("{:?}", ub.get().vals.clone());
 627         assert_eq!(ub.get().vals.clone(),
 628                    ~[ ~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3", ~"12"]);
 629     }
 630 }