From 4f9fe856a25ab29345b90e7725509e9ee38a37be Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:19:41 +0200 Subject: Adding upstream version 1.69.0+dfsg1. Signed-off-by: Daniel Baumann --- ...cached_layer_filters_dont_break_other_layers.rs | 123 ------ .../tests/duplicate_spans.rs | 48 --- .../tracing-subscriber-0.3.3/tests/field_filter.rs | 115 ------ vendor/tracing-subscriber-0.3.3/tests/filter.rs | 187 ---------- .../tracing-subscriber-0.3.3/tests/filter_log.rs | 63 ---- .../tests/fmt_max_level_hint.rs | 10 - ...hinted_layer_filters_dont_break_other_layers.rs | 131 ------- .../tests/layer_filter_interests_are_cached.rs | 69 ---- .../tests/layer_filters/boxed.rs | 42 --- .../tests/layer_filters/downcast_raw.rs | 68 ---- .../tests/layer_filters/filter_scopes.rs | 131 ------- .../tests/layer_filters/main.rs | 188 ---------- .../tests/layer_filters/targets.rs | 59 --- .../tests/layer_filters/trees.rs | 146 -------- .../multiple_layer_filter_interests_cached.rs | 131 ------- .../tests/registry_max_level_hint.rs | 11 - .../tests/registry_with_subscriber.rs | 25 -- vendor/tracing-subscriber-0.3.3/tests/reload.rs | 81 ---- .../tests/same_len_filters.rs | 81 ---- vendor/tracing-subscriber-0.3.3/tests/support.rs | 412 --------------------- ...hinted_layer_filters_dont_break_other_layers.rs | 123 ------ vendor/tracing-subscriber-0.3.3/tests/utils.rs | 39 -- 22 files changed, 2283 deletions(-) delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/cached_layer_filters_dont_break_other_layers.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/duplicate_spans.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/field_filter.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/filter.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/filter_log.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/fmt_max_level_hint.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/hinted_layer_filters_dont_break_other_layers.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/layer_filter_interests_are_cached.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/layer_filters/boxed.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/layer_filters/downcast_raw.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/layer_filters/filter_scopes.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/layer_filters/main.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/layer_filters/targets.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/layer_filters/trees.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/multiple_layer_filter_interests_cached.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/registry_max_level_hint.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/registry_with_subscriber.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/reload.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/same_len_filters.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/support.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/unhinted_layer_filters_dont_break_other_layers.rs delete mode 100644 vendor/tracing-subscriber-0.3.3/tests/utils.rs (limited to 'vendor/tracing-subscriber-0.3.3/tests') diff --git a/vendor/tracing-subscriber-0.3.3/tests/cached_layer_filters_dont_break_other_layers.rs b/vendor/tracing-subscriber-0.3.3/tests/cached_layer_filters_dont_break_other_layers.rs deleted file mode 100644 index 00e98a994..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/cached_layer_filters_dont_break_other_layers.rs +++ /dev/null @@ -1,123 +0,0 @@ -#![cfg(feature = "registry")] -mod support; -use self::support::*; -use tracing::Level; -use tracing_subscriber::{filter::LevelFilter, prelude::*}; - -#[test] -fn layer_filters() { - let (unfiltered, unfiltered_handle) = unfiltered("unfiltered"); - let (filtered, filtered_handle) = filtered("filtered"); - - let _subscriber = tracing_subscriber::registry() - .with(unfiltered) - .with(filtered.with_filter(filter())) - .set_default(); - - events(); - - unfiltered_handle.assert_finished(); - filtered_handle.assert_finished(); -} - -#[test] -fn layered_layer_filters() { - let (unfiltered1, unfiltered1_handle) = unfiltered("unfiltered_1"); - let (unfiltered2, unfiltered2_handle) = unfiltered("unfiltered_2"); - let unfiltered = unfiltered1.and_then(unfiltered2); - - let (filtered1, filtered1_handle) = filtered("filtered_1"); - let (filtered2, filtered2_handle) = filtered("filtered_2"); - let filtered = filtered1 - .with_filter(filter()) - .and_then(filtered2.with_filter(filter())); - - let _subscriber = tracing_subscriber::registry() - .with(unfiltered) - .with(filtered) - .set_default(); - - events(); - - unfiltered1_handle.assert_finished(); - unfiltered2_handle.assert_finished(); - filtered1_handle.assert_finished(); - filtered2_handle.assert_finished(); -} - -#[test] -fn out_of_order() { - let (unfiltered1, unfiltered1_handle) = unfiltered("unfiltered_1"); - let (unfiltered2, unfiltered2_handle) = unfiltered("unfiltered_2"); - - let (filtered1, filtered1_handle) = filtered("filtered_1"); - let (filtered2, filtered2_handle) = filtered("filtered_2"); - - let _subscriber = tracing_subscriber::registry() - .with(unfiltered1) - .with(filtered1.with_filter(filter())) - .with(unfiltered2) - .with(filtered2.with_filter(filter())) - .set_default(); - events(); - - unfiltered1_handle.assert_finished(); - unfiltered2_handle.assert_finished(); - filtered1_handle.assert_finished(); - filtered2_handle.assert_finished(); -} - -#[test] -fn mixed_layered() { - let (unfiltered1, unfiltered1_handle) = unfiltered("unfiltered_1"); - let (unfiltered2, unfiltered2_handle) = unfiltered("unfiltered_2"); - let (filtered1, filtered1_handle) = filtered("filtered_1"); - let (filtered2, filtered2_handle) = filtered("filtered_2"); - - let layered1 = filtered1.with_filter(filter()).and_then(unfiltered1); - let layered2 = unfiltered2.and_then(filtered2.with_filter(filter())); - - let _subscriber = tracing_subscriber::registry() - .with(layered1) - .with(layered2) - .set_default(); - - events(); - - unfiltered1_handle.assert_finished(); - unfiltered2_handle.assert_finished(); - filtered1_handle.assert_finished(); - filtered2_handle.assert_finished(); -} - -fn events() { - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); -} - -fn filter() -> LevelFilter { - LevelFilter::INFO -} - -fn unfiltered(name: &str) -> (ExpectLayer, subscriber::MockHandle) { - layer::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle() -} - -fn filtered(name: &str) -> (ExpectLayer, subscriber::MockHandle) { - layer::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle() -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/duplicate_spans.rs b/vendor/tracing-subscriber-0.3.3/tests/duplicate_spans.rs deleted file mode 100644 index c4a736f74..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/duplicate_spans.rs +++ /dev/null @@ -1,48 +0,0 @@ -#![cfg(all(feature = "env-filter", feature = "fmt"))] -mod support; -use tracing::{self, subscriber::with_default, Span}; -use tracing_subscriber::{filter::EnvFilter, FmtSubscriber}; - -#[test] -fn duplicate_spans() { - let subscriber = FmtSubscriber::builder() - .with_env_filter(EnvFilter::new("[root]=debug")) - .finish(); - - with_default(subscriber, || { - let root = tracing::debug_span!("root"); - root.in_scope(|| { - // root: - assert_eq!(root, Span::current(), "Current span must be 'root'"); - let leaf = tracing::debug_span!("leaf"); - leaf.in_scope(|| { - // root:leaf: - assert_eq!(leaf, Span::current(), "Current span must be 'leaf'"); - root.in_scope(|| { - // root:leaf: - assert_eq!( - leaf, - Span::current(), - "Current span must be 'leaf' after entering twice the 'root' span" - ); - }) - }); - // root: - assert_eq!( - root, - Span::current(), - "Current span must be root ('leaf' exited, nested 'root' exited)" - ); - - root.in_scope(|| { - assert_eq!(root, Span::current(), "Current span must be root"); - }); - // root: - assert_eq!( - root, - Span::current(), - "Current span must still be root after exiting nested 'root'" - ); - }); - }); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/field_filter.rs b/vendor/tracing-subscriber-0.3.3/tests/field_filter.rs deleted file mode 100644 index 12b4053b6..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/field_filter.rs +++ /dev/null @@ -1,115 +0,0 @@ -#![cfg(feature = "env-filter")] -mod support; -use self::support::*; -use tracing::{self, subscriber::with_default, Level}; -use tracing_subscriber::{filter::EnvFilter, prelude::*}; - -#[test] -#[cfg_attr(not(flaky_tests), ignore)] -fn field_filter_events() { - let filter: EnvFilter = "[{thing}]=debug".parse().expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .event( - event::mock() - .at_level(Level::INFO) - .with_fields(field::mock("thing")), - ) - .event( - event::mock() - .at_level(Level::DEBUG) - .with_fields(field::mock("thing")), - ) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - - with_default(subscriber, || { - tracing::trace!(disabled = true); - tracing::info!("also disabled"); - tracing::info!(thing = 1); - tracing::debug!(thing = 2); - tracing::trace!(thing = 3); - }); - - finished.assert_finished(); -} - -#[test] -#[cfg_attr(not(flaky_tests), ignore)] -fn field_filter_spans() { - let filter: EnvFilter = "[{enabled=true}]=debug" - .parse() - .expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .enter(span::mock().named("span1")) - .event( - event::mock() - .at_level(Level::INFO) - .with_fields(field::mock("something")), - ) - .exit(span::mock().named("span1")) - .enter(span::mock().named("span2")) - .exit(span::mock().named("span2")) - .enter(span::mock().named("span3")) - .event( - event::mock() - .at_level(Level::DEBUG) - .with_fields(field::mock("something")), - ) - .exit(span::mock().named("span3")) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - - with_default(subscriber, || { - tracing::trace!("disabled"); - tracing::info!("also disabled"); - tracing::info_span!("span1", enabled = true).in_scope(|| { - tracing::info!(something = 1); - }); - tracing::debug_span!("span2", enabled = false, foo = "hi").in_scope(|| { - tracing::warn!(something = 2); - }); - tracing::trace_span!("span3", enabled = true, answer = 42).in_scope(|| { - tracing::debug!(something = 2); - }); - }); - - finished.assert_finished(); -} - -#[test] -fn record_after_created() { - let filter: EnvFilter = "[{enabled=true}]=debug" - .parse() - .expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .enter(span::mock().named("span")) - .exit(span::mock().named("span")) - .record( - span::mock().named("span"), - field::mock("enabled").with_value(&true), - ) - .enter(span::mock().named("span")) - .event(event::mock().at_level(Level::DEBUG)) - .exit(span::mock().named("span")) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - - with_default(subscriber, || { - let span = tracing::info_span!("span", enabled = false); - span.in_scope(|| { - tracing::debug!("i'm disabled!"); - }); - - span.record("enabled", &true); - span.in_scope(|| { - tracing::debug!("i'm enabled!"); - }); - - tracing::debug!("i'm also disabled"); - }); - - finished.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/filter.rs b/vendor/tracing-subscriber-0.3.3/tests/filter.rs deleted file mode 100644 index 8386d34d2..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/filter.rs +++ /dev/null @@ -1,187 +0,0 @@ -#![cfg(feature = "env-filter")] - -mod support; -use self::support::*; -use tracing::{self, subscriber::with_default, Level}; -use tracing_subscriber::{ - filter::{EnvFilter, LevelFilter}, - prelude::*, -}; - -#[test] -fn level_filter_event() { - let filter: EnvFilter = "info".parse().expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - - with_default(subscriber, || { - tracing::trace!("this should be disabled"); - tracing::info!("this shouldn't be"); - tracing::debug!(target: "foo", "this should also be disabled"); - tracing::warn!(target: "foo", "this should be enabled"); - tracing::error!("this should be enabled too"); - }); - - finished.assert_finished(); -} - -#[test] -fn same_name_spans() { - let filter: EnvFilter = "[foo{bar}]=trace,[foo{baz}]=trace" - .parse() - .expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .new_span( - span::mock() - .named("foo") - .at_level(Level::TRACE) - .with_field(field::mock("bar")), - ) - .new_span( - span::mock() - .named("foo") - .at_level(Level::TRACE) - .with_field(field::mock("baz")), - ) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - with_default(subscriber, || { - tracing::trace_span!("foo", bar = 1); - tracing::trace_span!("foo", baz = 1); - }); - - finished.assert_finished(); -} - -#[test] -fn level_filter_event_with_target() { - let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - - with_default(subscriber, || { - tracing::trace!("this should be disabled"); - tracing::info!("this shouldn't be"); - tracing::debug!(target: "stuff", "this should be enabled"); - tracing::debug!("but this shouldn't"); - tracing::trace!(target: "stuff", "and neither should this"); - tracing::warn!(target: "stuff", "this should be enabled"); - tracing::error!("this should be enabled too"); - tracing::error!(target: "stuff", "this should be enabled also"); - }); - - finished.assert_finished(); -} - -#[test] -fn not_order_dependent() { - // this test reproduces tokio-rs/tracing#623 - - let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) - .event(event::mock().at_level(Level::WARN).with_target("stuff")) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::ERROR).with_target("stuff")) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - - with_default(subscriber, || { - tracing::trace!("this should be disabled"); - tracing::info!("this shouldn't be"); - tracing::debug!(target: "stuff", "this should be enabled"); - tracing::debug!("but this shouldn't"); - tracing::trace!(target: "stuff", "and neither should this"); - tracing::warn!(target: "stuff", "this should be enabled"); - tracing::error!("this should be enabled too"); - tracing::error!(target: "stuff", "this should be enabled also"); - }); - - finished.assert_finished(); -} - -#[test] -fn add_directive_enables_event() { - // this test reproduces tokio-rs/tracing#591 - - // by default, use info level - let mut filter = EnvFilter::new(LevelFilter::INFO.to_string()); - - // overwrite with a more specific directive - filter = filter.add_directive("hello=trace".parse().expect("directive should parse")); - - let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO).with_target("hello")) - .event(event::mock().at_level(Level::TRACE).with_target("hello")) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - - with_default(subscriber, || { - tracing::info!(target: "hello", "hello info"); - tracing::trace!(target: "hello", "hello trace"); - }); - - finished.assert_finished(); -} - -#[test] -fn span_name_filter_is_dynamic() { - let filter: EnvFilter = "info,[cool_span]=debug" - .parse() - .expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .enter(span::mock().named("cool_span")) - .event(event::mock().at_level(Level::DEBUG)) - .enter(span::mock().named("uncool_span")) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::DEBUG)) - .exit(span::mock().named("uncool_span")) - .exit(span::mock().named("cool_span")) - .enter(span::mock().named("uncool_span")) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .exit(span::mock().named("uncool_span")) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - - with_default(subscriber, || { - tracing::trace!("this should be disabled"); - tracing::info!("this shouldn't be"); - let cool_span = tracing::info_span!("cool_span"); - let uncool_span = tracing::info_span!("uncool_span"); - - { - let _enter = cool_span.enter(); - tracing::debug!("i'm a cool event"); - tracing::trace!("i'm cool, but not cool enough"); - let _enter2 = uncool_span.enter(); - tracing::warn!("warning: extremely cool!"); - tracing::debug!("i'm still cool"); - } - - let _enter = uncool_span.enter(); - tracing::warn!("warning: not that cool"); - tracing::trace!("im not cool enough"); - tracing::error!("uncool error"); - }); - - finished.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/filter_log.rs b/vendor/tracing-subscriber-0.3.3/tests/filter_log.rs deleted file mode 100644 index 28e742501..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/filter_log.rs +++ /dev/null @@ -1,63 +0,0 @@ -#![cfg(all(feature = "env-filter", feature = "tracing-log"))] -mod support; -use self::support::*; -use tracing::{self, Level}; -use tracing_subscriber::{filter::EnvFilter, prelude::*}; - -mod my_module { - pub(crate) fn test_records() { - log::trace!("this should be disabled"); - log::info!("this shouldn't be"); - log::debug!("this should be disabled"); - log::warn!("this should be enabled"); - log::warn!(target: "something else", "this shouldn't be enabled"); - log::error!("this should be enabled too"); - } - - pub(crate) fn test_log_enabled() { - assert!( - log::log_enabled!(log::Level::Info), - "info should be enabled inside `my_module`" - ); - assert!( - !log::log_enabled!(log::Level::Debug), - "debug should not be enabled inside `my_module`" - ); - assert!( - log::log_enabled!(log::Level::Warn), - "warn should be enabled inside `my_module`" - ); - } -} - -#[test] -fn log_is_enabled() { - let filter: EnvFilter = "filter_log::my_module=info" - .parse() - .expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle(); - - // Note: we have to set the global default in order to set the `log` max - // level, which can only be set once. - subscriber.with(filter).init(); - - my_module::test_records(); - log::info!("this is disabled"); - - my_module::test_log_enabled(); - assert!( - !log::log_enabled!(log::Level::Info), - "info should not be enabled outside `my_module`" - ); - assert!( - !log::log_enabled!(log::Level::Warn), - "warn should not be enabled outside `my_module`" - ); - - finished.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/fmt_max_level_hint.rs b/vendor/tracing-subscriber-0.3.3/tests/fmt_max_level_hint.rs deleted file mode 100644 index 57a0f6e3f..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/fmt_max_level_hint.rs +++ /dev/null @@ -1,10 +0,0 @@ -#![cfg(feature = "fmt")] -use tracing_subscriber::filter::LevelFilter; - -#[test] -fn fmt_sets_max_level_hint() { - tracing_subscriber::fmt() - .with_max_level(LevelFilter::DEBUG) - .init(); - assert_eq!(LevelFilter::current(), LevelFilter::DEBUG); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/hinted_layer_filters_dont_break_other_layers.rs b/vendor/tracing-subscriber-0.3.3/tests/hinted_layer_filters_dont_break_other_layers.rs deleted file mode 100644 index 897dae282..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/hinted_layer_filters_dont_break_other_layers.rs +++ /dev/null @@ -1,131 +0,0 @@ -#![cfg(feature = "registry")] -mod support; -use self::support::*; -use tracing::{Level, Metadata, Subscriber}; -use tracing_subscriber::{filter::DynFilterFn, layer::Context, prelude::*}; - -#[test] -fn layer_filters() { - let (unfiltered, unfiltered_handle) = unfiltered("unfiltered"); - let (filtered, filtered_handle) = filtered("filtered"); - - let subscriber = tracing_subscriber::registry() - .with(unfiltered) - .with(filtered.with_filter(filter())); - assert_eq!(subscriber.max_level_hint(), None); - let _subscriber = subscriber.set_default(); - - events(); - - unfiltered_handle.assert_finished(); - filtered_handle.assert_finished(); -} - -#[test] -fn layered_layer_filters() { - let (unfiltered1, unfiltered1_handle) = unfiltered("unfiltered_1"); - let (unfiltered2, unfiltered2_handle) = unfiltered("unfiltered_2"); - let unfiltered = unfiltered1.and_then(unfiltered2); - - let (filtered1, filtered1_handle) = filtered("filtered_1"); - let (filtered2, filtered2_handle) = filtered("filtered_2"); - let filtered = filtered1 - .with_filter(filter()) - .and_then(filtered2.with_filter(filter())); - - let subscriber = tracing_subscriber::registry() - .with(unfiltered) - .with(filtered); - assert_eq!(subscriber.max_level_hint(), None); - let _subscriber = subscriber.set_default(); - - events(); - - unfiltered1_handle.assert_finished(); - unfiltered2_handle.assert_finished(); - filtered1_handle.assert_finished(); - filtered2_handle.assert_finished(); -} - -#[test] -fn out_of_order() { - let (unfiltered1, unfiltered1_handle) = unfiltered("unfiltered_1"); - let (unfiltered2, unfiltered2_handle) = unfiltered("unfiltered_2"); - - let (filtered1, filtered1_handle) = filtered("filtered_1"); - let (filtered2, filtered2_handle) = filtered("filtered_2"); - - let subscriber = tracing_subscriber::registry() - .with(unfiltered1) - .with(filtered1.with_filter(filter())) - .with(unfiltered2) - .with(filtered2.with_filter(filter())); - assert_eq!(subscriber.max_level_hint(), None); - let _subscriber = subscriber.set_default(); - - events(); - - unfiltered1_handle.assert_finished(); - unfiltered2_handle.assert_finished(); - filtered1_handle.assert_finished(); - filtered2_handle.assert_finished(); -} - -#[test] -fn mixed_layered() { - let (unfiltered1, unfiltered1_handle) = unfiltered("unfiltered_1"); - let (unfiltered2, unfiltered2_handle) = unfiltered("unfiltered_2"); - let (filtered1, filtered1_handle) = filtered("filtered_1"); - let (filtered2, filtered2_handle) = filtered("filtered_2"); - - let layered1 = filtered1.with_filter(filter()).and_then(unfiltered1); - let layered2 = unfiltered2.and_then(filtered2.with_filter(filter())); - - let subscriber = tracing_subscriber::registry().with(layered1).with(layered2); - assert_eq!(subscriber.max_level_hint(), None); - let _subscriber = subscriber.set_default(); - - events(); - - unfiltered1_handle.assert_finished(); - unfiltered2_handle.assert_finished(); - filtered1_handle.assert_finished(); - filtered2_handle.assert_finished(); -} - -fn events() { - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); -} - -fn filter() -> DynFilterFn { - DynFilterFn::new( - (|metadata: &Metadata<'_>, _: &tracing_subscriber::layer::Context<'_, S>| { - metadata.level() <= &Level::INFO - }) as fn(&Metadata<'_>, &Context<'_, S>) -> bool, - ) - .with_max_level_hint(Level::INFO) -} - -fn unfiltered(name: &str) -> (ExpectLayer, subscriber::MockHandle) { - layer::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle() -} - -fn filtered(name: &str) -> (ExpectLayer, subscriber::MockHandle) { - layer::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle() -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/layer_filter_interests_are_cached.rs b/vendor/tracing-subscriber-0.3.3/tests/layer_filter_interests_are_cached.rs deleted file mode 100644 index d89d3bf17..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/layer_filter_interests_are_cached.rs +++ /dev/null @@ -1,69 +0,0 @@ -#![cfg(feature = "registry")] -mod support; -use self::support::*; - -use std::{ - collections::HashMap, - sync::{Arc, Mutex}, -}; -use tracing::{Level, Subscriber}; -use tracing_subscriber::{filter, prelude::*}; - -#[test] -fn layer_filter_interests_are_cached() { - let seen = Arc::new(Mutex::new(HashMap::new())); - let seen2 = seen.clone(); - let filter = filter::filter_fn(move |meta| { - *seen - .lock() - .unwrap() - .entry(meta.callsite()) - .or_insert(0usize) += 1; - meta.level() == &Level::INFO - }); - - let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let subscriber = tracing_subscriber::registry().with(expect.with_filter(filter)); - assert!(subscriber.max_level_hint().is_none()); - - let _subscriber = subscriber.set_default(); - - fn events() { - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); - } - - events(); - { - let lock = seen2.lock().unwrap(); - for (callsite, &count) in lock.iter() { - assert_eq!( - count, 1, - "callsite {:?} should have been seen 1 time (after first set of events)", - callsite - ); - } - } - - events(); - { - let lock = seen2.lock().unwrap(); - for (callsite, &count) in lock.iter() { - assert_eq!( - count, 1, - "callsite {:?} should have been seen 1 time (after second set of events)", - callsite - ); - } - } - - handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/boxed.rs b/vendor/tracing-subscriber-0.3.3/tests/layer_filters/boxed.rs deleted file mode 100644 index 0fe37188e..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/boxed.rs +++ /dev/null @@ -1,42 +0,0 @@ -use super::*; -use tracing_subscriber::{filter, prelude::*, Layer}; - -fn layer() -> (ExpectLayer, subscriber::MockHandle) { - layer::mock().done().run_with_handle() -} - -fn filter() -> filter::DynFilterFn { - // Use dynamic filter fn to disable interest caching and max-level hints, - // allowing us to put all of these tests in the same file. - filter::dynamic_filter_fn(|_, _| false) -} - -/// reproduces https://github.com/tokio-rs/tracing/issues/1563#issuecomment-921363629 -#[test] -fn box_works() { - let (layer, handle) = layer(); - let layer = Box::new(layer.with_filter(filter())); - - let _guard = tracing_subscriber::registry().with(layer).set_default(); - - for i in 0..2 { - tracing::info!(i); - } - - handle.assert_finished(); -} - -/// the same as `box_works` but with a type-erased `Box`. -#[test] -fn dyn_box_works() { - let (layer, handle) = layer(); - let layer: Box + Send + Sync + 'static> = Box::new(layer.with_filter(filter())); - - let _guard = tracing_subscriber::registry().with(layer).set_default(); - - for i in 0..2 { - tracing::info!(i); - } - - handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/downcast_raw.rs b/vendor/tracing-subscriber-0.3.3/tests/layer_filters/downcast_raw.rs deleted file mode 100644 index b5f7e35ce..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/downcast_raw.rs +++ /dev/null @@ -1,68 +0,0 @@ -use tracing::Subscriber; -use tracing_subscriber::filter::Targets; -use tracing_subscriber::prelude::*; -use tracing_subscriber::Layer; - -#[test] -fn downcast_ref_to_inner_layer_and_filter() { - // Test that a filtered layer gives downcast_ref access to - // both the layer and the filter. - - struct WrappedLayer; - - impl Layer for WrappedLayer - where - S: Subscriber, - S: for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>, - { - } - - let layer = WrappedLayer; - let filter = Targets::new().with_default(tracing::Level::INFO); - let registry = tracing_subscriber::registry().with(layer.with_filter(filter)); - let dispatch = tracing::dispatcher::Dispatch::new(registry); - - // The filter is available - assert!(dispatch.downcast_ref::().is_some()); - // The wrapped layer is available - assert!(dispatch.downcast_ref::().is_some()); -} - -#[test] -fn forward_downcast_raw_to_layer() { - // Test that a filtered layer still gives its wrapped layer a chance to - // return a custom struct from downcast_raw. - // https://github.com/tokio-rs/tracing/issues/1618 - - struct WrappedLayer { - with_context: WithContext, - } - - struct WithContext; - - impl Layer for WrappedLayer - where - S: Subscriber, - S: for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>, - { - unsafe fn downcast_raw(&self, id: std::any::TypeId) -> Option<*const ()> { - match id { - id if id == std::any::TypeId::of::() => Some(self as *const _ as *const ()), - id if id == std::any::TypeId::of::() => { - Some(&self.with_context as *const _ as *const ()) - } - _ => None, - } - } - } - - let layer = WrappedLayer { - with_context: WithContext, - }; - let filter = Targets::new().with_default(tracing::Level::INFO); - let registry = tracing_subscriber::registry().with(layer.with_filter(filter)); - let dispatch = tracing::dispatcher::Dispatch::new(registry); - - // Types from a custom implementation of `downcast_raw` are available - assert!(dispatch.downcast_ref::().is_some()); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/filter_scopes.rs b/vendor/tracing-subscriber-0.3.3/tests/layer_filters/filter_scopes.rs deleted file mode 100644 index 7fd7d843b..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/filter_scopes.rs +++ /dev/null @@ -1,131 +0,0 @@ -use super::*; - -#[test] -fn filters_span_scopes() { - let (debug_layer, debug_handle) = layer::named("debug") - .enter(span::mock().at_level(Level::DEBUG)) - .enter(span::mock().at_level(Level::INFO)) - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) - .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), - span::mock().at_level(Level::INFO), - span::mock().at_level(Level::DEBUG), - ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .exit(span::mock().at_level(Level::INFO)) - .exit(span::mock().at_level(Level::DEBUG)) - .done() - .run_with_handle(); - let (info_layer, info_handle) = layer::named("info") - .enter(span::mock().at_level(Level::INFO)) - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) - .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), - span::mock().at_level(Level::INFO), - ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .exit(span::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - let (warn_layer, warn_handle) = layer::named("warn") - .enter(span::mock().at_level(Level::WARN)) - .enter(span::mock().at_level(Level::ERROR)) - .event(event::msg("hello world").in_scope(vec![ - span::mock().at_level(Level::ERROR), - span::mock().at_level(Level::WARN), - ])) - .exit(span::mock().at_level(Level::ERROR)) - .exit(span::mock().at_level(Level::WARN)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(debug_layer.with_filter(LevelFilter::DEBUG)) - .with(info_layer.with_filter(LevelFilter::INFO)) - .with(warn_layer.with_filter(LevelFilter::WARN)) - .set_default(); - - { - let _trace = tracing::trace_span!("my_span").entered(); - let _debug = tracing::debug_span!("my_span").entered(); - let _info = tracing::info_span!("my_span").entered(); - let _warn = tracing::warn_span!("my_span").entered(); - let _error = tracing::error_span!("my_span").entered(); - tracing::error!("hello world"); - } - - debug_handle.assert_finished(); - info_handle.assert_finished(); - warn_handle.assert_finished(); -} - -#[test] -fn filters_interleaved_span_scopes() { - fn target_layer(target: &'static str) -> (ExpectLayer, subscriber::MockHandle) { - layer::named(format!("target_{}", target)) - .enter(span::mock().with_target(target)) - .enter(span::mock().with_target(target)) - .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target(target), - span::mock().with_target(target), - ])) - .event( - event::msg("hello to my target") - .in_scope(vec![ - span::mock().with_target(target), - span::mock().with_target(target), - ]) - .with_target(target), - ) - .exit(span::mock().with_target(target)) - .exit(span::mock().with_target(target)) - .done() - .run_with_handle() - } - - let (a_layer, a_handle) = target_layer("a"); - let (b_layer, b_handle) = target_layer("b"); - let (all_layer, all_handle) = layer::named("all") - .enter(span::mock().with_target("b")) - .enter(span::mock().with_target("a")) - .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target("a"), - span::mock().with_target("b"), - ])) - .exit(span::mock().with_target("a")) - .exit(span::mock().with_target("b")) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(all_layer.with_filter(LevelFilter::INFO)) - .with(a_layer.with_filter(filter::filter_fn(|meta| { - let target = meta.target(); - target == "a" || target == module_path!() - }))) - .with(b_layer.with_filter(filter::filter_fn(|meta| { - let target = meta.target(); - target == "b" || target == module_path!() - }))) - .set_default(); - - { - let _a1 = tracing::trace_span!(target: "a", "a/trace").entered(); - let _b1 = tracing::info_span!(target: "b", "b/info").entered(); - let _a2 = tracing::info_span!(target: "a", "a/info").entered(); - let _b2 = tracing::trace_span!(target: "b", "b/trace").entered(); - tracing::info!("hello world"); - tracing::debug!(target: "a", "hello to my target"); - tracing::debug!(target: "b", "hello to my target"); - } - - a_handle.assert_finished(); - b_handle.assert_finished(); - all_handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/main.rs b/vendor/tracing-subscriber-0.3.3/tests/layer_filters/main.rs deleted file mode 100644 index 2359584d7..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/main.rs +++ /dev/null @@ -1,188 +0,0 @@ -#![cfg(feature = "registry")] -#[path = "../support.rs"] -mod support; -use self::support::*; -mod boxed; -mod downcast_raw; -mod filter_scopes; -mod targets; -mod trees; - -use tracing::{level_filters::LevelFilter, Level}; -use tracing_subscriber::{filter, prelude::*}; - -#[test] -fn basic_layer_filters() { - let (trace_layer, trace_handle) = layer::named("trace") - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let (debug_layer, debug_handle) = layer::named("debug") - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let (info_layer, info_handle) = layer::named("info") - .event(event::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(trace_layer.with_filter(LevelFilter::TRACE)) - .with(debug_layer.with_filter(LevelFilter::DEBUG)) - .with(info_layer.with_filter(LevelFilter::INFO)) - .set_default(); - - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - - trace_handle.assert_finished(); - debug_handle.assert_finished(); - info_handle.assert_finished(); -} - -#[test] -fn basic_layer_filters_spans() { - let (trace_layer, trace_handle) = layer::named("trace") - .new_span(span::mock().at_level(Level::TRACE)) - .new_span(span::mock().at_level(Level::DEBUG)) - .new_span(span::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let (debug_layer, debug_handle) = layer::named("debug") - .new_span(span::mock().at_level(Level::DEBUG)) - .new_span(span::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let (info_layer, info_handle) = layer::named("info") - .new_span(span::mock().at_level(Level::INFO)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(trace_layer.with_filter(LevelFilter::TRACE)) - .with(debug_layer.with_filter(LevelFilter::DEBUG)) - .with(info_layer.with_filter(LevelFilter::INFO)) - .set_default(); - - tracing::trace_span!("hello trace"); - tracing::debug_span!("hello debug"); - tracing::info_span!("hello info"); - - trace_handle.assert_finished(); - debug_handle.assert_finished(); - info_handle.assert_finished(); -} - -#[test] -fn global_filters_layers_still_work() { - let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(expect) - .with(LevelFilter::INFO) - .set_default(); - - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); - - handle.assert_finished(); -} - -#[test] -fn global_filter_interests_are_cached() { - let (expect, handle) = layer::mock() - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(expect.with_filter(filter::filter_fn(|meta| { - assert!( - meta.level() <= &Level::INFO, - "enabled should not be called for callsites disabled by the global filter" - ); - meta.level() <= &Level::WARN - }))) - .with(LevelFilter::INFO) - .set_default(); - - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); - - handle.assert_finished(); -} - -#[test] -fn global_filters_affect_layer_filters() { - let (expect, handle) = layer::named("debug") - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(expect.with_filter(LevelFilter::DEBUG)) - .with(LevelFilter::INFO) - .set_default(); - - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); - - handle.assert_finished(); -} - -#[test] -fn filter_fn() { - let (all, all_handle) = layer::named("all_targets") - .event(event::msg("hello foo")) - .event(event::msg("hello bar")) - .done() - .run_with_handle(); - - let (foo, foo_handle) = layer::named("foo_target") - .event(event::msg("hello foo")) - .done() - .run_with_handle(); - - let (bar, bar_handle) = layer::named("bar_target") - .event(event::msg("hello bar")) - .done() - .run_with_handle(); - - let _subscriber = tracing_subscriber::registry() - .with(all) - .with(foo.with_filter(filter::filter_fn(|meta| meta.target().starts_with("foo")))) - .with(bar.with_filter(filter::filter_fn(|meta| meta.target().starts_with("bar")))) - .set_default(); - - tracing::trace!(target: "foo", "hello foo"); - tracing::trace!(target: "bar", "hello bar"); - - foo_handle.assert_finished(); - bar_handle.assert_finished(); - all_handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/targets.rs b/vendor/tracing-subscriber-0.3.3/tests/layer_filters/targets.rs deleted file mode 100644 index c8133044b..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/targets.rs +++ /dev/null @@ -1,59 +0,0 @@ -use super::*; -use tracing_subscriber::{ - filter::{filter_fn, Targets}, - prelude::*, -}; - -#[test] -#[cfg_attr(not(feature = "tracing-log"), ignore)] -fn log_events() { - // Reproduces https://github.com/tokio-rs/tracing/issues/1563 - mod inner { - pub(super) const MODULE_PATH: &str = module_path!(); - - #[tracing::instrument] - pub(super) fn logs() { - log::debug!("inner"); - } - } - - let filter = Targets::new() - .with_default(LevelFilter::DEBUG) - .with_target(inner::MODULE_PATH, LevelFilter::WARN); - - let layer = - tracing_subscriber::layer::Identity::new().with_filter(filter_fn(move |_meta| true)); - - let _guard = tracing_subscriber::registry() - .with(filter) - .with(layer) - .set_default(); - - inner::logs(); -} - -#[test] -fn inner_layer_short_circuits() { - // This test ensures that when a global filter short-circuits `Interest` - // evaluation, we aren't left with a "dirty" per-layer filter state. - - let (layer, handle) = layer::mock() - .event(event::msg("hello world")) - .done() - .run_with_handle(); - - let filter = Targets::new().with_target("magic_target", LevelFilter::DEBUG); - - let _guard = tracing_subscriber::registry() - // Note: we don't just use a `LevelFilter` for the global filter here, - // because it will just return a max level filter, and the chain of - // `register_callsite` calls that would trigger the bug never happens... - .with(filter::filter_fn(|meta| meta.level() <= &Level::INFO)) - .with(layer.with_filter(filter)) - .set_default(); - - tracing::debug!("skip me please!"); - tracing::info!(target: "magic_target", "hello world"); - - handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/trees.rs b/vendor/tracing-subscriber-0.3.3/tests/layer_filters/trees.rs deleted file mode 100644 index 18cdd8ccc..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/layer_filters/trees.rs +++ /dev/null @@ -1,146 +0,0 @@ -use super::*; - -#[test] -fn basic_trees() { - let (with_target, with_target_handle) = layer::named("info_with_target") - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .done() - .run_with_handle(); - - let (info, info_handle) = layer::named("info") - .event( - event::mock() - .at_level(Level::INFO) - .with_target(module_path!()), - ) - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .done() - .run_with_handle(); - - let (all, all_handle) = layer::named("all") - .event( - event::mock() - .at_level(Level::INFO) - .with_target(module_path!()), - ) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::INFO).with_target("my_target")) - .event( - event::mock() - .at_level(Level::TRACE) - .with_target("my_target"), - ) - .done() - .run_with_handle(); - - let info_tree = info - .and_then( - with_target.with_filter(filter::filter_fn(|meta| dbg!(meta.target()) == "my_target")), - ) - .with_filter(LevelFilter::INFO); - - let subscriber = tracing_subscriber::registry().with(info_tree).with(all); - let _guard = dbg!(subscriber).set_default(); - - tracing::info!("hello world"); - tracing::trace!("hello trace"); - tracing::info!(target: "my_target", "hi to my target"); - tracing::trace!(target: "my_target", "hi to my target at trace"); - - all_handle.assert_finished(); - info_handle.assert_finished(); - with_target_handle.assert_finished(); -} - -#[test] -fn filter_span_scopes() { - fn target_layer(target: &'static str) -> (ExpectLayer, subscriber::MockHandle) { - layer::named(format!("target_{}", target)) - .enter(span::mock().with_target(target).at_level(Level::INFO)) - .event( - event::msg("hello world") - .in_scope(vec![span::mock().with_target(target).at_level(Level::INFO)]), - ) - .exit(span::mock().with_target(target).at_level(Level::INFO)) - .done() - .run_with_handle() - } - - let (a_layer, a_handle) = target_layer("a"); - let (b_layer, b_handle) = target_layer("b"); - let (info_layer, info_handle) = layer::named("info") - .enter(span::mock().with_target("b").at_level(Level::INFO)) - .enter(span::mock().with_target("a").at_level(Level::INFO)) - .event(event::msg("hello world").in_scope(vec![ - span::mock().with_target("a").at_level(Level::INFO), - span::mock().with_target("b").at_level(Level::INFO), - ])) - .exit(span::mock().with_target("a").at_level(Level::INFO)) - .exit(span::mock().with_target("b").at_level(Level::INFO)) - .done() - .run_with_handle(); - - let full_scope = vec![ - span::mock().with_target("b").at_level(Level::TRACE), - span::mock().with_target("a").at_level(Level::INFO), - span::mock().with_target("b").at_level(Level::INFO), - span::mock().with_target("a").at_level(Level::TRACE), - ]; - let (all_layer, all_handle) = layer::named("all") - .enter(span::mock().with_target("a").at_level(Level::TRACE)) - .enter(span::mock().with_target("b").at_level(Level::INFO)) - .enter(span::mock().with_target("a").at_level(Level::INFO)) - .enter(span::mock().with_target("b").at_level(Level::TRACE)) - .event(event::msg("hello world").in_scope(full_scope.clone())) - .event( - event::msg("hello to my target") - .with_target("a") - .in_scope(full_scope.clone()), - ) - .event( - event::msg("hello to my target") - .with_target("b") - .in_scope(full_scope), - ) - .exit(span::mock().with_target("b").at_level(Level::TRACE)) - .exit(span::mock().with_target("a").at_level(Level::INFO)) - .exit(span::mock().with_target("b").at_level(Level::INFO)) - .exit(span::mock().with_target("a").at_level(Level::TRACE)) - .done() - .run_with_handle(); - - let a_layer = a_layer.with_filter(filter::filter_fn(|meta| { - let target = meta.target(); - target == "a" || target == module_path!() - })); - - let b_layer = b_layer.with_filter(filter::filter_fn(|meta| { - let target = meta.target(); - target == "b" || target == module_path!() - })); - - let info_tree = info_layer - .and_then(a_layer) - .and_then(b_layer) - .with_filter(LevelFilter::INFO); - - let subscriber = tracing_subscriber::registry() - .with(info_tree) - .with(all_layer); - let _guard = dbg!(subscriber).set_default(); - - { - let _a1 = tracing::trace_span!(target: "a", "a/trace").entered(); - let _b1 = tracing::info_span!(target: "b", "b/info").entered(); - let _a2 = tracing::info_span!(target: "a", "a/info").entered(); - let _b2 = tracing::trace_span!(target: "b", "b/trace").entered(); - tracing::info!("hello world"); - tracing::debug!(target: "a", "hello to my target"); - tracing::debug!(target: "b", "hello to my target"); - } - - all_handle.assert_finished(); - info_handle.assert_finished(); - a_handle.assert_finished(); - b_handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/multiple_layer_filter_interests_cached.rs b/vendor/tracing-subscriber-0.3.3/tests/multiple_layer_filter_interests_cached.rs deleted file mode 100644 index 5c25e7f03..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/multiple_layer_filter_interests_cached.rs +++ /dev/null @@ -1,131 +0,0 @@ -#![cfg(feature = "registry")] -mod support; -use self::support::*; - -use std::{ - collections::HashMap, - sync::{Arc, Mutex}, -}; -use tracing::{Level, Subscriber}; -use tracing_subscriber::{filter, prelude::*}; - -#[test] -fn multiple_layer_filter_interests_are_cached() { - // This layer will return Interest::always for INFO and lower. - let seen_info = Arc::new(Mutex::new(HashMap::new())); - let seen_info2 = seen_info.clone(); - let filter = filter::filter_fn(move |meta| { - *seen_info - .lock() - .unwrap() - .entry(*meta.level()) - .or_insert(0usize) += 1; - meta.level() <= &Level::INFO - }); - let seen_info = seen_info2; - - let (info_layer, info_handle) = layer::named("info") - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle(); - let info_layer = info_layer.with_filter(filter); - - // This layer will return Interest::always for WARN and lower. - let seen_warn = Arc::new(Mutex::new(HashMap::new())); - let seen_warn2 = seen_warn.clone(); - let filter = filter::filter_fn(move |meta| { - *seen_warn - .lock() - .unwrap() - .entry(*meta.level()) - .or_insert(0usize) += 1; - meta.level() <= &Level::WARN - }); - let seen_warn = seen_warn2; - - let (warn_layer, warn_handle) = layer::named("warn") - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle(); - let warn_layer = warn_layer.with_filter(filter); - - let subscriber = tracing_subscriber::registry() - .with(warn_layer) - .with(info_layer); - assert!(subscriber.max_level_hint().is_none()); - - let _subscriber = subscriber.set_default(); - - fn events() { - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); - } - - events(); - { - let lock = seen_info.lock().unwrap(); - for (&level, &count) in lock.iter() { - if level == Level::INFO { - continue; - } - assert_eq!( - count, 1, - "level {:?} should have been seen 1 time by the INFO layer (after first set of events)", - level - ); - } - - let lock = seen_warn.lock().unwrap(); - for (&level, &count) in lock.iter() { - if level == Level::INFO { - continue; - } - assert_eq!( - count, 1, - "level {:?} should have been seen 1 time by the WARN layer (after first set of events)", - level - ); - } - } - - events(); - { - let lock = seen_info.lock().unwrap(); - for (&level, &count) in lock.iter() { - if level == Level::INFO { - continue; - } - assert_eq!( - count, 1, - "level {:?} should have been seen 1 time by the INFO layer (after second set of events)", - level - ); - } - - let lock = seen_warn.lock().unwrap(); - for (&level, &count) in lock.iter() { - if level == Level::INFO { - continue; - } - assert_eq!( - count, 1, - "level {:?} should have been seen 1 time by the WARN layer (after second set of events)", - level - ); - } - } - - info_handle.assert_finished(); - warn_handle.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/registry_max_level_hint.rs b/vendor/tracing-subscriber-0.3.3/tests/registry_max_level_hint.rs deleted file mode 100644 index f94c8a1fb..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/registry_max_level_hint.rs +++ /dev/null @@ -1,11 +0,0 @@ -#![cfg(all(feature = "registry", feature = "fmt"))] -use tracing_subscriber::{filter::LevelFilter, prelude::*}; - -#[test] -fn registry_sets_max_level_hint() { - tracing_subscriber::registry() - .with(tracing_subscriber::fmt::layer()) - .with(LevelFilter::DEBUG) - .init(); - assert_eq!(LevelFilter::current(), LevelFilter::DEBUG); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/registry_with_subscriber.rs b/vendor/tracing-subscriber-0.3.3/tests/registry_with_subscriber.rs deleted file mode 100644 index 3f8d99b1d..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/registry_with_subscriber.rs +++ /dev/null @@ -1,25 +0,0 @@ -#![cfg(feature = "registry")] -use tracing_futures::{Instrument, WithSubscriber}; -use tracing_subscriber::prelude::*; - -#[tokio::test] -async fn future_with_subscriber() { - let _default = tracing_subscriber::registry().init(); - let span = tracing::info_span!("foo"); - let _e = span.enter(); - let span = tracing::info_span!("bar"); - let _e = span.enter(); - tokio::spawn( - async { - async { - let span = tracing::Span::current(); - println!("{:?}", span); - } - .instrument(tracing::info_span!("hi")) - .await - } - .with_subscriber(tracing_subscriber::registry()), - ) - .await - .unwrap(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/reload.rs b/vendor/tracing-subscriber-0.3.3/tests/reload.rs deleted file mode 100644 index 5fe422e08..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/reload.rs +++ /dev/null @@ -1,81 +0,0 @@ -#![cfg(feature = "reload")] -use std::sync::atomic::{AtomicUsize, Ordering}; -use tracing_core::{ - span::{Attributes, Id, Record}, - subscriber::Interest, - Event, Metadata, Subscriber, -}; -use tracing_subscriber::{layer, prelude::*, reload::*}; - -pub struct NopSubscriber; - -impl Subscriber for NopSubscriber { - fn register_callsite(&self, _: &'static Metadata<'static>) -> Interest { - Interest::never() - } - - fn enabled(&self, _: &Metadata<'_>) -> bool { - false - } - - fn new_span(&self, _: &Attributes<'_>) -> Id { - Id::from_u64(1) - } - - fn record(&self, _: &Id, _: &Record<'_>) {} - fn record_follows_from(&self, _: &Id, _: &Id) {} - fn event(&self, _: &Event<'_>) {} - fn enter(&self, _: &Id) {} - fn exit(&self, _: &Id) {} -} - -#[test] -fn reload_handle() { - static FILTER1_CALLS: AtomicUsize = AtomicUsize::new(0); - static FILTER2_CALLS: AtomicUsize = AtomicUsize::new(0); - - enum Filter { - One, - Two, - } - - impl tracing_subscriber::Layer for Filter { - fn register_callsite(&self, m: &Metadata<'_>) -> Interest { - println!("REGISTER: {:?}", m); - Interest::sometimes() - } - - fn enabled(&self, m: &Metadata<'_>, _: layer::Context<'_, S>) -> bool { - println!("ENABLED: {:?}", m); - match self { - Filter::One => FILTER1_CALLS.fetch_add(1, Ordering::SeqCst), - Filter::Two => FILTER2_CALLS.fetch_add(1, Ordering::SeqCst), - }; - true - } - } - fn event() { - tracing::trace!("my event"); - } - - let (layer, handle) = Layer::new(Filter::One); - - let subscriber = tracing_core::dispatcher::Dispatch::new(layer.with_subscriber(NopSubscriber)); - - tracing_core::dispatcher::with_default(&subscriber, || { - assert_eq!(FILTER1_CALLS.load(Ordering::SeqCst), 0); - assert_eq!(FILTER2_CALLS.load(Ordering::SeqCst), 0); - - event(); - - assert_eq!(FILTER1_CALLS.load(Ordering::SeqCst), 1); - assert_eq!(FILTER2_CALLS.load(Ordering::SeqCst), 0); - - handle.reload(Filter::Two).expect("should reload"); - - event(); - - assert_eq!(FILTER1_CALLS.load(Ordering::SeqCst), 1); - assert_eq!(FILTER2_CALLS.load(Ordering::SeqCst), 1); - }) -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/same_len_filters.rs b/vendor/tracing-subscriber-0.3.3/tests/same_len_filters.rs deleted file mode 100644 index b525ea6fd..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/same_len_filters.rs +++ /dev/null @@ -1,81 +0,0 @@ -// These tests include field filters with no targets, so they have to go in a -// separate file. -#![cfg(feature = "env-filter")] -mod support; -use self::support::*; -use tracing::{self, subscriber::with_default, Level}; -use tracing_subscriber::{filter::EnvFilter, prelude::*}; - -#[test] -fn same_length_targets() { - let filter: EnvFilter = "foo=trace,bar=trace".parse().expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::TRACE)) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - - with_default(subscriber, || { - tracing::trace!(target: "foo", "foo"); - tracing::trace!(target: "bar", "bar"); - }); - - finished.assert_finished(); -} - -#[test] -fn same_num_fields_event() { - let filter: EnvFilter = "[{foo}]=trace,[{bar}]=trace" - .parse() - .expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .event( - event::mock() - .at_level(Level::TRACE) - .with_fields(field::mock("foo")), - ) - .event( - event::mock() - .at_level(Level::TRACE) - .with_fields(field::mock("bar")), - ) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - with_default(subscriber, || { - tracing::trace!(foo = 1); - tracing::trace!(bar = 3); - }); - - finished.assert_finished(); -} - -#[test] -fn same_num_fields_and_name_len() { - let filter: EnvFilter = "[foo{bar=1}]=trace,[baz{boz=1}]=trace" - .parse() - .expect("filter should parse"); - let (subscriber, finished) = subscriber::mock() - .new_span( - span::mock() - .named("foo") - .at_level(Level::TRACE) - .with_field(field::mock("bar")), - ) - .new_span( - span::mock() - .named("baz") - .at_level(Level::TRACE) - .with_field(field::mock("boz")), - ) - .done() - .run_with_handle(); - let subscriber = subscriber.with(filter); - with_default(subscriber, || { - tracing::trace_span!("foo", bar = 1); - tracing::trace_span!("baz", boz = 1); - }); - - finished.assert_finished(); -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/support.rs b/vendor/tracing-subscriber-0.3.3/tests/support.rs deleted file mode 100644 index 848ebdc63..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/support.rs +++ /dev/null @@ -1,412 +0,0 @@ -#![allow(missing_docs, dead_code)] -pub use self::support::{event, field, span, subscriber}; -// This has to have the same name as the module in `tracing`. -// path attribute requires referenced module to have same name so allow module inception here -#[allow(clippy::module_inception)] -#[path = "../../tracing/tests/support/mod.rs"] -mod support; - -use self::{ - event::MockEvent, - span::{MockSpan, NewSpan}, - subscriber::{Expect, MockHandle}, -}; -use tracing_core::{ - span::{Attributes, Id, Record}, - Event, Subscriber, -}; -use tracing_subscriber::{ - layer::{Context, Layer}, - registry::{LookupSpan, SpanRef}, -}; - -use std::{ - collections::VecDeque, - fmt, - sync::{Arc, Mutex}, -}; - -pub mod layer { - use super::ExpectLayerBuilder; - - pub fn mock() -> ExpectLayerBuilder { - ExpectLayerBuilder { - expected: Default::default(), - name: std::thread::current() - .name() - .map(String::from) - .unwrap_or_default(), - } - } - - pub fn named(name: impl std::fmt::Display) -> ExpectLayerBuilder { - mock().named(name) - } -} - -pub struct ExpectLayerBuilder { - expected: VecDeque, - name: String, -} - -pub struct ExpectLayer { - expected: Arc>>, - current: Mutex>, - name: String, -} - -impl ExpectLayerBuilder { - /// Overrides the name printed by the mock subscriber's debugging output. - /// - /// The debugging output is displayed if the test panics, or if the test is - /// run with `--nocapture`. - /// - /// By default, the mock subscriber's name is the name of the test - /// (*technically*, the name of the thread where it was created, which is - /// the name of the test unless tests are run with `--test-threads=1`). - /// When a test has only one mock subscriber, this is sufficient. However, - /// some tests may include multiple subscribers, in order to test - /// interactions between multiple subscribers. In that case, it can be - /// helpful to give each subscriber a separate name to distinguish where the - /// debugging output comes from. - pub fn named(mut self, name: impl fmt::Display) -> Self { - use std::fmt::Write; - if !self.name.is_empty() { - write!(&mut self.name, "::{}", name).unwrap(); - } else { - self.name = name.to_string(); - } - self - } - - pub fn enter(mut self, span: MockSpan) -> Self { - self.expected.push_back(Expect::Enter(span)); - self - } - - pub fn event(mut self, event: MockEvent) -> Self { - self.expected.push_back(Expect::Event(event)); - self - } - - pub fn exit(mut self, span: MockSpan) -> Self { - self.expected.push_back(Expect::Exit(span)); - self - } - - pub fn done(mut self) -> Self { - self.expected.push_back(Expect::Nothing); - self - } - - pub fn record(mut self, span: MockSpan, fields: I) -> Self - where - I: Into, - { - self.expected.push_back(Expect::Visit(span, fields.into())); - self - } - - pub fn new_span(mut self, new_span: I) -> Self - where - I: Into, - { - self.expected.push_back(Expect::NewSpan(new_span.into())); - self - } - - pub fn run(self) -> ExpectLayer { - ExpectLayer { - expected: Arc::new(Mutex::new(self.expected)), - name: self.name, - current: Mutex::new(Vec::new()), - } - } - - pub fn run_with_handle(self) -> (ExpectLayer, MockHandle) { - let expected = Arc::new(Mutex::new(self.expected)); - let handle = MockHandle::new(expected.clone(), self.name.clone()); - let layer = ExpectLayer { - expected, - name: self.name, - current: Mutex::new(Vec::new()), - }; - (layer, handle) - } -} - -impl ExpectLayer { - fn check_span_ref<'spans, S>( - &self, - expected: &MockSpan, - actual: &SpanRef<'spans, S>, - what_happened: impl fmt::Display, - ) where - S: LookupSpan<'spans>, - { - if let Some(exp_name) = expected.name() { - assert_eq!( - actual.name(), - exp_name, - "\n[{}] expected {} a span named {:?}\n\ - [{}] but it was named {:?} instead (span {} {:?})", - self.name, - what_happened, - exp_name, - self.name, - actual.name(), - actual.name(), - actual.id() - ); - } - - if let Some(exp_level) = expected.level() { - let actual_level = actual.metadata().level(); - assert_eq!( - actual_level, - &exp_level, - "\n[{}] expected {} a span at {:?}\n\ - [{}] but it was at {:?} instead (span {} {:?})", - self.name, - what_happened, - exp_level, - self.name, - actual_level, - actual.name(), - actual.id(), - ); - } - - if let Some(exp_target) = expected.target() { - let actual_target = actual.metadata().target(); - assert_eq!( - actual_target, - exp_target, - "\n[{}] expected {} a span with target {:?}\n\ - [{}] but it had the target {:?} instead (span {} {:?})", - self.name, - what_happened, - exp_target, - self.name, - actual_target, - actual.name(), - actual.id(), - ); - } - } -} - -impl Layer for ExpectLayer -where - S: Subscriber + for<'a> LookupSpan<'a>, -{ - fn register_callsite( - &self, - metadata: &'static tracing::Metadata<'static>, - ) -> tracing_core::Interest { - println!("[{}] register_callsite {:#?}", self.name, metadata); - tracing_core::Interest::always() - } - - fn on_record(&self, _: &Id, _: &Record<'_>, _: Context<'_, S>) { - unimplemented!( - "so far, we don't have any tests that need an `on_record` \ - implementation.\nif you just wrote one that does, feel free to \ - implement it!" - ); - } - - fn on_event(&self, event: &Event<'_>, cx: Context<'_, S>) { - let name = event.metadata().name(); - println!( - "[{}] event: {}; level: {}; target: {}", - self.name, - name, - event.metadata().level(), - event.metadata().target(), - ); - match self.expected.lock().unwrap().pop_front() { - None => {} - Some(Expect::Event(mut expected)) => { - let get_parent_name = || cx.event_span(event).map(|span| span.name().to_string()); - expected.check(event, get_parent_name, &self.name); - let mut current_scope = cx.event_scope(event).into_iter().flatten(); - let expected_scope = expected.scope_mut(); - let mut i = 0; - for (expected, actual) in expected_scope.iter_mut().zip(&mut current_scope) { - println!( - "[{}] event_scope[{}] actual={} ({:?}); expected={}", - self.name, - i, - actual.name(), - actual.id(), - expected - ); - self.check_span_ref( - expected, - &actual, - format_args!("the {}th span in the event's scope to be", i), - ); - i += 1; - } - let remaining_expected = &expected_scope[i..]; - assert!( - remaining_expected.is_empty(), - "\n[{}] did not observe all expected spans in event scope!\n[{}] missing: {:#?}", - self.name, - self.name, - remaining_expected, - ); - assert!( - current_scope.next().is_none(), - "\n[{}] did not expect all spans in the actual event scope!", - self.name, - ); - } - Some(ex) => ex.bad(&self.name, format_args!("observed event {:#?}", event)), - } - } - - fn on_follows_from(&self, _span: &Id, _follows: &Id, _: Context<'_, S>) { - // TODO: it should be possible to expect spans to follow from other spans - } - - fn on_new_span(&self, span: &Attributes<'_>, id: &Id, cx: Context<'_, S>) { - let meta = span.metadata(); - println!( - "[{}] new_span: name={:?}; target={:?}; id={:?};", - self.name, - meta.name(), - meta.target(), - id - ); - let mut expected = self.expected.lock().unwrap(); - let was_expected = matches!(expected.front(), Some(Expect::NewSpan(_))); - if was_expected { - if let Expect::NewSpan(mut expected) = expected.pop_front().unwrap() { - let get_parent_name = || { - span.parent() - .and_then(|id| cx.span(id)) - .or_else(|| cx.lookup_current()) - .map(|span| span.name().to_string()) - }; - expected.check(span, get_parent_name, &self.name); - } - } - } - - fn on_enter(&self, id: &Id, cx: Context<'_, S>) { - let span = cx - .span(id) - .unwrap_or_else(|| panic!("[{}] no span for ID {:?}", self.name, id)); - println!("[{}] enter: {}; id={:?};", self.name, span.name(), id); - match self.expected.lock().unwrap().pop_front() { - None => {} - Some(Expect::Enter(ref expected_span)) => { - self.check_span_ref(expected_span, &span, "to enter"); - } - Some(ex) => ex.bad(&self.name, format_args!("entered span {:?}", span.name())), - } - self.current.lock().unwrap().push(id.clone()); - } - - fn on_exit(&self, id: &Id, cx: Context<'_, S>) { - if std::thread::panicking() { - // `exit()` can be called in `drop` impls, so we must guard against - // double panics. - println!("[{}] exit {:?} while panicking", self.name, id); - return; - } - let span = cx - .span(id) - .unwrap_or_else(|| panic!("[{}] no span for ID {:?}", self.name, id)); - println!("[{}] exit: {}; id={:?};", self.name, span.name(), id); - match self.expected.lock().unwrap().pop_front() { - None => {} - Some(Expect::Exit(ref expected_span)) => { - self.check_span_ref(expected_span, &span, "to exit"); - let curr = self.current.lock().unwrap().pop(); - assert_eq!( - Some(id), - curr.as_ref(), - "[{}] exited span {:?}, but the current span was {:?}", - self.name, - span.name(), - curr.as_ref().and_then(|id| cx.span(id)).map(|s| s.name()) - ); - } - Some(ex) => ex.bad(&self.name, format_args!("exited span {:?}", span.name())), - }; - } - - fn on_close(&self, id: Id, cx: Context<'_, S>) { - if std::thread::panicking() { - // `try_close` can be called in `drop` impls, so we must guard against - // double panics. - println!("[{}] close {:?} while panicking", self.name, id); - return; - } - let span = cx.span(&id); - let name = span.as_ref().map(|span| { - println!("[{}] close_span: {}; id={:?};", self.name, span.name(), id,); - span.name() - }); - if name.is_none() { - println!("[{}] drop_span: id={:?}", self.name, id); - } - if let Ok(mut expected) = self.expected.try_lock() { - let was_expected = match expected.front() { - Some(Expect::DropSpan(ref expected_span)) => { - // Don't assert if this function was called while panicking, - // as failing the assertion can cause a double panic. - if !::std::thread::panicking() { - if let Some(ref span) = span { - self.check_span_ref(expected_span, span, "to close"); - } - } - true - } - Some(Expect::Event(_)) => { - if !::std::thread::panicking() { - panic!( - "[{}] expected an event, but dropped span {} (id={:?}) instead", - self.name, - name.unwrap_or(""), - id - ); - } - true - } - _ => false, - }; - if was_expected { - expected.pop_front(); - } - } - } - - fn on_id_change(&self, _old: &Id, _new: &Id, _ctx: Context<'_, S>) { - panic!("well-behaved subscribers should never do this to us, lol"); - } -} - -impl fmt::Debug for ExpectLayer { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let mut s = f.debug_struct("ExpectLayer"); - s.field("name", &self.name); - - if let Ok(expected) = self.expected.try_lock() { - s.field("expected", &expected); - } else { - s.field("expected", &format_args!("")); - } - - if let Ok(current) = self.current.try_lock() { - s.field("current", &format_args!("{:?}", ¤t)); - } else { - s.field("current", &format_args!("")); - } - - s.finish() - } -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/unhinted_layer_filters_dont_break_other_layers.rs b/vendor/tracing-subscriber-0.3.3/tests/unhinted_layer_filters_dont_break_other_layers.rs deleted file mode 100644 index 9fa5c6bd4..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/unhinted_layer_filters_dont_break_other_layers.rs +++ /dev/null @@ -1,123 +0,0 @@ -#![cfg(feature = "registry")] -mod support; -use self::support::*; -use tracing::Level; -use tracing_subscriber::{filter::DynFilterFn, prelude::*}; - -#[test] -fn layer_filters() { - let (unfiltered, unfiltered_handle) = unfiltered("unfiltered"); - let (filtered, filtered_handle) = filtered("filtered"); - - let _subscriber = tracing_subscriber::registry() - .with(unfiltered) - .with(filtered.with_filter(filter())) - .set_default(); - - events(); - - unfiltered_handle.assert_finished(); - filtered_handle.assert_finished(); -} - -#[test] -fn layered_layer_filters() { - let (unfiltered1, unfiltered1_handle) = unfiltered("unfiltered_1"); - let (unfiltered2, unfiltered2_handle) = unfiltered("unfiltered_2"); - let unfiltered = unfiltered1.and_then(unfiltered2); - - let (filtered1, filtered1_handle) = filtered("filtered_1"); - let (filtered2, filtered2_handle) = filtered("filtered_2"); - let filtered = filtered1 - .with_filter(filter()) - .and_then(filtered2.with_filter(filter())); - - let _subscriber = tracing_subscriber::registry() - .with(unfiltered) - .with(filtered) - .set_default(); - - events(); - - unfiltered1_handle.assert_finished(); - unfiltered2_handle.assert_finished(); - filtered1_handle.assert_finished(); - filtered2_handle.assert_finished(); -} - -#[test] -fn out_of_order() { - let (unfiltered1, unfiltered1_handle) = unfiltered("unfiltered_1"); - let (unfiltered2, unfiltered2_handle) = unfiltered("unfiltered_2"); - - let (filtered1, filtered1_handle) = filtered("filtered_1"); - let (filtered2, filtered2_handle) = filtered("filtered_2"); - - let _subscriber = tracing_subscriber::registry() - .with(unfiltered1) - .with(filtered1.with_filter(filter())) - .with(unfiltered2) - .with(filtered2.with_filter(filter())) - .set_default(); - events(); - - unfiltered1_handle.assert_finished(); - unfiltered2_handle.assert_finished(); - filtered1_handle.assert_finished(); - filtered2_handle.assert_finished(); -} - -#[test] -fn mixed_layered() { - let (unfiltered1, unfiltered1_handle) = unfiltered("unfiltered_1"); - let (unfiltered2, unfiltered2_handle) = unfiltered("unfiltered_2"); - let (filtered1, filtered1_handle) = filtered("filtered_1"); - let (filtered2, filtered2_handle) = filtered("filtered_2"); - - let layered1 = filtered1.with_filter(filter()).and_then(unfiltered1); - let layered2 = unfiltered2.and_then(filtered2.with_filter(filter())); - - let _subscriber = tracing_subscriber::registry() - .with(layered1) - .with(layered2) - .set_default(); - - events(); - - unfiltered1_handle.assert_finished(); - unfiltered2_handle.assert_finished(); - filtered1_handle.assert_finished(); - filtered2_handle.assert_finished(); -} - -fn events() { - tracing::trace!("hello trace"); - tracing::debug!("hello debug"); - tracing::info!("hello info"); - tracing::warn!("hello warn"); - tracing::error!("hello error"); -} - -fn filter() -> DynFilterFn { - DynFilterFn::new(|metadata, _| metadata.level() <= &Level::INFO) -} - -fn unfiltered(name: &str) -> (ExpectLayer, subscriber::MockHandle) { - layer::named(name) - .event(event::mock().at_level(Level::TRACE)) - .event(event::mock().at_level(Level::DEBUG)) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle() -} - -fn filtered(name: &str) -> (ExpectLayer, subscriber::MockHandle) { - layer::named(name) - .event(event::mock().at_level(Level::INFO)) - .event(event::mock().at_level(Level::WARN)) - .event(event::mock().at_level(Level::ERROR)) - .done() - .run_with_handle() -} diff --git a/vendor/tracing-subscriber-0.3.3/tests/utils.rs b/vendor/tracing-subscriber-0.3.3/tests/utils.rs deleted file mode 100644 index ff025a2a2..000000000 --- a/vendor/tracing-subscriber-0.3.3/tests/utils.rs +++ /dev/null @@ -1,39 +0,0 @@ -#![cfg(feature = "std")] -mod support; -use self::support::*; -use tracing_subscriber::prelude::*; - -#[test] -fn init_ext_works() { - let (subscriber, finished) = subscriber::mock() - .event( - event::mock() - .at_level(tracing::Level::INFO) - .with_target("init_works"), - ) - .done() - .run_with_handle(); - - let _guard = subscriber.set_default(); - tracing::info!(target: "init_works", "it worked!"); - finished.assert_finished(); -} - -#[test] -#[cfg(feature = "fmt")] -fn builders_are_init_ext() { - tracing_subscriber::fmt().set_default(); - let _ = tracing_subscriber::fmt() - .with_target(false) - .compact() - .try_init(); -} - -#[test] -#[cfg(all(feature = "fmt", feature = "env-filter"))] -fn layered_is_init_ext() { - tracing_subscriber::registry() - .with(tracing_subscriber::fmt::layer()) - .with(tracing_subscriber::EnvFilter::new("foo=info")) - .set_default(); -} -- cgit v1.2.3