Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 1031 insertions, 0 deletions

diff --git a/vendor/log/src/kv/value.rs b/vendor/log/src/kv/value.rs
new file mode 100644
index 0000000..9485d48
--- /dev/null
+++ b/vendor/log/src/kv/value.rs
@@ -0,0 +1,1031 @@
+//! Structured values.
+
+use std::fmt;
+
+extern crate value_bag;
+
+#[cfg(feature = "kv_unstable_sval")]
+extern crate sval;
+#[cfg(feature = "kv_unstable_sval")]
+extern crate sval_ref;
+
+#[cfg(feature = "kv_unstable_serde")]
+extern crate serde;
+
+use self::value_bag::ValueBag;
+
+pub use kv::Error;
+
+/// A type that can be converted into a [`Value`](struct.Value.html).
+pub trait ToValue {
+    /// Perform the conversion.
+    fn to_value(&self) -> Value;
+}
+
+impl<'a, T> ToValue for &'a T
+where
+    T: ToValue + ?Sized,
+{
+    fn to_value(&self) -> Value {
+        (**self).to_value()
+    }
+}
+
+impl<'v> ToValue for Value<'v> {
+    fn to_value(&self) -> Value {
+        Value {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+/// Get a value from a type implementing `std::fmt::Debug`.
+#[macro_export]
+macro_rules! as_debug {
+    ($capture:expr) => {
+        $crate::kv::Value::from_debug(&$capture)
+    };
+}
+
+/// Get a value from a type implementing `std::fmt::Display`.
+#[macro_export]
+macro_rules! as_display {
+    ($capture:expr) => {
+        $crate::kv::Value::from_display(&$capture)
+    };
+}
+
+/// Get a value from an error.
+#[cfg(feature = "kv_unstable_std")]
+#[macro_export]
+macro_rules! as_error {
+    ($capture:expr) => {
+        $crate::kv::Value::from_dyn_error(&$capture)
+    };
+}
+
+#[cfg(feature = "kv_unstable_serde")]
+/// Get a value from a type implementing `serde::Serialize`.
+#[macro_export]
+macro_rules! as_serde {
+    ($capture:expr) => {
+        $crate::kv::Value::from_serde(&$capture)
+    };
+}
+
+/// Get a value from a type implementing `sval::Value`.
+#[cfg(feature = "kv_unstable_sval")]
+#[macro_export]
+macro_rules! as_sval {
+    ($capture:expr) => {
+        $crate::kv::Value::from_sval(&$capture)
+    };
+}
+
+/// A value in a structured key-value pair.
+///
+/// # Capturing values
+///
+/// There are a few ways to capture a value:
+///
+/// - Using the `Value::capture_*` methods.
+/// - Using the `Value::from_*` methods.
+/// - Using the `ToValue` trait.
+/// - Using the standard `From` trait.
+///
+/// ## Using the `Value::capture_*` methods
+///
+/// `Value` offers a few constructor methods that capture values of different kinds.
+/// These methods require a `T: 'static` to support downcasting.
+///
+/// ```
+/// use log::kv::Value;
+///
+/// let value = Value::capture_debug(&42i32);
+///
+/// assert_eq!(Some(42), value.to_i64());
+/// ```
+///
+/// ## Using the `Value::from_*` methods
+///
+/// `Value` offers a few constructor methods that capture values of different kinds.
+/// These methods don't require `T: 'static`, but can't support downcasting.
+///
+/// ```
+/// use log::kv::Value;
+///
+/// let value = Value::from_debug(&42i32);
+///
+/// assert_eq!(None, value.to_i64());
+/// ```
+///
+/// ## Using the `ToValue` trait
+///
+/// The `ToValue` trait can be used to capture values generically.
+/// It's the bound used by `Source`.
+///
+/// ```
+/// # use log::kv::ToValue;
+/// let value = 42i32.to_value();
+///
+/// assert_eq!(Some(42), value.to_i64());
+/// ```
+///
+/// ```
+/// # use std::fmt::Debug;
+/// use log::kv::ToValue;
+///
+/// let value = (&42i32 as &dyn Debug).to_value();
+///
+/// assert_eq!(None, value.to_i64());
+/// ```
+///
+/// ## Using the standard `From` trait
+///
+/// Standard types that implement `ToValue` also implement `From`.
+///
+/// ```
+/// use log::kv::Value;
+///
+/// let value = Value::from(42i32);
+///
+/// assert_eq!(Some(42), value.to_i64());
+/// ```
+pub struct Value<'v> {
+    inner: ValueBag<'v>,
+}
+
+impl<'v> Value<'v> {
+    /// Get a value from a type implementing `ToValue`.
+    pub fn from_any<T>(value: &'v T) -> Self
+    where
+        T: ToValue,
+    {
+        value.to_value()
+    }
+
+    /// Get a value from a type implementing `std::fmt::Debug`.
+    pub fn capture_debug<T>(value: &'v T) -> Self
+    where
+        T: fmt::Debug + 'static,
+    {
+        Value {
+            inner: ValueBag::capture_debug(value),
+        }
+    }
+
+    /// Get a value from a type implementing `std::fmt::Display`.
+    pub fn capture_display<T>(value: &'v T) -> Self
+    where
+        T: fmt::Display + 'static,
+    {
+        Value {
+            inner: ValueBag::capture_display(value),
+        }
+    }
+
+    /// Get a value from an error.
+    #[cfg(feature = "kv_unstable_std")]
+    pub fn capture_error<T>(err: &'v T) -> Self
+    where
+        T: std::error::Error + 'static,
+    {
+        Value {
+            inner: ValueBag::capture_error(err),
+        }
+    }
+
+    #[cfg(feature = "kv_unstable_serde")]
+    /// Get a value from a type implementing `serde::Serialize`.
+    pub fn capture_serde<T>(value: &'v T) -> Self
+    where
+        T: self::serde::Serialize + 'static,
+    {
+        Value {
+            inner: ValueBag::capture_serde1(value),
+        }
+    }
+
+    /// Get a value from a type implementing `sval::Value`.
+    #[cfg(feature = "kv_unstable_sval")]
+    pub fn capture_sval<T>(value: &'v T) -> Self
+    where
+        T: self::sval::Value + 'static,
+    {
+        Value {
+            inner: ValueBag::capture_sval2(value),
+        }
+    }
+
+    /// Get a value from a type implementing `std::fmt::Debug`.
+    pub fn from_debug<T>(value: &'v T) -> Self
+    where
+        T: fmt::Debug,
+    {
+        Value {
+            inner: ValueBag::from_debug(value),
+        }
+    }
+
+    /// Get a value from a type implementing `std::fmt::Display`.
+    pub fn from_display<T>(value: &'v T) -> Self
+    where
+        T: fmt::Display,
+    {
+        Value {
+            inner: ValueBag::from_display(value),
+        }
+    }
+
+    /// Get a value from a type implementing `serde::Serialize`.
+    #[cfg(feature = "kv_unstable_serde")]
+    pub fn from_serde<T>(value: &'v T) -> Self
+    where
+        T: self::serde::Serialize,
+    {
+        Value {
+            inner: ValueBag::from_serde1(value),
+        }
+    }
+
+    /// Get a value from a type implementing `sval::Value`.
+    #[cfg(feature = "kv_unstable_sval")]
+    pub fn from_sval<T>(value: &'v T) -> Self
+    where
+        T: self::sval::Value,
+    {
+        Value {
+            inner: ValueBag::from_sval2(value),
+        }
+    }
+
+    /// Get a value from a dynamic `std::fmt::Debug`.
+    pub fn from_dyn_debug(value: &'v dyn fmt::Debug) -> Self {
+        Value {
+            inner: ValueBag::from_dyn_debug(value),
+        }
+    }
+
+    /// Get a value from a dynamic `std::fmt::Display`.
+    pub fn from_dyn_display(value: &'v dyn fmt::Display) -> Self {
+        Value {
+            inner: ValueBag::from_dyn_display(value),
+        }
+    }
+
+    /// Get a value from a dynamic error.
+    #[cfg(feature = "kv_unstable_std")]
+    pub fn from_dyn_error(err: &'v (dyn std::error::Error + 'static)) -> Self {
+        Value {
+            inner: ValueBag::from_dyn_error(err),
+        }
+    }
+
+    /// Get a value from an internal primitive.
+    fn from_value_bag<T>(value: T) -> Self
+    where
+        T: Into<ValueBag<'v>>,
+    {
+        Value {
+            inner: value.into(),
+        }
+    }
+
+    /// Check whether this value can be downcast to `T`.
+    pub fn is<T: 'static>(&self) -> bool {
+        self.inner.is::<T>()
+    }
+
+    /// Try downcast this value to `T`.
+    pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
+        self.inner.downcast_ref::<T>()
+    }
+
+    /// Inspect this value using a simple visitor.
+    pub fn visit(&self, visitor: impl Visit<'v>) -> Result<(), Error> {
+        struct Visitor<V>(V);
+
+        impl<'v, V> value_bag::visit::Visit<'v> for Visitor<V>
+        where
+            V: Visit<'v>,
+        {
+            fn visit_any(&mut self, value: ValueBag) -> Result<(), value_bag::Error> {
+                self.0
+                    .visit_any(Value { inner: value })
+                    .map_err(Error::into_value)
+            }
+
+            fn visit_u64(&mut self, value: u64) -> Result<(), value_bag::Error> {
+                self.0.visit_u64(value).map_err(Error::into_value)
+            }
+
+            fn visit_i64(&mut self, value: i64) -> Result<(), value_bag::Error> {
+                self.0.visit_i64(value).map_err(Error::into_value)
+            }
+
+            fn visit_u128(&mut self, value: u128) -> Result<(), value_bag::Error> {
+                self.0.visit_u128(value).map_err(Error::into_value)
+            }
+
+            fn visit_i128(&mut self, value: i128) -> Result<(), value_bag::Error> {
+                self.0.visit_i128(value).map_err(Error::into_value)
+            }
+
+            fn visit_f64(&mut self, value: f64) -> Result<(), value_bag::Error> {
+                self.0.visit_f64(value).map_err(Error::into_value)
+            }
+
+            fn visit_bool(&mut self, value: bool) -> Result<(), value_bag::Error> {
+                self.0.visit_bool(value).map_err(Error::into_value)
+            }
+
+            fn visit_str(&mut self, value: &str) -> Result<(), value_bag::Error> {
+                self.0.visit_str(value).map_err(Error::into_value)
+            }
+
+            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), value_bag::Error> {
+                self.0.visit_borrowed_str(value).map_err(Error::into_value)
+            }
+
+            fn visit_char(&mut self, value: char) -> Result<(), value_bag::Error> {
+                self.0.visit_char(value).map_err(Error::into_value)
+            }
+
+            #[cfg(feature = "kv_unstable_std")]
+            fn visit_error(
+                &mut self,
+                err: &(dyn std::error::Error + 'static),
+            ) -> Result<(), value_bag::Error> {
+                self.0.visit_error(err).map_err(Error::into_value)
+            }
+
+            #[cfg(feature = "kv_unstable_std")]
+            fn visit_borrowed_error(
+                &mut self,
+                err: &'v (dyn std::error::Error + 'static),
+            ) -> Result<(), value_bag::Error> {
+                self.0.visit_borrowed_error(err).map_err(Error::into_value)
+            }
+        }
+
+        self.inner
+            .visit(&mut Visitor(visitor))
+            .map_err(Error::from_value)
+    }
+}
+
+impl<'v> fmt::Debug for Value<'v> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.inner, f)
+    }
+}
+
+impl<'v> fmt::Display for Value<'v> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.inner, f)
+    }
+}
+
+impl ToValue for dyn fmt::Debug {
+    fn to_value(&self) -> Value {
+        Value::from_dyn_debug(self)
+    }
+}
+
+impl ToValue for dyn fmt::Display {
+    fn to_value(&self) -> Value {
+        Value::from_dyn_display(self)
+    }
+}
+
+#[cfg(feature = "kv_unstable_std")]
+impl ToValue for dyn std::error::Error + 'static {
+    fn to_value(&self) -> Value {
+        Value::from_dyn_error(self)
+    }
+}
+
+#[cfg(feature = "kv_unstable_serde")]
+impl<'v> self::serde::Serialize for Value<'v> {
+    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+    where
+        S: self::serde::Serializer,
+    {
+        self.inner.serialize(s)
+    }
+}
+
+#[cfg(feature = "kv_unstable_sval")]
+impl<'v> self::sval::Value for Value<'v> {
+    fn stream<'sval, S: self::sval::Stream<'sval> + ?Sized>(
+        &'sval self,
+        stream: &mut S,
+    ) -> self::sval::Result {
+        self::sval::Value::stream(&self.inner, stream)
+    }
+}
+
+#[cfg(feature = "kv_unstable_sval")]
+impl<'v> self::sval_ref::ValueRef<'v> for Value<'v> {
+    fn stream_ref<S: self::sval::Stream<'v> + ?Sized>(&self, stream: &mut S) -> self::sval::Result {
+        self::sval_ref::ValueRef::stream_ref(&self.inner, stream)
+    }
+}
+
+impl ToValue for str {
+    fn to_value(&self) -> Value {
+        Value::from(self)
+    }
+}
+
+impl ToValue for u128 {
+    fn to_value(&self) -> Value {
+        Value::from(self)
+    }
+}
+
+impl ToValue for i128 {
+    fn to_value(&self) -> Value {
+        Value::from(self)
+    }
+}
+
+impl ToValue for std::num::NonZeroU128 {
+    fn to_value(&self) -> Value {
+        Value::from(self)
+    }
+}
+
+impl ToValue for std::num::NonZeroI128 {
+    fn to_value(&self) -> Value {
+        Value::from(self)
+    }
+}
+
+impl<'v> From<&'v str> for Value<'v> {
+    fn from(value: &'v str) -> Self {
+        Value::from_value_bag(value)
+    }
+}
+
+impl<'v> From<&'v u128> for Value<'v> {
+    fn from(value: &'v u128) -> Self {
+        Value::from_value_bag(value)
+    }
+}
+
+impl<'v> From<&'v i128> for Value<'v> {
+    fn from(value: &'v i128) -> Self {
+        Value::from_value_bag(value)
+    }
+}
+
+impl<'v> From<&'v std::num::NonZeroU128> for Value<'v> {
+    fn from(v: &'v std::num::NonZeroU128) -> Value<'v> {
+        // SAFETY: `NonZeroU128` and `u128` have the same ABI
+        Value::from_value_bag(unsafe { std::mem::transmute::<&std::num::NonZeroU128, &u128>(v) })
+    }
+}
+
+impl<'v> From<&'v std::num::NonZeroI128> for Value<'v> {
+    fn from(v: &'v std::num::NonZeroI128) -> Value<'v> {
+        // SAFETY: `NonZeroI128` and `i128` have the same ABI
+        Value::from_value_bag(unsafe { std::mem::transmute::<&std::num::NonZeroI128, &i128>(v) })
+    }
+}
+
+impl ToValue for () {
+    fn to_value(&self) -> Value {
+        Value::from_value_bag(())
+    }
+}
+
+impl<T> ToValue for Option<T>
+where
+    T: ToValue,
+{
+    fn to_value(&self) -> Value {
+        match *self {
+            Some(ref value) => value.to_value(),
+            None => Value::from_value_bag(()),
+        }
+    }
+}
+
+macro_rules! impl_to_value_primitive {
+    ($($into_ty:ty,)*) => {
+        $(
+            impl ToValue for $into_ty {
+                fn to_value(&self) -> Value {
+                    Value::from(*self)
+                }
+            }
+
+            impl<'v> From<$into_ty> for Value<'v> {
+                fn from(value: $into_ty) -> Self {
+                    Value::from_value_bag(value)
+                }
+            }
+        )*
+    };
+}
+
+macro_rules! impl_to_value_nonzero_primitive {
+    ($($into_ty:ident,)*) => {
+        $(
+            impl ToValue for std::num::$into_ty {
+                fn to_value(&self) -> Value {
+                    Value::from(self.get())
+                }
+            }
+
+            impl<'v> From<std::num::$into_ty> for Value<'v> {
+                fn from(value: std::num::$into_ty) -> Self {
+                    Value::from(value.get())
+                }
+            }
+        )*
+    };
+}
+
+macro_rules! impl_value_to_primitive {
+    ($(#[doc = $doc:tt] $into_name:ident -> $into_ty:ty,)*) => {
+        impl<'v> Value<'v> {
+            $(
+                #[doc = $doc]
+                pub fn $into_name(&self) -> Option<$into_ty> {
+                    self.inner.$into_name()
+                }
+            )*
+        }
+    }
+}
+
+impl_to_value_primitive![usize, u8, u16, u32, u64, isize, i8, i16, i32, i64, f32, f64, char, bool,];
+
+#[rustfmt::skip]
+impl_to_value_nonzero_primitive![
+    NonZeroUsize, NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64,
+    NonZeroIsize, NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64,
+];
+
+impl_value_to_primitive![
+    #[doc = "Try convert this value into a `u64`."]
+    to_u64 -> u64,
+    #[doc = "Try convert this value into a `i64`."]
+    to_i64 -> i64,
+    #[doc = "Try convert this value into a `u128`."]
+    to_u128 -> u128,
+    #[doc = "Try convert this value into a `i128`."]
+    to_i128 -> i128,
+    #[doc = "Try convert this value into a `f64`."]
+    to_f64 -> f64,
+    #[doc = "Try convert this value into a `char`."]
+    to_char -> char,
+    #[doc = "Try convert this value into a `bool`."]
+    to_bool -> bool,
+];
+
+impl<'v> Value<'v> {
+    /// Try convert this value into an error.
+    #[cfg(feature = "kv_unstable_std")]
+    pub fn to_borrowed_error(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        self.inner.to_borrowed_error()
+    }
+
+    /// Try convert this value into a borrowed string.
+    pub fn to_borrowed_str(&self) -> Option<&str> {
+        self.inner.to_borrowed_str()
+    }
+}
+
+#[cfg(feature = "kv_unstable_std")]
+mod std_support {
+    use super::*;
+
+    use std::borrow::Cow;
+
+    impl<T> ToValue for Box<T>
+    where
+        T: ToValue + ?Sized,
+    {
+        fn to_value(&self) -> Value {
+            (**self).to_value()
+        }
+    }
+
+    impl ToValue for String {
+        fn to_value(&self) -> Value {
+            Value::from(&**self)
+        }
+    }
+
+    impl<'v> ToValue for Cow<'v, str> {
+        fn to_value(&self) -> Value {
+            Value::from(&**self)
+        }
+    }
+
+    impl<'v> Value<'v> {
+        /// Try convert this value into a string.
+        pub fn to_str(&self) -> Option<Cow<str>> {
+            self.inner.to_str()
+        }
+    }
+
+    impl<'v> From<&'v String> for Value<'v> {
+        fn from(v: &'v String) -> Self {
+            Value::from(&**v)
+        }
+    }
+}
+
+/// A visitor for a `Value`.
+pub trait Visit<'v> {
+    /// Visit a `Value`.
+    ///
+    /// This is the only required method on `Visit` and acts as a fallback for any
+    /// more specific methods that aren't overridden.
+    /// The `Value` may be formatted using its `fmt::Debug` or `fmt::Display` implementation,
+    /// or serialized using its `sval::Value` or `serde::Serialize` implementation.
+    fn visit_any(&mut self, value: Value) -> Result<(), Error>;
+
+    /// Visit an unsigned integer.
+    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
+        self.visit_any(value.into())
+    }
+
+    /// Visit a signed integer.
+    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
+        self.visit_any(value.into())
+    }
+
+    /// Visit a big unsigned integer.
+    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
+        self.visit_any((&value).into())
+    }
+
+    /// Visit a big signed integer.
+    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
+        self.visit_any((&value).into())
+    }
+
+    /// Visit a floating point.
+    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
+        self.visit_any(value.into())
+    }
+
+    /// Visit a boolean.
+    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
+        self.visit_any(value.into())
+    }
+
+    /// Visit a string.
+    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
+        self.visit_any(value.into())
+    }
+
+    /// Visit a string.
+    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
+        self.visit_str(value)
+    }
+
+    /// Visit a Unicode character.
+    fn visit_char(&mut self, value: char) -> Result<(), Error> {
+        let mut b = [0; 4];
+        self.visit_str(&*value.encode_utf8(&mut b))
+    }
+
+    /// Visit an error.
+    #[cfg(feature = "kv_unstable_std")]
+    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
+        self.visit_any(Value::from_dyn_error(err))
+    }
+
+    /// Visit an error.
+    #[cfg(feature = "kv_unstable_std")]
+    fn visit_borrowed_error(
+        &mut self,
+        err: &'v (dyn std::error::Error + 'static),
+    ) -> Result<(), Error> {
+        self.visit_any(Value::from_dyn_error(err))
+    }
+}
+
+impl<'a, 'v, T: ?Sized> Visit<'v> for &'a mut T
+where
+    T: Visit<'v>,
+{
+    fn visit_any(&mut self, value: Value) -> Result<(), Error> {
+        (**self).visit_any(value)
+    }
+
+    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
+        (**self).visit_u64(value)
+    }
+
+    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
+        (**self).visit_i64(value)
+    }
+
+    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
+        (**self).visit_u128(value)
+    }
+
+    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
+        (**self).visit_i128(value)
+    }
+
+    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
+        (**self).visit_f64(value)
+    }
+
+    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
+        (**self).visit_bool(value)
+    }
+
+    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
+        (**self).visit_str(value)
+    }
+
+    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
+        (**self).visit_borrowed_str(value)
+    }
+
+    fn visit_char(&mut self, value: char) -> Result<(), Error> {
+        (**self).visit_char(value)
+    }
+
+    #[cfg(feature = "kv_unstable_std")]
+    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
+        (**self).visit_error(err)
+    }
+
+    #[cfg(feature = "kv_unstable_std")]
+    fn visit_borrowed_error(
+        &mut self,
+        err: &'v (dyn std::error::Error + 'static),
+    ) -> Result<(), Error> {
+        (**self).visit_borrowed_error(err)
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+
+    pub(crate) use super::value_bag::test::TestToken as Token;
+
+    impl<'v> Value<'v> {
+        pub(crate) fn to_token(&self) -> Token {
+            self.inner.to_test_token()
+        }
+    }
+
+    fn unsigned() -> impl Iterator<Item = Value<'static>> {
+        vec![
+            Value::from(8u8),
+            Value::from(16u16),
+            Value::from(32u32),
+            Value::from(64u64),
+            Value::from(1usize),
+            Value::from(std::num::NonZeroU8::new(8).unwrap()),
+            Value::from(std::num::NonZeroU16::new(16).unwrap()),
+            Value::from(std::num::NonZeroU32::new(32).unwrap()),
+            Value::from(std::num::NonZeroU64::new(64).unwrap()),
+            Value::from(std::num::NonZeroUsize::new(1).unwrap()),
+        ]
+        .into_iter()
+    }
+
+    fn signed() -> impl Iterator<Item = Value<'static>> {
+        vec![
+            Value::from(-8i8),
+            Value::from(-16i16),
+            Value::from(-32i32),
+            Value::from(-64i64),
+            Value::from(-1isize),
+            Value::from(std::num::NonZeroI8::new(-8).unwrap()),
+            Value::from(std::num::NonZeroI16::new(-16).unwrap()),
+            Value::from(std::num::NonZeroI32::new(-32).unwrap()),
+            Value::from(std::num::NonZeroI64::new(-64).unwrap()),
+            Value::from(std::num::NonZeroIsize::new(-1).unwrap()),
+        ]
+        .into_iter()
+    }
+
+    fn float() -> impl Iterator<Item = Value<'static>> {
+        vec![Value::from(32.32f32), Value::from(64.64f64)].into_iter()
+    }
+
+    fn bool() -> impl Iterator<Item = Value<'static>> {
+        vec![Value::from(true), Value::from(false)].into_iter()
+    }
+
+    fn str() -> impl Iterator<Item = Value<'static>> {
+        vec![Value::from("a string"), Value::from("a loong string")].into_iter()
+    }
+
+    fn char() -> impl Iterator<Item = Value<'static>> {
+        vec![Value::from('a'), Value::from('⛰')].into_iter()
+    }
+
+    #[test]
+    fn test_capture_fmt() {
+        assert_eq!(Some(42u64), Value::capture_display(&42).to_u64());
+        assert_eq!(Some(42u64), Value::capture_debug(&42).to_u64());
+
+        assert!(Value::from_display(&42).to_u64().is_none());
+        assert!(Value::from_debug(&42).to_u64().is_none());
+    }
+
+    #[cfg(feature = "kv_unstable_std")]
+    #[test]
+    fn test_capture_error() {
+        let err = std::io::Error::from(std::io::ErrorKind::Other);
+
+        assert!(Value::capture_error(&err).to_borrowed_error().is_some());
+        assert!(Value::from_dyn_error(&err).to_borrowed_error().is_some());
+    }
+
+    #[cfg(feature = "kv_unstable_serde")]
+    #[test]
+    fn test_capture_serde() {
+        assert_eq!(Some(42u64), Value::capture_serde(&42).to_u64());
+
+        assert_eq!(Some(42u64), Value::from_serde(&42).to_u64());
+    }
+
+    #[cfg(feature = "kv_unstable_sval")]
+    #[test]
+    fn test_capture_sval() {
+        assert_eq!(Some(42u64), Value::capture_sval(&42).to_u64());
+
+        assert_eq!(Some(42u64), Value::from_sval(&42).to_u64());
+    }
+
+    #[test]
+    fn test_to_value_display() {
+        assert_eq!(42u64.to_value().to_string(), "42");
+        assert_eq!(42i64.to_value().to_string(), "42");
+        assert_eq!(42.01f64.to_value().to_string(), "42.01");
+        assert_eq!(true.to_value().to_string(), "true");
+        assert_eq!('a'.to_value().to_string(), "a");
+        assert_eq!("a loong string".to_value().to_string(), "a loong string");
+        assert_eq!(Some(true).to_value().to_string(), "true");
+        assert_eq!(().to_value().to_string(), "None");
+        assert_eq!(Option::None::<bool>.to_value().to_string(), "None");
+    }
+
+    #[test]
+    fn test_to_value_structured() {
+        assert_eq!(42u64.to_value().to_token(), Token::U64(42));
+        assert_eq!(42i64.to_value().to_token(), Token::I64(42));
+        assert_eq!(42.01f64.to_value().to_token(), Token::F64(42.01));
+        assert_eq!(true.to_value().to_token(), Token::Bool(true));
+        assert_eq!('a'.to_value().to_token(), Token::Char('a'));
+        assert_eq!(
+            "a loong string".to_value().to_token(),
+            Token::Str("a loong string".into())
+        );
+        assert_eq!(Some(true).to_value().to_token(), Token::Bool(true));
+        assert_eq!(().to_value().to_token(), Token::None);
+        assert_eq!(Option::None::<bool>.to_value().to_token(), Token::None);
+    }
+
+    #[test]
+    fn test_to_number() {
+        for v in unsigned() {
+            assert!(v.to_u64().is_some());
+            assert!(v.to_i64().is_some());
+        }
+
+        for v in signed() {
+            assert!(v.to_i64().is_some());
+        }
+
+        for v in unsigned().chain(signed()).chain(float()) {
+            assert!(v.to_f64().is_some());
+        }
+
+        for v in bool().chain(str()).chain(char()) {
+            assert!(v.to_u64().is_none());
+            assert!(v.to_i64().is_none());
+            assert!(v.to_f64().is_none());
+        }
+    }
+
+    #[test]
+    fn test_to_str() {
+        for v in str() {
+            assert!(v.to_borrowed_str().is_some());
+
+            #[cfg(feature = "kv_unstable_std")]
+            assert!(v.to_str().is_some());
+        }
+
+        let short_lived = String::from("short lived");
+        let v = Value::from(&*short_lived);
+
+        assert!(v.to_borrowed_str().is_some());
+
+        #[cfg(feature = "kv_unstable_std")]
+        assert!(v.to_str().is_some());
+
+        for v in unsigned().chain(signed()).chain(float()).chain(bool()) {
+            assert!(v.to_borrowed_str().is_none());
+
+            #[cfg(feature = "kv_unstable_std")]
+            assert!(v.to_str().is_none());
+        }
+    }
+
+    #[test]
+    fn test_to_bool() {
+        for v in bool() {
+            assert!(v.to_bool().is_some());
+        }
+
+        for v in unsigned()
+            .chain(signed())
+            .chain(float())
+            .chain(str())
+            .chain(char())
+        {
+            assert!(v.to_bool().is_none());
+        }
+    }
+
+    #[test]
+    fn test_to_char() {
+        for v in char() {
+            assert!(v.to_char().is_some());
+        }
+
+        for v in unsigned()
+            .chain(signed())
+            .chain(float())
+            .chain(str())
+            .chain(bool())
+        {
+            assert!(v.to_char().is_none());
+        }
+    }
+
+    #[test]
+    fn test_downcast_ref() {
+        #[derive(Debug)]
+        struct Foo(u64);
+
+        let v = Value::capture_debug(&Foo(42));
+
+        assert!(v.is::<Foo>());
+        assert_eq!(42u64, v.downcast_ref::<Foo>().expect("invalid downcast").0);
+    }
+
+    #[test]
+    fn test_visit_integer() {
+        struct Extract(Option<u64>);
+
+        impl<'v> Visit<'v> for Extract {
+            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
+                unimplemented!("unexpected value: {:?}", value)
+            }
+
+            fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
+                self.0 = Some(value);
+
+                Ok(())
+            }
+        }
+
+        let mut extract = Extract(None);
+        Value::from(42u64).visit(&mut extract).unwrap();
+
+        assert_eq!(Some(42), extract.0);
+    }
+
+    #[test]
+    fn test_visit_borrowed_str() {
+        struct Extract<'v>(Option<&'v str>);
+
+        impl<'v> Visit<'v> for Extract<'v> {
+            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
+                unimplemented!("unexpected value: {:?}", value)
+            }
+
+            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
+                self.0 = Some(value);
+
+                Ok(())
+            }
+        }
+
+        let mut extract = Extract(None);
+
+        let short_lived = String::from("A short-lived string");
+        Value::from(&*short_lived).visit(&mut extract).unwrap();
+
+        assert_eq!(Some("A short-lived string"), extract.0);
+    }
+}