use std::cmp::{PartialEq, Eq, PartialOrd, Ord};
use std::hash::{DefaultHasher, Hash, Hasher};
use std::borrow::Borrow;
use std::mem::size_of;
use std::ops::Deref;
use std::fmt::Debug;
use std::sync::Arc;
use std::rc::Rc;

use our_string::{OurBytes, Comrade};

fn hash<T: Hash>(t: &T) -> u64 {
    let mut s = DefaultHasher::new();
    t.hash(&mut s);
    s.finish()
}

fn is_inline<T: Comrade, const N: usize>(v: &OurBytes<T, N>) -> bool {
    let l = v.len();
    let s = v.as_slice() as *const [u8] as *const () as usize;
    let v = v as *const OurBytes<T, N> as *const () as usize;
    s >= v && s + l <= v + size_of::<OurBytes<T, N>>()
}

#[test]
fn test_sizes() {
    assert_eq!(size_of::<Option<OurBytes<Rc<Vec<u8>>, { size_of::<String>() - 2 }>>>(), size_of::<String>());
    assert_eq!(size_of::<OurBytes<Rc<Vec<u8>>, { size_of::<String>() - 1 }>>(), size_of::<String>());
    assert_eq!(size_of::<OurBytes<Rc<Vec<u8>>, { size_of::<String>() - 1 - size_of::<usize>() }>>(), size_of::<String>() - size_of::<usize>());

    assert_eq!(size_of::<Option<OurBytes<Arc<Vec<u8>>, { size_of::<String>() - 2 }>>>(), size_of::<String>());
    assert_eq!(size_of::<OurBytes<Arc<Vec<u8>>, { size_of::<String>() - 1 }>>(), size_of::<String>());
    assert_eq!(size_of::<OurBytes<Arc<Vec<u8>>, { size_of::<String>() - 1 - size_of::<usize>() }>>(), size_of::<String>() - size_of::<usize>());

    assert_eq!(size_of::<OurBytes<Rc<[u8]>, { size_of::<String>() - 1 }>>(), size_of::<String>());

    assert_eq!(size_of::<OurBytes<Arc<[u8]>, { size_of::<String>() - 1 }>>(), size_of::<String>());
}

#[test]
fn test_traits() {
    macro_rules! assert_impl {
        ($t:ty : $($tr:tt)*) => {{
            fn checker<T: $($tr)*>() {}
            checker::<$t>();
        }};
    }

    assert_impl!(OurBytes<Rc<Vec<u8>>, 8> : Hash + Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Default + AsRef<[u8]> + Borrow<[u8]> + Deref<Target = [u8]> + for<'a> From<&'a [u8]> + From<Rc<Vec<u8>>>);
    assert_impl!(OurBytes<Rc<[u8]>,    8> : Hash + Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Default + AsRef<[u8]> + Borrow<[u8]> + Deref<Target = [u8]> + for<'a> From<&'a [u8]> + From<Rc<[u8]>>);

    assert_impl!(OurBytes<Arc<Vec<u8>>, 8> : Send + Sync + Hash + Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Default + AsRef<[u8]> + Borrow<[u8]> + Deref<Target = [u8]> + for<'a> From<&'a [u8]> + From<Arc<Vec<u8>>>);
    assert_impl!(OurBytes<Arc<[u8]>,    8> : Send + Sync + Hash + Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Default + AsRef<[u8]> + Borrow<[u8]> + Deref<Target = [u8]> + for<'a> From<&'a [u8]> + From<Arc<[u8]>>);
}

