nimbusqueue 0.2.7

#![cfg_attr(not(feature = "std"), no_std)]

#[cfg(feature = "no_std")]
extern crate alloc;

#[cfg(feature = "std")]
pub mod synchronous_queue;

#[cfg(feature = "no_std")]
pub mod crossbeam_queue;

#[cfg(test)]
mod tests {
    #[cfg(feature = "std")]
    mod std_tests {
        use crate::synchronous_queue::Queue;

        #[test]
        fn test_queue() {
            let queue: Queue<i32> = Queue::new();

            assert_eq!(queue.is_empty(), true);
            assert_eq!(queue.length(), 0);

            queue.enqueue(1);
            queue.enqueue(2);
            queue.enqueue(3);

            assert_eq!(queue.is_empty(), false);
            assert_eq!(queue.length(), 3);

            assert_eq!(queue.dequeue(), Some(1));
            assert_eq!(queue.dequeue(), Some(2));
            assert_eq!(queue.dequeue(), Some(3));

            assert_eq!(queue.is_empty(), true);
            assert_eq!(queue.length(), 0);

            // Enqueue some elements
            queue.enqueue(1);
            queue.enqueue(2);
            queue.enqueue(3);

            assert_eq!(queue.length(), 3);

            // Safely iterate over the queue by cloning the internal Vec
            for item in queue.iter() {
                println!("Read-only item: {}", item);
            }

            assert_eq!(queue.length(), 3);
        }
    }

    #[cfg(feature = "no_std")]
    mod no_std_tests {
        use crate::crossbeam_queue::Queue;
        use alloc::vec;
        use alloc::vec::Vec;

        // Basic Operations Tests
        #[test]
        fn test_segmented_queue_basic_operations() {
            let queue = Queue::new_segmented();
            assert!(queue.is_empty());
            assert_eq!(queue.length(), 0);

            queue.enqueue(1).unwrap();
            queue.enqueue(2).unwrap();
            queue.enqueue(3).unwrap();

            assert!(!queue.is_empty());
            assert_eq!(queue.length(), 3);
            assert_eq!(queue.dequeue(), Some(1));
            assert_eq!(queue.length(), 2);
        }

        #[test]
        fn test_array_queue_basic_operations() {
            let queue = Queue::new_array(3);
            assert!(queue.is_empty());
            assert_eq!(queue.length(), 0);

            queue.enqueue(1).unwrap();
            queue.enqueue(2).unwrap();
            queue.enqueue(3).unwrap();

            assert!(!queue.is_empty());
            assert_eq!(queue.length(), 3);
            assert_eq!(queue.dequeue(), Some(1));
            assert_eq!(queue.length(), 2);
        }

        // Capacity Tests
        #[test]
        fn test_array_queue_capacity() {
            let queue = Queue::new_array(2);

            assert!(queue.enqueue(1).is_ok());
            assert!(queue.enqueue(2).is_ok());
            assert!(queue.enqueue(3).is_err());

            assert_eq!(queue.length(), 2);
        }

        #[test]
        fn test_segmented_queue_no_capacity_limit() {
            let queue = Queue::new_segmented();

            for i in 0..1000 {
                assert!(queue.enqueue(i).is_ok());
            }

            assert_eq!(queue.length(), 1000);
        }

        // Iterator Tests
        #[test]
        fn test_segmented_queue_iterator() {
            let queue = Queue::new_segmented();
            queue.enqueue(1).unwrap();
            queue.enqueue(2).unwrap();
            queue.enqueue(3).unwrap();

            let mut iter = queue.iter();
            assert_eq!(iter.next(), Some(1));
            assert_eq!(iter.next(), Some(2));
            assert_eq!(iter.next(), Some(3));
            assert_eq!(iter.next(), None);

            // Verify queue still has items
            assert_eq!(queue.length(), 3);
        }

        #[test]
        fn test_array_queue_iterator() {
            let queue = Queue::new_array(3);
            queue.enqueue(1).unwrap();
            queue.enqueue(2).unwrap();
            queue.enqueue(3).unwrap();

            let mut iter = queue.iter();
            assert_eq!(iter.next(), Some(1));
            assert_eq!(iter.next(), Some(2));
            assert_eq!(iter.next(), Some(3));
            assert_eq!(iter.next(), None);

            // Verify queue still has items
            assert_eq!(queue.length(), 3);
        }

        // Clone Tests
        #[test]
        fn test_segmented_queue_clone() {
            let queue = Queue::new_segmented();
            queue.enqueue(1).unwrap();
            queue.enqueue(2).unwrap();

            let clone = queue.clone();
            assert_eq!(clone.dequeue(), Some(1));
            assert_eq!(clone.dequeue(), Some(2));
            assert_eq!(clone.dequeue(), None);

            // Original queue should still have its elements
            assert_eq!(queue.length(), 2);
            assert_eq!(queue.dequeue(), Some(1));
            assert_eq!(queue.dequeue(), Some(2));
        }

