//! Optimized Linux regression for the reviewed GLib iterator backport.
//! Borrowed strings must never escape their owning variant:
//! ```compile_fail,E0597
//! use glib::prelude::*;
//! let escaped;
//! {
//!     let owner = ["hello"].to_variant();
//!     escaped = owner.array_iter_str().unwrap().next().unwrap();
//! }
//! println!("{escaped}");
//! ```

#[cfg(test)]
mod tests {
    use glib::prelude::*;

    #[test]
    fn unicode_forward_reverse_and_last() {
        let owner = ["Gemäß", "日本", "😀", "tail"].to_variant();
        let expected = ["Gemäß", "日本", "😀", "tail"];
        assert_eq!(
            owner.array_iter_str().unwrap().collect::<Vec<_>>(),
            expected
        );
        assert_eq!(
            owner.array_iter_str().unwrap().rev().collect::<Vec<_>>(),
            expected.into_iter().rev().collect::<Vec<_>>()
        );
        assert_eq!(owner.array_iter_str().unwrap().last(), Some("tail"));
    }

    #[test]
    fn mixed_ends_exact_size_and_fused_exhaustion() {
        let owner = ["zero", "one", "two", "three", "four", "five"].to_variant();
        let mut iter = owner.array_iter_str().unwrap();
        assert_eq!(iter.size_hint(), (6, Some(6)));
        assert_eq!(iter.next(), Some("zero"));
        assert_eq!(iter.next_back(), Some("five"));
        assert_eq!(iter.nth(1), Some("two"));
        assert_eq!(iter.nth_back(0), Some("four"));
        assert_eq!(iter.len(), 1);
        assert_eq!(iter.next(), Some("three"));
        for _ in 0..3 {
            assert_eq!(iter.next(), None);
            assert_eq!(iter.next_back(), None);
            assert_eq!(iter.len(), 0);
        }
    }

    #[test]
    fn empty_and_out_of_range() {
        let empty: [&str; 0] = [];
        let owner = empty.to_variant();
        assert_eq!(owner.array_iter_str().unwrap().last(), None);
        assert_eq!(owner.array_iter_str().unwrap().next_back(), None);
        let owner = ["first", "second"].to_variant();
        let mut iter = owner.array_iter_str().unwrap();
        assert_eq!(iter.nth(usize::MAX), None);
        assert_eq!(iter.next(), None);
        let mut iter = owner.array_iter_str().unwrap();
        assert_eq!(iter.nth_back(usize::MAX), None);
        assert_eq!(iter.next_back(), None);
    }
}