src/vendor/quote/tests/test.rs

   1 #![cfg_attr(feature = "cargo-clippy", allow(blacklisted_name))]
   2
   3 use std::borrow::Cow;
   4
   5 extern crate proc_macro2;
   6 #[macro_use]
   7 extern crate quote;
   8
   9 use proc_macro2::{Span, Term};
  10
  11 struct X;
  12
  13 impl quote::ToTokens for X {
  14     fn to_tokens(&self, tokens: &mut quote::Tokens) {
  15         tokens.append(proc_macro2::TokenTree {
  16             kind: proc_macro2::TokenNode::Term(Term::intern("X")),
  17             span: Span::def_site(),
  18         });
  19     }
  20 }
  21
  22 #[test]
  23 fn test_quote_impl() {
  24     let tokens = quote!(
  25         impl<'a, T: ToTokens> ToTokens for &'a T {
  26             fn to_tokens(&self, tokens: &mut Tokens) {
  27                 (**self).to_tokens(tokens)
  28             }
  29         }
  30     );
  31
  32     let expected = concat!(
  33         "impl < 'a , T : ToTokens > ToTokens for & 'a T { ",
  34         "fn to_tokens ( & self , tokens : & mut Tokens ) { ",
  35         "( * * self ) . to_tokens ( tokens ) ",
  36         "} ",
  37         "}"
  38     );
  39
  40     assert_eq!(expected, tokens.to_string());
  41 }
  42
  43 #[test]
  44 fn test_substitution() {
  45     let x = X;
  46     let tokens = quote!(#x <#x> (#x) [#x] {#x});
  47
  48     let expected = "X < X > ( X ) [ X ] { X }";
  49
  50     assert_eq!(expected, tokens.to_string());
  51 }
  52
  53 #[test]
  54 fn test_iter() {
  55     let primes = &[X, X, X, X];
  56
  57     assert_eq!("X X X X", quote!(#(#primes)*).to_string());
  58
  59     assert_eq!("X , X , X , X ,", quote!(#(#primes,)*).to_string());
  60
  61     assert_eq!("X , X , X , X", quote!(#(#primes),*).to_string());
  62 }
  63
  64 #[test]
  65 fn test_advanced() {
  66     let generics = quote!( <'a, T> );
  67
  68     let where_clause = quote!( where T: Serialize );
  69
  70     let field_ty = quote!(String);
  71
  72     let item_ty = quote!(Cow<'a, str>);
  73
  74     let path = quote!(SomeTrait::serialize_with);
  75
  76     let value = quote!(self.x);
  77
  78     let tokens = quote! {
  79         struct SerializeWith #generics #where_clause {
  80             value: &'a #field_ty,
  81             phantom: ::std::marker::PhantomData<#item_ty>,
  82         }
  83
  84         impl #generics ::serde::Serialize for SerializeWith #generics #where_clause {
  85             fn serialize<S>(&self, s: &mut S) -> Result<(), S::Error>
  86                 where S: ::serde::Serializer
  87             {
  88                 #path(self.value, s)
  89             }
  90         }
  91
  92         SerializeWith {
  93             value: #value,
  94             phantom: ::std::marker::PhantomData::<#item_ty>,
  95         }
  96     };
  97
  98     let expected = concat!(
  99         "struct SerializeWith < 'a , T > where T : Serialize { ",
 100         "value : & 'a String , ",
 101         "phantom : :: std :: marker :: PhantomData < Cow < 'a , str > > , ",
 102         "} ",
 103         "impl < 'a , T > :: serde :: Serialize for SerializeWith < 'a , T > where T : Serialize { ",
 104         "fn serialize < S > ( & self , s : & mut S ) -> Result < ( ) , S :: Error > ",
 105         "where S : :: serde :: Serializer ",
 106         "{ ",
 107         "SomeTrait :: serialize_with ( self . value , s ) ",
 108         "} ",
 109         "} ",
 110         "SerializeWith { ",
 111         "value : self . x , ",
 112         "phantom : :: std :: marker :: PhantomData :: < Cow < 'a , str > > , ",
 113         "}"
 114     );
 115
 116     assert_eq!(expected, tokens.to_string());
 117 }
 118
 119 #[test]
 120 fn test_integer() {
 121     let ii8 = -1i8;
 122     let ii16 = -1i16;
 123     let ii32 = -1i32;
 124     let ii64 = -1i64;
 125     let iisize = -1isize;
 126     let uu8 = 1u8;
 127     let uu16 = 1u16;
 128     let uu32 = 1u32;
 129     let uu64 = 1u64;
 130     let uusize = 1usize;
 131
 132     let tokens = quote! {
 133         #ii8 #ii16 #ii32 #ii64 #iisize
 134         #uu8 #uu16 #uu32 #uu64 #uusize
 135     };
 136     let expected = "-1i8 -1i16 -1i32 -1i64 -1isize 1u8 1u16 1u32 1u64 1usize";
 137     assert_eq!(expected, tokens.to_string());
 138 }
 139
 140 #[test]
 141 fn test_floating() {
 142     let e32 = 2.345f32;
 143
 144     let e64 = 2.345f64;
 145
 146     let tokens = quote! {
 147         #e32
 148         #e64
 149     };
 150     let expected = concat!("2.345f32 2.345f64");
 151     assert_eq!(expected, tokens.to_string());
 152 }
 153
 154 #[test]
 155 fn test_char() {
 156     let zero = '\0';
 157     let pound = '#';
 158     let quote = '"';
 159     let apost = '\'';
 160     let newline = '\n';
 161     let heart = '\u{2764}';
 162
 163     let tokens = quote! {
 164         #zero #pound #quote #apost #newline #heart
 165     };
 166     let expected = "'\\u{0}' '#' '\\\"' '\\'' '\\n' '\\u{2764}'";
 167     assert_eq!(expected, tokens.to_string());
 168 }
 169
 170 #[test]
 171 fn test_str() {
 172     let s = "\0 a 'b \" c";
 173     let tokens = quote!(#s);
 174     let expected = "\"\\u{0} a \\'b \\\" c\"";
 175     assert_eq!(expected, tokens.to_string());
 176 }
 177
 178 #[test]
 179 fn test_string() {
 180     let s = "\0 a 'b \" c".to_string();
 181     let tokens = quote!(#s);
 182     let expected = "\"\\u{0} a \\'b \\\" c\"";
 183     assert_eq!(expected, tokens.to_string());
 184 }
 185
 186 #[test]
 187 fn test_ident() {
 188     let foo = Term::intern("Foo");
 189     let bar = Term::intern(&format!("Bar{}", 7));
 190     let tokens = quote!(struct #foo; enum #bar {});
 191     let expected = "struct Foo ; enum Bar7 { }";
 192     assert_eq!(expected, tokens.to_string());
 193 }
 194
 195 #[test]
 196 fn test_duplicate() {
 197     let ch = 'x';
 198
 199     let tokens = quote!(#ch #ch);
 200
 201     let expected = "'x' 'x'";
 202     assert_eq!(expected, tokens.to_string());
 203 }
 204
 205 #[test]
 206 fn test_fancy_repetition() {
 207     let foo = vec!["a", "b"];
 208     let bar = vec![true, false];
 209
 210     let tokens = quote! {
 211         #(#foo: #bar),*
 212     };
 213
 214     let expected = r#""a" : true , "b" : false"#;
 215     assert_eq!(expected, tokens.to_string());
 216 }
 217
 218 #[test]
 219 fn test_nested_fancy_repetition() {
 220     let nested = vec![vec!['a', 'b', 'c'], vec!['x', 'y', 'z']];
 221
 222     let tokens = quote! {
 223         #(
 224             #(#nested)*
 225         ),*
 226     };
 227
 228     let expected = "'a' 'b' 'c' , 'x' 'y' 'z'";
 229     assert_eq!(expected, tokens.to_string());
 230 }
 231
 232 #[test]
 233 fn test_empty_repetition() {
 234     let tokens = quote!(#(a b)* #(c d),*);
 235     assert_eq!("", tokens.to_string());
 236 }
 237
 238 #[test]
 239 fn test_variable_name_conflict() {
 240     // The implementation of `#(...),*` uses the variable `_i` but it should be
 241     // fine, if a little confusing when debugging.
 242     let _i = vec!['a', 'b'];
 243     let tokens = quote! { #(#_i),* };
 244     let expected = "'a' , 'b'";
 245     assert_eq!(expected, tokens.to_string());
 246 }
 247
 248 #[test]
 249 fn test_empty_quote() {
 250     let tokens = quote!();
 251     assert_eq!("", tokens.to_string());
 252 }
 253
 254 #[test]
 255 fn test_box_str() {
 256     let b = "str".to_owned().into_boxed_str();
 257     let tokens = quote! { #b };
 258     assert_eq!("\"str\"", tokens.to_string());
 259 }
 260
 261 #[test]
 262 fn test_cow() {
 263     let owned: Cow<Term> = Cow::Owned(Term::intern("owned"));
 264
 265     let ident = Term::intern("borrowed");
 266     let borrowed = Cow::Borrowed(&ident);
 267
 268     let tokens = quote! { #owned #borrowed };
 269     assert_eq!("owned borrowed", tokens.to_string());
 270 }
 271
 272 #[test]
 273 fn test_closure() {
 274     fn field_i(i: usize) -> Term {
 275         Term::intern(&format!("__field{}", i))
 276     }
 277
 278     let fields = (0usize..3)
 279         .map(field_i as fn(_) -> _)
 280         .map(|var| quote! { #var });
 281
 282     let tokens = quote! { #(#fields)* };
 283     assert_eq!("__field0 __field1 __field2", tokens.to_string());
 284 }
 285
 286 #[test]
 287 fn test_append_tokens() {
 288     let mut a = quote!(a);
 289     let b = quote!(b);
 290     a.append_all(b);
 291     assert_eq!("a b", a.to_string());
 292 }