#[cfg(feature="UDSI")]
#[cfg(test)]
pub mod functionaltest {
use ryley::{structs::vector::Vector, vector};
use ryley::structs::UDSI::Container;
#[test]
fn vector_method_test_new() {
let v: Vector<i32>=Vector::new();
assert!(v.is_empty())
}
#[test]
fn vector_method_distinct_sort() {
let mut v=vector![3,4,3,2,5,9,7,8,4,2,1,3,5,6,3,7,6];
v.distinct_sort(false);
assert_eq!(v,vector![1;1,2,3,4,5,6,7,8,9])
}
#[test]
fn vector_method_distinct_sort_rev() {
let mut v=vector![4,3,5,2,8,9,7,6,5,6,7,8,4,5,3,2,1,2,3,4,6,8,9,7,3,1,2,2,7,3];
v.distinct_sort(true);
assert_eq!(v,vector![-1;9,8,7,6,5,4,3,2,1])
}
#[test]
fn sorted_vector_method_distinct_sort() {
let mut v=vector![1;1,1,1,1,2,2,2,3,4,4,5,6,6,7];
v.distinct_sort(false);
assert_eq!(v,vector![1;1,2,3,4,5,6,7])
}
#[test]
fn sorted_vector_method_distinct_sort_rev() {
let mut v=vector![1;1,1,1,1,2,2,2,3,4,4,5,6,6,7];
v.distinct_sort(true);
assert_eq!(v,vector![-1;7,6,5,4,3,2,1])
}
#[test]
fn rev_sorted_vector_method_distinct_sort() {
let mut v=vector![-1;9,8,8,8,7,6,6,5,4,4,3,3,2,1];
v.distinct_sort(false);
assert_eq!(v,vector![1;1,2,3,4,5,6,7,8,9])
}
#[test]
fn rev_sorted_vector_method_distinct_sort_rev() {
let mut v=vector![-1;9,8,8,8,7,6,6,5,4,4,3,3,2,1];
v.distinct_sort(true);
assert_eq!(v,vector![-1;9,8,7,6,5,4,3,2,1])
}
#[test]
fn vector_method_split() {
let vec = vector![11, 12, 40, 33, 98, 20, 16];
let sp=vec.split(|num| num % 10 == 0);
assert_eq!(sp, vector![vector![11, 12], vector![33, 98], vector![16]]);
let vec = vector![3, 10, 40, 33];
let sp = vec.split(|num| num % 3 == 0);
assert_eq!(sp, vector![vector![], vector![10, 40], vector![]]);
let vec = vector![10, 6, 33, 20];
let sp = vec.split(|num| num % 3 == 0);
assert_eq!(sp, vector![vector![10], vector![], vector![20]]);
}
#[test]
fn vector_method_join() {
assert_eq!(vector![vector![1, 2], vector![3, 4]].join(Some(&vec![0])), vector![1, 2, 0, 3, 4]);
assert_eq!(vector![vector![1, 2], vector![3, 4]].join(None), vector![1, 2, 3, 4]);
}
#[test]
fn vector_method_sum() {
let v = vector![1, 2, 3];
let sum: i32 = v.sum();
assert_eq!(sum, 6);
}
}
#[cfg(feature="UDSI")]
#[cfg(test)]
pub mod listkindtest {
pub mod method_add {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_add_end() {
let mut v = vector!(1,2,3,4,5);
v.add(6,None);
assert_eq!(v,vector![1,2,3,4,5,6]);
}
#[test]
fn vector_method_add_start() {
let mut v = vector!(1,2,3,4,5);
v.add(0,Some(0));
assert_eq!(v,vector![0,1,2,3,4,5]);
}
#[test]
fn vector_method_add_middle() {
let mut v = vector!(1,2,3,4,5);
v.add(0,Some(3));
assert_eq!(v,vector![1,2,3,0,4,5]);
}
#[test]
fn vector_method_add_retain_sorted() {
let mut v = vector!(1;1,2,3,4,5);
v.add(3,Some(3));
assert_eq!(v,vector![1;1,2,3,3,4,5]);
}
#[test]
fn vector_method_add_retain_rev_sorted() {
let mut v = vector!(-1;5,4,3,2,1);
v.add(3,Some(3));
assert_eq!(v,vector![-1;5,4,3,3,2,1]);
}
}
pub mod method_add_slice {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_add_slice() {
let mut v=vector![1,2,3,4,5];
v.add_slice(vec![98,76,12], Some(2));
assert_eq!(v,vector![1,2,98,76,12,3,4,5]);
}
#[test]
fn vector_method_add_slice_edge_cases() {
let mut v=vector![1,2,3,4,5];
v.add_slice(vec![1,2,3], None);
assert_eq!(v,vector![1,2,3,4,5,1,2,3]);
v.add_slice(vec![9,1,2], Some(0));
assert_eq!(v,vector![9,1,2,1,2,3,4,5,1,2,3]);
}
#[test]
fn vector_method_add_slice_retain_sorted() {
let mut v=vector![1;1,2,6,7,8];
v.add_slice(vec![3,4,5], Some(2));
assert_eq!(v,vector![1;1,2,3,4,5,6,7,8]);
}
#[test]
fn vector_method_add_slice_retain_rev_sorted() {
let mut v=vector![-1;9,8,7,6,2,1];
v.add_slice(vec![5,4,3,2], Some(4));
assert_eq!(v,vector![-1;9,8,7,6,5,4,3,2,2,1]);
}
}
pub mod method_sort {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_sort() {
let mut v = vector!(4,2,3,1,5);
v.sort(None);
assert_eq!(v,vector![1;1,2,3,4,5]);
}
#[test]
fn sorted_vector_method_sort() {
let mut v = vector!(1;1,2,3,4,5);
v.sort(None);
assert_eq!(v,vector![1;1,2,3,4,5]);
}
#[test]
fn sorted_vector_method_rev_sort() {
let mut v = vector!(1;1,2,3,4,5);
v.sort(Some(true));
assert_eq!(v,vector![-1;5,4,3,2,1]);
}
#[test]
fn vector_method_rev_sort() {
let mut v = vector!(2,5,1,3,4);
v.sort(Some(true));
assert_eq!(v,vector![-1;5,4,3,2,1]);
}
#[test]
fn rev_sorted_vector_method_sort() {
let mut v = vector!(-1;5,4,3,2,1);
v.sort(None);
assert_eq!(v,vector![1;1,2,3,4,5]);
}
#[test]
fn rev_sorted_vector_method_rev_sort() {
let mut v = vector!(-1;5,4,3,2,1);
v.sort(Some(true));
assert_eq!(v,vector![-1;5,4,3,2,1]);
}
}
pub mod method_sort_by {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_sort_by_cmp() {
let mut v=vector![5,4,1,3,2];
v.sort_by(|a, b| a.cmp(b));
assert_eq!(v,vector![1,2,3,4,5]);
}
#[test]
fn vector_method_sort_by_rev_cmp() {
let mut v=vector![5,4,1,3,2];
v.sort_by(|a, b| b.cmp(a));
assert_eq!(v,vector![5,4,3,2,1]);
}
#[test]
fn vector_method_sort_by_str_len() {
let mut v=vector!["cat","a","raptor","b","be","attack helicopter","mario","bee","turtle"];
v.sort_by(|x, y| x.len().cmp(&y.len()));
assert_eq!(v,vector!["a","b","be","cat","bee","mario","raptor","turtle","attack helicopter"])
}
}
pub mod method_set {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_set() {
let mut v = vector!(1,2,9,4,5);
v.set(2,3);
assert_eq!(v,vector![1,2,3,4,5]);
}
#[test]
fn vector_method_set_retain_sorted() {
let mut v = vector!(1;1,2,3,4,5);
v.set(3,5);
assert_eq!(v,vector![1;1,2,3,5,5]);
}
#[test]
fn vector_method_set_retain_rev_sorted() {
let mut v = vector!(-1;5,4,3,2,1);
v.set(2,4);
assert_eq!(v,vector![-1;5,4,4,2,1]);
}
}
pub mod method_set_range {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_set_range() {
let mut v = vector!(1,2,9,4,5);
v.set_range(1..4,vec![9,4,3]);
assert_eq!(v,vector![1,9,4,3,5]);
}
#[test]
fn vector_method_set_range_retain_sorted() {
let mut v = vector!(1;1,2,3,4,5);
v.set_range(1..4,vec![1,1,2]);
assert_eq!(v,vector![1;1,1,1,2,5]);
}
#[test]
fn vector_method_set_range_retain_rev_sorted() {
let mut v = vector!(-1;5,4,3,2,1);
v.set_range(0..4,vec![4,4,2,2]);
assert_eq!(v,vector![-1;4,4,2,2,1]);
}
}
pub mod method_contains {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_contains() {
let v = vector![10, 40, 30];
assert!(v.contains(&30));
assert!(!v.contains(&50));
}
#[test]
fn sorted_vector_method_contains() {
let v = vector![1;10,20,30];
assert!(v.contains(&10));
assert!(v.contains(&20));
assert!(v.contains(&30));
assert!(!v.contains(&50));
}
#[test]
fn rev_sorted_vector_method_contains() {
let v = vector![-1;90,80,70,60,40,20];
assert!(v.contains(&20));
assert!(v.contains(&90));
assert!(!v.contains(&50));
}
}
pub mod method_contains_fn {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_contains_fn() {
let v = vector![10, 40, 30];
assert!(v.contains_fn(|x| x%2==0));
assert!(v.contains_fn(|x| x+2==42));
}
}
pub mod method_contains_slice {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_contains_slice() {
let v=vector![1,2,3,4,1,2,3,2,3,4,6,2,9,7,3];
assert!(v.contains_slice(&[2,3,2,3]));
assert!(!v.contains_slice(&[1,2,1]));
}
}
pub mod method_find {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_find() {
let v = vector!(1,2,3,4,5);
assert_eq!(v.find(&1,None),vec![0]);
}
#[test]
fn vector_method_find_multiple() {
let v = vector!(1,2,3,1,2,3);
assert_eq!(v.find(&1,Some(-1)),vec![0,3]);
assert!(v.find(&12,None).is_empty());
}
#[test]
fn sorted_vector_method_find() {
let v = vector!(1;1,1,2,3,3,4,5,5);
assert_eq!(v.find(&1,None),vec![0]);
assert_eq!(v.find(&1,Some(-1)),vec![0,1]);
assert_eq!(v.find(&3,None),vec![3]);
assert_eq!(v.find(&3,Some(-1)),vec![3,4]);
assert_eq!(v.find(&5,None),vec![6]);
assert_eq!(v.find(&5,Some(-1)),vec![6,7]);
assert!(v.find(&12,None).is_empty());
}
#[test]
fn rev_sorted_vector_method_find() {
let v = vector!(-1;5,5,4,3,3,2,1,1);
assert_eq!(v.find(&1,None),vec![6]);
assert_eq!(v.find(&1,Some(-1)),vec![6,7]);
assert_eq!(v.find(&3,None),vec![3]);
assert_eq!(v.find(&3,Some(-1)),vec![3,4]);
assert_eq!(v.find(&5,None),vec![0]);
assert_eq!(v.find(&5,Some(-1)),vec![0,1]);
assert!(v.find(&12,None).is_empty());
}
}
pub mod method_find_fn {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_find_fn_even() {
let v = vector!(1,2,3,4,5);
assert_eq!(v.find_fn(|x| x%2==0,None),vec![1]); }
#[test]
fn vector_method_find_fn() {
let v = vector!(1,2,3,1,2,3);
assert_eq!(v.find_fn(|x| x%3==0,Some(-1)), vec![2,5]);
assert!(v.find_fn(|&x| (x+1)==x,None).is_empty());
}
}
pub mod method_find_slice {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_find_slice() {
let v=vector![1,2,1,2,3,2,3,4,5,3,1,2,3,4,2,3,4,2,1,2,3];
assert_eq!(v.find_slice(&[1,2,3], Some(-1)), vec![2,10,18]);
assert!(v.find_slice(&[1,2,2], None).is_empty());
}
#[test]
fn vector_method_find_slice_overlap() {
let v=vector![1,1,1,1,1,1,1,1,1,1];
assert_eq!(v.find_slice(&[1,1], Some(5)),vec![0,1,2,3,4]);
assert_eq!(v.find_slice(&[1,1], Some(-1)),vec![0,1,2,3,4,5,6,7,8]);
}
}
pub mod method_count {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_count() {
let v = vector!(1,2,3,4,5);
assert_eq!(v.count(&1),1);
}
#[test]
fn vector_method_count_multiple() {
let v = vector!(1,1,1,1,1);
assert_eq!(v.count(&1),5);
}
#[test]
fn sorted_vector_method_count() {
let v = vector!(1;1,1,2,2,3,3,3,4,4,4,4,5,5,5);
assert_eq!(v.count(&1),2);
assert_eq!(v.count(&2),2);
assert_eq!(v.count(&3),3);
assert_eq!(v.count(&4),4);
assert_eq!(v.count(&5),3);
assert_eq!(v.count(&6),0);
}
#[test]
fn rev_sorted_vector_method_count() {
let v = vector!(-1;5,5,5,4,4,3,2,2,2,2,2,1,1,0);
assert_eq!(v.count(&5),3);
assert_eq!(v.count(&4),2);
assert_eq!(v.count(&3),1);
assert_eq!(v.count(&2),5);
assert_eq!(v.count(&1),2);
assert_eq!(v.count(&0),1);
assert_eq!(v.count(&73),0);
}
}
pub mod method_count_fn {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_count_fn_even() {
let v = vector!(1,2,3,4,5);
assert_eq!(v.count_fn(|x| x%2==0),2);
}
#[test]
fn vector_method_count_fn() {
let v = vector!(1,2,3,1,2,3);
assert_eq!(v.count_fn(|x| x%3==0),2);
assert_eq!(v.count_fn(|x| &(x+1)==x),0);
}
}
pub mod method_count_slice {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_count_slice() {
let v=vector![1,2,1,2,3,2,3,4,5,3,1,2,3,4,2,3,4,2,1,2,3];
assert_eq!(v.count_slice(&[1,2,3]),3);
assert_eq!(v.count_slice(&[1,2,2]),0);
}
#[test]
fn vector_method_count_slice_overlap() {
let v=vector![1,1,1,1,1,1,1,1,1,1];
assert_eq!(v.count_slice(&[1,1]),9);
assert_eq!(v.count_slice(&[1,1,1]),8);
}
}
pub mod method_rotate {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_rotate_left() {
let mut v = vector!['a', 'b', 'c', 'd', 'e', 'f'];
v.rotate(2);
assert_eq!(v, vector!['c', 'd', 'e', 'f', 'a', 'b']);
}
#[test]
fn vector_method_rotate_right() {
let mut v = vector!['a', 'b', 'c', 'd', 'e', 'f'];
v.rotate(-2);
assert_eq!(v, vector!['e', 'f', 'a', 'b', 'c', 'd']);
}
#[test]
fn vector_method_rotate_right_retain_sorted() {
let mut v=vector![1;1,1,1,1];
v.rotate(-2);
assert_eq!(v,vector![1;1,1,1,1]);
let mut v=vector![1;1,1,2,3];
v.rotate(-4);
assert_eq!(v,vector![1;1,1,2,3]);
let mut v=vector![1;1,1,2,3,4];
v.rotate(-25);
assert_eq!(v,vector![1;1,1,2,3,4]);
}
#[test]
fn vector_method_rotate_right_retain_rev_sorted() {
let mut v=vector![-1;1,1,1,1];
v.rotate(-2);
assert_eq!(v,vector![-1;1,1,1,1]);
let mut v=vector![-1;3,2,1,1];
v.rotate(-4);
assert_eq!(v,vector![-1;3,2,1,1]);
let mut v=vector![-1;4,3,2,1,1];
v.rotate(-25);
assert_eq!(v,vector![-1;4,3,2,1,1]);
}
#[test]
fn vector_method_rotate_left_retain_sorted() {
let mut v=vector![1;1,1,1,1];
v.rotate(2);
assert_eq!(v,vector![1;1,1,1,1]);
let mut v=vector![1;1,1,2,3];
v.rotate(4);
assert_eq!(v,vector![1;1,1,2,3]);
let mut v=vector![1;1,1,2,3,4];
v.rotate(25);
assert_eq!(v,vector![1;1,1,2,3,4]);
}
#[test]
fn vector_method_rotate_left_retain_rev_sorted() {
let mut v=vector![-1;1,1,1,1];
v.rotate(2);
assert_eq!(v,vector![-1;1,1,1,1]);
let mut v=vector![-1;3,2,1,1];
v.rotate(4);
assert_eq!(v,vector![-1;3,2,1,1]);
let mut v=vector![-1;4,3,2,1,1];
v.rotate(25);
assert_eq!(v,vector![-1;4,3,2,1,1]);
}
}
pub mod method_replace {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_replace() {
let mut v = vector!(1,2,3,4,5);
v.replace(&4,Some(&6),None);
assert_eq!(v,vector![1,2,3,6,5]);
let mut v = vector!(1,2,3,4,5);
v.replace(&1,None,None);
assert_eq!(v,vector![2,3,4,5]);
let mut v = vector!(1,2,3,4,5);
v.replace(&4,Some(&6),None);
assert_eq!(v,vector![1,2,3,6,5]);
}
#[test]
fn vector_method_replace_maxcount() {
let mut v = vector!(1,1,1,1,2,3,4,5,1,1);
v.replace(&1,Some(&6),None);
assert_eq!(v,vector![6,6,6,6,2,3,4,5,6,6]);
v.replace(&6,Some(&1),Some(2));
assert_eq!(v,vector![1,1,6,6,2,3,4,5,6,6]);
v.replace(&6,Some(&1),Some(0));
assert_eq!(v,vector![1,1,6,6,2,3,4,5,6,6]);
v.replace(&6,Some(&1),Some(3));
assert_eq!(v,vector![1,1,1,1,2,3,4,5,1,6]);
}
#[test]
fn vector_method_replace_retain_sorted() {
let mut v = vector!(1;1,2,3,4,5);
v.replace(&2,Some(&3),None);
assert_eq!(v,vector![1;1,3,3,4,5]);
v.replace(&1,Some(&3),None);
assert_eq!(v,vector![1;3,3,3,4,5]);
v.replace(&5,Some(&4),None);
assert_eq!(v,vector![1;3,3,3,4,4]);
}
#[test]
fn vector_method_replace_retain_rev_sorted() {
let mut v = vector!(-1;5,4,3,2,1);
v.replace(&2,Some(&3),None);
assert_eq!(v,vector![-1;5,4,3,3,1]);
v.replace(&5,Some(&4),None);
assert_eq!(v,vector![-1;4,4,3,3,1]);
v.replace(&1,Some(&3),None);
assert_eq!(v,vector![-1;4,4,3,3,3]);
}
#[test]
fn vector_method_replace_remove() {
let mut v = vector!(1,2,3,4,5);
v.replace(&1,None,None);
assert_eq!(v,vector![2,3,4,5]);
}
#[test]
fn sorted_vector_method_replace() {
let mut v=vector![1;1,1,2,3,4,5];
v.replace(&1, Some(&7), None);
v.sort(None);
assert_eq!(v,vector![1;2,3,4,5,7,7]);
v.replace(&3, Some(&2), None).replace(&2, Some(&7), Some(1));
assert_eq!(v,vector![7,2,4,5,7,7]);
}
#[test]
fn sorted_vector_method_replace_remove() {
let mut v=vector![1;1,1,2,3,4,5];
v.replace(&1, None, Some(1));
assert_eq!(v,vector![1;1,2,3,4,5]);
v.replace(&1, None, None).replace(&5, None, None);
assert_eq!(v,vector![1;2,3,4]);
v.replace(&3, None, None);
assert_eq!(v,vector![1;2,4]);
v.replace(&2, Some(&4), None).replace(&4, None, None);
assert!(v.is_empty());
}
#[test]
fn rev_sorted_vector_method_replace() {
let mut v=vector![-1;5,5,5,4,3,2,2,1,1];
v.replace(&5, Some(&4), None);
assert_eq!(v,vector![-1;4,4,4,4,3,2,2,1,1]);
v.replace(&1, Some(&2), None).replace(&4, Some(&3), None);
assert_eq!(v,vector![-1;3,3,3,3,3,2,2,2,2]);
}
#[test]
fn rev_sorted_vector_method_replace_remove() {
let mut v=vector![-1;5,5,5,5,4,3,2,2,1,1,1];
v.replace(&1, None, None);
assert_eq!(v,vector![-1;5,5,5,5,4,3,2,2]);
v.replace(&5, None, None).replace(&2, None, Some(1));
assert_eq!(v,vector![-1;4,3,2]);
v.replace(&3, None, None);
assert_eq!(v,vector![-1;4,2]);
v.replace(&2, Some(&4), None).replace(&4, None, None);
assert!(v.is_empty());
}
}
pub mod method_replace_fn {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_replace_fn() {
let mut v = vector!(1,2,3,4,5);
v.replace_fn(|&x| x>=4,Some(&6),None);
assert_eq!(v,vector![1,2,3,6,6]);
let mut v = vector!(1,2,3,4,5);
v.replace_fn(|x| x%2==0,None,None);
assert_eq!(v,vector![1,3,5]);
let mut v=vector![1,2,3,4,5];
v.replace_fn(|&x| x>3, Some(&4), None);
assert_eq!(v,vector![1,2,3,4,4])
}
#[test]
fn vector_method_replace_fn_retain_sorted() {
let mut v=vector![1;1,2,3,4,5];
v.replace_fn(|&x| x>=2, Some(&87), None);
assert_eq!(v,vector![1;1,87,87,87,87])
}
#[test]
fn vector_method_replace_fn_retain_rev_sorted() {
let mut v=vector![-1;5,4,3,2,1];
v.replace_fn(|&x| x<3, Some(&0), None);
assert_eq!(v,vector![-1;5,4,3,0,0])
}
#[test]
fn vector_method_replace_fn_even() {
let mut v=vector![1,2,3,4,5,6,7];
v.replace_fn(|&x| x%2==0, Some(&11), Some(2));
assert_eq!(v,vector![1,11,3,11,5,6,7]);
}
#[test]
fn vector_method_replace_fn_remove() {
let mut v=vector![1,2,3,4,5];
v.replace_fn(|&x| x>=3, None, Some(2));
assert_eq!(v,vector![1,2,5])
}
#[test]
fn vector_method_replace_fn_odd_remove() {
let mut v=vector![1,2,3,4,5,6,7];
v.replace_fn(|&x| x%2==1, None, None);
assert_eq!(v,vector![2,4,6]);
}
}
pub mod method_replace_slice {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_replace_slice() {
let mut v=vector![1,2,3,1,2,3,2,3,4,1,2,4,2,3,1,2,3,2,3,1,2,3];
v.replace_slice(&[1,2,3], Some(&[4,5,6]), None);
assert_eq!(v,vector![4,5,6,4,5,6,2,3,4,1,2,4,2,3,4,5,6,2,3,4,5,6])
}
#[test]
fn vector_method_replace_slice_overlap() {
let mut v=vector![1,1,1,1,1,2,1,2,1,1,1,1,2,1,2,1,1,1,1];
v.replace_slice(&[1,1], Some(&[9,8,7,6]), None);
assert_eq!(v,vector![9,8,7,6,9,8,7,6,9,8,7,6,9,8,7,6,2,1,2,9,8,7,6,9,8,7,6,9,8,7,6,2,1,2,9,8,7,6,9,8,7,6,9,8,7,6])
}
#[test]
fn vector_method_replace_slice_maxcount() {
let mut v=vector![1,1,1,1,1,2,1,2,1,1,1,1,2,1,2,1,1,1,1];
v.replace_slice(&[1,1], Some(&[9,8,7,6]), Some(3));
assert_eq!(v,vector![9,8,7,6,9,8,7,6,9,8,7,6,1,2,1,2,1,1,1,1,2,1,2,1,1,1,1])
}
#[test]
fn vector_method_replace_slice_remove() {
let mut v=vector![1,2,3,1,2,3,2,3,4,1,2,4,2,3,1,2,3,2,3,1,2,3];
v.replace_slice(&[1,2,3], None, None);
assert_eq!(v,vector![2,3,4,1,2,4,2,3,2,3])
}
#[test]
fn vector_method_replace_slice_remove_overlap() {
let mut v=vector![1,1,1,1,1,2,1,2,1,1,1,1,2,1,2,1,1,1,1];
v.replace_slice(&[1,1], None, None);
assert_eq!(v,vector![2,1,2,2,1,2])
}
#[test]
fn vector_method_replace_slice_remove_maxcount() {
let mut v=vector![1,1,1,1,1,2,1,2,1,1,1,1,2,1,2,1,1,1,1];
v.replace_slice(&[1,1], None, Some(2));
assert_eq!(v,vector![1,1,2,1,2,1,1,1,1,2,1,2,1,1,1,1])
}
#[test]
fn vector_method_replace_slice_retain_sorted() {
let mut v=vector![1;1,2,3,4,5,6,7,7,7];
v.replace_slice(&[7,7], Some(&[8]), None);
assert_eq!(v,vector![1;1,2,3,4,5,6,8,8]);
}
#[test]
fn vector_method_replace_slice_first_replace() {
let mut v=vector![1,1,3,4,5,6,7];
v.replace_slice(&[1,1], Some(&[8]), None);
assert_eq!(v,vector![8,3,4,5,6,7]);
}
#[test]
fn vector_method_replace_slice_retain_rev_sorted() {
let mut v=vector![-1;7,6,6,5,5,5,5,4,3,2,1];
v.replace_slice(&[5,5], Some(&[6,6,6]), Some(2));
assert_eq!(v,vector![-1;7,6,6,6,6,6,6,6,6,5,4,3,2,1]);
}
}
pub mod method_distinct {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_distinct() {
let mut vec = vector![1, 2, 2, 3, 2];
vec.distinct();
assert_eq!(vec, vector![1, 2, 3]);
let mut v=vector![1,2,3,3,4,4,4,5,3,5,3,2,4,5,2,1,2,2];
v.distinct();
assert_eq!(v,vector![1,2,3,4,5])
}
#[test]
fn sorted_vector_method_distinct() {
let mut v=vector![1;1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,3,4,4,4,5,5,5,5,5,5];
v.distinct();
assert_eq!(v,vector![1;1,2,3,4,5])
}
#[test]
fn rev_sorted_vector_method_distinct() {
let mut v=vector![-1;5,5,5,5,4,4,4,4,3,3,3,3,3,2,2,2,2,1,1,1,1,1,1];
v.distinct();
assert_eq!(v,vector![-1;5,4,3,2,1])
}
}
pub mod method_distinct_fn {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_distinct_fn() {
let mut v=vector![1,2,3,4,5];
v.distinct_fn(|x| x/2);
assert_eq!(v,vector![1,2,4]);
}
#[test]
fn vector_method_distinct_fn_even() {
let mut v=vector![1,2,3,4,5,6,7,8,9,10];
v.distinct_fn(|x| x%2);
assert_eq!(v,vector![1,2]);
}
}
pub mod method_clear {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_clear() {
let mut v = vector![1, 2, 3];
v.clear();
assert!(v.is_empty());
let mut v=vector![1,2,3,4,5];
v.clear();
assert!(v.is_empty());
let mut v=vector![1;1,2,3,4,5];
v.clear();
assert_eq!(v,vector![0;]);
let mut v=vector![-1;5,4,3,2,1];
v.clear();
assert_eq!(v,vector![0;]);
}
}
pub mod method_reverse {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_reverse() {
let mut v = vector![1, 2, 3];
v.reverse();
assert_eq!(v, vector![3, 2, 1]);
let mut v=vector![1,2,3,6,5,4];
v.reverse();
assert_eq!(v,vector![4,5,6,3,2,1]);
}
#[test]
fn sorted_vector_method_reverse() {
let mut v=vector![1;1,2,3,4,5];
v.reverse();
assert_eq!(v,vector![-1;5,4,3,2,1]);
}
#[test]
fn rev_sorted_vector_method_reverse() {
let mut v=vector![-1;5,4,3,2,1];
v.reverse();
assert_eq!(v,vector![1;1,2,3,4,5]);
}
}
pub mod method_remove {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_remove() {
let mut v = vector![1, 2, 3];
v.remove(Some(1));
assert_eq!(v, vector![1, 3]);
let mut v=vector![1,2,3,4,5,6,7];
v.remove(Some(3));
assert_eq!(v,vector![1,2,3,5,6,7]);
v.remove(None);
assert_eq!(v,vector![1,2,3,5,6])
}
#[test]
fn vector_method_remove_last() {
let mut v=vector![1,2,3,4,5];
v.remove(None);
assert_eq!(v,vector![1,2,3,4]);
v.remove(Some(-1));
assert_eq!(v,vector![1,2,3])
}
#[test]
fn vector_method_remove_all() {
let mut v=vector![1,2,3,4,5];
v.remove(None).remove(None).remove(Some(-2)).remove(Some(1)).remove(Some(0));
assert!(v.is_empty())
}
}
pub mod method_remove_slice {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_remove_slice() {
let mut v = vector![1, 2, 3, 4, 5];
v.remove_slice(1, Some(4));
assert_eq!(v, vector![1, 5]);
let mut v=vector![1,2,3,4,5,6,7];
v.remove_slice(2, Some(5));
assert_eq!(v,vector![1,2,6,7]);
v.remove_slice(2, None);
assert_eq!(v,vector![1,2])
}
#[test]
fn vector_method_remove_slice_end() {
let mut v=vector![1,2,3,4,5,6,7];
v.remove_slice(3, None);
assert_eq!(v,vector![1,2,3])
}
#[test]
fn vector_method_remove_slice_complete() {
let mut v=vector![1,2,3,4,5,6,7];
v.remove_slice(0, None);
assert!(v.is_empty())
}
}
pub mod method_pop {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_pop() {
let mut v = vector![1, 2, 3, 4, 5];
assert_eq!(v.pop_slice(1, Some(4)), vec![2, 3, 4]);
assert_eq!(v, vector![1, 5]);
let mut v=vector![1,2,3,4,5,6,7];
assert_eq!(v.pop(Some(3)),4);
assert_eq!(v,vector![1,2,3,5,6,7])
}
#[test]
fn vector_method_pop_last() {
let mut v=vector![1,2,3,4,5];
assert_eq!(v.pop(None),5);
assert_eq!(v,vector![1,2,3,4])
}
#[test]
fn vector_method_pop_all() {
let mut v=vector![1,2,3,4,5];
assert_eq!(v.pop(None),5);
assert_eq!(v.pop(Some(-1)),4);
assert_eq!(v.pop(Some(-2)),2);
assert_eq!(v.pop(Some(1)),3);
assert_eq!(v.pop(Some(0)),1);
assert!(v.is_empty())
}
}
pub mod method_pop_slice {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_pop_slice() {
let mut v = vector![1, 2, 3, 4, 5];
assert_eq!(v.pop_slice(1, Some(4)),vec![2,3,4]);
assert_eq!(v, vector![1, 5]);
let mut v=vector![1,2,3,4,5,6,7];
assert_eq!(v.pop_slice(2, Some(5)),vec![3,4,5]);
assert_eq!(v,vector![1,2,6,7])
}
#[test]
fn vector_method_pop_slice_end() {
let mut v=vector![1,2,3,4,5,6,7];
assert_eq!(v.pop_slice(3, None),vec![4,5,6,7]);
assert_eq!(v,vector![1,2,3])
}
#[test]
fn vector_method_pop_slice_complete() {
let mut v=vector![1,2,3,4,5,6,7];
assert_eq!(v.pop_slice(0, None),vec![1,2,3,4,5,6,7]);
assert!(v.is_empty())
}
}
pub mod method_max {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_max() {
let v = vector!(1,2,3,4,5);
assert_eq!(v.maxi(),(&5,4));
let v = vector!(1,8,2,5,9,3,3,4,5,7);
assert_eq!(v.maxi(),(&9,4));
}
#[test]
fn vector_method_max_first() {
let v=vector![1,2,1,2,4,5,3,2,8,5,6,4,5,9,3,4,2,3,6,7,8,9,9,5,9,3,5];
assert_eq!(v.maxi(),(&9,13))
}
#[test]
fn sorted_vector_method_max() {
let v = vector!(1;1,2,3,4,5);
assert_eq!(v.maxi(),(&5,4));
}
#[test]
fn sorted_vector_method_max_first() {
let v = vector!(1;1,1,1,1,2,3,3,3,4,4,5,5,5,5);
assert_eq!(v.maxi(),(&5,10));
}
#[test]
fn rev_sorted_vector_method_max() {
let v = vector!(-1;5,4,3,2,1);
assert_eq!(v.maxi(),(&5,0));
}
#[test]
fn rev_sorted_vector_method_max_first() {
let v = vector!(-1;5,5,5,5,5,5,5,5,4,4,4,4,3,3,3,3,2,2,1,1,1,1);
assert_eq!(v.maxi(),(&5,0));
}
}
pub mod method_min {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_min() {
let v = vector!(1,2,3,4,5);
assert_eq!(v.mini(),(&1,0));
let v=vector![1,2,3,4,2,4,6,7,1,0,1,4,7,3,6,5,3,4];
assert_eq!(v.mini(),(&0,9))
}
#[test]
fn vector_method_min_first() {
let v=vector![2,3,1,3,0,2,4,5,2,1,0,0,0,22,5,4,2,46,6,4,1,0,0,7,2];
assert_eq!(v.mini(),(&0,4))
}
#[test]
fn sorted_vector_method_min() {
let v = vector!(1;1,2,3,4,5);
assert_eq!(v.mini(),(&1,0));
}
#[test]
fn sorted_vector_method_min_first() {
let v = vector!(1;1,1,1,1,1,2,2,2,2,2,3,3,3,3,4,4,4,5,5,5,5,5,5,5);
assert_eq!(v.mini(),(&1,0));
}
#[test]
fn rev_sorted_vector_method_min() {
let v = vector!(-1;5,4,3,2,1);
assert_eq!(v.mini(),(&1,4));
}
#[test]
fn rev_sorted_vector_method_min_first() {
let v = vector!(-1;5,5,5,5,5,4,4,4,4,3,3,3,3,2,2,2,1,1,1,1,1,1,1);
assert_eq!(v.mini(),(&1,16));
}
}
pub mod method_union {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_union() {
let mut v = vector![1, 2 ,3];
v.union(vector![4, 5, 6]);
assert_eq!(v,vector![1, 2, 3, 4, 5, 6]);
let mut v = vector![1, 2 ,3];
v.union(vector![]);
assert_eq!(v,vector![1, 2, 3]);
}
#[test]
fn sorted_vector_method_union() {
let mut v=vector![1;1,2,3,4,5];
v.union(vector![1;6,6,7,8,9]);
assert_eq!(v, vector![1;1,2,3,4,5,6,6,7,8,9]);
let mut v=vector![1;1,2,3,4,5];
v.union(vector![6,6,7,8,9]);
assert_eq!(v, vector![1,2,3,4,5,6,6,7,8,9]);
let mut v=vector![1;1,2,3,4,5];
v.union(vector![1;3,4,5,6]);
assert_eq!(v, vector![1,2,3,4,5,3,4,5,6]);
}
#[test]
fn rev_sorted_vector_method_union() {
let mut v=vector![-1;5,4,3,2];
v.union(vector![-1;2,2,1,1]);
assert_eq!(v,vector![-1;5,4,3,2,2,2,1,1]);
let mut v=vector![-1;5,4,3,2];
v.union(vector![2,2,1,1]);
assert_eq!(v,vector![5,4,3,2,2,2,1,1]);
}
}
pub mod method_difference {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_difference() {
let mut v = vector![1, 2, 3, 3];
v.difference(&vector![2, 3, 4, 5]);
assert_eq!(v,vector![1, 3]);
let mut v = vector![1, 2, 3];
v.difference(&vector![]);
assert_eq!(v,vector![1, 2, 3]);
}
#[test]
fn vector_method_difference_remove_all() {
let mut v = vector![1, 2 ,3];
v.difference(&vector![1,2,3,2,1,3,5,6]);
assert!(v.is_empty());
}
#[test]
fn vector_method_difference_remove_none() {
let mut v = vector![1, 2 ,3];
v.difference(&vector![4,5,6,4]);
assert_eq!(v,vector![1,2,3]);
}
}
pub mod method_intersect {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_intersect() {
let mut v = vector![1,2,3];
v.intersect(&vector![2, 3, 4]);
assert_eq!(v,vector![2, 3]);
let mut v = vector![1,2,3];
v.intersect(&vector![]);
assert!(v.is_empty());
}
#[test]
fn vector_method_intersect_all() {
let mut v = vector![1,2,3,4,5];
v.intersect(&vector![1,2,3,4,5]);
assert_eq!(v,vector![1,2,3,4,5]);
}
#[test]
fn vector_method_intersect_none() {
let mut v = vector![1,2,3,4,5];
v.intersect(&vector![6,7,8,9,10]);
assert!(v.is_empty());
}
}
pub mod method_sym_diff {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_sym_diff() {
let mut v = vector![1, 2, 3];
v.sym_diff(vector![2, 3, 4]);
assert_eq!(v,vector![1, 4]);
let mut v = vector![1, 1, 1, 1, 2, 3];
v.sym_diff(vector![1, 2, 3, 4]);
assert_eq!(v,vector![1, 1, 1, 4]);
let mut v = vector![1, 2, 3];
v.sym_diff(vector![]);
assert_eq!(v,vector![1, 2, 3]);
}
#[test]
fn vector_method_sym_diff_all() {
let mut v = vector![1, 2, 3];
v.sym_diff(vector![4,5,6]);
assert_eq!(v,vector![1,2,3,4,5,6]);
}
#[test]
fn vector_method_sym_diff_none() {
let mut v = vector![1, 2, 3,4,5];
v.sym_diff(vector![5,4,3,2,1]);
assert!(v.is_empty());
}
#[test]
fn sorted_vector_method_sym_diff() {
let mut v = vector![1;1,2,3,4,5];
v.sym_diff(vector![1;5,6,7]);
assert_eq!(v,vector![1;1,2,3,4,6,7]);
let mut v = vector![1;1,2,3,4,5];
v.sym_diff(vector![5,6,7]);
assert_eq!(v,vector![1,2,3,4,6,7]);
let mut v = vector![1;1,2,3,4,5];
v.sym_diff(vector![1;1,3,3,4,5]);
assert_eq!(v,vector![1;2,3]);
}
#[test]
fn rev_sorted_vector_method_sym_diff() {
let mut v = vector![-1;7,6,5,4];
v.sym_diff(vector![-1;5,4,3,2,1]);
assert_eq!(v,vector![-1;7,6,3,2,1]);
let mut v = vector![-1;7,6,5,4];
v.sym_diff(vector![5,4,3,2,1]);
assert_eq!(v,vector![7,6,3,2,1]);
let mut v = vector![-1;7,6,6,5,4];
v.sym_diff(vector![-1;7,6,5,4,3]);
assert_eq!(v,vector![-1;6,3]);
}
}
pub mod method_merge {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn sorted_vector_method_merge() {
let mut v = vector![1; 1, 2, 3];
v.merge(vector![1; 2, 4, 6]);
assert_eq!(v,vector![1; 1, 2, 2, 3, 4, 6]);
let mut v = vector![1; 1, 2, 3, 4];
v.merge(vector![1; 2, 4, 6, 8]);
assert_eq!(v,vector![1; 1, 2, 2, 3, 4, 4, 6, 8]);
let mut v = vector![1; 1, 2, 3, 4];
v.merge(vector![-1; 5,4,3]);
assert_eq!(v,vector![1; 1, 2, 3, 3, 4, 4, 5]);
}
#[test]
fn rev_sorted_vector_method_merge() {
let mut v = vector![-1; 3,2,1];
v.merge(vector![-1; 6,4,2]);
assert_eq!(v,vector![-1; 6,4,3,2,2,1]);
let mut v = vector![-1; 3,2,1];
v.merge(vector![1; 3,4,5,6,7]);
assert_eq!(v,vector![-1; 7,6,5,4,3,3,2,1]);
}
}
pub mod method_repeat {
use ryley::vector;
use ryley::structs::UDSI::Linear;
#[test]
fn vector_method_repeat() {
let mut v = vector![1, 2];
v.repeat(3);
assert_eq!(v, vector![1, 2, 1, 2, 1, 2]);
}
#[test]
fn vector_method_repeat_a_lot() {
let mut v = vector![1, 2];
v.repeat(27364);
assert_eq!(v.len(),27364*2);
}
#[test]
fn sorted_vector_method_repeat() {
let mut v = vector![1;1,1];
v.repeat(3);
assert_eq!(v, vector![1;1,1,1,1,1,1]);
let mut v = vector![1;1,2];
v.repeat(3);
assert_eq!(v, vector![1,2,1,2,1,2]);
}
#[test]
fn rev_sorted_vector_method_repeat() {
let mut v = vector![-1;1,1];
v.repeat(3);
assert_eq!(v, vector![-1;1,1,1,1,1,1]);
let mut v = vector![-1;2,1];
v.repeat(3);
assert_eq!(v, vector![2,1,2,1,2,1]);
}
}
}
#[cfg(feature="UDSI")]
#[cfg(test)]
pub mod macrotest {
use ryley::{structs::vector::Vector, vector};
#[test]
fn macro_rules_vector_vec_x() {
let v=vector![cont: vec![1,2,3,4,5]];
let v_eq=Vector { cont: (vec![1,2,3,4,5]), sorted: (0) };
assert_eq!(v,v_eq)
}
#[test]
fn macro_rules_vector_vec_y_x() {
let v=vector![1; cont: vec![1,2,3,4,5]];
let v_eq=Vector { cont: (vec![1,2,3,4,5]), sorted: (1) };
assert_eq!(v,v_eq);
let v=vector![-1; cont: vec![5,4,3,2,1]];
let v_eq=Vector { cont: (vec![5,4,3,2,1]), sorted: (-1) };
assert_eq!(v,v_eq)
}
#[test]
fn macro_rules_vector_xexpr() {
let v=vector![1,2,3,4,5];
let v_eq=Vector { cont: (vec![1,2,3,4,5]), sorted: (0) };
assert_eq!(v,v_eq)
}
#[test]
fn macro_rules_vector_y_xexpr() {
let v=vector![1;1,2,3,4,5];
let v_eq=Vector { cont: (vec![1,2,3,4,5]), sorted: (1) };
assert_eq!(v,v_eq);
let v=vector![-1;5,4,3,2,1];
let v_eq=Vector { cont: (vec![5,4,3,2,1]), sorted: (-1) };
assert_eq!(v,v_eq);
}
#[test]
fn macro_rules_vector_x_len() {
let v=vector![;0;5];
let v_eq=Vector { cont: (vec![0;5]), sorted: (0) };
assert_eq!(v,v_eq)
}
#[test]
fn macro_rules_vector_y_x_len() {
let v=vector![1;0;5];
let v_eq=Vector { cont: (vec![0;5]), sorted: (1) };
assert_eq!(v,v_eq);
let v=vector![-1;0;5];
let v_eq=Vector { cont: (vec![0;5]), sorted: (-1) };
assert_eq!(v,v_eq)
}
}
#[cfg(feature="UDSI")]
#[cfg(test)]
pub mod panictest {
use ryley::structs::vector::Vector;
use ryley::structs::UDSI::Linear;
use ryley::vector;
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_add_overindex() {
let mut v=vector![1,2,3];
v.add(4,Some(4));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_add_overindex_neg() {
let mut v=vector![1,2,3];
v.add(4,Some(-5));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_add_slice_overindex() {
let mut v=vector![36,3,4,64,2,4];
v.add_slice(vec![4,3,1], Some(7));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_add_slice_overindex_neg() {
let mut v=vector![36,3,4,64,2,4];
v.add_slice(vec![4,3,1], Some(-8));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_set_overindex() {
let mut v=vector![1;1,2,3,4,5,7];
v.set(6, 8);
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_set_overindex_neg() {
let mut v=vector![1;1,2,3,4,5,7];
v.set(-7, 8);
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_set_range_overindex() {
let mut v=vector![9,8,7,6,5,4];
v.set_range(1..7, vec![1,2,3,4,5,6]);
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_set_range_overindex_neg() {
let mut v=vector![9,8,7,6,5,4];
v.set_range((-7..-2).rev(), vec![1,2,3,4,5]);
}
#[test]
#[should_panic(expected="Not enough items!")]
fn vector_method_set_range_not_enough_elems() {
let mut v=vector![9,8,7,6,5,4];
v.set_range(1..6, vec![1,2]);
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_remove_overindex() {
let mut v=vector![1,3,4,5];
v.remove(Some(12));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_remove_overindex_neg() {
let mut v=vector![1,3,4,5];
v.remove(Some(-5));
}
#[test]
#[should_panic(expected="Tried to remove element from empty")]
fn vector_method_remove_from_empty() {
let mut v: Vector<i32>=Vector::new();
v.remove(Some(2));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_remove_slice_overindex() {
let mut v=vector![1,2,3,4,5];
v.remove_slice(4, Some(7));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_remove_slice_overindex_neg() {
let mut v=vector![1,2,3,4,5];
v.remove_slice(-3, Some(-8));
}
#[test]
#[should_panic(expected="Tried to remove element from empty")]
fn vector_method_remove_slice_from_empty() {
let mut v: Vector<i32>=Vector::new();
v.remove_slice(1, Some(4));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_pop_overindex() {
let mut v=vector![1,3,4,5];
v.pop(Some(12));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_pop_overindex_neg() {
let mut v=vector![1,3,4,5];
v.pop(Some(-5));
}
#[test]
#[should_panic(expected="Tried to pop element from empty")]
fn vector_method_pop_from_empty() {
let mut v: Vector<i32>=Vector::new();
v.pop(Some(2));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_pop_slice_overindex() {
let mut v=vector![1,2,3,4,5];
v.pop_slice(4, Some(7));
}
#[test]
#[should_panic(expected="Index is out of bounds!")]
fn vector_method_pop_slice_overindex_neg() {
let mut v=vector![1,2,3,4,5];
v.pop_slice(-3, Some(-8));
}
#[test]
#[should_panic(expected="Tried to pop element from empty")]
fn vector_method_pop_slice_from_empty() {
let mut v: Vector<i32>=Vector::new();
v.pop_slice(1, Some(3));
}
#[test]
#[should_panic(expected="Can't find extremum in empty")]
fn vector_method_maxi_empty() {
let v: Vector<i32>=Vector::new();
v.maxi();
}
#[test]
#[should_panic(expected="Can't find extremum in empty")]
fn vector_method_mini_empty() {
let v: Vector<i32>=Vector::new();
v.mini();
}
#[test]
#[should_panic(expected="Tried to merge unsorted")]
fn vector_method_merge_unsorted() {
let mut v=vector![1;1,2,3,4,5];
v.merge(vector![4,2,4]);
}
#[test]
#[should_panic(expected="called `Option::unwrap()`")]
fn vector_method_repeat_a_lot() {
let mut v = vector!['c', 'h', 'a', 'r'];
v.repeat(usize::MAX);
}
}