#![allow(clippy::float_cmp)]
use pickledb::{PickleDb, PickleDbDumpPolicy, SerializationMethod};
use serde::{Deserialize, Serialize};
mod common;
#[cfg(test)]
extern crate rstest;
use rstest::rstest_parametrize;
#[allow(clippy::cognitive_complexity)]
#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]
fn basic_lists(ser_method_int: i32) {
test_setup!("basic_lists", ser_method_int, db_name);
let mut db = PickleDb::new(
&db_name,
PickleDbDumpPolicy::AutoDump,
ser_method!(ser_method_int),
);
db.lcreate("list1").unwrap();
let num = 100;
assert!(db.ladd("list1", &num).is_some());
let float_num = 1.224;
assert!(db.ladd("list1", &float_num).is_some());
let mystr = String::from("my string");
assert!(db.ladd("list1", &mystr).is_some());
let myvec = vec![1, 2, 3];
assert!(db.ladd("list1", &myvec).is_some());
#[derive(Serialize, Deserialize, Debug)]
struct Coor {
x: i32,
y: i32,
}
let mycoor = Coor { x: 1, y: 2 };
assert!(db.ladd("list1", &mycoor).is_some());
db.lcreate("list2").unwrap();
let num2 = 200;
assert!(db.ladd("list2", &num2).is_some());
let mystr2 = String::from("hello world");
assert!(db.ladd("list2", &mystr2).is_some());
assert_eq!(db.lget::<i32>("list1", 0).unwrap(), num);
assert_eq!(db.lget::<Vec<i32>>("list1", 3).unwrap(), myvec);
assert_eq!(db.lget::<String>("list2", 1).unwrap(), mystr2);
assert_eq!(db.lget::<f32>("list1", 1).unwrap(), float_num);
assert_eq!(db.lget::<String>("list1", 2).unwrap(), mystr);
assert_eq!(db.lget::<i32>("list2", 0).unwrap(), num2);
assert_eq!(db.lget::<Coor>("list1", 4).unwrap().x, mycoor.x);
assert_eq!(db.lget::<Coor>("list1", 4).unwrap().y, mycoor.y);
assert_eq!(db.llen("list1"), 5);
assert_eq!(db.llen("list2"), 2);
assert_eq!(db.llen("list3"), 0);
let read_db = PickleDb::load(
&db_name,
PickleDbDumpPolicy::NeverDump,
ser_method!(ser_method_int),
)
.unwrap();
assert_eq!(read_db.llen("list1"), 5);
assert_eq!(read_db.llen("list2"), 2);
assert_eq!(read_db.lget::<i32>("list1", 0).unwrap(), num);
assert_eq!(read_db.lget::<Vec<i32>>("list1", 3).unwrap(), myvec);
assert_eq!(read_db.lget::<String>("list2", 1).unwrap(), mystr2);
assert_eq!(read_db.lget::<f32>("list1", 1).unwrap(), float_num);
assert_eq!(read_db.lget::<String>("list1", 2).unwrap(), mystr);
assert_eq!(read_db.lget::<i32>("list2", 0).unwrap(), num2);
assert_eq!(read_db.lget::<Coor>("list1", 4).unwrap().x, mycoor.x);
assert_eq!(read_db.lget::<Coor>("list1", 4).unwrap().y, mycoor.y);
}
#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]
fn add_and_extend_lists(ser_method_int: i32) {
test_setup!("add_and_extend_lists", ser_method_int, db_name);
let mut db = PickleDb::new(
&db_name,
PickleDbDumpPolicy::AutoDump,
ser_method!(ser_method_int),
);
db.lcreate("list1").unwrap();
db.lcreate("list2").unwrap();
db.lcreate("list3").unwrap();
assert!(db.lextend("list1", &[1, 2, 3, 4, 5, 6]).is_some());
db.ladd("list2", &1)
.unwrap()
.ladd(&2)
.ladd(&3)
.ladd(&4)
.ladd(&5)
.ladd(&6);
db.ladd("list3", &1)
.unwrap()
.lextend(&[2, 3])
.ladd(&4)
.lextend(&[5, 6]);
assert_eq!(db.llen("list1"), 6);
assert_eq!(db.llen("list2"), 6);
assert_eq!(db.llen("list3"), 6);
for x in 0..5 {
assert_eq!(db.lget::<i32>("list1", x as usize).unwrap(), x + 1);
assert_eq!(db.lget::<i32>("list2", x as usize).unwrap(), x + 1);
assert_eq!(db.lget::<i32>("list3", x as usize).unwrap(), x + 1);
}
let read_db = PickleDb::load(
&db_name,
PickleDbDumpPolicy::NeverDump,
ser_method!(ser_method_int),
)
.unwrap();
for x in 0..5 {
assert_eq!(read_db.lget::<i32>("list1", x as usize).unwrap(), x + 1);
assert_eq!(read_db.lget::<i32>("list2", x as usize).unwrap(), x + 1);
assert_eq!(read_db.lget::<i32>("list3", x as usize).unwrap(), x + 1);
}
}
#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]
fn override_lists(ser_method_int: i32) {
test_setup!("override_lists", ser_method_int, db_name);
let mut db = PickleDb::new(
&db_name,
PickleDbDumpPolicy::AutoDump,
ser_method!(ser_method_int),
);
db.lcreate("list1").unwrap().lextend(&["aa", "bb", "cc"]);
assert_eq!(db.llen("list1"), 3);
db.lcreate("list1").unwrap();
assert!(db.lexists("list1"));
assert_eq!(db.llen("list1"), 0);
{
let read_db = PickleDb::load(
&db_name,
PickleDbDumpPolicy::NeverDump,
ser_method!(ser_method_int),
)
.unwrap();
assert!(read_db.lexists("list1"));
assert_eq!(read_db.llen("list1"), 0);
}
assert!(db.lextend("list1", &[1, 2, 3, 4]).is_some());
assert!(db.lexists("list1"));
assert_eq!(db.llen("list1"), 4);
{
let read_db = PickleDb::load(
&db_name,
PickleDbDumpPolicy::NeverDump,
ser_method!(ser_method_int),
)
.unwrap();
assert!(read_db.lexists("list1"));
assert_eq!(read_db.llen("list1"), 4);
}
}
#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]
fn lget_corner_cases(ser_method_int: i32) {
test_setup!("lget_corner_cases", ser_method_int, db_name);
let mut db = PickleDb::new(
&db_name,
PickleDbDumpPolicy::DumpUponRequest,
ser_method!(ser_method_int),
);
db.lcreate("list1")
.unwrap()
.lextend(&["hello", "world", "good", "morning"])
.ladd(&100);
assert_eq!(db.lget::<String>("list1", 0).unwrap(), "hello");
assert_eq!(db.lget::<i32>("list1", 4).unwrap(), 100);
if let SerializationMethod::Bin = ser_method!(ser_method_int) {
} else {
assert!(db.lget::<i32>("list1", 0).is_none());
assert!(db.lget::<Vec<i32>>("list1", 0).is_none());
if let SerializationMethod::Yaml = ser_method!(ser_method_int) {
} else {
assert!(db.lget::<String>("list1", 4).is_none());
}
}
assert!(db.lget::<i32>("list1", 5).is_none());
assert!(db.lget::<String>("list1", 5).is_none());
assert!(db.lget::<i32>("list2", 5).is_none());
}
#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]
fn add_to_non_existent_list(ser_method_int: i32) {
test_setup!("lget_corner_cases", ser_method_int, db_name);
let mut db = PickleDb::new(
&db_name,
PickleDbDumpPolicy::DumpUponRequest,
ser_method!(ser_method_int),
);
let num = 100;
let vec_of_nums = vec![1, 2, 3];
assert!(db.ladd("list1", &num).is_none());
assert!(db.lextend("list1", &vec_of_nums).is_none());
db.lcreate("list1").unwrap();
assert!(db.ladd("list2", &num).is_none());
assert!(db.lextend("list2", &vec_of_nums).is_none());
assert!(db.ladd("list1", &num).is_some());
assert!(db.lextend("list1", &vec_of_nums).is_some());
assert!(db.rem("list1").unwrap_or(false));
assert!(db.ladd("list1", &num).is_none());
assert!(db.lextend("list1", &vec_of_nums).is_none());
}
#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]
fn remove_list(ser_method_int: i32) {
test_setup!("remove_list", ser_method_int, db_name);
let mut db = PickleDb::new(
&db_name,
PickleDbDumpPolicy::AutoDump,
ser_method!(ser_method_int),
);
db.lcreate("list1")
.unwrap()
.lextend(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
db.lcreate("list2")
.unwrap()
.lextend(&['a', 'b', 'c', 'd', 'e']);
db.lcreate("list3")
.unwrap()
.lextend(&[1.2, 1.3, 2.1, 3.1, 3.3, 7.889]);
db.lcreate("list4")
.unwrap()
.lextend(&["aaa", "bbb", "ccc", "ddd", "eee"]);
{
let read_db = PickleDb::load(
&db_name,
PickleDbDumpPolicy::NeverDump,
ser_method!(ser_method_int),
)
.unwrap();
assert_eq!(read_db.total_keys(), 4);
}
assert!(db.rem("list1").unwrap_or(false));
assert_eq!(db.total_keys(), 3);
{
let read_db = PickleDb::load(
&db_name,
PickleDbDumpPolicy::NeverDump,
ser_method!(ser_method_int),
)
.unwrap();
assert_eq!(read_db.total_keys(), 3);
}
assert_eq!(db.lrem_list("list3").unwrap_or(0), 6);
assert_eq!(db.total_keys(), 2);
{
let read_db = PickleDb::load(
&db_name,
PickleDbDumpPolicy::NeverDump,
ser_method!(ser_method_int),
)
.unwrap();
assert_eq!(read_db.total_keys(), 2);
}
}
#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]
fn remove_values_from_list(ser_method_int: i32) {
test_setup!("remove_values_from_list", ser_method_int, db_name);
let mut db = PickleDb::new(
&db_name,
PickleDbDumpPolicy::AutoDump,
ser_method!(ser_method_int),
);
#[derive(Serialize, Deserialize, Debug)]
struct MySquare {
x: u32,
}
db.lcreate("list1")
.unwrap()
.lextend(&[1, 2, 3])
.ladd(&String::from("hello"))
.ladd(&1.234)
.lextend(&[MySquare { x: 4 }, MySquare { x: 10 }]);
assert_eq!(db.lpop::<f64>("list1", 4).unwrap(), 1.234);
assert_eq!(db.lget::<MySquare>("list1", 4).unwrap().x, 4);
assert_eq!(db.lget::<String>("list1", 3).unwrap(), "hello");
{
let read_db = PickleDb::load(
&db_name,
PickleDbDumpPolicy::NeverDump,
ser_method!(ser_method_int),
)
.unwrap();
assert_eq!(read_db.lget::<MySquare>("list1", 4).unwrap().x, 4);
assert_eq!(read_db.lget::<String>("list1", 3).unwrap(), "hello");
}
assert_eq!(db.lpop::<i32>("list1", 0).unwrap(), 1);
assert_eq!(db.lget::<MySquare>("list1", 4).unwrap().x, 10);
assert_eq!(db.lget::<i32>("list1", 1).unwrap(), 3);
assert!(db
.lrem_value("list1", &String::from("hello"))
.unwrap_or(false));
assert_eq!(db.lget::<MySquare>("list1", 3).unwrap().x, 10);
assert_eq!(db.lget::<i32>("list1", 1).unwrap(), 3);
{
let read_db = PickleDb::load(
&db_name,
PickleDbDumpPolicy::NeverDump,
ser_method!(ser_method_int),
)
.unwrap();
assert_eq!(read_db.lget::<MySquare>("list1", 3).unwrap().x, 10);
assert_eq!(read_db.lget::<i32>("list1", 1).unwrap(), 3);
}
assert!(db.lrem_value("list1", &MySquare { x: 4 }).unwrap_or(false));
assert_eq!(db.lget::<MySquare>("list1", 2).unwrap().x, 10);
assert_eq!(db.lget::<i32>("list1", 0).unwrap(), 2);
{
let read_db = PickleDb::load(
&db_name,
PickleDbDumpPolicy::NeverDump,
ser_method!(ser_method_int),
)
.unwrap();
assert_eq!(read_db.lget::<MySquare>("list1", 2).unwrap().x, 10);
assert_eq!(read_db.lget::<i32>("list1", 0).unwrap(), 2);
}
}
#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]
fn list_with_special_strings(ser_method_int: i32) {
test_setup!("list_with_special_strings", ser_method_int, db_name);
let mut db = PickleDb::new(
&db_name,
PickleDbDumpPolicy::AutoDump,
ser_method!(ser_method_int),
);
db.lcreate("list1")
.unwrap()
.ladd(&String::from("\"double_quotes\""))
.ladd(&String::from("\'single_quotes\'"))
.ladd(&String::from("שָׁלוֹם"))
.ladd(&String::from("😻"))
.ladd(&String::from("\nescapes\t\r"))
.ladd(&String::from("my\\folder"));
assert_eq!(
db.lget::<String>("list1", 0).unwrap(),
String::from("\"double_quotes\"")
);
assert_eq!(
db.lget::<String>("list1", 1).unwrap(),
String::from("\'single_quotes\'")
);
assert_eq!(db.lget::<String>("list1", 2).unwrap(), String::from("שָׁלוֹם"));
assert_eq!(db.lget::<String>("list1", 3).unwrap(), String::from("😻"));
assert_eq!(
db.lget::<String>("list1", 4).unwrap(),
String::from("\nescapes\t\r")
);
assert_eq!(
db.lget::<String>("list1", 5).unwrap(),
String::from("my\\folder")
);
let read_db = PickleDb::load_read_only(&db_name, ser_method!(ser_method_int)).unwrap();
assert_eq!(
read_db.lget::<String>("list1", 0).unwrap(),
String::from("\"double_quotes\"")
);
assert_eq!(
read_db.lget::<String>("list1", 1).unwrap(),
String::from("\'single_quotes\'")
);
assert_eq!(
read_db.lget::<String>("list1", 2).unwrap(),
String::from("שָׁלוֹם")
);
assert_eq!(
read_db.lget::<String>("list1", 3).unwrap(),
String::from("😻")
);
assert_eq!(
read_db.lget::<String>("list1", 4).unwrap(),
String::from("\nescapes\t\r")
);
assert_eq!(
read_db.lget::<String>("list1", 5).unwrap(),
String::from("my\\folder")
);
}
#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]
fn list_iter_test(ser_method_int: i32) {
test_setup!("list_iter_test", ser_method_int, db_name);
let mut db = PickleDb::new(
&db_name,
PickleDbDumpPolicy::AutoDump,
ser_method!(ser_method_int),
);
let values = (
1,
1.1,
String::from("value"),
vec![1, 2, 3],
('a', 'b', 'c'),
);
db.lcreate("list1")
.unwrap()
.ladd(&values.0)
.ladd(&values.1)
.ladd(&values.2)
.ladd(&values.3)
.ladd(&values.4);
let mut index = 0;
for item in db.liter("list1") {
match index {
0 => assert_eq!(item.get_item::<i32>().unwrap(), values.0),
1 => assert_eq!(item.get_item::<f32>().unwrap(), values.1),
2 => assert_eq!(item.get_item::<String>().unwrap(), values.2),
3 => assert_eq!(item.get_item::<Vec<i32>>().unwrap(), values.3),
4 => assert_eq!(item.get_item::<(char, char, char)>().unwrap(), values.4),
_ => panic!(),
}
index += 1;
}
assert_eq!(index, 5);
}
#[allow(unused_attributes)]
#[should_panic]
#[rstest_parametrize(ser_method_int, case(0), case(1), case(2), case(3))]
fn list_doesnt_exist_iter_test(ser_method_int: i32) {
test_setup!("list_doesnt_exist_iter_test", ser_method_int, db_name);
let mut db = PickleDb::new(
&db_name,
PickleDbDumpPolicy::AutoDump,
ser_method!(ser_method_int),
);
let values = (
1,
1.1,
String::from("value"),
vec![1, 2, 3],
('a', 'b', 'c'),
);
db.lcreate("list1")
.unwrap()
.ladd(&values.0)
.ladd(&values.1)
.ladd(&values.2)
.ladd(&values.3)
.ladd(&values.4);
for _item in db.liter("list2") {}
}