src/libcoretest/cell.rs

   1 // Copyright 2014 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 use core::cell::*;
  12 use core::default::Default;
  13 use std::mem::drop;
  14
  15 #[test]
  16 fn smoketest_cell() {
  17     let x = Cell::new(10);
  18     assert!(x == Cell::new(10));
  19     assert!(x.get() == 10);
  20     x.set(20);
  21     assert!(x == Cell::new(20));
  22     assert!(x.get() == 20);
  23
  24     let y = Cell::new((30, 40));
  25     assert!(y == Cell::new((30, 40)));
  26     assert!(y.get() == (30, 40));
  27 }
  28
  29 #[test]
  30 fn cell_has_sensible_show() {
  31     let x = Cell::new("foo bar");
  32     assert!(format!("{:?}", x).contains(x.get()));
  33
  34     x.set("baz qux");
  35     assert!(format!("{:?}", x).contains(x.get()));
  36 }
  37
  38 #[test]
  39 fn ref_and_refmut_have_sensible_show() {
  40     let refcell = RefCell::new("foo");
  41
  42     let refcell_refmut = refcell.borrow_mut();
  43     assert!(format!("{:?}", refcell_refmut).contains("foo"));
  44     drop(refcell_refmut);
  45
  46     let refcell_ref = refcell.borrow();
  47     assert!(format!("{:?}", refcell_ref).contains("foo"));
  48     drop(refcell_ref);
  49 }
  50
  51 #[test]
  52 fn double_imm_borrow() {
  53     let x = RefCell::new(0);
  54     let _b1 = x.borrow();
  55     x.borrow();
  56 }
  57
  58 #[test]
  59 fn no_mut_then_imm_borrow() {
  60     let x = RefCell::new(0);
  61     let _b1 = x.borrow_mut();
  62     assert_eq!(x.borrow_state(), BorrowState::Writing);
  63 }
  64
  65 #[test]
  66 fn no_imm_then_borrow_mut() {
  67     let x = RefCell::new(0);
  68     let _b1 = x.borrow();
  69     assert_eq!(x.borrow_state(), BorrowState::Reading);
  70 }
  71
  72 #[test]
  73 fn no_double_borrow_mut() {
  74     let x = RefCell::new(0);
  75     assert_eq!(x.borrow_state(), BorrowState::Unused);
  76     let _b1 = x.borrow_mut();
  77     assert_eq!(x.borrow_state(), BorrowState::Writing);
  78 }
  79
  80 #[test]
  81 fn imm_release_borrow_mut() {
  82     let x = RefCell::new(0);
  83     {
  84         let _b1 = x.borrow();
  85     }
  86     x.borrow_mut();
  87 }
  88
  89 #[test]
  90 fn mut_release_borrow_mut() {
  91     let x = RefCell::new(0);
  92     {
  93         let _b1 = x.borrow_mut();
  94     }
  95     x.borrow();
  96 }
  97
  98 #[test]
  99 fn double_borrow_single_release_no_borrow_mut() {
 100     let x = RefCell::new(0);
 101     let _b1 = x.borrow();
 102     {
 103         let _b2 = x.borrow();
 104     }
 105     assert_eq!(x.borrow_state(), BorrowState::Reading);
 106 }
 107
 108 #[test]
 109 #[should_panic]
 110 fn discard_doesnt_unborrow() {
 111     let x = RefCell::new(0);
 112     let _b = x.borrow();
 113     let _ = _b;
 114     let _b = x.borrow_mut();
 115 }
 116
 117 #[test]
 118 fn clone_ref_updates_flag() {
 119     let x = RefCell::new(0);
 120     {
 121         let b1 = x.borrow();
 122         assert_eq!(x.borrow_state(), BorrowState::Reading);
 123         {
 124             let _b2 = clone_ref(&b1);
 125             assert_eq!(x.borrow_state(), BorrowState::Reading);
 126         }
 127         assert_eq!(x.borrow_state(), BorrowState::Reading);
 128     }
 129     assert_eq!(x.borrow_state(), BorrowState::Unused);
 130 }
 131
 132 #[test]
 133 fn as_unsafe_cell() {
 134     let c1: Cell<usize> = Cell::new(0);
 135     c1.set(1);
 136     assert_eq!(1, unsafe { *c1.as_unsafe_cell().get() });
 137
 138     let c2: Cell<usize> = Cell::new(0);
 139     unsafe { *c2.as_unsafe_cell().get() = 1; }
 140     assert_eq!(1, c2.get());
 141
 142     let r1: RefCell<usize> = RefCell::new(0);
 143     *r1.borrow_mut() = 1;
 144     assert_eq!(1, unsafe { *r1.as_unsafe_cell().get() });
 145
 146     let r2: RefCell<usize> = RefCell::new(0);
 147     unsafe { *r2.as_unsafe_cell().get() = 1; }
 148     assert_eq!(1, *r2.borrow());
 149 }
 150
 151 #[test]
 152 fn cell_default() {
 153     let cell: Cell<u32> = Default::default();
 154     assert_eq!(0, cell.get());
 155 }
 156
 157 #[test]
 158 fn refcell_default() {
 159     let cell: RefCell<u64> = Default::default();
 160     assert_eq!(0, *cell.borrow());
 161 }