assertr 0.5.6

use ::alloc::{string::String, vec::Vec};
#[cfg(feature = "std")]
use ::core::fmt::Debug;
use ::core::ops::{Range, RangeInclusive};
#[cfg(feature = "std")]
use ::std::hash::BuildHasher;

pub mod alloc;
pub mod condition;
pub mod core;
#[cfg(feature = "http")]
pub mod http;
#[cfg(feature = "jiff")]
pub mod jiff;
#[cfg(feature = "num")]
pub mod num;
#[cfg(feature = "program")]
pub mod program;
#[cfg(feature = "reqwest")]
pub mod reqwest;
#[cfg(feature = "rootcause")]
pub mod rootcause;
#[cfg(feature = "std")]
pub mod std;
#[cfg(feature = "tokio")]
pub mod tokio;

pub trait HasLength {
    fn length(&self) -> usize;

    #[must_use]
    fn is_empty(&self) -> bool {
        self.length() == 0
    }

    #[must_use]
    fn is_not_empty(&self) -> bool {
        !self.is_empty()
    }
}

impl HasLength for &str {
    fn length(&self) -> usize {
        str::len(self)
    }

    fn is_empty(&self) -> bool {
        str::is_empty(self)
    }
}

impl HasLength for String {
    fn length(&self) -> usize {
        String::len(self)
    }

    fn is_empty(&self) -> bool {
        String::is_empty(self)
    }
}

impl HasLength for &String {
    fn length(&self) -> usize {
        String::len(self)
    }

    fn is_empty(&self) -> bool {
        String::is_empty(self)
    }
}

impl<T> HasLength for &[T] {
    fn length(&self) -> usize {
        self.len()
    }
}

impl<T, const S: usize> HasLength for [T; S] {
    fn length(&self) -> usize {
        self.len()
    }
}

impl<T> HasLength for Vec<T> {
    fn length(&self) -> usize {
        Vec::len(self)
    }

    fn is_empty(&self) -> bool {
        Vec::is_empty(self)
    }
}

impl<T> HasLength for &Vec<T> {
    fn length(&self) -> usize {
        Vec::len(self)
    }

    fn is_empty(&self) -> bool {
        Vec::is_empty(self)
    }
}

#[cfg(feature = "std")]
impl<K: Debug, V: Debug, S: BuildHasher> HasLength for ::std::collections::HashMap<K, V, S> {
    fn length(&self) -> usize {
        ::std::collections::HashMap::len(self)
    }

    fn is_empty(&self) -> bool {
        ::std::collections::HashMap::is_empty(self)
    }
}

#[cfg(feature = "std")]
impl<K: Debug, V: Debug, S: BuildHasher> HasLength for &::std::collections::HashMap<K, V, S> {
    fn length(&self) -> usize {
        ::std::collections::HashMap::len(self)
    }

    fn is_empty(&self) -> bool {
        ::std::collections::HashMap::is_empty(self)
    }
}

#[cfg(feature = "std")]
impl<V: Debug, S: BuildHasher> HasLength for ::std::collections::HashSet<V, S> {
    fn length(&self) -> usize {
        ::std::collections::HashSet::len(self)
    }

    fn is_empty(&self) -> bool {
        ::std::collections::HashSet::is_empty(self)
    }
}

#[cfg(feature = "std")]
impl<V: Debug, S: BuildHasher> HasLength for &::std::collections::HashSet<V, S> {
    fn length(&self) -> usize {
        ::std::collections::HashSet::len(self)
    }

    fn is_empty(&self) -> bool {
        ::std::collections::HashSet::is_empty(self)
    }
}

impl HasLength for Range<usize> {
    fn length(&self) -> usize {
        self.len()
    }
}

impl HasLength for RangeInclusive<usize> {
    fn length(&self) -> usize {
        if self.start() < self.end() {
            self.end() - self.start() + 1
        } else {
            0
        }
    }
}

impl HasLength for Range<u8> {
    fn length(&self) -> usize {
        if self.start < self.end {
            (self.end - self.start) as usize
        } else {
            0
        }
    }
}

impl HasLength for RangeInclusive<u8> {
    //noinspection DuplicatedCode
    fn length(&self) -> usize {
        if self.start() < self.end() {
            (*self.end() - *self.start()) as usize + 1
        } else {
            0
        }
    }
}

