use atomik::{Atomic, Ordering};

#[test]
fn atomic_bool() {
    static FLAG: Atomic::<bool> = Atomic::new(false);
    assert_eq!(FLAG.load(Ordering::Relaxed), false);
    FLAG.store(true, Ordering::Relaxed);
    assert_eq!(FLAG.swap(false, Ordering::Relaxed), true);
    assert_eq!(FLAG.compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed), Err(false));
    assert_eq!(FLAG.compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed), Ok(false));
    assert_eq!(FLAG.fetch_and(false, Ordering::Relaxed), true);
    assert_eq!(FLAG.fetch_or(true, Ordering::Relaxed), false);
    assert_eq!(FLAG.fetch_xor(false, Ordering::Relaxed), true);
    assert_eq!(FLAG.load(Ordering::Relaxed), true);
}

macro_rules! impl_test_unsigned {
    ($ty:ident) => {
        static NUM: Atomic::<$ty> = Atomic::new(0);

        assert_eq!(NUM.load(Ordering::Relaxed), 0);
        NUM.store(1, Ordering::Relaxed);
        assert_eq!(NUM.load(Ordering::Relaxed), 1);
        assert_eq!(NUM.swap(5, Ordering::Relaxed), 1);
        assert_eq!(NUM.load(Ordering::Relaxed), 5);

        assert_eq!(NUM.compare_exchange(5, 10, Ordering::Acquire, Ordering::Relaxed), Ok(5));
        assert_eq!(NUM.load(Ordering::Relaxed), 10);
        assert_eq!(NUM.compare_exchange(9, 20, Ordering::Acquire, Ordering::Relaxed), Err(10));
        assert_eq!(NUM.compare_exchange(10, 20, Ordering::Acquire, Ordering::Relaxed), Ok(10));
        assert_eq!(NUM.load(Ordering::Relaxed), 20);
        assert_eq!(NUM.compare_exchange(5, 10, Ordering::Acquire, Ordering::Relaxed), Err(20));

        assert_eq!(NUM.fetch_sub(17, Ordering::Relaxed), 20);
        assert_eq!(NUM.fetch_add(7, Ordering::Relaxed), 3);
        assert_eq!(NUM.fetch_sub(10, Ordering::Relaxed), 10);
        assert_eq!(NUM.fetch_sub(1, Ordering::Relaxed), 0);
        assert_eq!(NUM.fetch_and(0, Ordering::Relaxed), $ty::max_value());

        assert_eq!(NUM.fetch_add(0b101101, Ordering::Relaxed), 0);
        assert_eq!(NUM.fetch_or(0b110011, Ordering::Relaxed), 0b101101);

        NUM.store(0b101101, Ordering::Relaxed);
        assert_eq!(NUM.fetch_xor(0b110011, Ordering::Relaxed), 0b101101);
        assert_eq!(NUM.load(Ordering::Relaxed), 0b011110);

        NUM.store(0x13, Ordering::Relaxed);
        assert_eq!(NUM.fetch_nand(0x31, Ordering::Relaxed), 0x13);
        assert_eq!(NUM.load(Ordering::Relaxed), !(0x13 & 0x31));

        NUM.store(0b101101, Ordering::Relaxed);
        assert_eq!(NUM.fetch_and(0b110011, Ordering::Relaxed), 0b101101);
        assert_eq!(NUM.load(Ordering::Relaxed), 0b100001);

        NUM.store(7, Ordering::Relaxed);
        assert_eq!(NUM.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(7));
        assert_eq!(NUM.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(7));
        assert_eq!(NUM.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(8));
        assert_eq!(NUM.load(Ordering::SeqCst), 9);
    };
}

macro_rules! impl_test_signed {
    ($ty:ident) => {
        static NUM: Atomic::<$ty> = Atomic::new(0);

        assert_eq!(NUM.load(Ordering::Relaxed), 0);
        NUM.store(1, Ordering::Relaxed);
        assert_eq!(NUM.load(Ordering::Relaxed), 1);
        assert_eq!(NUM.swap(5, Ordering::Relaxed), 1);
        assert_eq!(NUM.load(Ordering::Relaxed), 5);

        assert_eq!(NUM.compare_exchange(5, 10, Ordering::Acquire, Ordering::Relaxed), Ok(5));
        assert_eq!(NUM.load(Ordering::Relaxed), 10);
        assert_eq!(NUM.compare_exchange(9, 20, Ordering::Acquire, Ordering::Relaxed), Err(10));
        assert_eq!(NUM.compare_exchange(10, 20, Ordering::Acquire, Ordering::Relaxed), Ok(10));
        assert_eq!(NUM.load(Ordering::Relaxed), 20);
        assert_eq!(NUM.compare_exchange(5, 10, Ordering::Acquire, Ordering::Relaxed), Err(20));

        assert_eq!(NUM.fetch_sub(17, Ordering::Relaxed), 20);
        assert_eq!(NUM.fetch_add(7, Ordering::Relaxed), 3);
        assert_eq!(NUM.fetch_sub(10, Ordering::Relaxed), 10);

        assert_eq!(NUM.fetch_add($ty::max_value(), Ordering::Relaxed), 0);
        assert_eq!(NUM.fetch_add(1, Ordering::Relaxed), $ty::max_value());
        assert_eq!(NUM.fetch_sub($ty::min_value(), Ordering::Relaxed), $ty::min_value());

        NUM.store(0b101101, Ordering::Relaxed);
        assert_eq!(NUM.fetch_or(0b110011, Ordering::Relaxed), 0b101101);

        NUM.store(0b101101, Ordering::Relaxed);
        assert_eq!(NUM.fetch_xor(0b110011, Ordering::Relaxed), 0b101101);
        assert_eq!(NUM.load(Ordering::Relaxed), 0b011110);

        NUM.store(0x13, Ordering::Relaxed);
        assert_eq!(NUM.fetch_nand(0x31, Ordering::Relaxed), 0x13);
        assert_eq!(NUM.load(Ordering::Relaxed), !(0x13 & 0x31));

        NUM.store(0b101101, Ordering::Relaxed);
        assert_eq!(NUM.fetch_and(0b110011, Ordering::Relaxed), 0b101101);
        assert_eq!(NUM.load(Ordering::Relaxed), 0b100001);

        NUM.store(7, Ordering::Relaxed);
        assert_eq!(NUM.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(7));
        assert_eq!(NUM.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(7));
        assert_eq!(NUM.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(8));
        assert_eq!(NUM.load(Ordering::SeqCst), 9);
    };
}

#[test]
fn should_check_methods_work_on_u8() {
    impl_test_unsigned!(u8);
}

#[test]
fn should_check_methods_work_on_u16() {
    impl_test_unsigned!(u16);
}

#[test]
fn should_check_methods_work_on_u32() {
    impl_test_unsigned!(u32);
}

#[test]
fn should_check_methods_work_on_u64() {
    impl_test_unsigned!(u64);
}

#[test]
fn should_check_methods_work_on_usize() {
    impl_test_unsigned!(usize);
}

#[test]
fn should_check_methods_work_on_i8() {
    impl_test_signed!(i8);
}

#[test]
fn should_check_methods_work_on_i16() {
    impl_test_signed!(i16);
}

#[test]
fn should_check_methods_work_on_i32() {
    impl_test_signed!(i32);
}

#[test]
fn should_check_methods_work_on_i64() {
    impl_test_signed!(i64);
}

#[test]
fn should_check_methods_work_on_isize() {
    impl_test_signed!(isize);
}