simple_ringbuf 0.1.2

use simple_ringbuf::RingBuffer;

mod common;
use common::*;

#[test]
fn add_remove() {
    let mut buf: RingBuffer<i32> = RingBuffer::new(200);

    buf.push(5);

    buf.push(6);
    assert_eq!(buf.pop(), Some(6));

    assert_eq!(buf.len(), 1);
}

#[test]
fn ringiness() {
    let mut buf = setup_full_buffer(5);
    println!("{:?}", buf);

    assert_eq!(buf.len(), 5);
    assert_eq!(buf.iter().len(), buf.len());
    assert_eq!(buf.iter().rev().len(), buf.len());
    assert!(buf.iter().rev().enumerate().all(|(i, &elem)| i + 1 == elem));

    buf.push(6);
    println!("{:?}", buf);

    assert_eq!(buf.len(), 5);
    assert_eq!(buf.iter().len(), buf.len());
    assert_eq!(buf.iter().rev().len(), buf.len());
    assert_eq!(6, buf[0]);
    buf.iter()
        .skip(1)
        .rev()
        .enumerate()
        .all(|(i, &elem)| i + 1 == elem);
}

#[test]
fn debug() {
    let mut buf: RingBuffer<usize> = RingBuffer::new(5);

    let output = "RingBuffer[Empty] ( _, _, _, _, _ )";
    assert_eq!(format!("{:?}", buf), output);

    buf.push(15);
    let output = "RingBuffer ( [ 15 ], _, _, _, _ )";
    assert_eq!(format!("{:?}", buf), output);

    buf.push(200);
    let output = "RingBuffer ( [ 15, 200 ], _, _, _ )";
    assert_eq!(format!("{:?}", buf), output);

    buf.pop_oldest();
    let output = "RingBuffer ( _, [ 200 ], _, _, _ )";
    assert_eq!(format!("{:?}", buf), output);

    buf.push(1);
    buf.push(2);
    buf.push(3);
    buf.push(4);
    let output = "RingBuffer ( 4 ], [ 200, 1, 2, 3 )";
    assert_eq!(format!("{:?}", buf), output);

    buf.pop_oldest();
    let output = "RingBuffer ( 4 ], _, [ 1, 2, 3 )";
    assert_eq!(format!("{:?}", buf), output);

    buf.pop();
    let output = "RingBuffer ( _, _, [ 1, 2, 3 ] )";
    assert_eq!(format!("{:?}", buf), output);
}

#[test]
fn clone() {
    let bufs = vec![
        setup_full_buffer(5),
        setup_rotated_full_buffer(5, 3),
        setup_left_empty_buffer(5, 2),
        setup_right_empty_buffer(5, 2),
        setup_island_buffer(5, 1, 1),
        setup_rotated_island_buffer(10, 5, 2, 2),
    ];

    for buf in bufs {
        assert_eq!(buf, buf.clone(), "Buf: {:?}, clone: {:?}", buf, buf.clone());
    }
}

#[test]
fn justify() {
    assert_eq!(setup_full_buffer(5), {
        let mut x = setup_full_buffer(5);
        x.justify();
        x
    },);

    assert_eq!(setup_rotated_full_buffer(5, 3), {
        let mut x = setup_rotated_full_buffer(5, 3);
        x.justify();
        x
    },);

    assert_eq!(setup_left_empty_buffer(5, 2), {
        let mut x = setup_left_empty_buffer(5, 2);
        x.justify();
        x
    },);

    assert_eq!(setup_right_empty_buffer(5, 3), {
        let mut x = setup_right_empty_buffer(5, 3);
        x.justify();
        x
    },);

    assert_eq!(setup_island_buffer(10, 2, 2), {
        let mut x = setup_island_buffer(10, 2, 2);
        x.justify();
        x
    },);

    assert_eq!(setup_rotated_island_buffer(10, 4, 2, 2), {
        let mut x = setup_rotated_island_buffer(10, 4, 2, 2);
        x.justify();
        x
    },);
}

#[test]
fn resize() {
    struct Test {
        x: RingBuffer<usize>,
        y: RingBuffer<usize>,
        larger: RingBuffer<usize>,
        new_cap: usize,
        new_els: Box<dyn Iterator<Item = usize>>,
    };
    let tests = vec![
        Test {
            x: setup_full_buffer(5),
            y: setup_full_buffer(5),
            larger: setup_full_buffer(10),
            new_cap: 10,
            new_els: Box::new(6..=10),
        },
        Test {
            x: setup_rotated_full_buffer(5, 3),
            y: setup_rotated_full_buffer(5, 3),
            larger: RingBuffer::from_exact_size_iter(vec![3, 4, 5, 10, 20, 6, 7, 8, 9, 10]),
            new_cap: 10,
            new_els: Box::new(6..=10),
        },
        Test {
            x: setup_left_empty_buffer(5, 3),
            y: setup_left_empty_buffer(5, 3),
            larger: setup_left_empty_buffer(10, 3),
            new_cap: 10,
            new_els: Box::new(6..=10),
        },
        Test {
            x: setup_right_empty_buffer(5, 3),
            y: setup_right_empty_buffer(5, 3),
            larger: setup_full_buffer(10),
            new_cap: 10,
            new_els: Box::new(3..=10),
        },
        Test {
            x: setup_island_buffer(5, 1, 1),
            y: setup_island_buffer(5, 1, 1),
            larger: RingBuffer::from_exact_size_iter(vec![2, 3, 4, 6, 7, 8, 9, 10]),
            new_cap: 8,
            new_els: Box::new(6..=10),
        },
        Test {
            x: setup_rotated_island_buffer(10, 4, 1, 2),
            y: setup_rotated_island_buffer(10, 4, 1, 2),
            larger: RingBuffer::from_exact_size_iter(vec![
                5, 6, 7, 8, 9, 10, 10, 100, 200, 300, 400,
            ]),
            new_cap: 11,
            new_els: Box::new(vec![100, 200, 300, 400].into_iter()),
        },
    ];

    for (
        i,
        Test {
            x,
            mut y,
            larger,
            new_cap,
            new_els,
        },
    ) in tests.into_iter().enumerate()
    {
        println!("Running test {}", i);
        assert_eq!(x, y);
        y.resize(new_cap);
        assert_eq!(y.cap(), new_cap);
        assert_eq!(y.len(), x.len());

        assert!(
            y.iter().zip(x.iter()).all(|(e1, e2)| e1 == e2),
            "x: {:?}, y: {:?}",
            x,
            y
        );

        for i in new_els {
            y.push(i);
        }

        assert_eq!(y, larger);
    }
}