Skip to content

Commit e8f0b3c

Browse files
twistedfalltwistedfall
committed
Cleanup
1 parent 8df9103 commit e8f0b3c

1 file changed

Lines changed: 53 additions & 56 deletions

File tree

‎src/tests/mod.rs‎

Lines changed: 53 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -400,13 +400,13 @@ fn zero_sized_handlers() {
400400
eprintln!("Can't acquire creds, skipping test");
401401
return;
402402
};
403-
let i = Arc::new(RwLock::new(0));
403+
let i = Arc::new(AtomicU16::new(0));
404404

405405
{
406406
let i_incrementer = {
407-
let i = i.clone();
407+
let i = Arc::clone(&i);
408408
move |_: &Context, _: &mut Connection, _: &Stanza| {
409-
*i.write().unwrap() += 1;
409+
i.fetch_add(1, Ordering::Relaxed);
410410
HandlerResult::RemoveHandler
411411
}
412412
};
@@ -448,10 +448,10 @@ fn zero_sized_handlers() {
448448
.unwrap();
449449
ctx.run();
450450
}
451-
assert_eq!(*i.read().unwrap(), 1);
451+
assert_eq!(i.load(Ordering::Relaxed), 1);
452452

453453
// non zero sized handlers are called
454-
*i.write().unwrap() = 0;
454+
i.store(0, Ordering::Relaxed);
455455
{
456456
assert_ne!(mem::size_of_val(&i_incrementer), 0);
457457

@@ -483,10 +483,10 @@ fn zero_sized_handlers() {
483483
.unwrap();
484484
ctx.run();
485485
}
486-
assert_eq!(*i.read().unwrap(), 1);
486+
assert_eq!(i.load(Ordering::Relaxed), 1);
487487

488488
// handlers_clear clears zs and non-zs handlers
489-
*i.write().unwrap() = 0;
489+
i.store(0, Ordering::Relaxed);
490490
{
491491
let zero_sized = |_: &Context, conn: &mut Connection, _: &Stanza| {
492492
let pres = Stanza::new_presence();
@@ -532,14 +532,13 @@ fn zero_sized_handlers() {
532532
.unwrap();
533533
ctx.run();
534534
}
535-
assert_eq!(*i.read().unwrap(), 0);
535+
assert_eq!(i.load(Ordering::Relaxed), 0);
536536
}
537537

538538
assert_eq!(
539539
Arc::try_unwrap(i)
540-
.expect("There are hanging references to Rc value")
541-
.into_inner()
542-
.unwrap(),
540+
.expect("There are hanging references to rc value")
541+
.into_inner(),
543542
0
544543
);
545544
}
@@ -578,7 +577,7 @@ fn connection_handler() {
578577
}
579578
assert_eq!(
580579
Arc::try_unwrap(flags)
581-
.expect("There are hanging references to Rc value")
580+
.expect("There are hanging references to rc value")
582581
.into_inner()
583582
.unwrap(),
584583
(1, 0, 1)
@@ -594,7 +593,7 @@ fn timed_handler_creds() {
594593
return;
595594
};
596595

597-
let i = Arc::new(RwLock::new(0));
596+
let i = Arc::new(AtomicU16::new(0));
598597

599598
let do_common_stuff = |conn: &mut Connection| {
600599
conn
@@ -610,9 +609,9 @@ fn timed_handler_creds() {
610609

611610
{
612611
let i_incrementer = {
613-
let i = i.clone();
612+
let i = Arc::clone(&i);
614613
move |_: &Context, _: &mut Connection| {
615-
*i.write().unwrap() += 1;
614+
i.fetch_add(1, Ordering::Relaxed);
616615
HandlerResult::KeepHandler
617616
}
618617
};
@@ -636,12 +635,12 @@ fn timed_handler_creds() {
636635
})
637636
.unwrap();
638637
ctx.run();
639-
assert!(*i.read().unwrap() > 0);
640-
assert!(*i.read().unwrap() < 1000);
638+
assert!(i.load(Ordering::Relaxed) > 0);
639+
assert!(i.load(Ordering::Relaxed) < 1000);
641640
}
642641

643642
// outside
644-
*i.write().unwrap() = 0;
643+
i.store(0, Ordering::Relaxed);
645644
{
646645
let mut conn = creds.make_conn();
647646
conn
@@ -661,12 +660,12 @@ fn timed_handler_creds() {
661660
})
662661
.unwrap();
663662
ctx.run();
664-
assert!(*i.read().unwrap() > 0);
665-
assert!(*i.read().unwrap() < 1000);
663+
assert!(i.load(Ordering::Relaxed) > 0);
664+
assert!(i.load(Ordering::Relaxed) < 1000);
666665
}
667666

668667
// delete
669-
*i.write().unwrap() = 0;
668+
i.store(0, Ordering::Relaxed);
670669
{
671670
let conn = creds.make_conn();
672671
let ctx = conn
@@ -688,11 +687,11 @@ fn timed_handler_creds() {
688687
})
689688
.unwrap();
690689
ctx.run();
691-
assert_eq!(*i.read().unwrap(), 0);
690+
assert_eq!(i.load(Ordering::Relaxed), 0);
692691
}
693692

694693
// clear
695-
*i.write().unwrap() = 0;
694+
i.store(0, Ordering::Relaxed);
696695
{
697696
let conn = creds.make_conn();
698697
let ctx = conn
@@ -714,14 +713,13 @@ fn timed_handler_creds() {
714713
})
715714
.unwrap();
716715
ctx.run();
717-
assert_eq!(*i.read().unwrap(), 0);
716+
assert_eq!(i.load(Ordering::Relaxed), 0);
718717
}
719718
}
720719
assert_eq!(
721720
Arc::try_unwrap(i)
722-
.expect("There are hanging references to Rc value")
723-
.into_inner()
724-
.unwrap(),
721+
.expect("There are hanging references to rc value")
722+
.into_inner(),
725723
0
726724
);
727725
}
@@ -748,7 +746,7 @@ fn id_handler_creds() {
748746
return;
749747
};
750748