#[test]
fn test_clone() {
    let a = OurBytes::<Rc<Vec<u8>>, 5>::from([5u8, 2, 7, 5, 2, 5, 4, 1, 7, 5].as_slice());
    let b = a.clone();
    assert_eq!(a, b);
    assert_eq!(a.as_slice(), b.as_slice());
    assert_eq!(a.as_slice() as *const [u8], b.as_slice() as *const [u8]);
}
#[cfg(not(miri))]
proptest::proptest! {
    #[test]
    fn proptest_clone(s: Vec<u8>) {
        let a = OurBytes::<Rc<Vec<u8>>, 5>::from(s.as_slice());
        let b = a.clone();
        assert_eq!(a, b);
        assert_eq!(a.as_slice(), b.as_slice());
        if a.len() > 5 {
            assert_eq!(a.as_slice() as *const [u8], b.as_slice() as *const [u8]);
        }
    }
}

#[test]
fn test_new_default() {
    const X: OurBytes<Rc<Vec<u8>>, 10> = OurBytes::new();
    const Y: OurBytes<Arc<[u8]>, 10> = OurBytes::new();

    assert_eq!(X.len(), 0);
    assert_eq!(X.is_empty(), true);
    assert_eq!(X.as_slice().is_empty(), true);

    assert_eq!(Y.len(), 0);
    assert_eq!(Y.is_empty(), true);
    assert_eq!(Y.as_slice().is_empty(), true);

    assert_eq!(OurBytes::<Rc<Vec<u8>>, 10>::default().len(), 0);
    assert_eq!(OurBytes::<Rc<Vec<u8>>, 10>::default().is_empty(), true);
    assert_eq!(OurBytes::<Rc<Vec<u8>>, 10>::default().as_slice().is_empty(), true);

    assert_eq!(OurBytes::<Arc<[u8]>, 10>::default().len(), 0);
    assert_eq!(OurBytes::<Arc<[u8]>, 10>::default().is_empty(), true);
    assert_eq!(OurBytes::<Arc<[u8]>, 10>::default().as_slice().is_empty(), true);
}

#[test]
fn test_from_slice_inlining() {
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255, 12] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as &[u8])), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as &[u8])), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as &[u8])), false);

    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84] as &[u8])), true);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255] as &[u8])), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255, 12] as &[u8])), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as &[u8])), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as &[u8])), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as &[u8])), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as &[u8])), false);
}

