From 45df4d0d9b577fecee798d672695fe24ff57fb1b Mon Sep 17 00:00:00 2001 From: mo khan Date: Tue, 15 Jul 2025 16:37:08 -0600 Subject: feat: migrate from Cedar to SpiceDB authorization system This is a major architectural change that replaces the Cedar policy-based authorization system with SpiceDB's relation-based authorization. Key changes: - Migrate from Rust to Go implementation - Replace Cedar policies with SpiceDB schema and relationships - Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks - Update build system and dependencies for Go ecosystem - Maintain Envoy integration for external authorization This change enables more flexible permission modeling through SpiceDB's Google Zanzibar inspired relation-based system, supporting complex hierarchical permissions that were difficult to express in Cedar. Breaking change: Existing Cedar policies and Rust-based configuration will no longer work and need to be migrated to SpiceDB schema. --- vendor/tinyvec/tests/arrayvec.rs | 500 --------------------------- vendor/tinyvec/tests/debugger_visualizer.rs | 91 ----- vendor/tinyvec/tests/tinyvec.rs | 501 ---------------------------- 3 files changed, 1092 deletions(-) delete mode 100644 vendor/tinyvec/tests/arrayvec.rs delete mode 100644 vendor/tinyvec/tests/debugger_visualizer.rs delete mode 100644 vendor/tinyvec/tests/tinyvec.rs (limited to 'vendor/tinyvec/tests') diff --git a/vendor/tinyvec/tests/arrayvec.rs b/vendor/tinyvec/tests/arrayvec.rs deleted file mode 100644 index bcde9b58..00000000 --- a/vendor/tinyvec/tests/arrayvec.rs +++ /dev/null @@ -1,500 +0,0 @@ -#![allow(bad_style)] -#![allow(clippy::clone_on_copy)] - -#[cfg(feature = "serde")] -use serde_test::{assert_tokens, Token}; -use std::iter::FromIterator; -use tinyvec::*; - -#[test] -fn test_a_vec() { - let mut expected: ArrayVec<[i32; 4]> = Default::default(); - expected.push(1); - expected.push(2); - expected.push(3); - - let actual = array_vec!(1, 2, 3); - - assert_eq!(expected, actual); - - assert_eq!(array_vec![0u8; 4], array_vec!(0u8, 0u8, 0u8, 0u8)); - assert_eq!(array_vec![0u8; 4], array_vec!([u8; 4] => 0, 0, 0, 0)); - assert_eq!(array_vec![0; 4], array_vec!(0, 0, 0, 0)); - assert_eq!(array_vec![0; 4], array_vec!([u8; 4] => 0, 0, 0, 0)); - - let expected2 = array_vec![1.1; 3]; - let actual2 = array_vec!([f32; 3] => 1.1, 1.1, 1.1); - assert_eq!(expected2, actual2); -} - -#[test] -fn ArrayVec_push_pop() { - let mut av: ArrayVec<[i32; 4]> = Default::default(); - assert_eq!(av.len(), 0); - assert_eq!(av.pop(), None); - - av.push(10_i32); - assert_eq!(av.len(), 1); - assert_eq!(av[0], 10); - assert_eq!(av.pop(), Some(10)); - assert_eq!(av.len(), 0); - assert_eq!(av.pop(), None); - - av.push(10); - av.push(11); - av.push(12); - av.push(13); - assert_eq!(av[0], 10); - assert_eq!(av[1], 11); - assert_eq!(av[2], 12); - assert_eq!(av[3], 13); - assert_eq!(av.len(), 4); - assert_eq!(av.pop(), Some(13)); - assert_eq!(av.len(), 3); - assert_eq!(av.pop(), Some(12)); - assert_eq!(av.len(), 2); - assert_eq!(av.pop(), Some(11)); - assert_eq!(av.len(), 1); - assert_eq!(av.pop(), Some(10)); - assert_eq!(av.len(), 0); - assert_eq!(av.pop(), None); -} - -#[test] -#[should_panic] -fn ArrayVec_push_overflow() { - let mut av: ArrayVec<[i32; 0]> = Default::default(); - av.push(7); -} - -#[test] -fn ArrayVec_formatting() { - // check that we get the comma placement correct - - let mut av: ArrayVec<[i32; 4]> = Default::default(); - assert_eq!(format!("{:?}", av), "[]"); - av.push(10); - assert_eq!(format!("{:?}", av), "[10]"); - av.push(11); - assert_eq!(format!("{:?}", av), "[10, 11]"); - av.push(12); - assert_eq!(format!("{:?}", av), "[10, 11, 12]"); - - // below here just asserts that the impls exist. - - // - let av: ArrayVec<[i32; 4]> = Default::default(); - assert_eq!(format!("{:b}", av), "[]"); - assert_eq!(format!("{:o}", av), "[]"); - assert_eq!(format!("{:x}", av), "[]"); - assert_eq!(format!("{:X}", av), "[]"); - assert_eq!(format!("{}", av), "[]"); - // - let av: ArrayVec<[f32; 4]> = Default::default(); - assert_eq!(format!("{:e}", av), "[]"); - assert_eq!(format!("{:E}", av), "[]"); - // - let av: ArrayVec<[&'static str; 4]> = Default::default(); - assert_eq!(format!("{:p}", av), "[]"); -} - -#[test] -fn ArrayVec_iteration() { - let av = array_vec!([i32; 4] => 10, 11, 12, 13); - - let mut i = av.into_iter(); - assert_eq!(i.next(), Some(10)); - assert_eq!(i.next(), Some(11)); - assert_eq!(i.next(), Some(12)); - assert_eq!(i.next(), Some(13)); - assert_eq!(i.next(), None); - - let av = array_vec!([i32; 4] => 10, 11, 12, 13); - - let mut av2: ArrayVec<[i32; 4]> = av.clone().into_iter().collect(); - assert_eq!(av, av2); - - // IntoIterator for &mut ArrayVec - for x in &mut av2 { - *x = -*x; - } - - // IntoIterator for &ArrayVec - assert!(av.iter().zip(&av2).all(|(&a, &b)| a == -b)); -} - -#[test] -fn ArrayVec_append() { - let mut av = array_vec!([i32; 8] => 1, 2, 3); - let mut av2 = array_vec!([i32; 8] => 4, 5, 6); - // - av.append(&mut av2); - assert_eq!(av.as_slice(), &[1_i32, 2, 3, 4, 5, 6]); - assert_eq!(av2.as_slice(), &[]); -} - -#[test] -fn ArrayVec_remove() { - let mut av: ArrayVec<[i32; 10]> = Default::default(); - av.push(1); - av.push(2); - av.push(3); - assert_eq!(av.remove(1), 2); - assert_eq!(&av[..], &[1, 3][..]); -} - -#[test] -#[should_panic] -fn ArrayVec_remove_invalid() { - let mut av: ArrayVec<[i32; 1]> = Default::default(); - av.push(1); - av.remove(1); -} - -#[test] -fn ArrayVec_swap_remove() { - let mut av: ArrayVec<[i32; 10]> = Default::default(); - av.push(1); - av.push(2); - av.push(3); - av.push(4); - assert_eq!(av.swap_remove(3), 4); - assert_eq!(&av[..], &[1, 2, 3][..]); - assert_eq!(av.swap_remove(0), 1); - assert_eq!(&av[..], &[3, 2][..]); - assert_eq!(av.swap_remove(0), 3); - assert_eq!(&av[..], &[2][..]); - assert_eq!(av.swap_remove(0), 2); - assert_eq!(&av[..], &[][..]); -} - -#[test] -fn ArrayVec_drain() { - let mut av: ArrayVec<[i32; 10]> = Default::default(); - av.push(1); - av.push(2); - av.push(3); - - assert_eq!(Vec::from_iter(av.clone().drain(..)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(av.clone().drain(..2)), vec![1, 2]); - assert_eq!(Vec::from_iter(av.clone().drain(..3)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(av.clone().drain(..=1)), vec![1, 2]); - assert_eq!(Vec::from_iter(av.clone().drain(..=2)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(av.clone().drain(0..)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(av.clone().drain(1..)), vec![2, 3]); - - assert_eq!(Vec::from_iter(av.clone().drain(0..2)), vec![1, 2]); - assert_eq!(Vec::from_iter(av.clone().drain(0..3)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(av.clone().drain(1..2)), vec![2]); - assert_eq!(Vec::from_iter(av.clone().drain(1..3)), vec![2, 3]); - - assert_eq!(Vec::from_iter(av.clone().drain(0..=1)), vec![1, 2]); - assert_eq!(Vec::from_iter(av.clone().drain(0..=2)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(av.clone().drain(1..=1)), vec![2]); - assert_eq!(Vec::from_iter(av.clone().drain(1..=2)), vec![2, 3]); -} - -#[test] -fn ArrayVec_splice() { - let mut av: ArrayVec<[i32; 10]> = Default::default(); - av.push(1); - av.push(2); - av.push(3); - - // splice returns the same things as drain - assert_eq!(Vec::from_iter(av.clone().splice(.., None)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(av.clone().splice(..2, None)), vec![1, 2]); - assert_eq!(Vec::from_iter(av.clone().splice(..3, None)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(av.clone().splice(..=1, None)), vec![1, 2]); - assert_eq!(Vec::from_iter(av.clone().splice(..=2, None)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(av.clone().splice(0.., None)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(av.clone().splice(1.., None)), vec![2, 3]); - - assert_eq!(Vec::from_iter(av.clone().splice(0..2, None)), vec![1, 2]); - assert_eq!(Vec::from_iter(av.clone().splice(0..3, None)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(av.clone().splice(1..2, None)), vec![2]); - assert_eq!(Vec::from_iter(av.clone().splice(1..3, None)), vec![2, 3]); - - assert_eq!(Vec::from_iter(av.clone().splice(0..=1, None)), vec![1, 2]); - assert_eq!(Vec::from_iter(av.clone().splice(0..=2, None)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(av.clone().splice(1..=1, None)), vec![2]); - assert_eq!(Vec::from_iter(av.clone().splice(1..=2, None)), vec![2, 3]); - - // splice removes the same things as drain - let mut av2 = av.clone(); - av2.splice(.., None); - assert_eq!(av2, array_vec![]); - - let mut av2 = av.clone(); - av2.splice(..2, None); - assert_eq!(av2, array_vec![3]); - - let mut av2 = av.clone(); - av2.splice(..3, None); - assert_eq!(av2, array_vec![]); - - let mut av2 = av.clone(); - av2.splice(..=1, None); - assert_eq!(av2, array_vec![3]); - let mut av2 = av.clone(); - av2.splice(..=2, None); - assert_eq!(av2, array_vec![]); - - let mut av2 = av.clone(); - av2.splice(0.., None); - assert_eq!(av2, array_vec![]); - let mut av2 = av.clone(); - av2.splice(1.., None); - assert_eq!(av2, array_vec![1]); - - let mut av2 = av.clone(); - av2.splice(0..2, None); - assert_eq!(av2, array_vec![3]); - - let mut av2 = av.clone(); - av2.splice(0..3, None); - assert_eq!(av2, array_vec![]); - let mut av2 = av.clone(); - av2.splice(1..2, None); - assert_eq!(av2, array_vec![1, 3]); - - let mut av2 = av.clone(); - av2.splice(1..3, None); - assert_eq!(av2, array_vec![1]); - - let mut av2 = av.clone(); - av2.splice(0..=1, None); - assert_eq!(av2, array_vec![3]); - - let mut av2 = av.clone(); - av2.splice(0..=2, None); - assert_eq!(av2, array_vec![]); - - let mut av2 = av.clone(); - av2.splice(1..=1, None); - assert_eq!(av2, array_vec![1, 3]); - - let mut av2 = av.clone(); - av2.splice(1..=2, None); - assert_eq!(av2, array_vec![1]); - - // splice adds the elements correctly - let mut av2 = av.clone(); - av2.splice(.., 4..=6); - assert_eq!(av2, array_vec![4, 5, 6]); - - let mut av2 = av.clone(); - av2.splice(..2, 4..=6); - assert_eq!(av2, array_vec![4, 5, 6, 3]); - - let mut av2 = av.clone(); - av2.splice(..3, 4..=6); - assert_eq!(av2, array_vec![4, 5, 6]); - - let mut av2 = av.clone(); - av2.splice(..=1, 4..=6); - assert_eq!(av2, array_vec![4, 5, 6, 3]); - - let mut av2 = av.clone(); - av2.splice(..=2, 4..=6); - assert_eq!(av2, array_vec![4, 5, 6]); - - let mut av2 = av.clone(); - av2.splice(0.., 4..=6); - assert_eq!(av2, array_vec![4, 5, 6]); - - let mut av2 = av.clone(); - av2.splice(1.., 4..=6); - assert_eq!(av2, array_vec![1, 4, 5, 6]); - - let mut av2 = av.clone(); - av2.splice(0..2, 4..=6); - assert_eq!(av2, array_vec![4, 5, 6, 3]); - - let mut av2 = av.clone(); - av2.splice(0..3, 4..=6); - assert_eq!(av2, array_vec![4, 5, 6]); - - let mut av2 = av.clone(); - av2.splice(1..2, 4..=6); - assert_eq!(av2, array_vec![1, 4, 5, 6, 3]); - - let mut av2 = av.clone(); - av2.splice(1..3, 4..=6); - assert_eq!(av2, array_vec![1, 4, 5, 6]); - - let mut av2 = av.clone(); - av2.splice(0..=1, 4..=6); - assert_eq!(av2, array_vec![4, 5, 6, 3]); - - let mut av2 = av.clone(); - av2.splice(0..=2, 4..=6); - assert_eq!(av2, array_vec![4, 5, 6]); - - let mut av2 = av.clone(); - av2.splice(1..=1, 4..=6); - assert_eq!(av2, array_vec![1, 4, 5, 6, 3]); - - let mut av2 = av.clone(); - av2.splice(1..=2, 4..=6); - assert_eq!(av2, array_vec![1, 4, 5, 6]); - - // splice adds the elements correctly when the replacement is smaller - let mut av2 = av.clone(); - av2.splice(.., Some(4)); - assert_eq!(av2, array_vec![4]); - - let mut av2 = av.clone(); - av2.splice(..2, Some(4)); - assert_eq!(av2, array_vec![4, 3]); - - let mut av2 = av.clone(); - av2.splice(1.., Some(4)); - assert_eq!(av2, array_vec![1, 4]); - - let mut av2 = av.clone(); - av2.splice(1..=1, Some(4)); - assert_eq!(av2, array_vec![1, 4, 3]); -} - -#[test] -fn iter_last_nth() { - let mut av: ArrayVec<[i32; 10]> = Default::default(); - av.push(1); - av.push(2); - av.push(3); - av.push(4); - assert_eq!(av.len(), 4); - let mut iter = av.into_iter(); - assert_eq!(iter.next(), Some(1)); - assert_eq!(iter.next(), Some(2)); - assert_eq!(iter.next(), Some(3)); - assert_eq!(iter.next(), Some(4)); - assert_eq!(iter.next(), None); - assert_eq!(iter.last(), None); - - let mut av: ArrayVec<[i32; 10]> = Default::default(); - av.push(1); - av.push(2); - av.push(3); - - assert_eq!(av.into_iter().next(), Some(1)); -} - -#[test] -#[cfg(feature = "rustc_1_40")] -fn reviter() { - let mut av: ArrayVec<[i32; 10]> = Default::default(); - av.push(1); - av.push(2); - av.push(3); - av.push(4); - - let mut iter = av.into_iter(); - - assert_eq!(iter.next(), Some(1)); - assert_eq!(iter.next_back(), Some(4)); - assert_eq!(iter.next(), Some(2)); - assert_eq!(iter.next_back(), Some(3)); - assert_eq!(iter.next(), None); - assert_eq!(iter.next_back(), None); - - let mut av: ArrayVec<[i32; 32]> = Default::default(); - av.extend(0..32); - - let mut iter = av.into_iter(); - - assert_eq!(iter.nth_back(0), Some(31)); - assert_eq!(iter.nth_back(2), Some(28)); - assert_eq!(iter.nth_back(0), Some(27)); - assert_eq!(iter.nth_back(99), None); - assert_eq!(iter.nth_back(99), None); -} - -#[cfg(feature = "serde")] -#[test] -fn ArrayVec_ser_de_empty() { - let tv: ArrayVec<[i32; 0]> = Default::default(); - - assert_tokens(&tv, &[Token::Seq { len: Some(0) }, Token::SeqEnd]); -} - -#[cfg(feature = "serde")] -#[test] -fn ArrayVec_ser_de() { - let mut tv: ArrayVec<[i32; 4]> = Default::default(); - tv.push(1); - tv.push(2); - tv.push(3); - tv.push(4); - - assert_tokens( - &tv, - &[ - Token::Seq { len: Some(4) }, - Token::I32(1), - Token::I32(2), - Token::I32(3), - Token::I32(4), - Token::SeqEnd, - ], - ); -} - -#[cfg(feature = "borsh")] -#[test] -fn ArrayVec_borsh_de_empty() { - let tv: ArrayVec<[i32; 0]> = Default::default(); - let buffer = borsh::to_vec(&tv).unwrap(); - let des: ArrayVec<[i32; 0]> = borsh::from_slice(&buffer).unwrap(); - assert_eq!(tv, des); -} - -#[cfg(feature = "borsh")] -#[test] -fn ArrayVec_borsh_de() { - let mut tv: ArrayVec<[i32; 4]> = Default::default(); - tv.push(1); - tv.push(2); - tv.push(3); - tv.push(4); - let buffer = borsh::to_vec(&tv).unwrap(); - let des: ArrayVec<[i32; 4]> = borsh::from_slice(&buffer).unwrap(); - assert_eq!(tv, des); -} - -#[test] -fn ArrayVec_try_from_slice() { - use std::convert::TryFrom; - - let nums = [1, 2, 3, 4]; - - let empty: Result, _> = ArrayVec::try_from(&nums[..0]); - assert!(empty.is_ok()); - assert_eq!(empty.unwrap().as_slice(), &[]); - - let fits: Result, _> = ArrayVec::try_from(&nums[..2]); - assert!(fits.is_ok()); - assert_eq!(fits.unwrap().as_slice(), &[1, 2]); - - let does_not_fit: Result, _> = - ArrayVec::try_from(&nums[..4]); - assert!(does_not_fit.is_err()); -} - -#[test] -fn ArrayVec_pretty_debug() { - let arr: [i32; 3] = [1, 2, 3]; - let expect = format!("{:#?}", arr); - - let arr: ArrayVec<[i32; 3]> = array_vec![1, 2, 3]; - let got = format!("{:#?}", arr); - - assert_eq!(got, expect); -} diff --git a/vendor/tinyvec/tests/debugger_visualizer.rs b/vendor/tinyvec/tests/debugger_visualizer.rs deleted file mode 100644 index de7cf71e..00000000 --- a/vendor/tinyvec/tests/debugger_visualizer.rs +++ /dev/null @@ -1,91 +0,0 @@ -use debugger_test::debugger_test; -use tinyvec::*; - -#[inline(never)] -fn __break() { - println!("breakpoint hit"); -} - -#[debugger_test( - debugger = "cdb", - commands = r#" -dx strings -dx inline_tv -dx inline_tv.__0 -g -dx slice_vec -g -dx strings -"#, - expected_statements = r#" -pattern:strings : \{ len=0x3 \} \[Type: tinyvec::arrayvec::ArrayVec >\] -pattern:\[\] \[Type: tinyvec::arrayvec::ArrayVec >\] -pattern:\[len\] : 0x3 \[Type: unsigned short\] -pattern:\[capacity\] : 7 -pattern:\[0\] : "a" \[Type: .*str.*\] -pattern:\[1\] : "b" \[Type: .*str.*\] -pattern:\[2\] : "c" \[Type: .*str.*\] - -inline_tv : Inline [Type: enum2$ > >] - [] [Type: enum2$ > >] - [+0x004] __0 : { len=0x4 } [Type: tinyvec::arrayvec::ArrayVec >] - -inline_tv.__0 : { len=0x4 } [Type: tinyvec::arrayvec::ArrayVec >] - [] [Type: tinyvec::arrayvec::ArrayVec >] - [len] : 0x4 [Type: unsigned short] - [capacity] : 4 - [0] : 1 [Type: i32] - [1] : 2 [Type: i32] - [2] : 3 [Type: i32] - [3] : 4 [Type: i32] - -pattern:slice_vec : \{ len=0x3 \} \[Type: tinyvec::slicevec::SliceVec<.*str.*>\] -pattern:\[\] \[Type: tinyvec::slicevec::SliceVec<.*str.*>\] -pattern:\[len\] : 0x3 \[Type: unsigned __int64\] -pattern:\[0\] : "a" \[Type: .*str.*\] -pattern:\[1\] : "b" \[Type: .*str.*\] -pattern:\[2\] : "d" \[Type: .*str.*\] - -pattern:strings : \{ len=0x6 \} \[Type: tinyvec::arrayvec::ArrayVec >\] -pattern:\[\] \[Type: tinyvec::arrayvec::ArrayVec >\] -pattern:\[len\] : 0x6 \[Type: unsigned short\] -pattern:\[capacity\] : 7 -pattern:\[0\] : "a" \[Type: .*str.*\] -pattern:\[1\] : "b" \[Type: .*str.*\] -pattern:\[2\] : "d" \[Type: .*str.*\] -pattern:\[3\] : "e" \[Type: .*str.*\] -pattern:\[4\] : "f" \[Type: .*str.*\] -pattern:\[5\] : "g" \[Type: .*str.*\] -"# -)] -#[inline(never)] -fn test_debugger_visualizer() { - let mut strings = ArrayVec::<[&str; 7]>::default(); - strings.push("a"); - strings.push("b"); - strings.push("c"); - assert_eq!(["a", "b", "c"], &strings[..]); - - let mut inline_tv = tiny_vec!([i32; 4] => 1, 2, 3); - assert!(inline_tv.is_inline()); - - inline_tv.push(4); - __break(); - - { - let mut slice_vec = SliceVec::from(strings.as_mut_slice()); - assert_eq!(3, slice_vec.capacity()); - assert_eq!("c", slice_vec.remove(2)); - slice_vec.push("d"); - println!("{:?}", slice_vec); - __break(); - - assert_eq!(["a", "b", "d"], &slice_vec[..]); - } - - strings.push("e"); - strings.push("f"); - strings.push("g"); - assert_eq!(["a", "b", "d", "e", "f", "g"], &strings[..]); - __break(); -} diff --git a/vendor/tinyvec/tests/tinyvec.rs b/vendor/tinyvec/tests/tinyvec.rs deleted file mode 100644 index c934646b..00000000 --- a/vendor/tinyvec/tests/tinyvec.rs +++ /dev/null @@ -1,501 +0,0 @@ -#![cfg(feature = "alloc")] -#![allow(bad_style)] -#![allow(clippy::redundant_clone)] - -#[cfg(feature = "serde")] -use serde_test::{assert_tokens, Token}; -use std::iter::FromIterator; -use tinyvec::*; - -#[test] -fn TinyVec_swap_remove() { - let mut tv: TinyVec<[i32; 10]> = Default::default(); - tv.push(1); - tv.push(2); - tv.push(3); - tv.push(4); - assert_eq!(tv.swap_remove(3), 4); - assert_eq!(&tv[..], &[1, 2, 3][..]); - assert_eq!(tv.swap_remove(0), 1); - assert_eq!(&tv[..], &[3, 2][..]); - assert_eq!(tv.swap_remove(0), 3); - assert_eq!(&tv[..], &[2][..]); - assert_eq!(tv.swap_remove(0), 2); - assert_eq!(&tv[..], &[][..]); -} - -#[test] -fn TinyVec_capacity() { - let mut tv: TinyVec<[i32; 1]> = Default::default(); - assert_eq!(tv.capacity(), 1); - tv.move_to_the_heap(); - tv.extend_from_slice(&[1, 2, 3, 4]); - assert_eq!(tv.capacity(), 4); -} - -#[test] -fn TinyVec_drain() { - let mut tv: TinyVec<[i32; 10]> = Default::default(); - tv.push(1); - tv.push(2); - tv.push(3); - - assert_eq!(Vec::from_iter(tv.clone().drain(..)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(tv.clone().drain(..2)), vec![1, 2]); - assert_eq!(Vec::from_iter(tv.clone().drain(..3)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(tv.clone().drain(..=1)), vec![1, 2]); - assert_eq!(Vec::from_iter(tv.clone().drain(..=2)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(tv.clone().drain(0..)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(tv.clone().drain(1..)), vec![2, 3]); - - assert_eq!(Vec::from_iter(tv.clone().drain(0..2)), vec![1, 2]); - assert_eq!(Vec::from_iter(tv.clone().drain(0..3)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(tv.clone().drain(1..2)), vec![2]); - assert_eq!(Vec::from_iter(tv.clone().drain(1..3)), vec![2, 3]); - - assert_eq!(Vec::from_iter(tv.clone().drain(0..=1)), vec![1, 2]); - assert_eq!(Vec::from_iter(tv.clone().drain(0..=2)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(tv.clone().drain(1..=1)), vec![2]); - assert_eq!(Vec::from_iter(tv.clone().drain(1..=2)), vec![2, 3]); -} - -#[test] -fn TinyVec_splice() { - let mut tv: TinyVec<[i32; 10]> = Default::default(); - tv.push(1); - tv.push(2); - tv.push(3); - - // splice returns the same things as drain - assert_eq!(Vec::from_iter(tv.clone().splice(.., None)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(tv.clone().splice(..2, None)), vec![1, 2]); - assert_eq!(Vec::from_iter(tv.clone().splice(..3, None)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(tv.clone().splice(..=1, None)), vec![1, 2]); - assert_eq!(Vec::from_iter(tv.clone().splice(..=2, None)), vec![1, 2, 3]); - - assert_eq!(Vec::from_iter(tv.clone().splice(0.., None)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(tv.clone().splice(1.., None)), vec![2, 3]); - - assert_eq!(Vec::from_iter(tv.clone().splice(0..2, None)), vec![1, 2]); - assert_eq!(Vec::from_iter(tv.clone().splice(0..3, None)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(tv.clone().splice(1..2, None)), vec![2]); - assert_eq!(Vec::from_iter(tv.clone().splice(1..3, None)), vec![2, 3]); - - assert_eq!(Vec::from_iter(tv.clone().splice(0..=1, None)), vec![1, 2]); - assert_eq!(Vec::from_iter(tv.clone().splice(0..=2, None)), vec![1, 2, 3]); - assert_eq!(Vec::from_iter(tv.clone().splice(1..=1, None)), vec![2]); - assert_eq!(Vec::from_iter(tv.clone().splice(1..=2, None)), vec![2, 3]); - - // splice removes the same things as drain - let mut tv2 = tv.clone(); - tv2.splice(.., None); - assert_eq!(tv2, tiny_vec![]); - - let mut tv2 = tv.clone(); - tv2.splice(..2, None); - assert_eq!(tv2, tiny_vec![3]); - - let mut tv2 = tv.clone(); - tv2.splice(..3, None); - assert_eq!(tv2, tiny_vec![]); - - let mut tv2 = tv.clone(); - tv2.splice(..=1, None); - assert_eq!(tv2, tiny_vec![3]); - let mut tv2 = tv.clone(); - tv2.splice(..=2, None); - assert_eq!(tv2, tiny_vec![]); - - let mut tv2 = tv.clone(); - tv2.splice(0.., None); - assert_eq!(tv2, tiny_vec![]); - let mut tv2 = tv.clone(); - tv2.splice(1.., None); - assert_eq!(tv2, tiny_vec![1]); - - let mut tv2 = tv.clone(); - tv2.splice(0..2, None); - assert_eq!(tv2, tiny_vec![3]); - - let mut tv2 = tv.clone(); - tv2.splice(0..3, None); - assert_eq!(tv2, tiny_vec![]); - let mut tv2 = tv.clone(); - tv2.splice(1..2, None); - assert_eq!(tv2, tiny_vec![1, 3]); - - let mut tv2 = tv.clone(); - tv2.splice(1..3, None); - assert_eq!(tv2, tiny_vec![1]); - - let mut tv2 = tv.clone(); - tv2.splice(0..=1, None); - assert_eq!(tv2, tiny_vec![3]); - - let mut tv2 = tv.clone(); - tv2.splice(0..=2, None); - assert_eq!(tv2, tiny_vec![]); - - let mut tv2 = tv.clone(); - tv2.splice(1..=1, None); - assert_eq!(tv2, tiny_vec![1, 3]); - - let mut tv2 = tv.clone(); - tv2.splice(1..=2, None); - assert_eq!(tv2, tiny_vec![1]); - - // splice adds the elements correctly - let mut tv2 = tv.clone(); - tv2.splice(.., 4..=6); - assert_eq!(tv2, tiny_vec![4, 5, 6]); - - let mut tv2 = tv.clone(); - tv2.splice(..2, 4..=6); - assert_eq!(tv2, tiny_vec![4, 5, 6, 3]); - - let mut tv2 = tv.clone(); - tv2.splice(..3, 4..=6); - assert_eq!(tv2, tiny_vec![4, 5, 6]); - - let mut tv2 = tv.clone(); - tv2.splice(..=1, 4..=6); - assert_eq!(tv2, tiny_vec![4, 5, 6, 3]); - - let mut tv2 = tv.clone(); - tv2.splice(..=2, 4..=6); - assert_eq!(tv2, tiny_vec![4, 5, 6]); - - let mut tv2 = tv.clone(); - tv2.splice(0.., 4..=6); - assert_eq!(tv2, tiny_vec![4, 5, 6]); - - let mut tv2 = tv.clone(); - tv2.splice(1.., 4..=6); - assert_eq!(tv2, tiny_vec![1, 4, 5, 6]); - - let mut tv2 = tv.clone(); - tv2.splice(0..2, 4..=6); - assert_eq!(tv2, tiny_vec![4, 5, 6, 3]); - - let mut tv2 = tv.clone(); - tv2.splice(0..3, 4..=6); - assert_eq!(tv2, tiny_vec![4, 5, 6]); - - let mut tv2 = tv.clone(); - tv2.splice(1..2, 4..=6); - assert_eq!(tv2, tiny_vec![1, 4, 5, 6, 3]); - - let mut tv2 = tv.clone(); - tv2.splice(1..3, 4..=6); - assert_eq!(tv2, tiny_vec![1, 4, 5, 6]); - - let mut tv2 = tv.clone(); - tv2.splice(0..=1, 4..=6); - assert_eq!(tv2, tiny_vec![4, 5, 6, 3]); - - let mut tv2 = tv.clone(); - tv2.splice(0..=2, 4..=6); - assert_eq!(tv2, tiny_vec![4, 5, 6]); - - let mut tv2 = tv.clone(); - tv2.splice(1..=1, 4..=6); - assert_eq!(tv2, tiny_vec![1, 4, 5, 6, 3]); - - let mut tv2 = tv.clone(); - tv2.splice(1..=2, 4..=6); - assert_eq!(tv2, tiny_vec![1, 4, 5, 6]); - - // splice adds the elements correctly when the replacement is smaller - let mut tv2 = tv.clone(); - tv2.splice(.., Some(4)); - assert_eq!(tv2, tiny_vec![4]); - - let mut tv2 = tv.clone(); - tv2.splice(..2, Some(4)); - assert_eq!(tv2, tiny_vec![4, 3]); - - let mut tv2 = tv.clone(); - tv2.splice(1.., Some(4)); - assert_eq!(tv2, tiny_vec![1, 4]); - - let mut tv2 = tv.clone(); - tv2.splice(1..=1, Some(4)); - assert_eq!(tv2, tiny_vec![1, 4, 3]); -} - -#[test] -fn TinyVec_resize() { - let mut tv: TinyVec<[i32; 10]> = Default::default(); - tv.resize(20, 5); - assert_eq!(&tv[..], &[5; 20]); -} - -#[test] -fn TinyVec_from_slice_impl() { - let bigger_slice: [u8; 11] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - let tinyvec: TinyVec<[u8; 10]> = TinyVec::Heap((&bigger_slice[..]).into()); - assert_eq!(TinyVec::from(&bigger_slice[..]), tinyvec); - - let smaller_slice: [u8; 5] = [0, 1, 2, 3, 4]; - let tinyvec: TinyVec<[u8; 10]> = TinyVec::Inline(ArrayVec::from_array_len( - [0, 1, 2, 3, 4, 0, 0, 0, 0, 0], - 5, - )); - assert_eq!(TinyVec::from(&smaller_slice[..]), tinyvec); - - let same_size: [u8; 4] = [0, 1, 2, 3]; - let tinyvec: TinyVec<[u8; 4]> = - TinyVec::Inline(ArrayVec::from_array_len(same_size, 4)); - assert_eq!(TinyVec::from(&same_size[..]), tinyvec); -} - -#[test] -fn TinyVec_from_array() { - let array = [9, 8, 7, 6, 5, 4, 3, 2, 1]; - let tv = TinyVec::from(array); - assert_eq!(&array, &tv[..]); -} - -#[test] -fn TinyVec_macro() { - let mut expected: TinyVec<[i32; 4]> = Default::default(); - expected.push(1); - expected.push(2); - expected.push(3); - - let actual = tiny_vec!(1, 2, 3); - - assert_eq!(expected, actual); - - assert_eq!(tiny_vec![0u8; 4], tiny_vec!(0u8, 0u8, 0u8, 0u8)); - assert_eq!(tiny_vec![0u8; 4], tiny_vec!([u8; 4] => 0, 0, 0, 0)); - assert_eq!(tiny_vec![0; 4], tiny_vec!(0, 0, 0, 0)); - assert_eq!(tiny_vec![0; 4], tiny_vec!([u8; 4] => 0, 0, 0, 0)); - - let expected2 = tiny_vec![1.1; 3]; - let actual2 = tiny_vec!([f32; 3] => 1.1, 1.1, 1.1); - assert_eq!(expected2, actual2); -} - -#[test] -fn TinyVec_macro_non_copy() { - // must use a variable here to avoid macro shenanigans - let s = String::new(); - let _: TinyVec<[String; 10]> = tiny_vec!([String; 10] => s); -} - -#[test] -fn TinyVec_reserve() { - let mut tv: TinyVec<[i32; 4]> = Default::default(); - assert_eq!(tv.capacity(), 4); - tv.extend_from_slice(&[1, 2]); - assert_eq!(tv.capacity(), 4); - tv.reserve(2); - assert_eq!(tv.capacity(), 4); - tv.reserve(4); - assert!(tv.capacity() >= 6); - tv.extend_from_slice(&[3, 4, 5, 6]); - tv.reserve(4); - assert!(tv.capacity() >= 10); -} - -#[cfg(feature = "rustc_1_57")] -#[test] -fn TinyVec_try_reserve() { - let mut tv: TinyVec<[i32; 4]> = Default::default(); - assert_eq!(tv.capacity(), 4); - tv.extend_from_slice(&[1, 2]); - assert_eq!(tv.capacity(), 4); - assert!(tv.try_reserve(2).is_ok()); - assert_eq!(tv.capacity(), 4); - assert!(tv.try_reserve(4).is_ok()); - assert!(tv.capacity() >= 6); - tv.extend_from_slice(&[3, 4, 5, 6]); - assert!(tv.try_reserve(4).is_ok()); - assert!(tv.capacity() >= 10); -} - -#[test] -fn TinyVec_reserve_exact() { - let mut tv: TinyVec<[i32; 4]> = Default::default(); - assert_eq!(tv.capacity(), 4); - - tv.extend_from_slice(&[1, 2]); - assert_eq!(tv.capacity(), 4); - tv.reserve_exact(2); - assert_eq!(tv.capacity(), 4); - tv.reserve_exact(4); - assert!(tv.capacity() >= 6); - tv.extend_from_slice(&[3, 4, 5, 6]); - tv.reserve_exact(4); - assert!(tv.capacity() >= 10); -} - -#[cfg(feature = "rustc_1_57")] -#[test] -fn TinyVec_try_reserve_exact() { - let mut tv: TinyVec<[i32; 4]> = Default::default(); - assert_eq!(tv.capacity(), 4); - - tv.extend_from_slice(&[1, 2]); - assert_eq!(tv.capacity(), 4); - assert!(tv.try_reserve_exact(2).is_ok()); - assert_eq!(tv.capacity(), 4); - assert!(tv.try_reserve_exact(4).is_ok()); - assert!(tv.capacity() >= 6); - tv.extend_from_slice(&[3, 4, 5, 6]); - assert!(tv.try_reserve_exact(4).is_ok()); - assert!(tv.capacity() >= 10); -} - -#[test] -fn TinyVec_move_to_heap_and_shrink() { - let mut tv: TinyVec<[i32; 4]> = Default::default(); - assert!(tv.is_inline()); - tv.move_to_the_heap(); - assert!(tv.is_heap()); - assert_eq!(tv.capacity(), 0); - - tv.push(1); - tv.shrink_to_fit(); - assert!(tv.is_inline()); - assert_eq!(tv.capacity(), 4); - - tv.move_to_the_heap_and_reserve(3); - assert!(tv.is_heap()); - assert_eq!(tv.capacity(), 4); - tv.extend(2..=4); - assert_eq!(tv.capacity(), 4); - assert_eq!(tv.as_slice(), [1, 2, 3, 4]); -} - -#[cfg(feature = "rustc_1_57")] -#[test] -fn TinyVec_try_move_to_heap_and_shrink() { - let mut tv: TinyVec<[i32; 4]> = Default::default(); - assert!(tv.is_inline()); - assert!(tv.try_move_to_the_heap().is_ok()); - assert!(tv.is_heap()); - assert_eq!(tv.capacity(), 0); - - assert!(tv.try_reserve_exact(1).is_ok()); - assert_eq!(tv.capacity(), 1); - tv.push(1); - tv.shrink_to_fit(); - assert!(tv.is_inline()); - assert_eq!(tv.capacity(), 4); - - assert!(tv.try_move_to_the_heap_and_reserve(3).is_ok()); - assert!(tv.is_heap()); - assert_eq!(tv.capacity(), 4); - tv.extend(2..=4); - assert_eq!(tv.capacity(), 4); - assert_eq!(tv.as_slice(), [1, 2, 3, 4]); -} - -#[cfg(feature = "serde")] -#[test] -fn TinyVec_ser_de_empty() { - let tv: TinyVec<[i32; 0]> = tiny_vec![]; - - assert_tokens(&tv, &[Token::Seq { len: Some(0) }, Token::SeqEnd]); -} - -#[cfg(feature = "serde")] -#[test] -fn TinyVec_ser_de() { - let tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4]; - - assert_tokens( - &tv, - &[ - Token::Seq { len: Some(4) }, - Token::I32(1), - Token::I32(2), - Token::I32(3), - Token::I32(4), - Token::SeqEnd, - ], - ); -} - -#[cfg(feature = "serde")] -#[test] -fn TinyVec_ser_de_heap() { - let mut tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4]; - tv.move_to_the_heap(); - - assert_tokens( - &tv, - &[ - Token::Seq { len: Some(4) }, - Token::I32(1), - Token::I32(2), - Token::I32(3), - Token::I32(4), - Token::SeqEnd, - ], - ); -} - -#[cfg(feature = "borsh")] -#[test] -fn TinyVec_borsh_de_empty() { - let tv: ArrayVec<[i32; 0]> = Default::default(); - let buffer = borsh::to_vec(&tv).unwrap(); - let des: ArrayVec<[i32; 0]> = borsh::from_slice(&buffer).unwrap(); - assert_eq!(tv, des); -} - -#[cfg(feature = "borsh")] -#[test] -fn TinyVec_borsh_de() { - let mut tv: ArrayVec<[i32; 4]> = Default::default(); - tv.push(1); - tv.push(2); - tv.push(3); - tv.push(4); - let buffer = borsh::to_vec(&tv).unwrap(); - let des: ArrayVec<[i32; 4]> = borsh::from_slice(&buffer).unwrap(); - assert_eq!(tv, des); -} - -#[cfg(feature = "borsh")] -#[test] -fn TinyVec_borsh_de_heap() { - let mut tv: TinyVec<[i32; 4]> = tiny_vec![1, 2, 3, 4]; - tv.move_to_the_heap(); - - let buffer = borsh::to_vec(&tv).unwrap(); - let des: TinyVec<[i32; 4]> = borsh::from_slice(&buffer).unwrap(); - assert_eq!(tv, des); -} - -#[test] -fn TinyVec_pretty_debug() { - let tv: TinyVec<[i32; 6]> = tiny_vec![1, 2, 3]; - let s = format!("{:#?}", tv); - let expected = format!("{:#?}", tv.as_slice()); - - assert_eq!(s, expected); -} - -#[cfg(feature = "std")] -#[test] -fn TinyVec_std_io_write() { - use std::io::Write; - let mut tv: TinyVec<[u8; 3]> = TinyVec::new(); - - tv.write_all(b"foo").ok(); - assert!(tv.is_inline()); - assert_eq!(tv, tiny_vec![b'f', b'o', b'o']); - - tv.write_all(b"bar").ok(); - assert!(tv.is_heap()); - assert_eq!(tv, tiny_vec![b'f', b'o', b'o', b'b', b'a', b'r']); -} -- cgit v1.2.3