Review

elfo-core/src/init.rs

@@ -10,7 +10,7 @@ use tracing::{error, info, level_filters::LevelFilter, warn};
 use elfo_utils::time::Instant;
 
 #[cfg(target_os = "linux")]
-use crate::{memory_tracker::MemoryTracker, time::Interval};
+use crate::{memory_tracker::{MemoryTracker, MemoryCheckResult}, time::Interval};
 
 use crate::{
     actor::{Actor, ActorMeta, ActorStartInfo, ActorStatus},
@@ -241,8 +241,8 @@ async fn termination(mut ctx: Context, topology: Topology) {
         #[cfg(target_os = "linux")]
         if envelope.is::<CheckMemoryUsageTick>() {
             match memory_tracker.as_ref().map(|mt| mt.check()) {
-                Some(Ok(memory_tracker::MemoryCheckResult::Passed)) | None => {}
-                Some(Ok(memory_tracker::MemoryCheckResult::Failed(stats))) => {
+                Some(Ok(MemoryCheckResult::Passed)) | None => {}
+                Some(Ok(MemoryCheckResult::Failed(stats))) => {
                     let percents_of_total =
                         |x| ((x as f64) / (stats.total as f64) * 100.).round() as u64;
                     let used = percents_of_total(stats.used);

elfo-core/src/request_table.rs

@@ -303,11 +303,6 @@ impl<R> ResponseToken<R> {
     pub fn is_forgotten(&self) -> bool {
         self.data.is_none()
     }
-
-    #[cfg(any(test, feature = "test-util"))]
-    pub fn test() -> Self {
-        ResponseToken::forgotten()
-    }
 }
 
 impl<T> Drop for ResponseToken<T> {

elfo-test/src/lib.rs

@@ -1,7 +1,7 @@
 #![warn(rust_2018_idioms, unreachable_pub)]
 
 pub use proxy::{proxy, Proxy};
-pub use util::{extract_msg, extract_req};
+pub use utils::{extract_message, extract_request};
 
 mod proxy;
-mod util;
+mod utils;

elfo-test/src/util.rs → elfo-test/src/utils.rs

@@ -2,27 +2,27 @@ use elfo_core::{msg, Envelope, Message, Request, ResponseToken};
 
 /// Extracts message with type [`M`] from [`Envelope`], panics otherwise.
 #[track_caller]
-pub fn extract_msg<M: Message>(msg: Envelope) -> M {
+pub fn extract_message<M: Message>(msg: Envelope) -> M {
     msg!(match msg {
         msg @ M => msg,
         msg => panic!(
-            "unexpected message: expected {}, got: {:?}",
+            r#"unexpected message: expected {}, got: {}"#,
             elfo_core::dumping::extract_name_by_type::<M>(),
-            msg
+            msg.message().name()
         ),
     })
 }
 
 /// Extracts request message with type [`R`] from [`Envelope`], panics
 /// otherwise.
 #[track_caller]
-pub fn extract_req<R: Request>(msg: Envelope) -> (R, ResponseToken<R>) {
+pub fn extract_request<R: Request>(msg: Envelope) -> (R, ResponseToken<R>) {
     msg!(match msg {
         (req @ R, token) => (req, token),
         msg => panic!(
-            "unexpected request: expected {}, got: {:?}",
+            r#"unexpected request: expected {}, got: {}"#,
             elfo_core::dumping::extract_name_by_type::<R>(),
-            msg
+            msg.message().name()
         ),
     })
 }
@@ -42,21 +42,22 @@ mod tests {
     struct TestRequest;
 
     #[test]
-    fn extract_message() {
+    fn extract_message_test() {
         create_scope().sync_within(|| {
             let envelop =
                 Envelope::new(TestMessage, MessageKind::Regular { sender: Addr::NULL }).upcast();
-            assert_eq!(extract_msg::<TestMessage>(envelop), TestMessage);
+            let resp = extract_message::<TestMessage>(envelop);
+            assert_eq!(resp, TestMessage);
         });
     }
 
     #[test]
-    fn extract_request() {
+    fn extract_request_test() {
         create_scope().sync_within(|| {
             let envelop =
-                Envelope::new(TestRequest, MessageKind::RequestAll(ResponseToken::test())).upcast();
-            let (msg, _token) = extract_req::<TestRequest>(envelop);
-            assert_eq!(msg, TestRequest);
+                Envelope::new(TestRequest, MessageKind::Regular { sender: Addr::NULL }).upcast();
+            let (resp, _token) = extract_request::<TestRequest>(envelop);
+            assert_eq!(resp, TestRequest);
         });
     }