#[test]
fn test_from_slice() {
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[] as &[u8]) as &[u8], &[] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8] as &[u8]) as &[u8], &[4u8] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6] as &[u8]) as &[u8], &[4u8, 6] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1] as &[u8]) as &[u8], &[4u8, 6, 1] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84] as &[u8]) as &[u8], &[4u8, 6, 1, 84] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255, 12] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255, 12] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as &[u8]);

    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[] as &[u8]) as &[u8], &[] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8] as &[u8]) as &[u8], &[4u8] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6] as &[u8]) as &[u8], &[4u8, 6] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1] as &[u8]) as &[u8], &[4u8, 6, 1] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84] as &[u8]) as &[u8], &[4u8, 6, 1, 84] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255, 12] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255, 12] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as &[u8]) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as &[u8]);
}
#[cfg(not(miri))]
proptest::proptest! {
    #[test]
    fn proptest_from_slice(s: Vec<u8>) {
        assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(s.as_slice()) as &[u8], s.as_slice());
        assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 10>::from(s.as_slice()) as &[u8], s.as_slice());
        assert_eq!(&*OurBytes::<Rc<[u8]>, 10>::from(s.as_slice()) as &[u8], s.as_slice());
        assert_eq!(&*OurBytes::<Arc<[u8]>, 10>::from(s.as_slice()) as &[u8], s.as_slice());

        assert_eq!(OurBytes::<Rc<Vec<u8>>, 10>::from(s.as_slice()).as_slice() as &[u8], s.as_slice());
        assert_eq!(OurBytes::<Arc<Vec<u8>>, 10>::from(s.as_slice()).as_slice() as &[u8], s.as_slice());
        assert_eq!(OurBytes::<Rc<[u8]>, 10>::from(s.as_slice()).as_slice() as &[u8], s.as_slice());
        assert_eq!(OurBytes::<Arc<[u8]>, 10>::from(s.as_slice()).as_slice() as &[u8], s.as_slice());

        assert_eq!(OurBytes::<Rc<Vec<u8>>, 10>::from(s.as_slice()).as_ref() as &[u8], s.as_slice());
        assert_eq!(OurBytes::<Arc<Vec<u8>>, 10>::from(s.as_slice()).as_ref() as &[u8], s.as_slice());
        assert_eq!(OurBytes::<Rc<[u8]>, 10>::from(s.as_slice()).as_ref() as &[u8], s.as_slice());
        assert_eq!(OurBytes::<Arc<[u8]>, 10>::from(s.as_slice()).as_ref() as &[u8], s.as_slice());

        assert_eq!(<_ as AsRef<[u8]>>::as_ref(&OurBytes::<Rc<Vec<u8>>, 10>::from(s.as_slice())) as &[u8], s.as_slice());
        assert_eq!(<_ as AsRef<[u8]>>::as_ref(&OurBytes::<Arc<Vec<u8>>, 10>::from(s.as_slice())) as &[u8], s.as_slice());
        assert_eq!(<_ as AsRef<[u8]>>::as_ref(&OurBytes::<Rc<[u8]>, 10>::from(s.as_slice())) as &[u8], s.as_slice());
        assert_eq!(<_ as AsRef<[u8]>>::as_ref(&OurBytes::<Arc<[u8]>, 10>::from(s.as_slice())) as &[u8], s.as_slice());

        assert_eq!(OurBytes::<Rc<Vec<u8>>, 10>::from(s.as_slice()).borrow() as &[u8], s.as_slice());
        assert_eq!(OurBytes::<Arc<Vec<u8>>, 10>::from(s.as_slice()).borrow() as &[u8], s.as_slice());
        assert_eq!(OurBytes::<Rc<[u8]>, 10>::from(s.as_slice()).borrow() as &[u8], s.as_slice());
        assert_eq!(OurBytes::<Arc<[u8]>, 10>::from(s.as_slice()).borrow() as &[u8], s.as_slice());

        assert_eq!(<_ as Borrow<[u8]>>::borrow(&OurBytes::<Rc<Vec<u8>>, 10>::from(s.as_slice())) as &[u8], s.as_slice());
        assert_eq!(<_ as Borrow<[u8]>>::borrow(&OurBytes::<Arc<Vec<u8>>, 10>::from(s.as_slice())) as &[u8], s.as_slice());
        assert_eq!(<_ as Borrow<[u8]>>::borrow(&OurBytes::<Rc<[u8]>, 10>::from(s.as_slice())) as &[u8], s.as_slice());
        assert_eq!(<_ as Borrow<[u8]>>::borrow(&OurBytes::<Arc<[u8]>, 10>::from(s.as_slice())) as &[u8], s.as_slice());
    }
}

#[test]
fn test_hash() {
    assert_eq!(hash(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[] as &[u8])), hash(&[].as_slice() as &&[u8]));
    assert_eq!(hash(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[7u8] as &[u8])), hash(&[7u8].as_slice()));
    assert_eq!(hash(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6] as &[u8])), hash(&[4u8, 6].as_slice()));
    assert_eq!(hash(&OurBytes::<Arc<Vec<u8>>, 4>::from(&[4u8, 6, 7, 4, 5, 2, 4, 3, 2, 255, 160, 2] as &[u8])), hash(&[4u8, 6, 7, 4, 5, 2, 4, 3, 2, 255, 160, 2].as_slice()));
}
#[cfg(not(miri))]
proptest::proptest! {
    #[test]
    fn proptest_hash(s: Vec<u8>) {
        assert_eq!(hash(&OurBytes::<Rc<Vec<u8>>, 4>::from(s.as_slice())), hash(&s.as_slice()));
        assert_eq!(hash(&OurBytes::<Rc<[u8]>, 4>::from(s.as_slice())), hash(&s.as_slice()));
        assert_eq!(hash(&OurBytes::<Arc<Vec<u8>>, 4>::from(s.as_slice())), hash(&s.as_slice()));
        assert_eq!(hash(&OurBytes::<Arc<[u8]>, 4>::from(s.as_slice())), hash(&s.as_slice()));
    }
}