impl HasLength for Range<u16> {
    fn length(&self) -> usize {
        if self.start < self.end {
            (self.end - self.start) as usize
        } else {
            0
        }
    }
}

impl HasLength for RangeInclusive<u16> {
    //noinspection DuplicatedCode
    fn length(&self) -> usize {
        if self.start() < self.end() {
            (*self.end() - *self.start()) as usize + 1
        } else {
            0
        }
    }
}

impl HasLength for Range<u32> {
    fn length(&self) -> usize {
        if self.start < self.end {
            (self.end - self.start) as usize
        } else {
            0
        }
    }
}

impl HasLength for RangeInclusive<u32> {
    //noinspection DuplicatedCode
    fn length(&self) -> usize {
        if self.start() < self.end() {
            (*self.end() - *self.start()) as usize + 1
        } else {
            0
        }
    }
}

impl HasLength for Range<u64> {
    #[allow(clippy::cast_possible_truncation)]
    fn length(&self) -> usize {
        if self.start < self.end {
            (self.end - self.start) as usize
        } else {
            0
        }
    }
}

impl HasLength for RangeInclusive<u64> {
    //noinspection DuplicatedCode
    #[allow(clippy::cast_possible_truncation)]
    fn length(&self) -> usize {
        if self.start() < self.end() {
            (*self.end() - *self.start()) as usize + 1
        } else {
            0
        }
    }
}

impl HasLength for Range<i8> {
    #[allow(clippy::cast_sign_loss)]
    fn length(&self) -> usize {
        if self.start < self.end {
            (self.end - self.start) as usize
        } else {
            0
        }
    }
}

impl HasLength for RangeInclusive<i8> {
    //noinspection DuplicatedCode
    fn length(&self) -> usize {
        if self.start() < self.end() {
            (*self.end() - *self.start()).unsigned_abs() as usize + 1
        } else {
            0
        }
    }
}

impl HasLength for Range<i16> {
    #[allow(clippy::cast_sign_loss)]
    fn length(&self) -> usize {
        if self.start < self.end {
            (self.end - self.start) as usize
        } else {
            0
        }
    }
}

impl HasLength for RangeInclusive<i16> {
    //noinspection DuplicatedCode
    fn length(&self) -> usize {
        if self.start() < self.end() {
            (*self.end() - *self.start()).unsigned_abs() as usize + 1
        } else {
            0
        }
    }
}

impl HasLength for Range<i32> {
    #[allow(clippy::cast_sign_loss)]
    fn length(&self) -> usize {
        if self.start < self.end {
            (self.end - self.start) as usize
        } else {
            0
        }
    }
}

impl HasLength for RangeInclusive<i32> {
    //noinspection DuplicatedCode
    fn length(&self) -> usize {
        if self.start() < self.end() {
            (*self.end() - *self.start()).unsigned_abs() as usize + 1
        } else {
            0
        }
    }
}

impl HasLength for Range<i64> {
    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
    fn length(&self) -> usize {
        if self.start < self.end {
            (self.end - self.start) as usize
        } else {
            0
        }
    }
}

impl HasLength for RangeInclusive<i64> {
    //noinspection DuplicatedCode
    #[allow(clippy::cast_possible_truncation)]
    fn length(&self) -> usize {
        if self.start() < self.end() {
            (*self.end() - *self.start()).unsigned_abs() as usize + 1
        } else {
            0
        }
    }
}

#[cfg(test)]
mod tests {
    mod has_length {

        mod on_usize_ranges {
            use crate::prelude::*;

            #[test]
            fn works_on_range_and_inclusive_range() {
                assert_that!(1_usize..9_usize).has_length(8);
                assert_that!(1_usize..=9_usize).has_length(9);

                // inverted range
                assert_that!(9_usize..1_usize).has_length(0);
                assert_that!(9_usize..=1_usize).has_length(0);
            }
        }

        mod on_u8_ranges {
            use crate::prelude::*;

            #[test]
            fn works_on_range_and_inclusive_range() {
                assert_that!(1_u8..9_u8).has_length(8);
                assert_that!(1_u8..=9_u8).has_length(9);

                // inverted range
                assert_that!(9_u8..1_u8).has_length(0);
                assert_that!(9_u8..=1_u8).has_length(0);
            }
        }

