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