#[test]
fn test_from_comrade_inlining() {
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255, 12] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as Vec<u8>))), false);

    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255, 12] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as Vec<u8>))), false);
    assert_eq!(is_inline(&OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as Vec<u8>))), false);
}

#[test]
fn test_from_comrade() {
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![] as Vec<u8>)) as &[u8], &[] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8] as Vec<u8>)) as &[u8], &[4u8] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6] as Vec<u8>)) as &[u8], &[4u8, 6] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1] as Vec<u8>)) as &[u8], &[4u8, 6, 1] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255, 12] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255, 12] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as &[u8]);
    assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as &[u8]);

    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![] as Vec<u8>)) as &[u8], &[] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8] as Vec<u8>)) as &[u8], &[4u8] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6] as Vec<u8>)) as &[u8], &[4u8, 6] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1] as Vec<u8>)) as &[u8], &[4u8, 6, 1] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255, 12] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255, 12] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65] as &[u8]);
    assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 4>::from(Arc::new(vec![4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as Vec<u8>)) as &[u8], &[4u8, 6, 1, 84, 255, 12, 23, 98, 169, 23, 45, 65, 56, 23, 76, 45, 98, 23, 56] as &[u8]);
}
#[cfg(not(miri))]
proptest::proptest! {
    #[test]
    fn proptest_from_comrade(s: Vec<u8>) {
        assert_eq!(&*OurBytes::<Rc<Vec<u8>>, 10>::from(Rc::new(s.clone())) as &[u8], s.as_slice());
        assert_eq!(&*OurBytes::<Arc<Vec<u8>>, 10>::from(Arc::new(s.clone())) as &[u8], s.as_slice());
        assert_eq!(&*OurBytes::<Rc<[u8]>, 10>::from(Rc::from(s.as_slice())) as &[u8], s.as_slice());
        assert_eq!(&*OurBytes::<Arc<[u8]>, 10>::from(Arc::from(s.as_slice())) as &[u8], s.as_slice());
    }
}

#[test]
fn test_debug() {
    assert_eq!(format!("{:?}", OurBytes::<Rc<[u8]>, 4>::from(&[1u8, 2, 7] as &[u8])), format!("{:?}", &[1u8, 2, 7]));
    assert_eq!(format!("{:?}", OurBytes::<Rc<Vec<u8>>, 4>::from(&[1u8, 2, 3, 4] as &[u8])), format!("{:?}", &[1u8, 2, 3, 4]));
    assert_eq!(format!("{:?}", OurBytes::<Arc<Vec<u8>>, 4>::from(&[1u8, 2, 3, 4, 9, 1, 3, 255] as &[u8])), format!("{:?}", &[1u8, 2, 3, 4, 9, 1, 3, 255]));
}
#[cfg(not(miri))]
proptest::proptest! {
    #[test]
    fn proptest_debug(s: Vec<u8>) {
        assert_eq!(format!("{:?}", OurBytes::<Rc<[u8]>, 4>::from(Rc::from(s.as_slice()))), format!("{s:?}"));
        assert_eq!(format!("{:?}", OurBytes::<Arc<[u8]>, 4>::from(Arc::from(s.as_slice()))), format!("{s:?}"));
    }
}

