vendor/derive_more/tests/as_mut.rs

   1 #![allow(dead_code)]
   2
   3 #[macro_use]
   4 extern crate derive_more;
   5
   6 use std::path::PathBuf;
   7 use std::ptr;
   8
   9 #[derive(AsMut)]
  10 struct SingleFieldTuple(String);
  11
  12 #[test]
  13 fn single_field_tuple() {
  14     let mut item = SingleFieldTuple(String::from("test"));
  15
  16     assert!(ptr::eq(&mut item.0, item.as_mut()));
  17 }
  18
  19 #[derive(AsMut)]
  20 #[as_mut(forward)]
  21 struct SingleFieldForward(Vec<i32>);
  22
  23 #[test]
  24 fn single_field_forward() {
  25     let mut item = SingleFieldForward(vec![]);
  26     let _: &mut [i32] = (&mut item).as_mut();
  27 }
  28
  29 #[derive(AsMut)]
  30 struct SingleFieldStruct {
  31     first: String,
  32 }
  33
  34 #[test]
  35 fn single_field_struct() {
  36     let mut item = SingleFieldStruct {
  37         first: String::from("test"),
  38     };
  39
  40     assert!(ptr::eq(&mut item.first, item.as_mut()));
  41 }
  42
  43 #[derive(AsMut)]
  44 struct MultiFieldTuple(#[as_mut] String, #[as_mut] PathBuf, Vec<usize>);
  45
  46 #[test]
  47 fn multi_field_tuple() {
  48     let mut item = MultiFieldTuple(String::from("test"), PathBuf::new(), vec![]);
  49
  50     assert!(ptr::eq(&mut item.0, item.as_mut()));
  51     assert!(ptr::eq(&mut item.1, item.as_mut()));
  52 }
  53
  54 #[derive(AsMut)]
  55 struct MultiFieldStruct {
  56     #[as_mut]
  57     first: String,
  58     #[as_mut]
  59     second: PathBuf,
  60     third: Vec<usize>,
  61 }
  62
  63 #[test]
  64 fn multi_field_struct() {
  65     let mut item = MultiFieldStruct {
  66         first: String::from("test"),
  67         second: PathBuf::new(),
  68         third: vec![],
  69     };
  70
  71     assert!(ptr::eq(&mut item.first, item.as_mut()));
  72     assert!(ptr::eq(&mut item.second, item.as_mut()));
  73 }
  74
  75 #[derive(AsMut)]
  76 struct SingleFieldGenericStruct<T> {
  77     first: T,
  78 }
  79
  80 #[test]
  81 fn single_field_generic_struct() {
  82     let mut item = SingleFieldGenericStruct {
  83         first: String::from("test"),
  84     };
  85
  86     assert!(ptr::eq(&mut item.first, item.as_mut()));
  87 }
  88
  89 #[derive(AsMut)]
  90 struct MultiFieldGenericStruct<T> {
  91     #[as_mut]
  92     first: Vec<T>,
  93     #[as_mut]
  94     second: PathBuf,
  95     third: Vec<usize>,
  96 }
  97
  98 #[test]
  99 fn multi_field_generic_struct() {
 100     let mut item = MultiFieldGenericStruct {
 101         first: b"test".to_vec(),
 102         second: PathBuf::new(),
 103         third: vec![],
 104     };
 105
 106     assert!(ptr::eq(&mut item.first, item.as_mut()));
 107     assert!(ptr::eq(&mut item.second, item.as_mut()));
 108 }