751-
let i = Arc::new(RwLock::new(0));
749+
let i = Arc::new(AtomicU16::new(0));
752750

753751
let do_common_stuff = |_: &Context, conn: &mut Connection| {
754752
let mut iq = Stanza::new_iq(Some("get"), Some("get_roster"));
@@ -771,9 +769,9 @@ fn id_handler_creds() {
771769

772770
{
773771
let i_incrementer = {
774-
let i = i.clone();
772+
let i = Arc::clone(&i);
775773
move |_: &Context, _: &mut Connection, _: &Stanza| {
776-
*i.write().unwrap() += 1;
774+
i.fetch_add(1, Ordering::Relaxed);
777775
HandlerResult::KeepHandler
778776
}
779777
};
@@ -807,11 +805,11 @@ fn id_handler_creds() {
807805
})
808806
.unwrap();
809807
ctx.run();
810-
assert_eq!(*i.read().unwrap(), 1);
808+
assert_eq!(i.load(Ordering::Relaxed), 1);
811809
}
812810

813811
// outside
814-
*i.write().unwrap() = 0;
812+
i.store(0, Ordering::Relaxed);
815813
{
816814
let mut conn = creds.make_conn();
817815
conn
@@ -838,11 +836,11 @@ fn id_handler_creds() {
838836
})
839837
.unwrap();
840838
ctx.run();
841-
assert_eq!(*i.read().unwrap(), 1);
839+
assert_eq!(i.load(Ordering::Relaxed), 1);
842840
}
843841

844842
// delete
845-
*i.write().unwrap() = 0;
843+
i.store(0, Ordering::Relaxed);
846844
{
847845
let conn = creds.make_conn();
848846
let ctx = conn
@@ -865,11 +863,11 @@ fn id_handler_creds() {
865863
})
866864
.unwrap();
867865
ctx.run();
868-
assert_eq!(*i.read().unwrap(), 0);
866+
assert_eq!(i.load(Ordering::Relaxed), 0);
869867
}
870868

871869
// clear
872-
*i.write().unwrap() = 0;
870+
i.store(0, Ordering::Relaxed);
873871
{
874872
let conn = creds.make_conn();
875873
let ctx = conn
@@ -891,14 +889,13 @@ fn id_handler_creds() {
891889
})
892890
.unwrap();
893891
ctx.run();
894-
assert_eq!(*i.read().unwrap(), 0);
892+
assert_eq!(i.load(Ordering::Relaxed), 0);
895893
}
896894
}
897895
assert_eq!(
898896
Arc::try_unwrap(i)
899-
.expect("There are hanging references to Rc value")
900-
.into_inner()
901-
.unwrap(),
897+
.expect("There are hanging references to rc value")
898+
.into_inner(),
902899
0
903900
);
904901
}
@@ -912,7 +909,7 @@ fn handler() {
912909
return;
913910
};
914911

915-
let i = Arc::new(RwLock::new(0));
912+
let i = Arc::new(AtomicU16::new(0));
916913

