src/test/run-pass/threads-sendsync/sync-send-iterators-in-libcore.rs

   1 // run-pass
   2 // pretty-expanded FIXME #23616
   3
   4 #![allow(warnings)]
   5 #![feature(iter_empty)]
   6 #![feature(iter_once)]
   7 #![feature(str_escape)]
   8
   9 use std::iter::{empty, once, repeat};
  10
  11 fn is_sync<T>(_: T) where T: Sync {}
  12 fn is_send<T>(_: T) where T: Send {}
  13
  14 macro_rules! all_sync_send {
  15     ($ctor:expr, $iter:ident) => ({
  16         let mut x = $ctor;
  17         is_sync(x.$iter());
  18         let mut y = $ctor;
  19         is_send(y.$iter());
  20     });
  21     ($ctor:expr, $iter:ident($($param:expr),+)) => ({
  22         let mut x = $ctor;
  23         is_sync(x.$iter($( $param ),+));
  24         let mut y = $ctor;
  25         is_send(y.$iter($( $param ),+));
  26     });
  27     ($ctor:expr, $iter:ident, $($rest:tt)*) => ({
  28         all_sync_send!($ctor, $iter);
  29         all_sync_send!($ctor, $($rest)*);
  30     });
  31     ($ctor:expr, $iter:ident($($param:expr),+), $($rest:tt)*) => ({
  32         all_sync_send!($ctor, $iter($( $param ),+));
  33         all_sync_send!($ctor, $($rest)*);
  34     });
  35 }
  36
  37 macro_rules! all_sync_send_mutable_ref {
  38     ($ctor:expr, $($iter:ident),+) => ({
  39         $(
  40             let mut x = $ctor;
  41             is_sync((&mut x).$iter());
  42             let mut y = $ctor;
  43             is_send((&mut y).$iter());
  44         )+
  45     })
  46 }
  47
  48 macro_rules! is_sync_send {
  49     ($ctor:expr) => ({
  50         let x = $ctor;
  51         is_sync(x);
  52         let y = $ctor;
  53         is_send(y);
  54     })
  55 }
  56
  57 fn main() {
  58     // for char.rs
  59     all_sync_send!("Я", escape_debug, escape_default, escape_unicode);
  60
  61     // for iter.rs
  62     all_sync_send_mutable_ref!([1], iter);
  63
  64     // Bytes implements DoubleEndedIterator
  65     all_sync_send!("a".bytes(), rev);
  66
  67     let a = [1];
  68     let b = [2];
  69     all_sync_send!(a.iter(),
  70                    cloned,
  71                    cycle,
  72                    chain([2].iter()),
  73                    zip([2].iter()),
  74                    map(|_| 1),
  75                    filter(|_| true),
  76                    filter_map(|_| Some(1)),
  77                    enumerate,
  78                    peekable,
  79                    skip_while(|_| true),
  80                    take_while(|_| true),
  81                    skip(1),
  82                    take(1),
  83                    scan(1, |_, _| Some(1)),
  84                    flat_map(|_| b.iter()),
  85                    fuse,
  86                    inspect(|_| ()));
  87
  88     is_sync_send!((1..).step_by(2));
  89     is_sync_send!((1..2).step_by(2));
  90     is_sync_send!((1..2));
  91     is_sync_send!((1..));
  92     is_sync_send!(repeat(1));
  93     is_sync_send!(empty::<usize>());
  94     is_sync_send!(once(1));
  95
  96     // for option.rs
  97     // FIXME
  98
  99     // for result.rs
 100     // FIXME
 101
 102     // for slice.rs
 103     // FIXME
 104
 105     // for str/mod.rs
 106     // FIXME
 107 }