library/core/tests/any.rs

   1 use core::any::*;
   2
   3 #[derive(PartialEq, Debug)]
   4 struct Test;
   5
   6 static TEST: &'static str = "Test";
   7
   8 #[test]
   9 fn any_referenced() {
  10     let (a, b, c) = (&5 as &dyn Any, &TEST as &dyn Any, &Test as &dyn Any);
  11
  12     assert!(a.is::<i32>());
  13     assert!(!b.is::<i32>());
  14     assert!(!c.is::<i32>());
  15
  16     assert!(!a.is::<&'static str>());
  17     assert!(b.is::<&'static str>());
  18     assert!(!c.is::<&'static str>());
  19
  20     assert!(!a.is::<Test>());
  21     assert!(!b.is::<Test>());
  22     assert!(c.is::<Test>());
  23 }
  24
  25 #[test]
  26 fn any_owning() {
  27     let (a, b, c) =
  28         (box 5_usize as Box<dyn Any>, box TEST as Box<dyn Any>, box Test as Box<dyn Any>);
  29
  30     assert!(a.is::<usize>());
  31     assert!(!b.is::<usize>());
  32     assert!(!c.is::<usize>());
  33
  34     assert!(!a.is::<&'static str>());
  35     assert!(b.is::<&'static str>());
  36     assert!(!c.is::<&'static str>());
  37
  38     assert!(!a.is::<Test>());
  39     assert!(!b.is::<Test>());
  40     assert!(c.is::<Test>());
  41 }
  42
  43 #[test]
  44 fn any_downcast_ref() {
  45     let a = &5_usize as &dyn Any;
  46
  47     match a.downcast_ref::<usize>() {
  48         Some(&5) => {}
  49         x => panic!("Unexpected value {x:?}"),
  50     }
  51
  52     match a.downcast_ref::<Test>() {
  53         None => {}
  54         x => panic!("Unexpected value {x:?}"),
  55     }
  56 }
  57
  58 #[test]
  59 fn any_downcast_mut() {
  60     let mut a = 5_usize;
  61     let mut b: Box<_> = box 7_usize;
  62
  63     let a_r = &mut a as &mut dyn Any;
  64     let tmp: &mut usize = &mut *b;
  65     let b_r = tmp as &mut dyn Any;
  66
  67     match a_r.downcast_mut::<usize>() {
  68         Some(x) => {
  69             assert_eq!(*x, 5);
  70             *x = 612;
  71         }
  72         x => panic!("Unexpected value {x:?}"),
  73     }
  74
  75     match b_r.downcast_mut::<usize>() {
  76         Some(x) => {
  77             assert_eq!(*x, 7);
  78             *x = 413;
  79         }
  80         x => panic!("Unexpected value {x:?}"),
  81     }
  82
  83     match a_r.downcast_mut::<Test>() {
  84         None => (),
  85         x => panic!("Unexpected value {x:?}"),
  86     }
  87
  88     match b_r.downcast_mut::<Test>() {
  89         None => (),
  90         x => panic!("Unexpected value {x:?}"),
  91     }
  92
  93     match a_r.downcast_mut::<usize>() {
  94         Some(&mut 612) => {}
  95         x => panic!("Unexpected value {x:?}"),
  96     }
  97
  98     match b_r.downcast_mut::<usize>() {
  99         Some(&mut 413) => {}
 100         x => panic!("Unexpected value {x:?}"),
 101     }
 102 }
 103
 104 #[test]
 105 fn any_fixed_vec() {
 106     let test = [0_usize; 8];
 107     let test = &test as &dyn Any;
 108     assert!(test.is::<[usize; 8]>());
 109     assert!(!test.is::<[usize; 10]>());
 110 }
 111
 112 #[test]
 113 fn any_unsized() {
 114     fn is_any<T: Any + ?Sized>() {}
 115     is_any::<[i32]>();
 116 }
 117
 118 #[test]
 119 fn distinct_type_names() {
 120     // https://github.com/rust-lang/rust/issues/84666
 121
 122     struct Velocity(f32, f32);
 123
 124     fn type_name_of_val<T>(_: T) -> &'static str {
 125         type_name::<T>()
 126     }
 127
 128     assert_ne!(type_name_of_val(Velocity), type_name_of_val(Velocity(0.0, -9.8)),);
 129 }