src/liballoc/tests.rs

   1 //! Test for `boxed` mod.
   2
   3 use core::any::Any;
   4 use core::clone::Clone;
   5 use core::convert::TryInto;
   6 use core::f64;
   7 use core::i64;
   8 use core::ops::Deref;
   9 use core::result::Result::{Err, Ok};
  10
  11 use std::boxed::Box;
  12
  13 #[test]
  14 fn test_owned_clone() {
  15     let a = Box::new(5);
  16     let b: Box<i32> = a.clone();
  17     assert!(a == b);
  18 }
  19
  20 #[derive(PartialEq, Eq)]
  21 struct Test;
  22
  23 #[test]
  24 fn any_move() {
  25     let a = Box::new(8) as Box<dyn Any>;
  26     let b = Box::new(Test) as Box<dyn Any>;
  27
  28     match a.downcast::<i32>() {
  29         Ok(a) => {
  30             assert!(a == Box::new(8));
  31         }
  32         Err(..) => panic!(),
  33     }
  34     match b.downcast::<Test>() {
  35         Ok(a) => {
  36             assert!(a == Box::new(Test));
  37         }
  38         Err(..) => panic!(),
  39     }
  40
  41     let a = Box::new(8) as Box<dyn Any>;
  42     let b = Box::new(Test) as Box<dyn Any>;
  43
  44     assert!(a.downcast::<Box<Test>>().is_err());
  45     assert!(b.downcast::<Box<i32>>().is_err());
  46 }
  47
  48 #[test]
  49 fn test_show() {
  50     let a = Box::new(8) as Box<dyn Any>;
  51     let b = Box::new(Test) as Box<dyn Any>;
  52     let a_str = format!("{:?}", a);
  53     let b_str = format!("{:?}", b);
  54     assert_eq!(a_str, "Any");
  55     assert_eq!(b_str, "Any");
  56
  57     static EIGHT: usize = 8;
  58     static TEST: Test = Test;
  59     let a = &EIGHT as &dyn Any;
  60     let b = &TEST as &dyn Any;
  61     let s = format!("{:?}", a);
  62     assert_eq!(s, "Any");
  63     let s = format!("{:?}", b);
  64     assert_eq!(s, "Any");
  65 }
  66
  67 #[test]
  68 fn deref() {
  69     fn homura<T: Deref<Target = i32>>(_: T) {}
  70     homura(Box::new(765));
  71 }
  72
  73 #[test]
  74 fn raw_sized() {
  75     let x = Box::new(17);
  76     let p = Box::into_raw(x);
  77     unsafe {
  78         assert_eq!(17, *p);
  79         *p = 19;
  80         let y = Box::from_raw(p);
  81         assert_eq!(19, *y);
  82     }
  83 }
  84
  85 #[test]
  86 fn raw_trait() {
  87     trait Foo {
  88         fn get(&self) -> u32;
  89         fn set(&mut self, value: u32);
  90     }
  91
  92     struct Bar(u32);
  93
  94     impl Foo for Bar {
  95         fn get(&self) -> u32 {
  96             self.0
  97         }
  98
  99         fn set(&mut self, value: u32) {
 100             self.0 = value;
 101         }
 102     }
 103
 104     let x: Box<dyn Foo> = Box::new(Bar(17));
 105     let p = Box::into_raw(x);
 106     unsafe {
 107         assert_eq!(17, (*p).get());
 108         (*p).set(19);
 109         let y: Box<dyn Foo> = Box::from_raw(p);
 110         assert_eq!(19, y.get());
 111     }
 112 }
 113
 114 #[test]
 115 fn f64_slice() {
 116     let slice: &[f64] = &[-1.0, 0.0, 1.0, f64::INFINITY];
 117     let boxed: Box<[f64]> = Box::from(slice);
 118     assert_eq!(&*boxed, slice)
 119 }
 120
 121 #[test]
 122 fn i64_slice() {
 123     let slice: &[i64] = &[i64::MIN, -2, -1, 0, 1, 2, i64::MAX];
 124     let boxed: Box<[i64]> = Box::from(slice);
 125     assert_eq!(&*boxed, slice)
 126 }
 127
 128 #[test]
 129 fn str_slice() {
 130     let s = "Hello, world!";
 131     let boxed: Box<str> = Box::from(s);
 132     assert_eq!(&*boxed, s)
 133 }
 134
 135 #[test]
 136 fn boxed_slice_from_iter() {
 137     let iter = 0..100;
 138     let boxed: Box<[u32]> = iter.collect();
 139     assert_eq!(boxed.len(), 100);
 140     assert_eq!(boxed[7], 7);
 141 }
 142
 143 #[test]
 144 fn test_array_from_slice() {
 145     let v = vec![1, 2, 3];
 146     let r: Box<[u32]> = v.into_boxed_slice();
 147
 148     let a: Result<Box<[u32; 3]>, _> = r.clone().try_into();
 149     assert!(a.is_ok());
 150
 151     let a: Result<Box<[u32; 2]>, _> = r.clone().try_into();
 152     assert!(a.is_err());
 153 }