combined tests test_filter & test_line_number -> 1 main function

tests/integration.rs

@@ -1,9 +1,6 @@
 #![allow(dead_code, unused_imports)]
 
-use lazy_static::lazy_static;
 use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record};
-use std::mem::MaybeUninit;
-use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex};
 
 #[cfg(feature = "std")]
@@ -32,28 +29,9 @@ impl Log for Logger {
     }
     fn flush(&self) {}
 }
-
-static mut setup_state: Mutex<bool> = Mutex::new(false);
-
-lazy_static! {
-    static ref a: Arc<State> = Arc::new(State {
-        last_log_level: Mutex::new(None),
-        last_log_location: Mutex::new(None),
-    });
-}
-
-fn setup() {
-    unsafe {
-        let mut guard = setup_state.lock().unwrap();
-        if *guard == false {
-            set_boxed_logger(Box::new(Logger(a.clone()))).unwrap();
-            *guard = true;
-        }
-    }
-}
-
+// #[cfg_attr(lib_build, test)]
 #[test]
-fn filters() {
+fn main() {
     // These tests don't really make sense when static
     // max level filtering is applied
     #[cfg(not(any(
@@ -71,73 +49,61 @@ fn filters() {
         feature = "release_max_level_trace",
     )))]
     {
-        setup();
+        let me = Arc::new(State {
+            last_log_level: Mutex::new(None),
+            last_log_location: Mutex::new(None),
+        });
+        let a = me.clone();
+        set_boxed_logger(Box::new(Logger(me))).unwrap();
 
         test_filter(&a, LevelFilter::Off);
         test_filter(&a, LevelFilter::Error);
         test_filter(&a, LevelFilter::Warn);
         test_filter(&a, LevelFilter::Info);
         test_filter(&a, LevelFilter::Debug);
         test_filter(&a, LevelFilter::Trace);
-    }
-
-    fn test_filter(b: &State, filter: LevelFilter) {
-        log::set_max_level(filter);
-        error!("");
-        last(b, t(Level::Error, filter));
-        warn!("");
-        last(b, t(Level::Warn, filter));
-        info!("");
-        last(b, t(Level::Info, filter));
-        debug!("");
-        last(b, t(Level::Debug, filter));
-        trace!("");
-        last(b, t(Level::Trace, filter));
 
-        fn last(state: &State, expected: Option<Level>) {
-            let lvl = state.last_log_level.lock().unwrap().take();
-            assert_eq!(lvl, expected);
-        }
+        test_line_numbers(&a);
+    }
+}
 
-        fn t(lvl: Level, filter: LevelFilter) -> Option<Level> {
-            if lvl <= filter {
-                Some(lvl)
-            } else {
-                None
-            }
+fn test_filter(a: &State, filter: LevelFilter) {
+    // tests to ensure logs with a level beneath 'max_level' are filtered out
+    log::set_max_level(filter);
+    error!("");
+    last(a, t(Level::Error, filter));
+    warn!("");
+    last(a, t(Level::Warn, filter));
+    info!("");
+    last(a, t(Level::Info, filter));
+    debug!("");
+    last(a, t(Level::Debug, filter));
+    trace!("");
+    last(a, t(Level::Trace, filter));
+
+    fn t(lvl: Level, filter: LevelFilter) -> Option<Level> {
+        if lvl <= filter {
+            Some(lvl)
+        } else {
+            None
         }
     }
+    fn last(state: &State, expected: Option<Level>) {
+        let lvl = state.last_log_level.lock().unwrap().take();
+        assert_eq!(lvl, expected);
+    }
 }
 
-#[test]
-fn line_numbers() {
-    #[cfg(not(any(
-        feature = "max_level_off",
-        feature = "max_level_error",
-        feature = "max_level_warn",
-        feature = "max_level_info",
-        feature = "max_level_debug",
-        feature = "max_level_trace",
-        feature = "release_max_level_off",
-        feature = "release_max_level_error",
-        feature = "release_max_level_warn",
-        feature = "release_max_level_info",
-        feature = "release_max_level_debug",
-        feature = "release_max_level_trace",
-    )))]
-    {
-        setup();
-        log::set_max_level(LevelFilter::Trace);
+fn test_line_numbers(state: &State) {
+    log::set_max_level(LevelFilter::Trace);
+
+    info!(""); // ensure check_line function follows log macro
+    check_log_location(&state);
 
-        info!(""); // ensure check_line function follows log macro
-        check_log_location(&a);
-    }
     #[track_caller]
     fn check_log_location(state: &State) {
-        // gets check_line calling location -> compares w/ location preserved in most recent log
-        // ensure check_line function follows log macro
-        let location = std::panic::Location::caller().line();
-        let line_number = state.last_log_location.lock().unwrap().take().unwrap();
+        let location = std::panic::Location::caller().line(); // get function calling location
+        let line_number = state.last_log_location.lock().unwrap().take().unwrap(); // get location of most recent log
         assert_eq!(line_number, location - 1);
     }
 }