1 use super::*; 2 3 use tokio::timer::delay; 4 use tokio_test::assert_ok; 5 6 use std::time::Duration; 7 8 #[tokio::test] 9 async fn test_buffer() { 10 let mut buffer = Buffer::new(0, 0); 11 let mut packet: Vec<u8> = vec![0; 4]; 12 13 // Write once 14 let n = assert_ok!(buffer.write(&[0, 1]).await); 15 assert_eq!(n, 2, "n must be 2"); 16 17 // Read once 18 let n = assert_ok!(buffer.read(&mut packet).await); 19 assert_eq!(n, 2, "n must be 2"); 20 assert_eq!(&[0, 1], &packet[..n]); 21 22 // Write twice 23 let n = assert_ok!(buffer.write(&[2, 3, 4]).await); 24 assert_eq!(n, 3, "n must be 3"); 25 26 let n = assert_ok!(buffer.write(&[5, 6, 7]).await); 27 assert_eq!(n, 3, "n must be 3"); 28 29 // Read twice 30 let n = assert_ok!(buffer.read(&mut packet).await); 31 assert_eq!(n, 3, "n must be 3"); 32 assert_eq!(&[2, 3, 4], &packet[..n]); 33 34 let n = assert_ok!(buffer.read(&mut packet).await); 35 assert_eq!(n, 3, "n must be 3"); 36 assert_eq!(&[5, 6, 7], &packet[..n]); 37 38 // Write once prior to close. 39 let n = assert_ok!(buffer.write(&[3]).await); 40 assert_eq!(n, 1, "n must be 1"); 41 42 // Close 43 buffer.close().await; 44 45 // Future writes will error 46 let result = buffer.write(&[4]).await; 47 assert!(result.is_err()); 48 49 // But we can read the remaining data. 50 let n = assert_ok!(buffer.read(&mut packet).await); 51 assert_eq!(n, 1, "n must be 1"); 52 assert_eq!(&[3], &packet[..n]); 53 54 // Until EOF 55 let result = buffer.read(&mut packet).await; 56 assert!(result.is_err()); 57 if let Err(err) = result { 58 assert_eq!(err, ERR_BUFFER_CLOSED.clone()); 59 } 60 } 61 62 #[tokio::test] 63 async fn test_buffer_async() { 64 let mut buffer = Buffer::new(0, 0); 65 66 let (done_tx, mut done_rx) = mpsc::channel::<()>(1); 67 68 let mut buffer2 = buffer.clone(); 69 tokio::spawn(async move { 70 let mut packet: Vec<u8> = vec![0; 4]; 71 72 let n = assert_ok!(buffer2.read(&mut packet).await); 73 assert_eq!(n, 2, "n must be 2"); 74 assert_eq!(&[0, 1], &packet[..n]); 75 76 let result = buffer2.read(&mut packet).await; 77 assert!(result.is_err()); 78 if let Err(err) = result { 79 assert_eq!(err, ERR_BUFFER_CLOSED.clone()); 80 } 81 82 drop(done_tx); 83 }); 84 85 // Wait for the reader to start reading. 86 let when = tokio::clock::now() + Duration::from_millis(1); 87 delay(when).await; 88 89 // Write once 90 let n = assert_ok!(buffer.write(&[0, 1]).await); 91 assert_eq!(n, 2, "n must be 2"); 92 93 // Wait for the reader to start reading again. 94 let when = tokio::clock::now() + Duration::from_millis(1); 95 delay(when).await; 96 97 // Close will unblock the reader. 98 buffer.close().await; 99 100 done_rx.recv().await; 101 } 102 103 #[tokio::test] 104 async fn test_buffer_limit_count() { 105 let mut buffer = Buffer::new(2, 0); 106 107 assert_eq!(0, buffer.count().await); 108 109 // Write twice 110 let n = assert_ok!(buffer.write(&[0, 1]).await); 111 assert_eq!(n, 2, "n must be 2"); 112 assert_eq!(1, buffer.count().await); 113 114 let n = assert_ok!(buffer.write(&[2, 3]).await); 115 assert_eq!(n, 2, "n must be 2"); 116 assert_eq!(2, buffer.count().await); 117 118 // Over capacity 119 let result = buffer.write(&[4, 5]).await; 120 assert!(result.is_err()); 121 if let Err(err) = result { 122 assert_eq!(err, ERR_BUFFER_FULL.clone()); 123 } 124 assert_eq!(2, buffer.count().await); 125 126 // Read once 127 let mut packet: Vec<u8> = vec![0; 4]; 128 let n = assert_ok!(buffer.read(&mut packet).await); 129 assert_eq!(n, 2, "n must be 2"); 130 assert_eq!(&[0, 1], &packet[..n]); 131 assert_eq!(1, buffer.count().await); 132 133 // Write once 134 let n = assert_ok!(buffer.write(&[6, 7]).await); 135 assert_eq!(n, 2, "n must be 2"); 136 assert_eq!(2, buffer.count().await); 137 138 // Over capacity 139 let result = buffer.write(&[8, 9]).await; 140 assert!(result.is_err()); 141 if let Err(err) = result { 142 assert_eq!(err, ERR_BUFFER_FULL.clone()); 143 } 144 assert_eq!(2, buffer.count().await); 145 146 // Read twice 147 let n = assert_ok!(buffer.read(&mut packet).await); 148 assert_eq!(n, 2, "n must be 2"); 149 assert_eq!(&[2, 3], &packet[..n]); 150 assert_eq!(1, buffer.count().await); 151 152 let n = assert_ok!(buffer.read(&mut packet).await); 153 assert_eq!(n, 2, "n must be 2"); 154 assert_eq!(&[6, 7], &packet[..n]); 155 assert_eq!(0, buffer.count().await); 156 157 // Nothing left. 158 buffer.close().await; 159 } 160 161 #[tokio::test] 162 async fn test_buffer_limit_size() { 163 let mut buffer = Buffer::new(0, 5); 164 165 assert_eq!(0, buffer.size().await); 166 167 // Write twice 168 let n = assert_ok!(buffer.write(&[0, 1]).await); 169 assert_eq!(n, 2, "n must be 2"); 170 assert_eq!(2, buffer.size().await); 171 172 let n = assert_ok!(buffer.write(&[2, 3]).await); 173 assert_eq!(n, 2, "n must be 2"); 174 assert_eq!(4, buffer.size().await); 175 176 // Over capacity 177 let result = buffer.write(&[4, 5]).await; 178 assert!(result.is_err()); 179 if let Err(err) = result { 180 assert_eq!(err, ERR_BUFFER_FULL.clone()); 181 } 182 assert_eq!(4, buffer.size().await); 183 184 // Cheeky write at exact size. 185 let n = assert_ok!(buffer.write(&[6]).await); 186 assert_eq!(n, 1, "n must be 1"); 187 assert_eq!(5, buffer.size().await); 188 189 // Read once 190 let mut packet: Vec<u8> = vec![0; 4]; 191 let n = assert_ok!(buffer.read(&mut packet).await); 192 assert_eq!(n, 2, "n must be 2"); 193 assert_eq!(&[0, 1], &packet[..n]); 194 assert_eq!(3, buffer.size().await); 195 196 // Write once 197 let n = assert_ok!(buffer.write(&[7, 8]).await); 198 assert_eq!(n, 2, "n must be 2"); 199 assert_eq!(5, buffer.size().await); 200 201 // Over capacity 202 let result = buffer.write(&[9, 10]).await; 203 assert!(result.is_err()); 204 if let Err(err) = result { 205 assert_eq!(err, ERR_BUFFER_FULL.clone()); 206 } 207 assert_eq!(5, buffer.size().await); 208 209 // Read everything 210 let n = assert_ok!(buffer.read(&mut packet).await); 211 assert_eq!(n, 2, "n must be 2"); 212 assert_eq!(&[2, 3], &packet[..n]); 213 assert_eq!(3, buffer.size().await); 214 215 let n = assert_ok!(buffer.read(&mut packet).await); 216 assert_eq!(n, 1, "n must be 1"); 217 assert_eq!(&[6], &packet[..n]); 218 assert_eq!(2, buffer.size().await); 219 220 let n = assert_ok!(buffer.read(&mut packet).await); 221 assert_eq!(n, 2, "n must be 2"); 222 assert_eq!(&[7, 8], &packet[..n]); 223 assert_eq!(0, buffer.size().await); 224 225 // Nothing left. 226 buffer.close().await; 227 } 228 229 #[tokio::test] 230 async fn test_buffer_misc() { 231 let mut buffer = Buffer::new(0, 0); 232 233 // Write once 234 let n = assert_ok!(buffer.write(&[0, 1, 2, 3]).await); 235 assert_eq!(n, 4, "n must be 4"); 236 assert_eq!(4, buffer.size().await); 237 238 // Try to read with a short buffer 239 let mut packet: Vec<u8> = vec![0; 3]; 240 let result = buffer.read(&mut packet).await; 241 assert!(result.is_err()); 242 if let Err(err) = result { 243 assert_eq!(err, ERR_BUFFER_SHORT.clone()); 244 } 245 246 // Try again with the right size 247 let mut packet: Vec<u8> = vec![0; 4]; 248 let n = assert_ok!(buffer.read(&mut packet).await); 249 assert_eq!(n, 4, "n must be 4"); 250 assert_eq!(&[0, 1, 2, 3], &packet[..n]); 251 assert_eq!(0, buffer.size().await); 252 253 // Close 254 buffer.close().await; 255 256 // check is_close 257 assert!(buffer.is_closed().await); 258 259 // Make sure you can Close twice 260 buffer.close().await; 261 } 262