917914
let default_con_handler = |ctx: &Context, conn: &mut Connection, evt: ConnectionEvent| match evt {
918915
ConnectionEvent::Connect => {
@@ -925,9 +922,9 @@ fn handler() {
925922
};
926923

927924
let i_incrementer = {
928-
let i = i.clone();
925+
let i = Arc::clone(&i);
929926
move |_: &Context, _: &mut Connection, _: &Stanza| {
930-
*i.write().unwrap() += 1;
927+
i.fetch_add(1, Ordering::Relaxed);
931928
HandlerResult::KeepHandler
932929
}
933930
};
@@ -940,23 +937,23 @@ fn handler() {
940937
.expect("Can't add handler");
941938
let ctx = conn.connect_client(None, None, default_con_handler).unwrap();
942939
ctx.run();
943-
assert_eq!(*i.read().unwrap(), 1);
940+
assert_eq!(i.load(Ordering::Relaxed), 1);
944941
}
945942

946943
// handler call stanza name not existent
947-
*i.write().unwrap() = 0;
944+
i.store(0, Ordering::Relaxed);
948945
{
949946
let mut conn = creds.make_conn();
950947
conn
951948
.handler_add(i_incrementer.clone(), None, Some("non-existent"), None)
952949
.expect("Can't add handler");
953950
let ctx = conn.connect_client(None, None, default_con_handler).unwrap();
954951
ctx.run();
955-
assert_eq!(*i.read().unwrap(), 0);
952+
assert_eq!(i.load(Ordering::Relaxed), 0);
956953
}
957954

958955
// handler delete
959-
*i.write().unwrap() = 0;
956+
i.store(0, Ordering::Relaxed);
960957
{
961958
let mut conn = creds.make_conn();
962959
let handler = conn
@@ -965,11 +962,11 @@ fn handler() {
965962
conn.handler_delete(handler);
966963
let ctx = conn.connect_client(None, None, default_con_handler).unwrap();
967964
ctx.run();
968-
assert_eq!(*i.read().unwrap(), 0);
965+
assert_eq!(i.load(Ordering::Relaxed), 0);
969966
}
970967

971968
// handler clear
972-
*i.write().unwrap() = 0;
969+
i.store(0, Ordering::Relaxed);
973970
{
974971
let mut conn = creds.make_conn();
975972
conn
@@ -978,29 +975,29 @@ fn handler() {
978975
conn.handlers_clear();
979976
let ctx = conn.connect_client(None, None, default_con_handler).unwrap();
980977
ctx.run();
981-
assert_eq!(*i.read().unwrap(), 0);
978+
assert_eq!(i.load(Ordering::Relaxed), 0);
982979
}
983980

984981
// same handler twice
985-
*i.write().unwrap() = 0;
982+
i.store(0, Ordering::Relaxed);
986983
{
987984
let mut conn = creds.make_conn();
988985
assert!(conn.handler_add(&i_incrementer, None, Some("iq"), None,).is_some());
989986
assert!(conn.handler_add(&i_incrementer, None, Some("iq"), None).is_none());
990987
let ctx = conn.connect_client(None, None, default_con_handler).unwrap();
991988
ctx.run();
992-
assert_eq!(*i.read().unwrap(), 1);
989+
assert_eq!(i.load(Ordering::Relaxed), 1);
993990
}
994991

995992
// cloned handler twice, not sure if this behaviour is right
996-
*i.write().unwrap() = 0;
993+
i.store(0, Ordering::Relaxed);
997994
{
998995
let mut conn = creds.make_conn();
999996
assert!(conn.handler_add(i_incrementer.clone(), None, Some("iq"), None,).is_some());
1000997
assert!(conn.handler_add(i_incrementer.clone(), None, Some("iq"), None).is_none());
1001998
let ctx = conn.connect_client(None, None, default_con_handler).unwrap();
1002999
ctx.run();
1003-
assert_eq!(*i.read().unwrap(), 1);
1000+
assert_eq!(i.load(Ordering::Relaxed), 1);
10041001
}
10051002
}
10061003

@@ -1096,7 +1093,7 @@ fn connection_handler_tls() {
10961093
}
10971094
assert_eq!(
10981095
Arc::try_unwrap(flags)
1099-
.expect("There are hanging references to Rc value")
1096+
.expect("There are hanging references to rc value")
11001097
.into_inner()
11011098
.unwrap(),
11021099
(1, 0, 0, 1)
@@ -1139,7 +1136,7 @@ fn connection_handler_tls() {
11391136
ctx.run();
11401137
}
11411138
let call_counts = Arc::try_unwrap(flags)
1142-
.expect("There are hanging references to Rc value")
1139+
.expect("There are hanging references to rc value")
11431140
.into_inner()
11441141
.unwrap();
11451142
// gives different results in CI and locally, probably difference in ejabberd versions

0 commit comments

Comments
 (0)