        mod on_u16_ranges {
            use crate::prelude::*;

            #[test]
            fn works_on_range_and_inclusive_range() {
                assert_that!(1_u16..9_u16).has_length(8);
                assert_that!(1_u16..=9_u16).has_length(9);

                // inverted range
                assert_that!(9_u16..1_u16).has_length(0);
                assert_that!(9_u16..=1_u16).has_length(0);
            }
        }

        mod on_u32_ranges {
            use crate::prelude::*;

            #[test]
            fn works_on_range_and_inclusive_range() {
                assert_that!(1_u32..9_u32).has_length(8);
                assert_that!(1_u32..=9_u32).has_length(9);

                // inverted range
                assert_that!(9_u32..1_u32).has_length(0);
                assert_that!(9_u32..=1_u32).has_length(0);
            }
        }

        mod on_u64_ranges {
            use crate::prelude::*;

            #[test]
            fn works_on_range_and_inclusive_range() {
                assert_that!(1_u64..9_u64).has_length(8);
                assert_that!(1_u64..=9_u64).has_length(9);

                // inverted range
                assert_that!(9_u64..1_u64).has_length(0);
                assert_that!(9_u64..=1_u64).has_length(0);
            }
        }

        mod on_i8_ranges {
            use crate::prelude::*;

            #[test]
            fn works_on_range_and_inclusive_range() {
                assert_that!(1_i8..9_i8).has_length(8);
                assert_that!(1_i8..=9_i8).has_length(9);

                // inverted range
                assert_that!(9_i8..1_i8).has_length(0);
                assert_that!(9_i8..=1_i8).has_length(0);

                // negative range
                assert_that!(-9_i8..-1_i8).has_length(8);
                assert_that!(-9_i8..=-1_i8).has_length(9);

                // across zero
                assert_that!(-4_i8..4_i8).has_length(8);
                assert_that!(-4_i8..=4_i8).has_length(9);
            }
        }

        mod on_i16_ranges {
            use crate::prelude::*;

            #[test]
            fn works_on_range_and_inclusive_range() {
                assert_that!(1_i16..9_i16).has_length(8);
                assert_that!(1_i16..=9_i16).has_length(9);

                // inverted range
                assert_that!(9_i16..1_i16).has_length(0);
                assert_that!(9_i16..=1_i16).has_length(0);

                // negative range
                assert_that!(-9_i16..-1_i16).has_length(8);
                assert_that!(-9_i16..=-1_i16).has_length(9);

                // across zero
                assert_that!(-4_i16..4_i16).has_length(8);
                assert_that!(-4_i16..=4_i16).has_length(9);
            }
        }

        mod on_i32_ranges {
            use crate::prelude::*;

            #[test]
            fn works_on_range_and_inclusive_range() {
                assert_that!(1_i32..9_i32).has_length(8);
                assert_that!(1_i32..=9_i32).has_length(9);

                // inverted range
                assert_that!(9_i32..1_i32).has_length(0);
                assert_that!(9_i32..=1_i32).has_length(0);

                // negative range
                assert_that!(-9_i32..-1_i32).has_length(8);
                assert_that!(-9_i32..=-1_i32).has_length(9);

                // across zero
                assert_that!(-4_i32..4_i32).has_length(8);
                assert_that!(-4_i32..=4_i32).has_length(9);
            }
        }

        mod on_i64_ranges {
            use crate::prelude::*;

            #[test]
            fn works_on_range_and_inclusive_range() {
                assert_that!(1_i64..9_i64).has_length(8);
                assert_that!(1_i64..=9_i64).has_length(9);

                // inverted range
                assert_that!(9_i64..1_i64).has_length(0);
                assert_that!(9_i64..=1_i64).has_length(0);

                // negative range
                assert_that!(-9_i64..-1_i64).has_length(8);
                assert_that!(-9_i64..=-1_i64).has_length(9);

                // across zero
                assert_that!(-4_i64..4_i64).has_length(8);
                assert_that!(-4_i64..=4_i64).has_length(9);
            }
        }
    }
}