library/std/src/io/readbuf/tests.rs

   1 use super::ReadBuf;
   2 use crate::mem::MaybeUninit;
   3
   4 /// Test that ReadBuf has the correct numbers when created with new
   5 #[test]
   6 fn new() {
   7     let mut buf = [0; 16];
   8     let rbuf = ReadBuf::new(&mut buf);
   9
  10     assert_eq!(rbuf.filled_len(), 0);
  11     assert_eq!(rbuf.initialized_len(), 16);
  12     assert_eq!(rbuf.capacity(), 16);
  13     assert_eq!(rbuf.remaining(), 16);
  14 }
  15
  16 /// Test that ReadBuf has the correct numbers when created with uninit
  17 #[test]
  18 fn uninit() {
  19     let mut buf = [MaybeUninit::uninit(); 16];
  20     let rbuf = ReadBuf::uninit(&mut buf);
  21
  22     assert_eq!(rbuf.filled_len(), 0);
  23     assert_eq!(rbuf.initialized_len(), 0);
  24     assert_eq!(rbuf.capacity(), 16);
  25     assert_eq!(rbuf.remaining(), 16);
  26 }
  27
  28 #[test]
  29 fn initialize_unfilled() {
  30     let mut buf = [MaybeUninit::uninit(); 16];
  31     let mut rbuf = ReadBuf::uninit(&mut buf);
  32
  33     rbuf.initialize_unfilled();
  34
  35     assert_eq!(rbuf.initialized_len(), 16);
  36 }
  37
  38 #[test]
  39 fn initialize_unfilled_to() {
  40     let mut buf = [MaybeUninit::uninit(); 16];
  41     let mut rbuf = ReadBuf::uninit(&mut buf);
  42
  43     rbuf.initialize_unfilled_to(8);
  44
  45     assert_eq!(rbuf.initialized_len(), 8);
  46
  47     rbuf.initialize_unfilled_to(4);
  48
  49     assert_eq!(rbuf.initialized_len(), 8);
  50
  51     rbuf.set_filled(8);
  52
  53     rbuf.initialize_unfilled_to(6);
  54
  55     assert_eq!(rbuf.initialized_len(), 14);
  56
  57     rbuf.initialize_unfilled_to(8);
  58
  59     assert_eq!(rbuf.initialized_len(), 16);
  60 }
  61
  62 #[test]
  63 fn add_filled() {
  64     let mut buf = [0; 16];
  65     let mut rbuf = ReadBuf::new(&mut buf);
  66
  67     rbuf.add_filled(1);
  68
  69     assert_eq!(rbuf.filled_len(), 1);
  70     assert_eq!(rbuf.remaining(), 15);
  71 }
  72
  73 #[test]
  74 #[should_panic]
  75 fn add_filled_panic() {
  76     let mut buf = [MaybeUninit::uninit(); 16];
  77     let mut rbuf = ReadBuf::uninit(&mut buf);
  78
  79     rbuf.add_filled(1);
  80 }
  81
  82 #[test]
  83 fn set_filled() {
  84     let mut buf = [0; 16];
  85     let mut rbuf = ReadBuf::new(&mut buf);
  86
  87     rbuf.set_filled(16);
  88
  89     assert_eq!(rbuf.filled_len(), 16);
  90     assert_eq!(rbuf.remaining(), 0);
  91
  92     rbuf.set_filled(6);
  93
  94     assert_eq!(rbuf.filled_len(), 6);
  95     assert_eq!(rbuf.remaining(), 10);
  96 }
  97
  98 #[test]
  99 #[should_panic]
 100 fn set_filled_panic() {
 101     let mut buf = [MaybeUninit::uninit(); 16];
 102     let mut rbuf = ReadBuf::uninit(&mut buf);
 103
 104     rbuf.set_filled(16);
 105 }
 106
 107 #[test]
 108 fn clear() {
 109     let mut buf = [255; 16];
 110     let mut rbuf = ReadBuf::new(&mut buf);
 111
 112     rbuf.set_filled(16);
 113
 114     assert_eq!(rbuf.filled_len(), 16);
 115     assert_eq!(rbuf.remaining(), 0);
 116
 117     rbuf.clear();
 118
 119     assert_eq!(rbuf.filled_len(), 0);
 120     assert_eq!(rbuf.remaining(), 16);
 121
 122     assert_eq!(rbuf.initialized(), [255; 16]);
 123 }
 124
 125 #[test]
 126 fn assume_init() {
 127     let mut buf = [MaybeUninit::uninit(); 16];
 128     let mut rbuf = ReadBuf::uninit(&mut buf);
 129
 130     unsafe {
 131         rbuf.assume_init(8);
 132     }
 133
 134     assert_eq!(rbuf.initialized_len(), 8);
 135
 136     rbuf.add_filled(4);
 137
 138     unsafe {
 139         rbuf.assume_init(2);
 140     }
 141
 142     assert_eq!(rbuf.initialized_len(), 8);
 143
 144     unsafe {
 145         rbuf.assume_init(8);
 146     }
 147
 148     assert_eq!(rbuf.initialized_len(), 12);
 149 }
 150
 151 #[test]
 152 fn append() {
 153     let mut buf = [MaybeUninit::new(255); 16];
 154     let mut rbuf = ReadBuf::uninit(&mut buf);
 155
 156     rbuf.append(&[0; 8]);
 157
 158     assert_eq!(rbuf.initialized_len(), 8);
 159     assert_eq!(rbuf.filled_len(), 8);
 160     assert_eq!(rbuf.filled(), [0; 8]);
 161
 162     rbuf.clear();
 163
 164     rbuf.append(&[1; 16]);
 165
 166     assert_eq!(rbuf.initialized_len(), 16);
 167     assert_eq!(rbuf.filled_len(), 16);
 168     assert_eq!(rbuf.filled(), [1; 16]);
 169 }
 170
 171 #[test]
 172 fn filled_mut() {
 173     let mut buf = [0; 16];
 174     let mut rbuf = ReadBuf::new(&mut buf);
 175
 176     rbuf.add_filled(8);
 177
 178     let filled = rbuf.filled().to_vec();
 179
 180     assert_eq!(&*filled, &*rbuf.filled_mut());
 181 }