mirror of
https://forgejo.ellis.link/continuwuation/continuwuity.git
synced 2025-06-30 10:24:28 +02:00
136 lines
2.9 KiB
Rust
136 lines
2.9 KiB
Rust
#![cfg(test)]
|
|
|
|
use crate::utils;
|
|
|
|
#[test]
|
|
fn increment_none() {
|
|
let bytes: [u8; 8] = utils::increment(None);
|
|
let res = u64::from_be_bytes(bytes);
|
|
assert_eq!(res, 1);
|
|
}
|
|
|
|
#[test]
|
|
fn increment_fault() {
|
|
let start: u8 = 127;
|
|
let bytes: [u8; 1] = start.to_be_bytes();
|
|
let bytes: [u8; 8] = utils::increment(Some(&bytes));
|
|
let res = u64::from_be_bytes(bytes);
|
|
assert_eq!(res, 1);
|
|
}
|
|
|
|
#[test]
|
|
fn increment_norm() {
|
|
let start: u64 = 1_234_567;
|
|
let bytes: [u8; 8] = start.to_be_bytes();
|
|
let bytes: [u8; 8] = utils::increment(Some(&bytes));
|
|
let res = u64::from_be_bytes(bytes);
|
|
assert_eq!(res, 1_234_568);
|
|
}
|
|
|
|
#[test]
|
|
fn increment_wrap() {
|
|
let start = u64::MAX;
|
|
let bytes: [u8; 8] = start.to_be_bytes();
|
|
let bytes: [u8; 8] = utils::increment(Some(&bytes));
|
|
let res = u64::from_be_bytes(bytes);
|
|
assert_eq!(res, 0);
|
|
}
|
|
|
|
#[test]
|
|
fn common_prefix() {
|
|
use utils::string;
|
|
|
|
let input = ["conduwuit", "conduit", "construct"];
|
|
let output = string::common_prefix(&input);
|
|
assert_eq!(output, "con");
|
|
}
|
|
|
|
#[test]
|
|
fn common_prefix_empty() {
|
|
use utils::string;
|
|
|
|
let input = ["abcdefg", "hijklmn", "opqrstu"];
|
|
let output = string::common_prefix(&input);
|
|
assert_eq!(output, "");
|
|
}
|
|
|
|
#[test]
|
|
fn common_prefix_none() {
|
|
use utils::string;
|
|
|
|
let input = [];
|
|
let output = string::common_prefix(&input);
|
|
assert_eq!(output, "");
|
|
}
|
|
|
|
#[test]
|
|
fn checked_add() {
|
|
use crate::checked;
|
|
|
|
let a = 1234;
|
|
let res = checked!(a + 1).unwrap();
|
|
assert_eq!(res, 1235);
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic(expected = "overflow")]
|
|
fn checked_add_overflow() {
|
|
use crate::checked;
|
|
|
|
let a = u64::MAX;
|
|
let res = checked!(a + 1).expect("overflow");
|
|
assert_eq!(res, 0);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn mutex_map_cleanup() {
|
|
use crate::utils::MutexMap;
|
|
|
|
let map = MutexMap::<String, ()>::new();
|
|
|
|
let lock = map.lock("foo").await;
|
|
assert!(!map.is_empty(), "map must not be empty");
|
|
|
|
drop(lock);
|
|
assert!(map.is_empty(), "map must be empty");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn mutex_map_contend() {
|
|
use std::sync::Arc;
|
|
|
|
use tokio::sync::Barrier;
|
|
|
|
use crate::utils::MutexMap;
|
|
|
|
let map = Arc::new(MutexMap::<String, ()>::new());
|
|
let seq = Arc::new([Barrier::new(2), Barrier::new(2)]);
|
|
let str = "foo".to_owned();
|
|
|
|
let seq_ = seq.clone();
|
|
let map_ = map.clone();
|
|
let str_ = str.clone();
|
|
let join_a = tokio::spawn(async move {
|
|
let _lock = map_.lock(&str_).await;
|
|
assert!(!map_.is_empty(), "A0 must not be empty");
|
|
seq_[0].wait().await;
|
|
assert!(map_.contains(&str_), "A1 must contain key");
|
|
});
|
|
|
|
let seq_ = seq.clone();
|
|
let map_ = map.clone();
|
|
let str_ = str.clone();
|
|
let join_b = tokio::spawn(async move {
|
|
let _lock = map_.lock(&str_).await;
|
|
assert!(!map_.is_empty(), "B0 must not be empty");
|
|
seq_[1].wait().await;
|
|
assert!(map_.contains(&str_), "B1 must contain key");
|
|
});
|
|
|
|
seq[0].wait().await;
|
|
assert!(map.contains(&str), "Must contain key");
|
|
seq[1].wait().await;
|
|
|
|
tokio::try_join!(join_b, join_a).expect("joined");
|
|
assert!(map.is_empty(), "Must be empty");
|
|
}
|