From d9f4a65678c31a87f718bf17014f2c7e8e31171b Mon Sep 17 00:00:00 2001 From: Divkov575 Date: Sat, 16 Mar 2024 10:23:11 -0400 Subject: [PATCH 01/10] added line_numbers.rs --- tests/line_numbers.rs | 58 +++++++++++++++++++++++++++++++++++++++++++ tests/src/lib.rs | 5 ++++ 2 files changed, 63 insertions(+) create mode 100644 tests/line_numbers.rs diff --git a/tests/line_numbers.rs b/tests/line_numbers.rs new file mode 100644 index 000000000..2e3b2b045 --- /dev/null +++ b/tests/line_numbers.rs @@ -0,0 +1,58 @@ +#![allow(dead_code, unused_imports)] + +use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record}; +use std::sync::{Arc, Mutex}; + +#[cfg(feature = "std")] +use log::set_boxed_logger; + +#[cfg(not(feature = "std"))] +fn set_boxed_logger(logger: Box) -> Result<(), log::SetLoggerError> { + log::set_logger(Box::leak(logger)) +} + +struct State<'a> { + last_log: Mutex>>, +} + +struct Logger<'a>(Arc>); + +impl Log for Logger { + fn enabled(&self, _: &Metadata) -> bool { + true + } + + fn log(&self, record: Record) { + *self.0.last_log.lock().unwrap() = Some(record); + } + fn flush(&self) {} +} + +#[cfg_attr(lib_build, test)] +fn main() { + let me = Arc::new(State { + last_log: Mutex::new(None), + }); + let a = me.clone(); + set_boxed_logger(Box::new(Logger(me))).unwrap(); + + + error!(""); + last(&a, 40); + warn!(""); + last(&a, 42); + info!(""); + last(&a, 44); + debug!(""); + last(&a, 46); + trace!(""); + last(&a, 48); + +} + +fn last(state: &State, expected: u32) { + let last_log= state.last_log.lock().unwrap().take().unwrap(); + let line_number = last_log.line().unwrap(); + + assert_eq!(line_number, expected); +} diff --git a/tests/src/lib.rs b/tests/src/lib.rs index 73f0753ca..49e0d03e1 100644 --- a/tests/src/lib.rs +++ b/tests/src/lib.rs @@ -12,3 +12,8 @@ mod filters; #[cfg(test)] #[path = "../macros.rs"] mod macros; + + +#[cfg(test)] +#[path = "../line_numbers.rs"] +mod line_numbers; From 96c3fdc9ad304a238f51b1dfe516732b02aaf076 Mon Sep 17 00:00:00 2001 From: Divkov575 Date: Sat, 16 Mar 2024 10:47:58 -0400 Subject: [PATCH 02/10] changed state to state in order to store line number only --- tests/line_numbers.rs | 36 +++++++++++------------------------- 1 file changed, 11 insertions(+), 25 deletions(-) diff --git a/tests/line_numbers.rs b/tests/line_numbers.rs index 2e3b2b045..de280e748 100644 --- a/tests/line_numbers.rs +++ b/tests/line_numbers.rs @@ -11,48 +11,34 @@ fn set_boxed_logger(logger: Box) -> Result<(), log::SetLoggerError> { log::set_logger(Box::leak(logger)) } -struct State<'a> { - last_log: Mutex>>, -} +struct State { last_log: Mutex> } -struct Logger<'a>(Arc>); +struct Logger(Arc); impl Log for Logger { fn enabled(&self, _: &Metadata) -> bool { true } - fn log(&self, record: Record) { - *self.0.last_log.lock().unwrap() = Some(record); + fn log(&self, record: &Record) { + *self.0.last_log.lock().unwrap() = Some(record.line().unwrap()); } fn flush(&self) {} } -#[cfg_attr(lib_build, test)] -fn main() { - let me = Arc::new(State { - last_log: Mutex::new(None), - }); - let a = me.clone(); - set_boxed_logger(Box::new(Logger(me))).unwrap(); - +#[test] +fn line_number() { + let default_state = Arc::new(State { last_log: Mutex::new(None) }); + let state = default_state.clone(); + set_boxed_logger(Box::new(Logger(default_state))).unwrap(); - error!(""); - last(&a, 40); - warn!(""); - last(&a, 42); info!(""); - last(&a, 44); - debug!(""); - last(&a, 46); - trace!(""); - last(&a, 48); + last(&state, 35); } fn last(state: &State, expected: u32) { - let last_log= state.last_log.lock().unwrap().take().unwrap(); - let line_number = last_log.line().unwrap(); + let line_number = state.last_log.lock().unwrap().take().unwrap(); assert_eq!(line_number, expected); } From eeaeeb80bdf2674978d3d95c741f5b903fd9c7fd Mon Sep 17 00:00:00 2001 From: Divkov575 Date: Sat, 16 Mar 2024 13:02:06 -0400 Subject: [PATCH 03/10] extra option wrapping record.lien() on line 21 removed --- tests/line_numbers.rs | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/tests/line_numbers.rs b/tests/line_numbers.rs index de280e748..fd9f84cfc 100644 --- a/tests/line_numbers.rs +++ b/tests/line_numbers.rs @@ -16,13 +16,10 @@ struct State { last_log: Mutex> } struct Logger(Arc); impl Log for Logger { - fn enabled(&self, _: &Metadata) -> bool { - true - } + fn enabled(&self, _: &Metadata) -> bool { true } + + fn log(&self, record: &Record) { *self.0.last_log.lock().unwrap() = record.line(); } - fn log(&self, record: &Record) { - *self.0.last_log.lock().unwrap() = Some(record.line().unwrap()); - } fn flush(&self) {} } @@ -32,8 +29,12 @@ fn line_number() { let state = default_state.clone(); set_boxed_logger(Box::new(Logger(default_state))).unwrap(); + // let record = RecordBuilder::new().args(format_args!("")).metadata(Metadata::builder().build()).module_path(None).file(None).line(Some(5)).build(); + // let logger = Logger(a.clone()); + // logger.log(&record); + info!(""); - last(&state, 35); + last(&state, 36); } From 8e1fa960a5270633d925dacf5aacc6aba8ff8b93 Mon Sep 17 00:00:00 2001 From: Divkov575 Date: Tue, 19 Mar 2024 08:00:22 -0400 Subject: [PATCH 04/10] added checks for log filtering + set_max_level log --- tests/line_numbers.rs | 61 +++++++++++++++++++++++++++++-------------- 1 file changed, 42 insertions(+), 19 deletions(-) diff --git a/tests/line_numbers.rs b/tests/line_numbers.rs index fd9f84cfc..7adb76936 100644 --- a/tests/line_numbers.rs +++ b/tests/line_numbers.rs @@ -1,8 +1,10 @@ +// ensure line number (from log!() calling position) is correctly within log record + #![allow(dead_code, unused_imports)] -use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record}; use std::sync::{Arc, Mutex}; +use log::{info, LevelFilter, Log, Metadata, Record}; #[cfg(feature = "std")] use log::set_boxed_logger; @@ -11,35 +13,56 @@ fn set_boxed_logger(logger: Box) -> Result<(), log::SetLoggerError> { log::set_logger(Box::leak(logger)) } -struct State { last_log: Mutex> } +struct State { + last_log: Mutex>, +} struct Logger(Arc); impl Log for Logger { - fn enabled(&self, _: &Metadata) -> bool { true } + fn enabled(&self, _: &Metadata) -> bool { + true + } - fn log(&self, record: &Record) { *self.0.last_log.lock().unwrap() = record.line(); } + fn log(&self, record: &Record) { + *self.0.last_log.lock().unwrap() = record.line(); + } fn flush(&self) {} } #[test] fn line_number() { - let default_state = Arc::new(State { last_log: Mutex::new(None) }); - let state = default_state.clone(); - set_boxed_logger(Box::new(Logger(default_state))).unwrap(); - - // let record = RecordBuilder::new().args(format_args!("")).metadata(Metadata::builder().build()).module_path(None).file(None).line(Some(5)).build(); - // let logger = Logger(a.clone()); - // logger.log(&record); - - info!(""); - last(&state, 36); + // These tests don't really make sense when static + // max level filtering is applied + #[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", + )))] + { + let default_state = Arc::new(State { + last_log: Mutex::new(None), + }); + let state = default_state.clone(); + set_boxed_logger(Box::new(Logger(default_state))).unwrap(); + log::set_max_level(LevelFilter::Trace); + info!(""); + check_line(&state, 61); + } + fn check_line(state: &State, expected: u32) { + let line_number = state.last_log.lock().unwrap().take().unwrap(); + assert_eq!(line_number, expected); + } } -fn last(state: &State, expected: u32) { - let line_number = state.last_log.lock().unwrap().take().unwrap(); - - assert_eq!(line_number, expected); -} From cffcd66e5442fb44a9c3580e85c27061e7eb9482 Mon Sep 17 00:00:00 2001 From: Divkov575 Date: Tue, 19 Mar 2024 08:02:36 -0400 Subject: [PATCH 05/10] fmt + update line# for assertion --- tests/line_numbers.rs | 29 ++++++++++++++--------------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/tests/line_numbers.rs b/tests/line_numbers.rs index 7adb76936..3aed38cc4 100644 --- a/tests/line_numbers.rs +++ b/tests/line_numbers.rs @@ -4,9 +4,9 @@ use std::sync::{Arc, Mutex}; -use log::{info, LevelFilter, Log, Metadata, Record}; #[cfg(feature = "std")] use log::set_boxed_logger; +use log::{info, LevelFilter, Log, Metadata, Record}; #[cfg(not(feature = "std"))] fn set_boxed_logger(logger: Box) -> Result<(), log::SetLoggerError> { @@ -36,18 +36,18 @@ fn line_number() { // These tests don't really make sense when static // max level filtering is applied #[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", + 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", )))] { let default_state = Arc::new(State { @@ -58,11 +58,10 @@ fn line_number() { log::set_max_level(LevelFilter::Trace); info!(""); - check_line(&state, 61); + check_line(&state, 60); } fn check_line(state: &State, expected: u32) { let line_number = state.last_log.lock().unwrap().take().unwrap(); assert_eq!(line_number, expected); } } - From d94009e43204b9dd7d106e04b6755bfef29e7a4e Mon Sep 17 00:00:00 2001 From: Divkov575 Date: Tue, 19 Mar 2024 11:43:59 -0400 Subject: [PATCH 06/10] added line_numbers test to cargo.toml and lib.rs --- Cargo.toml | 5 +++++ tests/line_numbers.rs | 8 +++----- tests/src/lib.rs | 1 - 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index c0ea52a77..83518332f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,6 +24,11 @@ name = "filters" path = "tests/filters.rs" harness = false +[[test]] +name = "line_numbers" +path = "tests/line_numbers.rs" +harness = true + [[test]] name = "macros" path = "tests/macros.rs" diff --git a/tests/line_numbers.rs b/tests/line_numbers.rs index 3aed38cc4..9a376f800 100644 --- a/tests/line_numbers.rs +++ b/tests/line_numbers.rs @@ -2,11 +2,11 @@ #![allow(dead_code, unused_imports)] +use log::{info, LevelFilter, Log, Metadata, Record}; use std::sync::{Arc, Mutex}; #[cfg(feature = "std")] use log::set_boxed_logger; -use log::{info, LevelFilter, Log, Metadata, Record}; #[cfg(not(feature = "std"))] fn set_boxed_logger(logger: Box) -> Result<(), log::SetLoggerError> { @@ -32,9 +32,7 @@ impl Log for Logger { } #[test] -fn line_number() { - // These tests don't really make sense when static - // max level filtering is applied +fn line_numbers() { #[cfg(not(any( feature = "max_level_off", feature = "max_level_error", @@ -58,7 +56,7 @@ fn line_number() { log::set_max_level(LevelFilter::Trace); info!(""); - check_line(&state, 60); + check_line(&state, 58); } fn check_line(state: &State, expected: u32) { let line_number = state.last_log.lock().unwrap().take().unwrap(); diff --git a/tests/src/lib.rs b/tests/src/lib.rs index 49e0d03e1..795f60651 100644 --- a/tests/src/lib.rs +++ b/tests/src/lib.rs @@ -13,7 +13,6 @@ mod filters; #[path = "../macros.rs"] mod macros; - #[cfg(test)] #[path = "../line_numbers.rs"] mod line_numbers; From 8f79efefa17a1e9197feecbdf9df2af1f83c73ff Mon Sep 17 00:00:00 2001 From: Divkov575 Date: Tue, 19 Mar 2024 12:41:41 -0400 Subject: [PATCH 07/10] removed harness from line_numbers test --- Cargo.toml | 2 +- tests/line_numbers.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 83518332f..03eb08ee1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -27,7 +27,7 @@ harness = false [[test]] name = "line_numbers" path = "tests/line_numbers.rs" -harness = true +harness = false [[test]] name = "macros" diff --git a/tests/line_numbers.rs b/tests/line_numbers.rs index 9a376f800..41fb1537d 100644 --- a/tests/line_numbers.rs +++ b/tests/line_numbers.rs @@ -31,8 +31,8 @@ impl Log for Logger { fn flush(&self) {} } -#[test] -fn line_numbers() { +#[cfg_attr(lib_build, test)] +fn main() { #[cfg(not(any( feature = "max_level_off", feature = "max_level_error", From 90edfc3b17dd065cc14d403aed3b2360e397ff96 Mon Sep 17 00:00:00 2001 From: Divkov575 Date: Fri, 22 Mar 2024 21:02:17 -0400 Subject: [PATCH 08/10] (filters.rs & line_numbers.rs -> integration.rs) --- Cargo.toml | 12 ++-- tests/filters.rs | 90 -------------------------- tests/integration.rs | 143 ++++++++++++++++++++++++++++++++++++++++++ tests/line_numbers.rs | 65 ------------------- tests/src/lib.rs | 7 +-- 5 files changed, 149 insertions(+), 168 deletions(-) delete mode 100644 tests/filters.rs create mode 100644 tests/integration.rs delete mode 100644 tests/line_numbers.rs diff --git a/Cargo.toml b/Cargo.toml index 03eb08ee1..25e571279 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,14 +20,9 @@ edition = "2021" features = ["std", "serde", "kv_std", "kv_sval", "kv_serde"] [[test]] -name = "filters" -path = "tests/filters.rs" -harness = false - -[[test]] -name = "line_numbers" -path = "tests/line_numbers.rs" -harness = false +name = "integration" +path = "tests/integration.rs" +harness = true [[test]] name = "macros" @@ -64,6 +59,7 @@ kv_unstable_std = ["kv_std", "kv_unstable"] kv_unstable_serde = ["kv_serde", "kv_unstable_std"] [dependencies] +lazy_static = "1.4.0" serde = { version = "1.0", optional = true, default-features = false } sval = { version = "2.1", optional = true, default-features = false } sval_ref = { version = "2.1", optional = true, default-features = false } diff --git a/tests/filters.rs b/tests/filters.rs deleted file mode 100644 index 3e0810d07..000000000 --- a/tests/filters.rs +++ /dev/null @@ -1,90 +0,0 @@ -#![allow(dead_code, unused_imports)] - -use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record}; -use std::sync::{Arc, Mutex}; - -#[cfg(feature = "std")] -use log::set_boxed_logger; - -#[cfg(not(feature = "std"))] -fn set_boxed_logger(logger: Box) -> Result<(), log::SetLoggerError> { - log::set_logger(Box::leak(logger)) -} - -struct State { - last_log: Mutex>, -} - -struct Logger(Arc); - -impl Log for Logger { - fn enabled(&self, _: &Metadata) -> bool { - true - } - - fn log(&self, record: &Record) { - *self.0.last_log.lock().unwrap() = Some(record.level()); - } - fn flush(&self) {} -} - -#[cfg_attr(lib_build, test)] -fn main() { - // These tests don't really make sense when static - // max level filtering is applied - #[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", - )))] - { - let me = Arc::new(State { - last_log: Mutex::new(None), - }); - let a = me.clone(); - set_boxed_logger(Box::new(Logger(me))).unwrap(); - - test(&a, LevelFilter::Off); - test(&a, LevelFilter::Error); - test(&a, LevelFilter::Warn); - test(&a, LevelFilter::Info); - test(&a, LevelFilter::Debug); - test(&a, LevelFilter::Trace); - } -} - -fn test(a: &State, filter: LevelFilter) { - 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 { - if lvl <= filter { - Some(lvl) - } else { - None - } - } -} - -fn last(state: &State, expected: Option) { - let lvl = state.last_log.lock().unwrap().take(); - assert_eq!(lvl, expected); -} diff --git a/tests/integration.rs b/tests/integration.rs new file mode 100644 index 000000000..98abc23d0 --- /dev/null +++ b/tests/integration.rs @@ -0,0 +1,143 @@ +#![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")] +use log::set_boxed_logger; + +#[cfg(not(feature = "std"))] +fn set_boxed_logger(logger: Box) -> Result<(), log::SetLoggerError> { + log::set_logger(Box::leak(logger)) +} + +struct State { + last_log_level: Mutex>, + last_log_location: Mutex>, +} + +struct Logger(Arc); + +impl Log for Logger { + fn enabled(&self, _: &Metadata) -> bool { + true + } + + fn log(&self, record: &Record) { + *self.0.last_log_level.lock().unwrap() = Some(record.level()); + *self.0.last_log_location.lock().unwrap() = record.line(); + } + fn flush(&self) {} +} + +static mut setup_state: Mutex = Mutex::new(false); + +lazy_static! { + static ref a: Arc = 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; + } + } +} + +#[test] +fn filters() { + // These tests don't really make sense when static + // max level filtering is applied + #[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(); + + 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) { + let lvl = state.last_log_level.lock().unwrap().take(); + assert_eq!(lvl, expected); + } + + fn t(lvl: Level, filter: LevelFilter) -> Option { + if lvl <= filter { + Some(lvl) + } else { + None + } + } + } +} + +#[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); + + 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(); + assert_eq!(line_number, location - 1); + } +} diff --git a/tests/line_numbers.rs b/tests/line_numbers.rs deleted file mode 100644 index 41fb1537d..000000000 --- a/tests/line_numbers.rs +++ /dev/null @@ -1,65 +0,0 @@ -// ensure line number (from log!() calling position) is correctly within log record - -#![allow(dead_code, unused_imports)] - -use log::{info, LevelFilter, Log, Metadata, Record}; -use std::sync::{Arc, Mutex}; - -#[cfg(feature = "std")] -use log::set_boxed_logger; - -#[cfg(not(feature = "std"))] -fn set_boxed_logger(logger: Box) -> Result<(), log::SetLoggerError> { - log::set_logger(Box::leak(logger)) -} - -struct State { - last_log: Mutex>, -} - -struct Logger(Arc); - -impl Log for Logger { - fn enabled(&self, _: &Metadata) -> bool { - true - } - - fn log(&self, record: &Record) { - *self.0.last_log.lock().unwrap() = record.line(); - } - - fn flush(&self) {} -} - -#[cfg_attr(lib_build, test)] -fn main() { - #[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", - )))] - { - let default_state = Arc::new(State { - last_log: Mutex::new(None), - }); - let state = default_state.clone(); - set_boxed_logger(Box::new(Logger(default_state))).unwrap(); - log::set_max_level(LevelFilter::Trace); - - info!(""); - check_line(&state, 58); - } - fn check_line(state: &State, expected: u32) { - let line_number = state.last_log.lock().unwrap().take().unwrap(); - assert_eq!(line_number, expected); - } -} diff --git a/tests/src/lib.rs b/tests/src/lib.rs index 795f60651..951fc2430 100644 --- a/tests/src/lib.rs +++ b/tests/src/lib.rs @@ -6,13 +6,10 @@ #![allow(dead_code)] #[cfg(test)] -#[path = "../filters.rs"] -mod filters; +#[path = "../integration.rs"] +mod integration; #[cfg(test)] #[path = "../macros.rs"] mod macros; -#[cfg(test)] -#[path = "../line_numbers.rs"] -mod line_numbers; From 36b1a1cac9babeb6c854ef5ee23931838df1aaa5 Mon Sep 17 00:00:00 2001 From: Divkov575 Date: Sun, 24 Mar 2024 10:39:34 -0400 Subject: [PATCH 09/10] combined tests test_filter & test_line_number -> 1 main function --- tests/integration.rs | 116 +++++++++++++++---------------------------- 1 file changed, 41 insertions(+), 75 deletions(-) diff --git a/tests/integration.rs b/tests/integration.rs index 98abc23d0..7b8c1be0f 100644 --- a/tests/integration.rs +++ b/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 = Mutex::new(false); - -lazy_static! { - static ref a: Arc = 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,7 +49,12 @@ 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); @@ -79,65 +62,48 @@ fn filters() { 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) { - let lvl = state.last_log_level.lock().unwrap().take(); - assert_eq!(lvl, expected); - } + test_line_numbers(&a); + } +} - fn t(lvl: Level, filter: LevelFilter) -> Option { - 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 { + if lvl <= filter { + Some(lvl) + } else { + None } } + fn last(state: &State, expected: Option) { + 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); } } From 3aea361cffdffa60d58f3eef538433696666a64f Mon Sep 17 00:00:00 2001 From: Divkov575 Date: Sun, 24 Mar 2024 10:59:20 -0400 Subject: [PATCH 10/10] fmt + change test harness + remove (unnecessary) lazy_static from dev-deps --- Cargo.toml | 3 +-- tests/integration.rs | 3 +-- tests/src/lib.rs | 1 - 3 files changed, 2 insertions(+), 5 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 25e571279..72fcdb0e4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,7 +22,7 @@ features = ["std", "serde", "kv_std", "kv_sval", "kv_serde"] [[test]] name = "integration" path = "tests/integration.rs" -harness = true +harness = false [[test]] name = "macros" @@ -59,7 +59,6 @@ kv_unstable_std = ["kv_std", "kv_unstable"] kv_unstable_serde = ["kv_serde", "kv_unstable_std"] [dependencies] -lazy_static = "1.4.0" serde = { version = "1.0", optional = true, default-features = false } sval = { version = "2.1", optional = true, default-features = false } sval_ref = { version = "2.1", optional = true, default-features = false } diff --git a/tests/integration.rs b/tests/integration.rs index 7b8c1be0f..7bf456e02 100644 --- a/tests/integration.rs +++ b/tests/integration.rs @@ -29,8 +29,7 @@ impl Log for Logger { } fn flush(&self) {} } -// #[cfg_attr(lib_build, test)] -#[test] +#[cfg_attr(lib_build, test)] fn main() { // These tests don't really make sense when static // max level filtering is applied diff --git a/tests/src/lib.rs b/tests/src/lib.rs index 951fc2430..a791a0c87 100644 --- a/tests/src/lib.rs +++ b/tests/src/lib.rs @@ -12,4 +12,3 @@ mod integration; #[cfg(test)] #[path = "../macros.rs"] mod macros; -