        #[test]
        fn test_array_queue_clone() {
            let queue = Queue::new_array(2);
            queue.enqueue(1).unwrap();
            queue.enqueue(2).unwrap();

            let clone = queue.clone();
            assert_eq!(clone.dequeue(), Some(1));
            assert_eq!(clone.dequeue(), Some(2));
            assert_eq!(clone.dequeue(), None);

            // Original queue should still have its elements
            assert_eq!(queue.length(), 2);
            assert_eq!(queue.dequeue(), Some(1));
            assert_eq!(queue.dequeue(), Some(2));
        }

        // try_iter Tests
        #[test]
        fn test_segmented_queue_try_iter() {
            let queue = Queue::new_segmented();
            queue.enqueue(1).unwrap();
            queue.enqueue(2).unwrap();

            let items = queue.try_iter().unwrap();
            assert_eq!(items, vec![1, 2]);

            // Queue should still have its elements
            assert_eq!(queue.length(), 2);
            assert_eq!(queue.dequeue(), Some(1));
            assert_eq!(queue.dequeue(), Some(2));
        }

        #[test]
        fn test_array_queue_try_iter() {
            let queue = Queue::new_array(2);
            queue.enqueue(1).unwrap();
            queue.enqueue(2).unwrap();

            let items = queue.try_iter().unwrap();
            assert_eq!(items, vec![1, 2]);

            // Queue should still have its elements
            assert_eq!(queue.length(), 2);
            assert_eq!(queue.dequeue(), Some(1));
            assert_eq!(queue.dequeue(), Some(2));
        }

        // Empty Queue Tests
        #[test]
        fn test_empty_queue_operations() {
            let queue: Queue<i32> = Queue::new_segmented();
            assert!(queue.is_empty());
            assert_eq!(queue.dequeue(), None);
            assert_eq!(queue.try_iter(), None);

            let mut iter = queue.iter();
            assert_eq!(iter.next(), None);
        }

        // Mixed Operations Tests
        #[test]
        fn test_mixed_operations() {
            let queue = Queue::new_array(5);

            // Fill queue
            for i in 0..3 {
                queue.enqueue(i).unwrap();
            }

            // Remove some items
            assert_eq!(queue.dequeue(), Some(0));
            assert_eq!(queue.dequeue(), Some(1));

            // Add more items
            queue.enqueue(3).unwrap();
            queue.enqueue(4).unwrap();

            // Check final state
            let items: Vec<i32> = queue.iter().collect();
            assert_eq!(items, vec![2, 3, 4]);
        }

        // Test Default Implementation
        #[test]
        fn test_default_implementation() {
            let queue: Queue<i32> = Queue::default();
            assert!(queue.is_empty());
            assert_eq!(queue.length(), 0);

            // Should be able to enqueue without capacity limits (segmented queue)
            for i in 0..100 {
                assert!(queue.enqueue(i).is_ok());
            }
        }

        // Test Queue Type Specific Behaviors
        #[test]
        fn test_queue_type_specific_behaviors() {
            // SegQueue should handle large numbers of items
            let seg_queue = Queue::new_segmented();
            for i in 0..1000 {
                assert!(seg_queue.enqueue(i).is_ok());
            }
            assert_eq!(seg_queue.length(), 1000);

            // ArrayQueue should respect capacity
            let array_queue = Queue::new_array(5);
            for i in 0..5 {
                assert!(array_queue.enqueue(i).is_ok());
            }
            assert!(array_queue.enqueue(5).is_err());
            assert_eq!(array_queue.length(), 5);
        }

        // Test Iterator After Modifications
        #[test]
        fn test_iterator_after_modifications() {
            let queue = Queue::new_array(3);
            queue.enqueue(1).unwrap();
            queue.enqueue(2).unwrap();

            // Dequeue an item
            assert_eq!(queue.dequeue(), Some(1));

            // Add new item
            queue.enqueue(3).unwrap();

            // Iterator should reflect current state
            let items: Vec<_> = queue.iter().collect();
            assert_eq!(items, vec![2, 3]);
        }

        // Test Clone Accuracy
        #[test]
        fn test_clone_accuracy() {
            let original = Queue::new_array(3);
            original.enqueue(1).unwrap();
            original.enqueue(2).unwrap();

            let cloned = original.clone();

            // Modify original
            original.enqueue(3).unwrap();
            assert_eq!(original.dequeue(), Some(1));

            // Cloned queue should be unaffected
            let cloned_items: Vec<_> = cloned.iter().collect();
            assert_eq!(cloned_items, vec![1, 2]);
        }
    }
}