#[test]
fn test_comparison() {
    let a = [6u8, 2, 3, 9, 3].as_slice();
    let a1 = OurBytes::<Rc<Vec<u8>>, 10>::from(a);
    let a2 = OurBytes::<Arc<Vec<u8>>, 3>::from(a);
    let a3 = Vec::from(a);

    let b = [7u8, 2, 7, 5].as_slice();
    let b1 = OurBytes::<Rc<[u8]>, 7>::from(b);
    let b2 = OurBytes::<Rc<[u8]>, 2>::from(b);
    let b3 = Vec::from(b);

    assert_eq!(a1, a ); assert_eq!(a1, a1); assert_eq!(a1, a2); assert_eq!(a1, a3); assert_eq!(a2, a );
    assert_eq!(a2, a1); assert_eq!(a2, a2); assert_eq!(a2, a3); assert_eq!(a,  a1); assert_eq!(a,  a2);

    assert_ne!(b1, a ); assert_ne!(b1, a1); assert_ne!(b1, a2); assert_ne!(b1, a3); assert_ne!(b2, a );
    assert_ne!(b2, a1); assert_ne!(b2, a2); assert_ne!(b2, a3); assert_ne!(b,  a1); assert_ne!(b,  a2);

    assert_ne!(a1, b ); assert_ne!(a1, b1); assert_ne!(a1, b2); assert_ne!(a1, b3); assert_ne!(a2, b );
    assert_ne!(a2, b1); assert_ne!(a2, b2); assert_ne!(a2, b3); assert_ne!(a,  b1); assert_ne!(a,  b2);

    assert_eq!(b1, b ); assert_eq!(b1, b1); assert_eq!(b1, b2); assert_eq!(b1, b3); assert_eq!(b2, b );
    assert_eq!(b2, b1); assert_eq!(b2, b2); assert_eq!(b2, b3); assert_eq!(b,  b1); assert_eq!(b,  b2);

    assert_eq!(a1 <= a , true); assert_eq!(a1 <= a1, true); assert_eq!(a1 <= a2, true); assert_eq!(a1 <= a3, true); assert_eq!(a2 <= a , true);
    assert_eq!(a2 <= a1, true); assert_eq!(a2 <= a2, true); assert_eq!(a2 <= a3, true); assert_eq!(a  <= a1, true); assert_eq!(a  <= a2, true);
    assert_eq!(a1 >= a , true); assert_eq!(a1 >= a1, true); assert_eq!(a1 >= a2, true); assert_eq!(a1 >= a3, true); assert_eq!(a2 >= a , true);
    assert_eq!(a2 >= a1, true); assert_eq!(a2 >= a2, true); assert_eq!(a2 >= a3, true); assert_eq!(a  >= a1, true); assert_eq!(a  >= a2, true);
    assert_eq!(a1 < a , false); assert_eq!(a1 < a1, false); assert_eq!(a1 < a2, false); assert_eq!(a1 < a3, false); assert_eq!(a2 < a , false);
    assert_eq!(a2 < a1, false); assert_eq!(a2 < a2, false); assert_eq!(a2 < a3, false); assert_eq!(a  < a1, false); assert_eq!(a  < a2, false);
    assert_eq!(a1 > a , false); assert_eq!(a1 > a1, false); assert_eq!(a1 > a2, false); assert_eq!(a1 > a3, false); assert_eq!(a2 > a , false);
    assert_eq!(a2 > a1, false); assert_eq!(a2 > a2, false); assert_eq!(a2 > a3, false); assert_eq!(a  > a1, false); assert_eq!(a  > a2, false);

    assert_eq!(b1 <= a , false); assert_eq!(b1 <= a1, false); assert_eq!(b1 <= a2, false); assert_eq!(b1 <= a3, false); assert_eq!(b2 <= a , false);
    assert_eq!(b2 <= a1, false); assert_eq!(b2 <= a2, false); assert_eq!(b2 <= a3, false); assert_eq!(b  <= a1, false); assert_eq!(b  <= a2, false);
    assert_eq!(b1 >= a , true ); assert_eq!(b1 >= a1, true ); assert_eq!(b1 >= a2, true ); assert_eq!(b1 >= a3, true ); assert_eq!(b2 >= a , true );
    assert_eq!(b2 >= a1, true ); assert_eq!(b2 >= a2, true ); assert_eq!(b2 >= a3, true ); assert_eq!(b  >= a1, true ); assert_eq!(b  >= a2, true );
    assert_eq!(b1 < a ,  false); assert_eq!(b1 < a1,  false); assert_eq!(b1 < a2,  false); assert_eq!(b1 < a3,  false); assert_eq!(b2 < a ,  false);
    assert_eq!(b2 < a1,  false); assert_eq!(b2 < a2,  false); assert_eq!(b2 < a3,  false); assert_eq!(b  < a1,  false); assert_eq!(b  < a2,  false);
    assert_eq!(b1 > a ,  true ); assert_eq!(b1 > a1,  true ); assert_eq!(b1 > a2,  true ); assert_eq!(b1 > a3,  true ); assert_eq!(b2 > a ,  true );
    assert_eq!(b2 > a1,  true ); assert_eq!(b2 > a2,  true ); assert_eq!(b2 > a3,  true ); assert_eq!(b  > a1,  true ); assert_eq!(b  > a2,  true );
}
#[cfg(not(miri))]
proptest::proptest! {
    #[test]
    fn proptest_comparison(a: Vec<u8>, b: Vec<u8>) {
        fn partial_cmp<A, B>(a: &A, b: &B) -> Option<core::cmp::Ordering> where A: PartialOrd<B> {
            a.partial_cmp(b)
        }
        fn cmp<A>(a: &A, b: &A) -> core::cmp::Ordering where A: Ord {
            a.cmp(b)
        }

        assert_eq!(partial_cmp(&a.as_slice(), &OurBytes::<Rc<[u8]>, 4>::from(b.as_slice())), partial_cmp(&a, &b));
        assert_eq!(partial_cmp(&OurBytes::<Rc<[u8]>, 4>::from(a.as_slice()), &b), partial_cmp(&a, &b));
        assert_eq!(partial_cmp(&OurBytes::<Rc<[u8]>, 4>::from(a.as_slice()), &OurBytes::<Rc<[u8]>, 4>::from(b.as_slice())), partial_cmp(&a, &b));
        assert_eq!(partial_cmp(&OurBytes::<Rc<[u8]>, 4>::from(a.as_slice()), &OurBytes::<Rc<[u8]>, 8>::from(b.as_slice())), partial_cmp(&a, &b));
        assert_eq!(partial_cmp(&OurBytes::<Rc<[u8]>, 8>::from(a.as_slice()), &OurBytes::<Rc<[u8]>, 4>::from(b.as_slice())), partial_cmp(&a, &b));

        assert_eq!(cmp(&OurBytes::<Rc<[u8]>, 4>::from(a.as_slice()), &OurBytes::<Rc<[u8]>, 4>::from(b.as_slice())), cmp(&a, &b));
    }
}

