compiler/rustc_expand/src/tokenstream/tests.rs

   1 use crate::tests::string_to_stream;
   2
   3 use rustc_ast::token;
   4 use rustc_ast::tokenstream::{Spacing, TokenStream, TokenStreamBuilder, TokenTree};
   5 use rustc_span::with_default_session_globals;
   6 use rustc_span::{BytePos, Span, Symbol};
   7 use smallvec::smallvec;
   8
   9 fn string_to_ts(string: &str) -> TokenStream {
  10     string_to_stream(string.to_owned())
  11 }
  12
  13 fn sp(a: u32, b: u32) -> Span {
  14     Span::with_root_ctxt(BytePos(a), BytePos(b))
  15 }
  16
  17 fn joint(tree: TokenTree) -> TokenStream {
  18     TokenStream::new(vec![(tree, Spacing::Joint)])
  19 }
  20
  21 #[test]
  22 fn test_concat() {
  23     with_default_session_globals(|| {
  24         let test_res = string_to_ts("foo::bar::baz");
  25         let test_fst = string_to_ts("foo::bar");
  26         let test_snd = string_to_ts("::baz");
  27         let eq_res = TokenStream::from_streams(smallvec![test_fst, test_snd]);
  28         assert_eq!(test_res.trees().count(), 5);
  29         assert_eq!(eq_res.trees().count(), 5);
  30         assert_eq!(test_res.eq_unspanned(&eq_res), true);
  31     })
  32 }
  33
  34 #[test]
  35 fn test_to_from_bijection() {
  36     with_default_session_globals(|| {
  37         let test_start = string_to_ts("foo::bar(baz)");
  38         let test_end = test_start.trees().collect();
  39         assert_eq!(test_start, test_end)
  40     })
  41 }
  42
  43 #[test]
  44 fn test_eq_0() {
  45     with_default_session_globals(|| {
  46         let test_res = string_to_ts("foo");
  47         let test_eqs = string_to_ts("foo");
  48         assert_eq!(test_res, test_eqs)
  49     })
  50 }
  51
  52 #[test]
  53 fn test_eq_1() {
  54     with_default_session_globals(|| {
  55         let test_res = string_to_ts("::bar::baz");
  56         let test_eqs = string_to_ts("::bar::baz");
  57         assert_eq!(test_res, test_eqs)
  58     })
  59 }
  60
  61 #[test]
  62 fn test_eq_3() {
  63     with_default_session_globals(|| {
  64         let test_res = string_to_ts("");
  65         let test_eqs = string_to_ts("");
  66         assert_eq!(test_res, test_eqs)
  67     })
  68 }
  69
  70 #[test]
  71 fn test_diseq_0() {
  72     with_default_session_globals(|| {
  73         let test_res = string_to_ts("::bar::baz");
  74         let test_eqs = string_to_ts("bar::baz");
  75         assert_eq!(test_res == test_eqs, false)
  76     })
  77 }
  78
  79 #[test]
  80 fn test_diseq_1() {
  81     with_default_session_globals(|| {
  82         let test_res = string_to_ts("(bar,baz)");
  83         let test_eqs = string_to_ts("bar,baz");
  84         assert_eq!(test_res == test_eqs, false)
  85     })
  86 }
  87
  88 #[test]
  89 fn test_is_empty() {
  90     with_default_session_globals(|| {
  91         let test0: TokenStream = Vec::<TokenTree>::new().into_iter().collect();
  92         let test1: TokenStream =
  93             TokenTree::token(token::Ident(Symbol::intern("a"), false), sp(0, 1)).into();
  94         let test2 = string_to_ts("foo(bar::baz)");
  95
  96         assert_eq!(test0.is_empty(), true);
  97         assert_eq!(test1.is_empty(), false);
  98         assert_eq!(test2.is_empty(), false);
  99     })
 100 }
 101
 102 #[test]
 103 fn test_dotdotdot() {
 104     with_default_session_globals(|| {
 105         let mut builder = TokenStreamBuilder::new();
 106         builder.push(joint(TokenTree::token(token::Dot, sp(0, 1))));
 107         builder.push(joint(TokenTree::token(token::Dot, sp(1, 2))));
 108         builder.push(TokenTree::token(token::Dot, sp(2, 3)));
 109         let stream = builder.build();
 110         assert!(stream.eq_unspanned(&string_to_ts("...")));
 111         assert_eq!(stream.trees().count(), 1);
 112     })
 113 }