diff --git a/src/arrayvec.rs b/src/arrayvec.rs index e304c83..675e1a3 100644 --- a/src/arrayvec.rs +++ b/src/arrayvec.rs @@ -418,7 +418,19 @@ mod tests { use super::ArrayVec; #[test] - fn array_vec() { + fn popability() { + let mut v = ArrayVec::::new(); + for i in 0..128 { + v.push(i); + } + assert_eq!(v.len(), 128); + for _ in 0..128 { + assert!(v.pop().is_some()); + } + assert!(v.pop().is_none()); + } + #[test] + fn bounds() { let mut v = ArrayVec::::new(); for i in 0..128 { v.push(i); @@ -426,9 +438,33 @@ mod tests { assert_eq!(v.len(), 128); assert!(v.try_push(1000).is_err()); assert_eq!(v.len(), 128); - for _ in 0..128 { - assert!(v.pop().is_some()); + } + #[test] + fn clear() { + let mut v = ArrayVec::::new(); + for i in 0..128 { + v.push(i); } + assert_eq!(v.len(), 128); + v.clear(); assert!(v.pop().is_none()); } + #[test] + fn order() { + let mut v = ArrayVec::::new(); + for i in 0..128 { + v.push(i); + } + assert_eq!(v.len(), 128); + + assert!(v.first() == Some(&0)); + assert!(v.last() == Some(&127)); + + let size: usize = 128; + for i in 0..size { + let popped_val = v.pop(); + assert!(popped_val.is_some()); + assert!(popped_val == Some((size - 1) - i)); + } + } } diff --git a/src/base64.rs b/src/base64.rs index e0a504f..cb1798b 100644 --- a/src/base64.rs +++ b/src/base64.rs @@ -6,7 +6,8 @@ * https://www.zerotier.com/ */ -use base64::{engine::general_purpose, Engine as _}; +use base64::engine::general_purpose; +use base64::Engine as _; /// Encode a byte slice as Base64 using the URL-safe alphabet without padding #[inline(always)] diff --git a/src/blob.rs b/src/blob.rs index a9ce9ef..d6ffe96 100644 --- a/src/blob.rs +++ b/src/blob.rs @@ -9,14 +9,12 @@ use std::array::TryFromSliceError; use std::fmt::Debug; use std::hash::Hash; -use std::ops::Deref; -use std::ops::DerefMut; +use std::ops::{Deref, DerefMut}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use zeroize::Zeroize; -use crate::base64; -use crate::hex; +use crate::{base64, hex}; /// Fixed size Serde serializable byte array. /// This makes it easier to deal with blobs larger than 32 bytes (due to serde array limitations) diff --git a/src/buf.rs b/src/buf.rs index 7287215..aeff63c 100644 --- a/src/buf.rs +++ b/src/buf.rs @@ -48,7 +48,7 @@ impl Buf { } } pub fn create_from(buffer: &[u8]) -> Buf { - let mut buf = Self::new((buffer.len() + 7)/8*8); + let mut buf = Self::new((buffer.len() + 7) / 8 * 8); let _ = buf.append(buffer); buf } diff --git a/src/inetaddress.rs b/src/inetaddress.rs index da4bbfe..c73399b 100644 --- a/src/inetaddress.rs +++ b/src/inetaddress.rs @@ -1227,4 +1227,22 @@ mod tests { let ip = InetAddress::from_str("1.2.3.4/1234").unwrap(); assert_eq!("1.2.3.4/1234", ip.to_string()); } + + #[test] + fn ip_from_invalid_string() { + let ip4 = InetAddress::from_str("-1.-2.-3.-4/1234"); + assert!(ip4.is_err()); + let ip6 = InetAddress::from_str("-2603:6010:6e00:1118:d92a:ab88:4dfb:670a/1234"); + assert!(ip6.is_err()); + } + + #[test] + fn zero() { + let mut ip4 = InetAddress::from_str("1.2.3.4/1234").unwrap(); + ip4.zero(); + assert!(ip4.is_nil()); + let mut ip6 = InetAddress::from_str("2603:6010:6e00:1118:d92a:ab88:4dfb:670a/1234").unwrap(); + ip6.zero(); + assert!(ip6.is_nil()); + } } diff --git a/src/lib.rs b/src/lib.rs index dff4a75..05590e0 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -145,9 +145,10 @@ pub extern "C" fn unlikely_branch() {} #[cfg(test)] mod tests { - use super::ms_monotonic; use std::time::Duration; + use super::ms_monotonic; + #[test] fn monotonic_clock_sanity_check() { let start = ms_monotonic(); diff --git a/src/memory.rs b/src/memory.rs index 60d7bfd..889f9e6 100644 --- a/src/memory.rs +++ b/src/memory.rs @@ -11,7 +11,7 @@ #[allow(unused_imports)] use std::mem::{needs_drop, size_of, MaybeUninit}; - +#[allow(unused_imports)] use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; #[allow(unused_imports)] use std::ptr::copy_nonoverlapping; diff --git a/src/ringbuffer.rs b/src/ringbuffer.rs index 225fbf5..a591366 100644 --- a/src/ringbuffer.rs +++ b/src/ringbuffer.rs @@ -91,6 +91,8 @@ impl<'a, T, const C: usize> Iterator for RingBufferIterator<'a, T, C> { #[cfg(test)] mod tests { + use std::default; + use super::*; #[test] @@ -117,4 +119,9 @@ mod tests { assert_eq!(*i, *j); } } + #[test] + fn default() { + let mut rb: RingBuffer = RingBuffer::default(); + rb.add(42i32); + } } diff --git a/src/str.rs b/src/str.rs index adcc3f8..56684d1 100644 --- a/src/str.rs +++ b/src/str.rs @@ -6,6 +6,8 @@ * https://www.zerotier.com/ */ +use serde::de::Unexpected; + use crate::hex::HEX_CHARS; /// Escape non-ASCII-printable characters in a string. @@ -54,3 +56,25 @@ pub fn unescape(s: &str) -> Vec { } b } + +#[test] +fn escape_unescape() { + let s = "\\000"; + let unescaped = unescape(s); + let escaped = escape(&unescaped); + assert_eq!(escaped, "\\000"); + assert_eq!(unescaped[0], 0); + // short string + let s = "\\00"; + let unescaped = unescape(s); + let escaped = escape(&unescaped); + assert_eq!(escaped, "\\00"); + assert_eq!(unescaped[0], 0); + // string containing upper and lower case hex + let s = "\\A0a"; + let unescaped = unescape(s); + let escaped = escape(&unescaped); + assert_eq!(escaped, "\\a0a"); + assert_eq!(unescaped[0], 160); // A0 + assert_eq!(unescaped[1], 97); // A +} diff --git a/src/sync.rs b/src/sync.rs index ea065b3..17c89f5 100644 --- a/src/sync.rs +++ b/src/sync.rs @@ -6,7 +6,9 @@ * https://www.zerotier.com/ */ -use std::{mem::MaybeUninit, ops::Deref, sync::RwLockReadGuard}; +use std::mem::MaybeUninit; +use std::ops::Deref; +use std::sync::RwLockReadGuard; #[allow(unused)] pub struct MappedReadGuard<'a, S, T: ?Sized> { diff --git a/src/varint.rs b/src/varint.rs index fa51417..62fb9ca 100644 --- a/src/varint.rs +++ b/src/varint.rs @@ -97,6 +97,7 @@ mod tests { assert!(write(&mut t, ii).is_ok()); let mut t2 = t.as_slice(); assert_eq!(read(&mut t2).unwrap().0, ii); + assert_eq!(ii, decode(&t).unwrap().0); } } }