From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Wed, 17 Apr 2024 14:02:58 +0200
Subject: Adding upstream version 1.64.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 vendor/tracing/tests/subscriber.rs | 130 +++++++++++++++++++++++++++++++++++++
 1 file changed, 130 insertions(+)
 create mode 100644 vendor/tracing/tests/subscriber.rs

(limited to 'vendor/tracing/tests/subscriber.rs')

diff --git a/vendor/tracing/tests/subscriber.rs b/vendor/tracing/tests/subscriber.rs
new file mode 100644
index 000000000..15557c107
--- /dev/null
+++ b/vendor/tracing/tests/subscriber.rs
@@ -0,0 +1,130 @@
+// These tests require the thread-local scoped dispatcher, which only works when
+// we have a standard library. The behaviour being tested should be the same
+// with the standard lib disabled.
+//
+// The alternative would be for each of these tests to be defined in a separate
+// file, which is :(
+#![cfg(feature = "std")]
+use tracing::{
+    field::display,
+    span::{Attributes, Id, Record},
+    subscriber::{with_default, Interest, Subscriber},
+    Event, Level, Metadata,
+};
+
+use tracing_mock::*;
+
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[test]
+fn event_macros_dont_infinite_loop() {
+    // This test ensures that an event macro within a subscriber
+    // won't cause an infinite loop of events.
+    struct TestSubscriber;
+    impl Subscriber for TestSubscriber {
+        fn register_callsite(&self, _: &Metadata<'_>) -> Interest {
+            // Always return sometimes so that `enabled` will be called
+            // (which can loop).
+            Interest::sometimes()
+        }
+
+        fn enabled(&self, meta: &Metadata<'_>) -> bool {
+            assert!(meta.fields().iter().any(|f| f.name() == "foo"));
+            tracing::event!(Level::TRACE, bar = false);
+            true
+        }
+
+        fn new_span(&self, _: &Attributes<'_>) -> Id {
+            Id::from_u64(0xAAAA)
+        }
+
+        fn record(&self, _: &Id, _: &Record<'_>) {}
+
+        fn record_follows_from(&self, _: &Id, _: &Id) {}
+
+        fn event(&self, event: &Event<'_>) {
+            assert!(event.metadata().fields().iter().any(|f| f.name() == "foo"));
+            tracing::event!(Level::TRACE, baz = false);
+        }
+
+        fn enter(&self, _: &Id) {}
+
+        fn exit(&self, _: &Id) {}
+    }
+
+    with_default(TestSubscriber, || {
+        tracing::event!(Level::TRACE, foo = false);
+    })
+}
+
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[test]
+fn boxed_subscriber() {
+    let (subscriber, handle) = subscriber::mock()
+        .new_span(
+            span::mock().named("foo").with_field(
+                field::mock("bar")
+                    .with_value(&display("hello from my span"))
+                    .only(),
+            ),
+        )
+        .enter(span::mock().named("foo"))
+        .exit(span::mock().named("foo"))
+        .drop_span(span::mock().named("foo"))
+        .done()
+        .run_with_handle();
+    let subscriber: Box<dyn Subscriber + Send + Sync + 'static> = Box::new(subscriber);
+
+    with_default(subscriber, || {
+        let from = "my span";
+        let span = tracing::span!(
+            Level::TRACE,
+            "foo",
+            bar = format_args!("hello from {}", from)
+        );
+        span.in_scope(|| {});
+    });
+
+    handle.assert_finished();
+}
+
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[test]
+fn arced_subscriber() {
+    use std::sync::Arc;
+
+    let (subscriber, handle) = subscriber::mock()
+        .new_span(
+            span::mock().named("foo").with_field(
+                field::mock("bar")
+                    .with_value(&display("hello from my span"))
+                    .only(),
+            ),
+        )
+        .enter(span::mock().named("foo"))
+        .exit(span::mock().named("foo"))
+        .drop_span(span::mock().named("foo"))
+        .event(
+            event::mock()
+                .with_fields(field::mock("message").with_value(&display("hello from my event"))),
+        )
+        .done()
+        .run_with_handle();
+    let subscriber: Arc<dyn Subscriber + Send + Sync + 'static> = Arc::new(subscriber);
+
+    // Test using a clone of the `Arc`ed subscriber
+    with_default(subscriber.clone(), || {
+        let from = "my span";
+        let span = tracing::span!(
+            Level::TRACE,
+            "foo",
+            bar = format_args!("hello from {}", from)
+        );
+        span.in_scope(|| {});
+    });
+
+    with_default(subscriber, || {
+        tracing::info!("hello from my event");
+    });
+
+    handle.assert_finished();
+}
-- 
cgit v1.2.3