vecna
/
lox
mirror of https://gitlab.torproject.org/vecna/lox.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added Updated tests file and readme

This commit is contained in:
onyinyang 2022-04-03 05:54:53 +00:00
parent 7f7522faf2
commit a7be6d3bfd
No known key found for this signature in database
GPG Key ID: 156A6435430C2036
2 changed files with 92 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
crates/lox-library/src/readme.md Normal file
View File

@ -0,0 +1,17 @@
# Lox
Lox is a reputation-based bridge distribution system that provides privacy protection to users and their social graph and is open to all users.
Lox is written in rust and requires `cargo` to test. [Install Rust](https://www.rust-lang.org/tools/install)
### To run the tests used for our experimental results:
```
cargo test -- --nocapture stats_test > stats_test.log
```
Note that: our implementation is coded such that the reachability certificate expires at 00:00 UTC. A workaround has been included in each test to pause if it is too close to this time so the request won't fail. In reality, if the bucket is still reachable, a user could simply request a new reachability token if their request fails for this reason (a new certificate should be available prior to the outdated certificate expiring).
### To run all Lox tests:
```
cargo test -- --nocapture test > testing.log
```

150
crates/lox-library/src/tests.rs
View File

@ -372,7 +372,7 @@ impl TestHarness {
} }
} }
//#[test] #[test]
fn test_open_invite() { fn test_open_invite() {
let mut th = TestHarness::new(); let mut th = TestHarness::new();
@ -393,7 +393,7 @@ fn test_open_invite() {
assert!(bridgeline == bucket.0[0]); assert!(bridgeline == bucket.0[0]);
} }
//#[test] #[test]
fn test_trust_promotion() { fn test_trust_promotion() {
let mut th = TestHarness::new(); let mut th = TestHarness::new();
@ -417,7 +417,7 @@ fn test_trust_promotion() {
assert!(th.ba.verify_reachability(&bucket.1.unwrap())); assert!(th.ba.verify_reachability(&bucket.1.unwrap()));
} }
//#[test] #[test]
fn test_level0_migration() { fn test_level0_migration() {
let mut th = TestHarness::new(); let mut th = TestHarness::new();
@ -448,7 +448,7 @@ fn test_level0_migration() {
assert!(th.ba.verify_reachability(&bucket.1.unwrap())); assert!(th.ba.verify_reachability(&bucket.1.unwrap()));
} }
//#[test] #[test]
fn test_level_up() { fn test_level_up() {
let mut th = TestHarness::new(); let mut th = TestHarness::new();
@ -503,7 +503,7 @@ fn test_level_up() {
assert!(th.ba.verify_lox(&cred4)); assert!(th.ba.verify_lox(&cred4));
} }
//#[test] #[test]
fn test_issue_invite() { fn test_issue_invite() {
let mut th = TestHarness::new(); let mut th = TestHarness::new();
@ -543,7 +543,7 @@ fn test_issue_invite() {
println!("invite = {:?}", invite); println!("invite = {:?}", invite);
} }
//#[test] #[test]
fn test_redeem_invite() { fn test_redeem_invite() {
let mut th = TestHarness::new(); let mut th = TestHarness::new();
@ -593,7 +593,7 @@ fn test_redeem_invite() {
println!("bob_cred = {:?}", bob_cred); println!("bob_cred = {:?}", bob_cred);
} }
//#[test] #[test]
fn test_mark_unreachable() { fn test_mark_unreachable() {
let mut th = TestHarness::new(); let mut th = TestHarness::new();
@ -643,7 +643,7 @@ fn test_mark_unreachable() {
println!("openinv = {:?}\n", th.bdb.openinv_buckets); println!("openinv = {:?}\n", th.bdb.openinv_buckets);
} }
//#[test] #[test]
fn test_blockage_migration() { fn test_blockage_migration() {
let mut th = TestHarness::new(); let mut th = TestHarness::new();
@ -714,9 +714,9 @@ fn test_blockage_migration() {
assert!(th.ba.verify_lox(&cred4)); assert!(th.ba.verify_lox(&cred4));
} }
//#[test] #[test]
fn stats_test_trust_levels() { fn stats_test_trust_levels() {
let buckets: Vec<u16> = vec![900, 1050, 1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -754,7 +754,7 @@ fn stats_test_trust_levels() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -857,9 +857,9 @@ fn stats_test_trust_levels() {
} }
} }
//#[test] #[test]
fn stats_test_invitations() { fn stats_test_invitations() {
let buckets: Vec<u16> = vec![1050, 1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -878,7 +878,7 @@ fn stats_test_invitations() {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -918,9 +918,9 @@ fn stats_test_invitations() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_5() { fn stats_test_blockage_migration_5() {
let buckets: Vec<u16> = vec![1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -928,7 +928,7 @@ fn stats_test_blockage_migration_5() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -951,9 +951,9 @@ fn stats_test_blockage_migration_5() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_10() { fn stats_test_blockage_migration_10() {
let buckets: Vec<u16> = vec![1050, 1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -961,7 +961,7 @@ fn stats_test_blockage_migration_10() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -984,9 +984,9 @@ fn stats_test_blockage_migration_10() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_15() { fn stats_test_blockage_migration_15() {
let buckets: Vec<u16> = vec![1050, 1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -994,7 +994,7 @@ fn stats_test_blockage_migration_15() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1017,9 +1017,9 @@ fn stats_test_blockage_migration_15() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_20() { fn stats_test_blockage_migration_20() {
let buckets: Vec<u16> = vec![1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1027,7 +1027,7 @@ fn stats_test_blockage_migration_20() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1050,9 +1050,9 @@ fn stats_test_blockage_migration_20() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_25() { fn stats_test_blockage_migration_25() {
let buckets: Vec<u16> = vec![1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1060,7 +1060,7 @@ fn stats_test_blockage_migration_25() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1083,9 +1083,9 @@ fn stats_test_blockage_migration_25() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_30() { fn stats_test_blockage_migration_30() {
let buckets: Vec<u16> = vec![1050, 1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1093,7 +1093,7 @@ fn stats_test_blockage_migration_30() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1116,9 +1116,9 @@ fn stats_test_blockage_migration_30() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_35() { fn stats_test_blockage_migration_35() {
let buckets: Vec<u16> = vec![1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1126,7 +1126,7 @@ fn stats_test_blockage_migration_35() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1151,7 +1151,7 @@ fn stats_test_blockage_migration_35() {
#[test] #[test]
fn stats_test_blockage_migration_40() { fn stats_test_blockage_migration_40() {
let buckets: Vec<u16> = vec![900]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1159,7 +1159,7 @@ fn stats_test_blockage_migration_40() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1184,7 +1184,7 @@ fn stats_test_blockage_migration_40() {
#[test] #[test]
fn stats_test_blockage_migration_45() { fn stats_test_blockage_migration_45() {
let buckets: Vec<u16> = vec![900]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1192,7 +1192,7 @@ fn stats_test_blockage_migration_45() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1217,7 +1217,7 @@ fn stats_test_blockage_migration_45() {
#[test] #[test]
fn stats_test_blockage_migration_50() { fn stats_test_blockage_migration_50() {
let buckets: Vec<u16> = vec![1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1225,7 +1225,7 @@ fn stats_test_blockage_migration_50() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1250,7 +1250,7 @@ fn stats_test_blockage_migration_50() {
#[test] #[test]
fn stats_test_blockage_migration_55() { fn stats_test_blockage_migration_55() {
let buckets: Vec<u16> = vec![900]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1258,7 +1258,7 @@ fn stats_test_blockage_migration_55() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1281,9 +1281,9 @@ fn stats_test_blockage_migration_55() {
} }
} }
////#[test] #[test]
fn stats_test_blockage_migration_60() { fn stats_test_blockage_migration_60() {
let buckets: Vec<u16> = vec![1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1291,7 +1291,7 @@ fn stats_test_blockage_migration_60() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1314,9 +1314,9 @@ fn stats_test_blockage_migration_60() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_65() { fn stats_test_blockage_migration_65() {
let buckets: Vec<u16> = vec![1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1324,7 +1324,7 @@ fn stats_test_blockage_migration_65() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1347,9 +1347,9 @@ fn stats_test_blockage_migration_65() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_70() { fn stats_test_blockage_migration_70() {
let buckets: Vec<u16> = vec![1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1357,7 +1357,7 @@ fn stats_test_blockage_migration_70() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1380,9 +1380,9 @@ fn stats_test_blockage_migration_70() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_75() { fn stats_test_blockage_migration_75() {
let buckets: Vec<u16> = vec![1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1390,7 +1390,7 @@ fn stats_test_blockage_migration_75() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1413,9 +1413,9 @@ fn stats_test_blockage_migration_75() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_80() { fn stats_test_blockage_migration_80() {
let buckets: Vec<u16> = vec![900, 1050, 1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1423,7 +1423,7 @@ fn stats_test_blockage_migration_80() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1446,9 +1446,9 @@ fn stats_test_blockage_migration_80() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_85() { fn stats_test_blockage_migration_85() {
let buckets: Vec<u16> = vec![1050, 1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1456,7 +1456,7 @@ fn stats_test_blockage_migration_85() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1479,9 +1479,9 @@ fn stats_test_blockage_migration_85() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_90() { fn stats_test_blockage_migration_90() {
let buckets: Vec<u16> = vec![1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1489,7 +1489,7 @@ fn stats_test_blockage_migration_90() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1512,9 +1512,9 @@ fn stats_test_blockage_migration_90() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_95() { fn stats_test_blockage_migration_95() {
let buckets: Vec<u16> = vec![1050, 1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1522,7 +1522,7 @@ fn stats_test_blockage_migration_95() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1545,9 +1545,9 @@ fn stats_test_blockage_migration_95() {
} }
} }
//#[test] #[test]
fn stats_test_blockage_migration_100() { fn stats_test_blockage_migration_100() {
let buckets: Vec<u16> = vec![750, 900, 1050, 1200, 1350, 1500]; let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
for x in buckets { for x in buckets {
let mut th = TestHarness::new_buckets(x, x); let mut th = TestHarness::new_buckets(x, x);
@ -1555,7 +1555,7 @@ fn stats_test_blockage_migration_100() {
for _ in 0..10000 { for _ in 0..10000 {
let h: NaiveTime = DateTime::time(&Utc::now()); let h: NaiveTime = DateTime::time(&Utc::now());
if h.hour() == 23 && h.minute() == 59 { if h.hour() == 23 && h.minute() == 59 {
println!("Biding my time for a minute"); println!("Wait for UTC 00:00");
thread::sleep(Duration::new(60,0)); thread::sleep(Duration::new(60,0));
println!("Ready to work again"); println!("Ready to work again");
} }
@ -1667,11 +1667,11 @@ fn print_test_results(perf_stat: PerfStat) {
println!("Response handle time = {:?}", perf_stat.resp_handle_t); println!("Response handle time = {:?}", perf_stat.resp_handle_t);
} }
fn print_time_test_results(perf_stat: PerfStat) { //fn print_time_test_results(perf_stat: PerfStat) {
println!("Request time = {:?}", perf_stat.req_t); // println!("Request time = {:?}", perf_stat.req_t);
println!("Response time = {:?}", perf_stat.resp_t); // println!("Response time = {:?}", perf_stat.resp_t);
println!("Response handle time = {:?}", perf_stat.resp_handle_t); // println!("Response handle time = {:?}", perf_stat.resp_handle_t);
} //}
fn print_stats_test_results( fn print_stats_test_results(
req_size: Vec<f64>, req_size: Vec<f64>,