src/vendor/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 iter::plumbing::*;
   9 use super::Collect;
  10
  11 /// Promises to produce 2 items, but then produces 3.  Does not do any
  12 /// splits at all.
  13 #[test]
  14 #[should_panic(expected = "too many values")]
  15 fn produce_too_many_items() {
  16     let mut v = vec![];
  17     let mut collect = Collect::new(&mut v, 2);
  18     let consumer = collect.as_consumer();
  19     let mut folder = consumer.into_folder();
  20     folder = folder.consume(22);
  21     folder = folder.consume(23);
  22     folder.consume(24);
  23 }
  24
  25 /// Produces fewer items than promised. Does not do any
  26 /// splits at all.
  27 #[test]
  28 #[should_panic(expected = "too few values")]
  29 fn produce_fewer_items() {
  30     let mut v = vec![];
  31     let mut collect = Collect::new(&mut v, 5);
  32     let consumer = collect.as_consumer();
  33     let mut folder = consumer.into_folder();
  34     folder = folder.consume(22);
  35     folder = folder.consume(23);
  36     folder.complete();
  37 }
  38
  39 // Complete is not called by the consumer.Hence,the collection vector is not fully initialized.
  40 #[test]
  41 #[should_panic(expected = "expected 4 total writes, but got 2")]
  42 fn left_produces_items_with_no_complete() {
  43     let mut v = vec![];
  44     let mut collect = Collect::new(&mut v, 4);
  45     {
  46         let consumer = collect.as_consumer();
  47         let (left_consumer, right_consumer, _) = consumer.split_at(2);
  48         let mut left_folder = left_consumer.into_folder();
  49         let mut right_folder = right_consumer.into_folder();
  50         left_folder = left_folder.consume(0).consume(1);
  51         right_folder = right_folder.consume(2).consume(3);
  52         right_folder.complete();
  53     }
  54     collect.complete();
  55 }
  56
  57 // Complete is not called by the right consumer. Hence,the
  58 // collection vector is not fully initialized.
  59 #[test]
  60 #[should_panic(expected = "expected 4 total writes, but got 2")]
  61 fn right_produces_items_with_no_complete() {
  62     let mut v = vec![];
  63     let mut collect = Collect::new(&mut v, 4);
  64     {
  65         let consumer = collect.as_consumer();
  66         let (left_consumer, right_consumer, _) = consumer.split_at(2);
  67         let mut left_folder = left_consumer.into_folder();
  68         let mut right_folder = right_consumer.into_folder();
  69         left_folder = left_folder.consume(0).consume(1);
  70         right_folder = right_folder.consume(2).consume(3);
  71         left_folder.complete();
  72     }
  73     collect.complete();
  74 }
  75
  76 // Complete is not called by the consumer. Hence,the collection vector is not fully initialized.
  77 #[test]
  78 #[should_panic(expected = "expected 2 total writes, but got 0")]
  79 fn produces_items_with_no_complete() {
  80     let mut v = vec![];
  81     let mut collect = Collect::new(&mut v, 2);
  82     {
  83         let consumer = collect.as_consumer();
  84         let mut folder = consumer.into_folder();
  85         folder = folder.consume(22);
  86         folder = folder.consume(23);
  87     }
  88     collect.complete();
  89 }
  90
  91 // The left consumer produces too many items while the right
  92 // consumer produces correct number.
  93 #[test]
  94 #[should_panic(expected = "too many values")]
  95 fn left_produces_too_many_items() {
  96     let mut v = vec![];
  97     let mut collect = Collect::new(&mut v, 4);
  98     {
  99         let consumer = collect.as_consumer();
 100         let (left_consumer, right_consumer, _) = consumer.split_at(2);
 101         let mut left_folder = left_consumer.into_folder();
 102         let mut right_folder = right_consumer.into_folder();
 103         left_folder = left_folder.consume(0).consume(1).consume(2);
 104         right_folder = right_folder.consume(2).consume(3);
 105         right_folder.complete();
 106     }
 107     collect.complete();
 108 }
 109
 110 // The right consumer produces too many items while the left
 111 // consumer produces correct number.
 112 #[test]
 113 #[should_panic(expected = "too many values")]
 114 fn right_produces_too_many_items() {
 115     let mut v = vec![];
 116     let mut collect = Collect::new(&mut v, 4);
 117     {
 118         let consumer = collect.as_consumer();
 119         let (left_consumer, right_consumer, _) = consumer.split_at(2);
 120         let mut left_folder = left_consumer.into_folder();
 121         let mut right_folder = right_consumer.into_folder();
 122         left_folder = left_folder.consume(0).consume(1);
 123         right_folder = right_folder.consume(2).consume(3).consume(4);
 124         left_folder.complete();
 125     }
 126     collect.complete();
 127 }
 128
 129
 130 // The left consumer produces fewer items while the right
 131 // consumer produces correct number.
 132 #[test]
 133 #[should_panic(expected = "too few values")]
 134 fn left_produces_fewer_items() {
 135     let mut v = vec![];
 136     let mut collect = Collect::new(&mut v, 4);
 137     {
 138         let consumer = collect.as_consumer();
 139         let (left_consumer, right_consumer, _) = consumer.split_at(2);
 140         let mut left_folder = left_consumer.into_folder();
 141         let mut right_folder = right_consumer.into_folder();
 142         left_folder = left_folder.consume(0);
 143         right_folder = right_folder.consume(2).consume(3);
 144         left_folder.complete();
 145         right_folder.complete();
 146     }
 147     collect.complete();
 148 }
 149
 150 // The right consumer produces fewer items while the left
 151 // consumer produces correct number.
 152 #[test]
 153 #[should_panic(expected = "too few values")]
 154 fn right_produces_fewer_items() {
 155     let mut v = vec![];
 156     let mut collect = Collect::new(&mut v, 4);
 157     {
 158         let consumer = collect.as_consumer();
 159         let (left_consumer, right_consumer, _) = consumer.split_at(2);
 160         let mut left_folder = left_consumer.into_folder();
 161         let mut right_folder = right_consumer.into_folder();
 162         left_folder = left_folder.consume(0).consume(1);
 163         right_folder = right_folder.consume(2);
 164         left_folder.complete();
 165         right_folder.complete();
 166     }
 167     collect.complete();
 168 }