vendor/rustc-rayon/src/iter/collect/test.rs

   1 #![cfg(test)]
   2 #![allow(unused_assignments)]
   3
   4 // These tests are primarily targeting "abusive" producers that will
   5 // try to drive the "collect consumer" incorrectly. These should
   6 // result in panics.
   7
   8 use super::Collect;
   9 use crate::iter::plumbing::*;
  10 use rayon_core::join;
  11
  12 /// Promises to produce 2 items, but then produces 3.  Does not do any
  13 /// splits at all.
  14 #[test]
  15 #[should_panic(expected = "too many values")]
  16 fn produce_too_many_items() {
  17     let mut v = vec![];
  18     let mut collect = Collect::new(&mut v, 2);
  19     let consumer = collect.as_consumer();
  20     let mut folder = consumer.into_folder();
  21     folder = folder.consume(22);
  22     folder = folder.consume(23);
  23     folder.consume(24);
  24 }
  25
  26 /// Produces fewer items than promised. Does not do any
  27 /// splits at all.
  28 #[test]
  29 #[should_panic(expected = "expected 5 total writes, but got 2")]
  30 fn produce_fewer_items() {
  31     let mut v = vec![];
  32     let mut collect = Collect::new(&mut v, 5);
  33     {
  34         let consumer = collect.as_consumer();
  35         let mut folder = consumer.into_folder();
  36         folder = folder.consume(22);
  37         folder = folder.consume(23);
  38         folder.complete();
  39     }
  40     collect.complete();
  41 }
  42
  43 // Complete is not called by the consumer.Hence,the collection vector is not fully initialized.
  44 #[test]
  45 #[should_panic(expected = "expected 4 total writes, but got 2")]
  46 fn left_produces_items_with_no_complete() {
  47     let mut v = vec![];
  48     let mut collect = Collect::new(&mut v, 4);
  49     {
  50         let consumer = collect.as_consumer();
  51         let (left_consumer, right_consumer, _) = consumer.split_at(2);
  52         let mut left_folder = left_consumer.into_folder();
  53         let mut right_folder = right_consumer.into_folder();
  54         left_folder = left_folder.consume(0).consume(1);
  55         right_folder = right_folder.consume(2).consume(3);
  56         right_folder.complete();
  57     }
  58     collect.complete();
  59 }
  60
  61 // Complete is not called by the right consumer. Hence,the
  62 // collection vector is not fully initialized.
  63 #[test]
  64 #[should_panic(expected = "expected 4 total writes, but got 2")]
  65 fn right_produces_items_with_no_complete() {
  66     let mut v = vec![];
  67     let mut collect = Collect::new(&mut v, 4);
  68     {
  69         let consumer = collect.as_consumer();
  70         let (left_consumer, right_consumer, _) = consumer.split_at(2);
  71         let mut left_folder = left_consumer.into_folder();
  72         let mut right_folder = right_consumer.into_folder();
  73         left_folder = left_folder.consume(0).consume(1);
  74         right_folder = right_folder.consume(2).consume(3);
  75         left_folder.complete();
  76     }
  77     collect.complete();
  78 }
  79
  80 // Complete is not called by the consumer. Hence,the collection vector is not fully initialized.
  81 #[test]
  82 #[should_panic(expected = "expected 2 total writes, but got 0")]
  83 fn produces_items_with_no_complete() {
  84     let mut v = vec![];
  85     let mut collect = Collect::new(&mut v, 2);
  86     {
  87         let consumer = collect.as_consumer();
  88         let mut folder = consumer.into_folder();
  89         folder = folder.consume(22);
  90         folder = folder.consume(23);
  91     }
  92     collect.complete();
  93 }
  94
  95 // The left consumer produces too many items while the right
  96 // consumer produces correct number.
  97 #[test]
  98 #[should_panic(expected = "too many values")]
  99 fn left_produces_too_many_items() {
 100     let mut v = vec![];
 101     let mut collect = Collect::new(&mut v, 4);
 102     {
 103         let consumer = collect.as_consumer();
 104         let (left_consumer, right_consumer, _) = consumer.split_at(2);
 105         let mut left_folder = left_consumer.into_folder();
 106         let mut right_folder = right_consumer.into_folder();
 107         left_folder = left_folder.consume(0).consume(1).consume(2);
 108         right_folder = right_folder.consume(2).consume(3);
 109         right_folder.complete();
 110     }
 111     collect.complete();
 112 }
 113
 114 // The right consumer produces too many items while the left
 115 // consumer produces correct number.
 116 #[test]
 117 #[should_panic(expected = "too many values")]
 118 fn right_produces_too_many_items() {
 119     let mut v = vec![];
 120     let mut collect = Collect::new(&mut v, 4);
 121     {
 122         let consumer = collect.as_consumer();
 123         let (left_consumer, right_consumer, _) = consumer.split_at(2);
 124         let mut left_folder = left_consumer.into_folder();
 125         let mut right_folder = right_consumer.into_folder();
 126         left_folder = left_folder.consume(0).consume(1);
 127         right_folder = right_folder.consume(2).consume(3).consume(4);
 128         left_folder.complete();
 129     }
 130     collect.complete();
 131 }
 132
 133 // The left consumer produces fewer items while the right
 134 // consumer produces correct number.
 135 #[test]
 136 #[should_panic(expected = "expected 4 total writes, but got 3")]
 137 fn left_produces_fewer_items() {
 138     let mut v = vec![];
 139     let mut collect = Collect::new(&mut v, 4);
 140     {
 141         let consumer = collect.as_consumer();
 142         let (left_consumer, right_consumer, _) = consumer.split_at(2);
 143         let mut left_folder = left_consumer.into_folder();
 144         let mut right_folder = right_consumer.into_folder();
 145         left_folder = left_folder.consume(0);
 146         right_folder = right_folder.consume(2).consume(3);
 147         left_folder.complete();
 148         right_folder.complete();
 149     }
 150     collect.complete();
 151 }
 152
 153 // The right consumer produces fewer items while the left
 154 // consumer produces correct number.
 155 #[test]
 156 #[should_panic(expected = "expected 4 total writes, but got 3")]
 157 fn right_produces_fewer_items() {
 158     let mut v = vec![];
 159     let mut collect = Collect::new(&mut v, 4);
 160     {
 161         let consumer = collect.as_consumer();
 162         let (left_consumer, right_consumer, _) = consumer.split_at(2);
 163         let mut left_folder = left_consumer.into_folder();
 164         let mut right_folder = right_consumer.into_folder();
 165         left_folder = left_folder.consume(0).consume(1);
 166         right_folder = right_folder.consume(2);
 167         left_folder.complete();
 168         right_folder.complete();
 169     }
 170     collect.complete();
 171 }
 172
 173 // The left consumer panics and the right stops short, like `panic_fuse()`.
 174 // We should get the left panic without ever reaching `Collect::complete()`.
 175 #[test]
 176 #[should_panic(expected = "left consumer panic")]
 177 fn left_panics() {
 178     let mut v = vec![];
 179     let mut collect = Collect::new(&mut v, 4);
 180     {
 181         let consumer = collect.as_consumer();
 182         let (left_consumer, right_consumer, _) = consumer.split_at(2);
 183         join(
 184             || {
 185                 let mut left_folder = left_consumer.into_folder();
 186                 left_folder = left_folder.consume(0);
 187                 panic!("left consumer panic");
 188             },
 189             || {
 190                 let mut right_folder = right_consumer.into_folder();
 191                 right_folder = right_folder.consume(2);
 192                 right_folder.complete() // early return
 193             },
 194         );
 195     }
 196     collect.complete();
 197 }
 198
 199 // The right consumer panics and the left stops short, like `panic_fuse()`.
 200 // We should get the right panic without ever reaching `Collect::complete()`.
 201 #[test]
 202 #[should_panic(expected = "right consumer panic")]
 203 fn right_panics() {
 204     let mut v = vec![];
 205     let mut collect = Collect::new(&mut v, 4);
 206     {
 207         let consumer = collect.as_consumer();
 208         let (left_consumer, right_consumer, _) = consumer.split_at(2);
 209         join(
 210             || {
 211                 let mut left_folder = left_consumer.into_folder();
 212                 left_folder = left_folder.consume(0);
 213                 left_folder.complete() // early return
 214             },
 215             || {
 216                 let mut right_folder = right_consumer.into_folder();
 217                 right_folder = right_folder.consume(2);
 218                 panic!("right consumer panic");
 219             },
 220         );
 221     }
 222     collect.complete();
 223 }