#[test]
fn test_index() {
    let a = OurBytes::<Rc<Vec<u8>>, 8>::from([5u8, 3, 7, 12, 174, 255, 34].as_slice());
    assert_eq!(a[..], a.as_slice()[..]);
    assert_eq!(a[3..], a.as_slice()[3..]);
    assert_eq!(a[..7], a.as_slice()[..7]);
    assert_eq!(a[3..7], a.as_slice()[3..7]);
    assert_eq!(a[5], a.as_slice()[5]);
    assert_eq!(a[3], a.as_slice()[3]);
    assert_eq!(a[0], a.as_slice()[0]);
}

#[test]
fn test_convert() {
    let a = OurBytes::<Rc<[u8]>, 8>::from([5u8, 1, 6, 3, 6].as_slice());
    assert_eq!(is_inline(&a), true);
    let b: OurBytes<Rc<[u8]>, 5> = a.convert();
    assert_eq!(is_inline(&b), true);
    let c: OurBytes<Rc<[u8]>, 10> = b.convert();
    assert_eq!(is_inline(&c), true);
    let d: OurBytes<Rc<[u8]>, 4> = c.convert();
    assert_eq!(is_inline(&d), false);
    let e: OurBytes<Rc<[u8]>, 10> = d.clone().convert();
    assert_eq!(is_inline(&e), false);
    assert_eq!(d.as_slice().as_ptr(), e.as_slice().as_ptr());
}