1 use super::*; 2 3 use tokio::time::delay_for; 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 delay_for(Duration::from_micros(1)).await; 87 88 // Write once 89 let n = assert_ok!(buffer.write(&[0, 1]).await); 90 assert_eq!(n, 2, "n must be 2"); 91 92 // Wait for the reader to start reading again. 93 delay_for(Duration::from_micros(1)).await; 94 95 // Close will unblock the reader. 96 buffer.close().await; 97 98 done_rx.recv().await; 99 } 100 101 #[tokio::test] 102 async fn test_buffer_limit_count() { 103 let mut buffer = Buffer::new(2, 0); 104 105 assert_eq!(0, buffer.count().await); 106 107 // Write twice 108 let n = assert_ok!(buffer.write(&[0, 1]).await); 109 assert_eq!(n, 2, "n must be 2"); 110 assert_eq!(1, buffer.count().await); 111 112 let n = assert_ok!(buffer.write(&[2, 3]).await); 113 assert_eq!(n, 2, "n must be 2"); 114 assert_eq!(2, buffer.count().await); 115 116 // Over capacity 117 let result = buffer.write(&[4, 5]).await; 118 assert!(result.is_err()); 119 if let Err(err) = result { 120 assert_eq!(err, ERR_BUFFER_FULL.clone()); 121 } 122 assert_eq!(2, buffer.count().await); 123 124 // Read once 125 let mut packet: Vec<u8> = vec![0; 4]; 126 let n = assert_ok!(buffer.read(&mut packet).await); 127 assert_eq!(n, 2, "n must be 2"); 128 assert_eq!(&[0, 1], &packet[..n]); 129 assert_eq!(1, buffer.count().await); 130 131 // Write once 132 let n = assert_ok!(buffer.write(&[6, 7]).await); 133 assert_eq!(n, 2, "n must be 2"); 134 assert_eq!(2, buffer.count().await); 135 136 // Over capacity 137 let result = buffer.write(&[8, 9]).await; 138 assert!(result.is_err()); 139 if let Err(err) = result { 140 assert_eq!(err, ERR_BUFFER_FULL.clone()); 141 } 142 assert_eq!(2, buffer.count().await); 143 144 // Read twice 145 let n = assert_ok!(buffer.read(&mut packet).await); 146 assert_eq!(n, 2, "n must be 2"); 147 assert_eq!(&[2, 3], &packet[..n]); 148 assert_eq!(1, buffer.count().await); 149 150 let n = assert_ok!(buffer.read(&mut packet).await); 151 assert_eq!(n, 2, "n must be 2"); 152 assert_eq!(&[6, 7], &packet[..n]); 153 assert_eq!(0, buffer.count().await); 154 155 // Nothing left. 156 buffer.close().await; 157 } 158 159 #[tokio::test] 160 async fn test_buffer_limit_size() { 161 let mut buffer = Buffer::new(0, 5); 162 163 assert_eq!(0, buffer.size().await); 164 165 // Write twice 166 let n = assert_ok!(buffer.write(&[0, 1]).await); 167 assert_eq!(n, 2, "n must be 2"); 168 assert_eq!(2, buffer.size().await); 169 170 let n = assert_ok!(buffer.write(&[2, 3]).await); 171 assert_eq!(n, 2, "n must be 2"); 172 assert_eq!(4, buffer.size().await); 173 174 // Over capacity 175 let result = buffer.write(&[4, 5]).await; 176 assert!(result.is_err()); 177 if let Err(err) = result { 178 assert_eq!(err, ERR_BUFFER_FULL.clone()); 179 } 180 assert_eq!(4, buffer.size().await); 181 182 // Cheeky write at exact size. 183 let n = assert_ok!(buffer.write(&[6]).await); 184 assert_eq!(n, 1, "n must be 1"); 185 assert_eq!(5, buffer.size().await); 186 187 // Read once 188 let mut packet: Vec<u8> = vec![0; 4]; 189 let n = assert_ok!(buffer.read(&mut packet).await); 190 assert_eq!(n, 2, "n must be 2"); 191 assert_eq!(&[0, 1], &packet[..n]); 192 assert_eq!(3, buffer.size().await); 193 194 // Write once 195 let n = assert_ok!(buffer.write(&[7, 8]).await); 196 assert_eq!(n, 2, "n must be 2"); 197 assert_eq!(5, buffer.size().await); 198 199 // Over capacity 200 let result = buffer.write(&[9, 10]).await; 201 assert!(result.is_err()); 202 if let Err(err) = result { 203 assert_eq!(err, ERR_BUFFER_FULL.clone()); 204 } 205 assert_eq!(5, buffer.size().await); 206 207 // Read everything 208 let n = assert_ok!(buffer.read(&mut packet).await); 209 assert_eq!(n, 2, "n must be 2"); 210 assert_eq!(&[2, 3], &packet[..n]); 211 assert_eq!(3, buffer.size().await); 212 213 let n = assert_ok!(buffer.read(&mut packet).await); 214 assert_eq!(n, 1, "n must be 1"); 215 assert_eq!(&[6], &packet[..n]); 216 assert_eq!(2, buffer.size().await); 217 218 let n = assert_ok!(buffer.read(&mut packet).await); 219 assert_eq!(n, 2, "n must be 2"); 220 assert_eq!(&[7, 8], &packet[..n]); 221 assert_eq!(0, buffer.size().await); 222 223 // Nothing left. 224 buffer.close().await; 225 } 226 227 #[tokio::test] 228 async fn test_buffer_misc() { 229 let mut buffer = Buffer::new(0, 0); 230 231 // Write once 232 let n = assert_ok!(buffer.write(&[0, 1, 2, 3]).await); 233 assert_eq!(n, 4, "n must be 4"); 234 assert_eq!(4, buffer.size().await); 235 236 // Try to read with a short buffer 237 let mut packet: Vec<u8> = vec![0; 3]; 238 let result = buffer.read(&mut packet).await; 239 assert!(result.is_err()); 240 if let Err(err) = result { 241 assert_eq!(err, ERR_BUFFER_SHORT.clone()); 242 } 243 244 // Try again with the right size 245 let mut packet: Vec<u8> = vec![0; 4]; 246 let n = assert_ok!(buffer.read(&mut packet).await); 247 assert_eq!(n, 4, "n must be 4"); 248 assert_eq!(&[0, 1, 2, 3], &packet[..n]); 249 assert_eq!(0, buffer.size().await); 250 251 // Close 252 buffer.close().await; 253 254 // check is_close 255 assert!(buffer.is_closed().await); 256 257 // Make sure you can Close twice 258 buffer.close().await; 259 } 260