#[macro_use]
extern crate bitfield;

// We use a constant to make sure bits positions don't need to be literals but
// can also be constants or expressions.
const THREE: usize = 3;

#[derive(Copy, Clone, Debug)]
pub struct Foo(u16);
impl From<u8> for Foo {
    fn from(value: u8) -> Foo {
        Foo(u16::from(value))
    }
}

bitfield! {
    #[derive(Copy, Clone)]
    /// documentation comments also work!
    struct FooBar(u32);
    impl Debug;
    foo1, set_foo1: 0, 0;
    u8;
    foo2, set_foo2: 31, 31;
    foo3, set_foo3: THREE, 0;
    // We make sure attributes are applied to fields. If attributes were not
    // applied, the compilation would fail with a `duplicate definition`
    // error.
    #[cfg(not(test))]
    foo3, set_foo3: 3, 0;
    u16, foo4, set_foo4: 31, 28;
    foo5, set_foo5: 0, 0, 32;
    u32;
    foo6, set_foo6: 5, THREE, THREE;
    getter_only, _: 3, 1;
    _, setter_only: 2*2, 2;
    getter_only_array, _: 5, 3, 3;
    _, setter_only_array: 2*THREE, 4, 3;
    all_bits, set_all_bits: 31, 0;
    single_bit, set_single_bit: 3;
    #[allow(dead_code)]
    u8, into Foo, into_foo1, set_into_foo1: 31, 31;
    #[allow(dead_code)]
    pub u8, into Foo, into_foo2, set_into_foo2: 31, 31;
    u8;
    #[allow(dead_code)]
    into Foo, into_foo3, set_into_foo3: 31, 31;
    #[allow(dead_code)]
    pub into Foo, into_foo4, set_into_foo4: 31, 31;
    #[allow(dead_code)]
    into Foo, _, set_into_foo5: 31, 31;
    into Foo, into_foo6, _: 29, 29, 3;
    i8;
    signed_single_bit, set_signed_single_bit: 0, 0;
    signed_two_bits, set_signed_two_bits: 1, 0;
    signed_eight_bits, set_signed_eight_bits: 7, 0;
    signed_eight_bits_unaligned, set_signed_eight_bits_unaligned: 8, 1;
    u128, u128_getter, set_u128: 8, 1;
    i128, i128_getter, set_i128: 8, 1;
}

impl FooBar {
    bitfield_fields!{
        // Boolean field don't need a type
        foo7, _: 1;
    }

    bitfield_fields!{
        // If all fields have a type, we don't need to specify a default type
        u8, foo8,_: 1, 0;
        u32, foo9, _: 2, 0;
    }

    bitfield_fields! {
        // We can still set a default type
        u16;
        foo10, _: 2, 0;
        u32, foo11, _: 2, 0;
        foo12, _: 2, 0;
    }

    // Check if an empty bitfield_fields compiles without errors.
    bitfield_fields!{}
}

#[test]
fn test_single_bit() {
    let mut fb = FooBar(0);

    fb.set_foo1(1);
    assert_eq!(0x1, fb.0);
    assert_eq!(0x1, fb.foo1());
    assert_eq!(0x0, fb.foo2());
    assert_eq!(false, fb.single_bit());
    assert_eq!(-1, fb.signed_single_bit());

    fb.set_foo2(1);
    assert_eq!(0x8000_0001, fb.0);
    assert_eq!(0x1, fb.foo1());
    assert_eq!(0x1, fb.foo2());
    assert_eq!(false, fb.single_bit());
    assert_eq!(-1, fb.signed_single_bit());

    fb.set_foo1(0);
    assert_eq!(0x8000_0000, fb.0);
    assert_eq!(0x0, fb.foo1());
    assert_eq!(0x1, fb.foo2());
    assert_eq!(false, fb.single_bit());
    assert_eq!(0, fb.signed_single_bit());

    fb.set_single_bit(true);
    assert_eq!(0x8000_0008, fb.0);
    assert_eq!(0x0, fb.foo1());
    assert_eq!(0x1, fb.foo2());
    assert_eq!(true, fb.single_bit());
    assert_eq!(0, fb.signed_single_bit());

    fb.set_signed_single_bit(-1);
    assert_eq!(0x8000_0009, fb.0);
    assert_eq!(0x1, fb.foo1());
    assert_eq!(0x1, fb.foo2());
    assert_eq!(true, fb.single_bit());
    assert_eq!(-1, fb.signed_single_bit());
}

#[test]
fn test_single_bit_plus_garbage() {
    let mut fb = FooBar(0);

    fb.set_foo1(0b10);
    assert_eq!(0x0, fb.0);
    assert_eq!(0x0, fb.foo1());
    assert_eq!(0x0, fb.foo2());

    fb.set_foo1(0b11);
    assert_eq!(0x1, fb.0);
    assert_eq!(0x1, fb.foo1());
    assert_eq!(0x0, fb.foo2());
}

#[test]
fn test_multiple_bit() {
    let mut fb = FooBar(0);

    fb.set_foo3(0x0F);
    assert_eq!(0xF, fb.0);
    assert_eq!(0xF, fb.foo3());
    assert_eq!(0x0, fb.foo4());

    fb.set_foo4(0x0F);
    assert_eq!(0xF000_000F, fb.0);
    assert_eq!(0xF, fb.foo3());
    assert_eq!(0xF, fb.foo4());

    fb.set_foo3(0);
    assert_eq!(0xF000_0000, fb.0);
    assert_eq!(0x0, fb.foo3());
    assert_eq!(0xF, fb.foo4());

    fb.set_foo3(0xA);
    assert_eq!(0xF000_000A, fb.0);
    assert_eq!(0xA, fb.foo3());
    assert_eq!(0xF, fb.foo4());
}

#[test]
fn test_getter_setter_only() {
    let mut fb = FooBar(0);
    fb.setter_only(0x7);
    assert_eq!(0x1C, fb.0);
    assert_eq!(0x6, fb.getter_only());
}

#[test]
fn test_array_field1() {
    let mut fb = FooBar(0);

    fb.set_foo5(0, 1);
    assert_eq!(0x1, fb.0);
    assert_eq!(1, fb.foo5(0));

    fb.set_foo5(0, 0);
    assert_eq!(0x0, fb.0);
    assert_eq!(0, fb.foo5(0));

    fb.set_foo5(0, 1);
    fb.set_foo5(6, 1);
    fb.set_foo5(31, 1);
    assert_eq!(0x8000_0041, fb.0);
    assert_eq!(1, fb.foo5(0));
    assert_eq!(1, fb.foo5(6));
    assert_eq!(1, fb.foo5(31));
    assert_eq!(0, fb.foo5(1));
    assert_eq!(0, fb.foo5(5));
    assert_eq!(0, fb.foo5(7));
    assert_eq!(0, fb.foo5(30));
}

#[test]
fn test_array_field2() {
    let mut fb = FooBar(0);

    fb.set_foo6(0, 1);
    assert_eq!(0x8, fb.0);
    assert_eq!(1, fb.foo6(0));
    assert_eq!(0, fb.foo6(1));
    assert_eq!(0, fb.foo6(2));

    fb.set_foo6(0, 7);
    assert_eq!(0x38, fb.0);
    assert_eq!(7, fb.foo6(0));
    assert_eq!(0, fb.foo6(1));
    assert_eq!(0, fb.foo6(2));

    fb.set_foo6(2, 7);
    assert_eq!(0xE38, fb.0);
    assert_eq!(7, fb.foo6(0));
    assert_eq!(0, fb.foo6(1));
    assert_eq!(7, fb.foo6(2));

    fb.set_foo6(0, 0);
    assert_eq!(0xE00, fb.0);
    assert_eq!(0, fb.foo6(0));
    assert_eq!(0, fb.foo6(1));
    assert_eq!(7, fb.foo6(2));
}

#[allow(unknown_lints)]
#[allow(identity_op)]
#[allow(erasing_op)]
#[test]
fn test_setter_only_array() {
    let mut fb = FooBar(0);

    fb.setter_only_array(0, 0);
    assert_eq!(0x0, fb.0);

    fb.setter_only_array(0, 0b111);
    assert_eq!(0b111 << (4 + 0 * 2), fb.0);

    fb.setter_only_array(0, 0);
    fb.setter_only_array(1, 0b111);
    assert_eq!(0b111 << (4 + 1 * 3), fb.0);

    fb.setter_only_array(1, 0);
    fb.setter_only_array(2, 0b111);
    assert_eq!(0b111 << (4 + 2 * 3), fb.0);
}

#[test]
fn test_getter_only_array() {
    let mut fb = FooBar(0);

    assert_eq!(0, fb.getter_only_array(0));
    assert_eq!(0, fb.getter_only_array(1));
    assert_eq!(0, fb.getter_only_array(2));

    fb.0 = !(0x1FF << 3);
    assert_eq!(0, fb.getter_only_array(0));
    assert_eq!(0, fb.getter_only_array(1));
    assert_eq!(0, fb.getter_only_array(2));

    fb.0 = 0xF << 3;
    assert_eq!(0b111, fb.getter_only_array(0));
    assert_eq!(0b001, fb.getter_only_array(1));
    assert_eq!(0, fb.getter_only_array(2));

    fb.0 = 0xF << 6;
    assert_eq!(0, fb.getter_only_array(0));
    assert_eq!(0b111, fb.getter_only_array(1));
    assert_eq!(0b001, fb.getter_only_array(2));

    fb.0 = 0xF << 8;
    assert_eq!(0, fb.getter_only_array(0));
    assert_eq!(0b100, fb.getter_only_array(1));
    assert_eq!(0b111, fb.getter_only_array(2));

    fb.0 = 0b101_010_110 << 3;
    assert_eq!(0b110, fb.getter_only_array(0));
    assert_eq!(0b010, fb.getter_only_array(1));
    assert_eq!(0b101, fb.getter_only_array(2));
}

#[test]
fn test_signed() {
    let mut fb = FooBar(0);

    assert_eq!(0, fb.signed_two_bits());
    assert_eq!(0, fb.signed_eight_bits());
    assert_eq!(0, fb.signed_eight_bits_unaligned());

    fb.set_signed_two_bits(-2);
    assert_eq!(0b10, fb.0);
    assert_eq!(-2, fb.signed_two_bits());
    assert_eq!(2, fb.signed_eight_bits());
    assert_eq!(1, fb.signed_eight_bits_unaligned());

    fb.set_signed_two_bits(-1);
    assert_eq!(0b11, fb.0);
    assert_eq!(-1, fb.signed_two_bits());
    assert_eq!(3, fb.signed_eight_bits());
    assert_eq!(1, fb.signed_eight_bits_unaligned());

    fb.set_signed_two_bits(0);
    assert_eq!(0, fb.0);
    assert_eq!(0, fb.signed_two_bits());
    assert_eq!(0, fb.signed_eight_bits());
    assert_eq!(0, fb.signed_eight_bits_unaligned());

    fb.set_signed_two_bits(1);
    assert_eq!(1, fb.0);
    assert_eq!(1, fb.signed_two_bits());
    assert_eq!(1, fb.signed_eight_bits());
    assert_eq!(0, fb.signed_eight_bits_unaligned());

    fb.set_signed_eight_bits(0);
    assert_eq!(0, fb.0);
    assert_eq!(0, fb.signed_two_bits());
    assert_eq!(0, fb.signed_eight_bits());
    assert_eq!(0, fb.signed_eight_bits_unaligned());

    fb.set_signed_eight_bits(-1);
    assert_eq!(0xFF, fb.0);
    assert_eq!(-1, fb.signed_two_bits());
    assert_eq!(-1, fb.signed_eight_bits());
    assert_eq!(127, fb.signed_eight_bits_unaligned());

    fb.set_signed_eight_bits(-128);
    assert_eq!(0x80, fb.0);
    assert_eq!(0, fb.signed_two_bits());
    assert_eq!(-128, fb.signed_eight_bits());
    assert_eq!(64, fb.signed_eight_bits_unaligned());

    fb.set_signed_eight_bits(127);
    assert_eq!(0x7F, fb.0);
    assert_eq!(-1, fb.signed_two_bits());
    assert_eq!(127, fb.signed_eight_bits());
    assert_eq!(63, fb.signed_eight_bits_unaligned());

    fb.set_signed_eight_bits_unaligned(0);
    assert_eq!(1, fb.0);
    assert_eq!(1, fb.signed_two_bits());
    assert_eq!(1, fb.signed_eight_bits());
    assert_eq!(0, fb.signed_eight_bits_unaligned());

    fb.set_signed_eight_bits(0);
    fb.set_signed_eight_bits_unaligned(-1);
    assert_eq!(0x1FE, fb.0);
    assert_eq!(-2, fb.signed_two_bits());
    assert_eq!(-2, fb.signed_eight_bits());
    assert_eq!(-1, fb.signed_eight_bits_unaligned());

    fb.set_signed_eight_bits_unaligned(-128);
    assert_eq!(0x100, fb.0);
    assert_eq!(0, fb.signed_two_bits());
    assert_eq!(0, fb.signed_eight_bits());
    assert_eq!(-128, fb.signed_eight_bits_unaligned());
    fb.set_signed_eight_bits_unaligned(127);
    assert_eq!(0xFE, fb.0);
    assert_eq!(-2, fb.signed_two_bits());
    assert_eq!(-2, fb.signed_eight_bits());
    assert_eq!(127, fb.signed_eight_bits_unaligned());
}

#[test]
fn test_field_type() {
    let fb = FooBar(0);
    let _: u32 = fb.foo1();
    let _: u8 = fb.foo2();
    let _: u8 = fb.foo3();
    let _: u16 = fb.foo4();
    let _: u8 = fb.foo5(0);
    let _: u32 = fb.foo6(0);

    let _: bool = fb.foo7();
    let _: u8 = fb.foo8();
    let _: u32 = fb.foo9();
    let _: u16 = fb.foo10();
    let _: u32 = fb.foo11();
    let _: u16 = fb.foo12();

    let _: Foo = fb.into_foo1();
    let _: Foo = fb.into_foo2();
    let _: Foo = fb.into_foo3();
    let _: Foo = fb.into_foo4();
    let _: Foo = fb.into_foo6(0);

    let _: i8 = fb.signed_single_bit();
    let _: i8 = fb.signed_two_bits();
    let _: i8 = fb.signed_eight_bits();
    let _: i8 = fb.signed_eight_bits_unaligned();

    let _: u128 = fb.u128_getter();
    let _: i128 = fb.i128_getter();
}

#[test]
fn test_all_bits() {
    let mut fb = FooBar(0);

    assert_eq!(0, fb.all_bits());

    fb.set_all_bits(!0u32);
    assert_eq!(!0u32, fb.0);
    assert_eq!(!0u32, fb.all_bits());

    fb.0 = 0x8000_0001;
    assert_eq!(0x8000_0001, fb.all_bits());
}

#[test]
fn test_is_copy() {
    let a = FooBar(0);
    let _b = a;
    let _c = a;
}

#[test]
fn test_debug() {
    let fb = FooBar(1_234_567_890);
    let expected = "FooBar { .0: 1234567890, foo1: 0, foo2: 0, foo3: 2, foo3: 2, foo4: 4, foo5: [0\
                    , 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0\
                    , 1, 0, 0, 1, 0], foo6: [2, 3, 1], getter_only: 1, getter_only_array: [2, 3, 1]\
                    , all_bits: 1234567890, single_bit: false, into_foo1: Foo(0), into_foo2: Foo(0)\
                    , into_foo3: Foo(0), into_foo4: Foo(0), into_foo6: [Foo(0), Foo(1), Foo(0)], \
                    signed_single_bit: 0, signed_two_bits: -2, signed_eight_bits: -46, \
                    signed_eight_bits_unaligned: 105, u128_getter: 105, i128_getter: 105 }";
    assert_eq!(expected, format!("{:?}", fb))
}

bitfield! {
    struct ArrayBitfield([u8]);
    u32;
    foo1, set_foo1: 0, 0;
    foo2, set_foo2: 7, 0;
    foo3, set_foo3: 8, 1;
    foo4, set_foo4: 19, 4;
    i32;
    signed_foo1, set_signed_foo1: 0, 0;
    signed_foo2, set_signed_foo2: 7, 0;
    signed_foo3, set_signed_foo3: 8, 1;
    signed_foo4, set_signed_foo4: 19, 4;
    u128, u128_getter, set_u128: 19, 4;
}

#[test]
fn test_arraybitfield() {
    let mut ab = ArrayBitfield([0; 3]);

    assert_eq!(0u32, ab.foo1());
    assert_eq!(0u32, ab.foo2());
    assert_eq!(0u32, ab.foo3());
    assert_eq!(0u32, ab.foo4());
    assert_eq!(0i32, ab.signed_foo1());
    assert_eq!(0i32, ab.signed_foo2());
    assert_eq!(0i32, ab.signed_foo3());
    assert_eq!(0i32, ab.signed_foo4());
    assert_eq!(0u128, ab.u128_getter());

    ab.set_foo1(1);
    assert_eq!([1, 0, 0], ab.0);
    assert_eq!(1, ab.foo1());
    assert_eq!(1, ab.foo2());
    assert_eq!(0, ab.foo3());
    assert_eq!(0, ab.foo4());
    assert_eq!(-1, ab.signed_foo1());
    assert_eq!(1, ab.signed_foo2());
    assert_eq!(0, ab.signed_foo3());
    assert_eq!(0, ab.signed_foo4());
    assert_eq!(0, ab.u128_getter());

    ab.set_foo1(0);
    ab.set_foo2(0xFF);
    assert_eq!([0xFF, 0, 0], ab.0);
    assert_eq!(1, ab.foo1());
    assert_eq!(0xFF, ab.foo2());
    assert_eq!(0x7F, ab.foo3());
    assert_eq!(0x0F, ab.foo4());
    assert_eq!(-1, ab.signed_foo1());
    assert_eq!(-1, ab.signed_foo2());
    assert_eq!(127, ab.signed_foo3());
    assert_eq!(0x0F, ab.signed_foo4());
    assert_eq!(0x0F, ab.u128_getter());

    ab.set_foo2(0);
    ab.set_foo3(0xFF);
    assert_eq!([0xFE, 0x01, 0], ab.0);
    assert_eq!(0, ab.foo1());
    assert_eq!(0xFE, ab.foo2());
    assert_eq!(0xFF, ab.foo3());
    assert_eq!(0x1F, ab.foo4());
    assert_eq!(0, ab.signed_foo1());
    assert_eq!(-2, ab.signed_foo2());
    assert_eq!(-1, ab.signed_foo3());
    assert_eq!(0x1F, ab.signed_foo4());
    assert_eq!(0x1F, ab.u128_getter());

    ab.set_foo3(0);
    ab.set_foo4(0xFFFF);
    assert_eq!([0xF0, 0xFF, 0x0F], ab.0);
    assert_eq!(0, ab.foo1());
    assert_eq!(0xF0, ab.foo2());
    assert_eq!(0xF8, ab.foo3());
    assert_eq!(0xFFFF, ab.foo4());
    assert_eq!(0, ab.signed_foo1());
    assert_eq!(-16, ab.signed_foo2());
    assert_eq!(-8, ab.signed_foo3());
    assert_eq!(-1, ab.signed_foo4());
    assert_eq!(0xFFFF, ab.u128_getter());

    ab.set_foo4(0x0);
    ab.set_signed_foo1(0);
    assert_eq!([0x00, 0x00, 0x00], ab.0);

    ab.set_signed_foo1(-1);
    assert_eq!([0x01, 0x00, 0x00], ab.0);

    ab.set_signed_foo1(0);
    ab.set_signed_foo2(127);
    assert_eq!([0x7F, 0x00, 0x00], ab.0);

    ab.set_signed_foo2(-128);
    assert_eq!([0x80, 0x00, 0x00], ab.0);

    ab.set_signed_foo2(1);
    assert_eq!([0x01, 0x00, 0x00], ab.0);

    ab.set_signed_foo2(-1);
    assert_eq!([0xFF, 0x00, 0x00], ab.0);

    ab.set_signed_foo2(0);
    ab.set_signed_foo3(127);
    assert_eq!([0xFE, 0x00, 0x00], ab.0);

    ab.set_signed_foo3(-1);
    assert_eq!([0xFE, 0x01, 0x00], ab.0);

    ab.set_signed_foo3(0);
    ab.set_signed_foo4(-1);
    assert_eq!([0xF0, 0xFF, 0x0F], ab.0);

    ab.set_signed_foo4(0);
    ab.set_u128(0xFFFF);
    assert_eq!([0xF0, 0xFF, 0x0F], ab.0);
}

#[test]
fn test_arraybitfield2() {
    // Check that the macro can be called from a function.
    bitfield! {
        struct ArrayBitfield2([u16]);
        impl Debug;
        u32;
        foo1, set_foo1: 0, 0;
        foo2, set_foo2: 7, 0;
        foo3, set_foo3: 8, 1;
        foo4, set_foo4: 20, 4;
    }
    let mut ab = ArrayBitfield2([0; 2]);

    assert_eq!(0, ab.foo1());
    assert_eq!(0, ab.foo2());
    assert_eq!(0, ab.foo3());
    assert_eq!(0, ab.foo4());

    ab.set_foo1(1);
    assert_eq!([1, 0], ab.0);
    assert_eq!(1, ab.foo1());
    assert_eq!(1, ab.foo2());
    assert_eq!(0, ab.foo3());
    assert_eq!(0, ab.foo4());

    ab.set_foo1(0);
    ab.set_foo2(0xFF);
    assert_eq!([0xFF, 0], ab.0);
    assert_eq!(1, ab.foo1());
    assert_eq!(0xFF, ab.foo2());
    assert_eq!(0x7F, ab.foo3());
    assert_eq!(0x0F, ab.foo4());

    ab.set_foo2(0);
    ab.set_foo3(0xFF);
    assert_eq!([0x1FE, 0x0], ab.0);
    assert_eq!(0, ab.foo1());
    assert_eq!(0xFE, ab.foo2());
    assert_eq!(0xFF, ab.foo3());
    assert_eq!(0x1F, ab.foo4());

    ab.set_foo3(0);
    ab.set_foo4(0xFFFF);
    assert_eq!([0xFFF0, 0xF], ab.0);
    assert_eq!(0, ab.foo1());
    assert_eq!(0xF0, ab.foo2());
    assert_eq!(0xF8, ab.foo3());
    assert_eq!(0xFFFF, ab.foo4());
}

bitfield! {
    struct ArrayBitfieldMsb0(MSB0 [u8]);
    impl Debug;
    u32;
    foo1, set_foo1: 0, 0;
    foo2, set_foo2: 7, 0;
    foo3, set_foo3: 8, 1;
    foo4, set_foo4: 19, 4;
    i32;
    signed_foo1, set_signed_foo1: 0, 0;
    signed_foo2, set_signed_foo2: 7, 0;
    signed_foo3, set_signed_foo3: 8, 1;
    signed_foo4, set_signed_foo4: 19, 4;
}

#[test]
fn test_arraybitfield_msb0() {
    let mut ab = ArrayBitfieldMsb0([0; 3]);

    assert_eq!(0, ab.foo1());
    assert_eq!(0, ab.foo2());
    assert_eq!(0, ab.foo3());
    assert_eq!(0, ab.foo4());
    assert_eq!(0, ab.signed_foo1());
    assert_eq!(0, ab.signed_foo2());
    assert_eq!(0, ab.signed_foo3());
    assert_eq!(0, ab.signed_foo4());

    ab.set_foo1(1);
    assert_eq!([0b1000_0000, 0, 0], ab.0);
    assert_eq!(1, ab.foo1());
    assert_eq!(0b1000_0000, ab.foo2());
    assert_eq!(0, ab.foo3());
    assert_eq!(0, ab.foo4());
    assert_eq!(-1, ab.signed_foo1());
    assert_eq!(-128, ab.signed_foo2());
    assert_eq!(0, ab.signed_foo3());
    assert_eq!(0, ab.signed_foo4());

    ab.set_foo1(0);
    ab.set_foo2(0xFF);
    assert_eq!([0b1111_1111, 0, 0], ab.0);
    assert_eq!(1, ab.foo1());
    assert_eq!(0b1111_1111, ab.foo2());
    assert_eq!(0b1111_1110, ab.foo3());
    assert_eq!(0b1111_0000_0000_0000, ab.foo4());
    assert_eq!(-1, ab.signed_foo1());
    assert_eq!(-1, ab.signed_foo2());
    assert_eq!(-2, ab.signed_foo3());
    assert_eq!(-4096, ab.signed_foo4());

    ab.set_foo2(0);
    ab.set_foo3(0xFF);
    assert_eq!([0b0111_1111, 0b1000_0000, 0], ab.0);
    assert_eq!(0, ab.foo1());
    assert_eq!(0b0111_1111, ab.foo2());
    assert_eq!(0xFF, ab.foo3());
    assert_eq!(0b1111_1000_0000_0000, ab.foo4());
    assert_eq!(0, ab.signed_foo1());
    assert_eq!(127, ab.signed_foo2());
    assert_eq!(-1, ab.signed_foo3());
    assert_eq!(-2048, ab.signed_foo4());

    ab.set_foo3(0);
    ab.set_foo4(0xFFFF);
    assert_eq!([0x0F, 0xFF, 0xF0], ab.0);
    assert_eq!(0, ab.foo1());
    assert_eq!(0x0F, ab.foo2());
    assert_eq!(0b0001_1111, ab.foo3());
    assert_eq!(0xFFFF, ab.foo4());
    assert_eq!(0, ab.signed_foo1());
    assert_eq!(0x0F, ab.signed_foo2());
    assert_eq!(0b0001_1111, ab.signed_foo3());
    assert_eq!(-1, ab.signed_foo4());

    ab.set_foo4(0x0);
    ab.set_signed_foo1(0);
    assert_eq!([0x00, 0x00, 0x00], ab.0);

    ab.set_signed_foo1(-1);
    assert_eq!([0b1000_0000, 0x00, 0x00], ab.0);

    ab.set_signed_foo1(0);
    ab.set_signed_foo2(127);
    assert_eq!([0x7F, 0x00, 0x00], ab.0);

    ab.set_signed_foo2(-128);
    assert_eq!([0x80, 0x00, 0x00], ab.0);

    ab.set_signed_foo2(1);
    assert_eq!([0x01, 0x00, 0x00], ab.0);

    ab.set_signed_foo2(-1);
    assert_eq!([0xFF, 0x00, 0x00], ab.0);

    ab.set_signed_foo2(0);
    ab.set_signed_foo3(127);
    assert_eq!([0b0011_1111, 0b1000_0000, 0], ab.0);

    ab.set_signed_foo3(-1);
    assert_eq!([0b0111_1111, 0b1000_0000, 0], ab.0);

    ab.set_signed_foo3(0);
    ab.set_signed_foo4(-1);
    assert_eq!([0x0F, 0xFF, 0xF0], ab.0);
}

mod some_module {
    bitfield! {
        pub struct PubBitFieldInAModule(u32);
        impl Debug;
        /// Attribute works on pub fields
        pub field1, set_field1: 1;
        pub field2, _: 1;
        pub _, set_field3: 1;
        pub u16, field4, set_field4: 1;
        /// Check if multiple attributes are applied
        #[cfg(not(test))]
        pub u16, field4, set_field4: 1;
        pub u16, _, set_field5: 1;
        pub u16, field6, _: 1;
        pub field7, set_field7: 1;
        pub field8, set_field8: 1, 1;
        #[cfg(not(test))]
        /// And make sure not only the last attributes is applied
        pub field8, set_field8: 1, 1;
        pub field9, set_field9: 1, 1, 1;
        pub u32, field10, set_field10: 1;
        pub u32, field11, set_field11: 1, 1;
        pub u32, field12, set_field12: 1, 1, 1;
    }

}

#[test]
fn struct_can_be_public() {
    let _ = some_module::PubBitFieldInAModule(0);
}
#[test]
fn field_can_be_public() {
    let mut a = some_module::PubBitFieldInAModule(0);
    let _ = a.field1();
    a.set_field1(true);
    let _ = a.field2();
    a.set_field3(true);
    let _ = a.field4();
    a.set_field4(true);
    a.set_field5(true);
    let _ = a.field6();
    let _ = a.field7();
    a.set_field7(true);
    let _ = a.field8();
    a.set_field8(0);
    let _ = a.field9(0);
    a.set_field9(0, 0);
    let _ = a.field10();
    a.set_field10(true);
    let _ = a.field11();
    a.set_field11(0);
    let _ = a.field12(0);
    a.set_field12(0, 0);
}

// Everything in this module is to make sure that its possible to specify types
// in most of the possible ways.
#[allow(dead_code)]
mod test_types {
    use bitfield::BitRange;
    use std;
    use std::sync::atomic::{self, AtomicUsize};

    struct Foo;

    impl Foo {
        bitfield_fields!{
            std::sync::atomic::AtomicUsize, field1, set_field1: 0, 0;
            std::sync::atomic::AtomicUsize;
            field2, set_field2: 0, 0;
            ::std::sync::atomic::AtomicUsize, field3, set_field3: 0, 0;
            ::std::sync::atomic::AtomicUsize;
            field4, set_field4: 0, 0;
            atomic::AtomicUsize, field5, set_field5: 0, 0;
            atomic::AtomicUsize;
            field6, set_field6: 0, 0;
            AtomicUsize, field7, set_field7: 0, 0;
            AtomicUsize;
            field8, set_field8: 0, 0;
            Vec<std::sync::atomic::AtomicUsize>, field9, set_field9: 0, 0;
            Vec<std::sync::atomic::AtomicUsize>;
            field10, set_field10: 0, 0;
            Vec<::std::sync::atomic::AtomicUsize>, field11, set_field11: 0, 0;
            Vec<::std::sync::atomic::AtomicUsize>;
            field12, set_field12: 0, 0;
            Vec<atomic::AtomicUsize>, field13, set_field13: 0, 0;
            Vec<atomic::AtomicUsize>;
            field14, set_field14: 0, 0;
            Vec<AtomicUsize>, field15, set_field15: 0, 0;
            Vec<AtomicUsize>;
            field16, set_field16: 0, 0;
            &str, field17, set_field17: 0, 0;
            &str;
            field18, set_field18: 0, 0;
            &'static str, field19, set_field19: 0, 0;
            &'static str;
            field20, set_field20: 0, 0;
        }
    }

    impl BitRange<AtomicUsize> for Foo {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> AtomicUsize {
            AtomicUsize::new(0)
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: AtomicUsize) {}
    }

    impl BitRange<Vec<AtomicUsize>> for Foo {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> Vec<AtomicUsize> {
            vec![AtomicUsize::new(0)]
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: Vec<AtomicUsize>) {}
    }

    impl<'a> BitRange<&'a str> for Foo {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> &'a str {
            ""
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: &'a str) {}
    }

    #[test]
    fn test_field_type() {
        let test = Foo;
        let _: AtomicUsize = test.field1();
        let _: AtomicUsize = test.field2();
        let _: AtomicUsize = test.field3();
        let _: AtomicUsize = test.field4();
        let _: AtomicUsize = test.field5();
        let _: AtomicUsize = test.field6();
        let _: AtomicUsize = test.field7();
        let _: AtomicUsize = test.field8();
        let _: Vec<AtomicUsize> = test.field9();
        let _: Vec<AtomicUsize> = test.field10();
        let _: Vec<AtomicUsize> = test.field11();
        let _: Vec<AtomicUsize> = test.field12();
        let _: Vec<AtomicUsize> = test.field13();
        let _: Vec<AtomicUsize> = test.field14();
        let _: Vec<AtomicUsize> = test.field15();
        let _: Vec<AtomicUsize> = test.field16();
        let _: &str = test.field17();
        let _: &str = test.field18();
        let _: &'static str = test.field19();
        let _: &'static str = test.field20();
    }
}

#[allow(dead_code)]
mod test_no_default_bitrange {
    use bitfield::BitRange;
    use std::fmt::Debug;
    use std::fmt::Error;
    use std::fmt::Formatter;
    bitfield!{
      #[derive(Eq, PartialEq)]
      pub struct BitField1(u16);
      no default BitRange;
      impl Debug;
      u8;
      field1, set_field1: 10, 0;
      pub field2, _ : 12, 3;
      field3, set_field3: 2;
    }

    impl BitRange<u8> for BitField1 {
        fn bit_range(&self, msb: usize, lsb: usize) -> u8 {
            (msb + lsb) as u8
        }
        fn set_bit_range(&mut self, msb: usize, lsb: usize, value: u8) {
            self.0 = msb as u16 + lsb as u16 + u16::from(value)
        }
    }

    #[allow(unknown_lints)]
    #[allow(identity_op)]
    #[test]
    fn custom_bitrange_implementation_is_used() {
        let mut bf = BitField1(0);
        assert_eq!(bf.field1(), 10 + 0);
        assert_eq!(bf.field2(), 12 + 3);
        assert_eq!(bf.field3(), true);
        bf.set_field1(42);
        assert_eq!(bf, BitField1(10 + 0 + 42));
    }

    bitfield!{
      pub struct BitField2(u16);
      no default BitRange;
      u8;
      field1, set_field1: 10, 0;
      pub field2, _ : 12, 3;
      field3, set_field3: 0;
    }

    impl BitRange<u8> for BitField2 {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> u8 {
            0
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: u8) {}
    }

    // Make sure Debug wasn't implemented by implementing it.
    impl Debug for BitField2 {
        fn fmt(&self, _: &mut Formatter) -> Result<(), Error> {
            unimplemented!()
        }
    }

    // Check that we can put `impl Debug` before `no default BitRange`
    bitfield! {
      pub struct BitField3(u16);
      impl Debug;
      no default BitRange;
      u8;
      field1, set_field1: 10, 0;
      pub field2, _ : 12, 3;
      field3, set_field3: 0;
    }

    impl BitRange<u8> for BitField3 {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> u8 {
            0
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: u8) {}
    }

    bitfield!{
      #[derive(Eq, PartialEq)]
      pub struct BitField4([u16]);
      no default BitRange;
      impl Debug;
      u8;
      field1, set_field1: 10, 0;
      pub field2, _ : 12, 3;
      field3, set_field3: 2;
    }

    impl<T> BitRange<u8> for BitField4<T> {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> u8 {
            0
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: u8) {}
    }

    bitfield!{
      pub struct BitField5([u16]);
      no default BitRange;
      u8;
      field1, set_field1: 10, 0;
      pub field2, _ : 12, 3;
      field3, set_field3: 0;
    }

    impl<T> BitRange<u8> for BitField5<T> {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> u8 {
            0
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: u8) {}
    }

    // Make sure Debug wasn't implemented by implementing it.
    impl<T> Debug for BitField5<T> {
        fn fmt(&self, _: &mut Formatter) -> Result<(), Error> {
            unimplemented!()
        }
    }

    // Check that we can put `impl Debug` before `no default BitRange`
    bitfield! {
      pub struct BitField6([u16]);
      impl Debug;
      no default BitRange;
      u8;
      field1, set_field1: 10, 0;
      pub field2, _ : 12, 3;
      field3, set_field3: 0;
    }

    impl<T> BitRange<u8> for BitField6<T> {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> u8 {
            0
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: u8) {}
    }

    bitfield!{
      #[derive(Eq, PartialEq)]
      pub struct BitField7(MSB0 [u16]);
      no default BitRange;
      impl Debug;
      u8;
      field1, set_field1: 10, 0;
      pub field2, _ : 12, 3;
      field3, set_field3: 2;
    }

    impl<T> BitRange<u8> for BitField7<T> {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> u8 {
            0
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: u8) {}
    }

    bitfield!{
      pub struct BitField8(MSB0 [u16]);
      no default BitRange;
      u8;
      field1, set_field1: 10, 0;
      pub field2, _ : 12, 3;
      field3, set_field3: 0;
    }

    impl<T> BitRange<u8> for BitField8<T> {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> u8 {
            0
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: u8) {}
    }

    // Make sure Debug wasn't implemented by implementing it.
    impl<T> Debug for BitField8<T> {
        fn fmt(&self, _: &mut Formatter) -> Result<(), Error> {
            unimplemented!()
        }
    }

    // Check that we can put `impl Debug` before `no default BitRange`
    bitfield! {
      pub struct BitField9([u16]);
      impl Debug;
      no default BitRange;
      u8;
      field1, set_field1: 10, 0;
      pub field2, _ : 12, 3;
      field3, set_field3: 0;
    }

    impl<T> BitRange<u8> for BitField9<T> {
        fn bit_range(&self, _msb: usize, _lsb: usize) -> u8 {
            0
        }
        fn set_bit_range(&mut self, _msb: usize, _lsb: usize, _value: u8) {}
    }

    #[test]
    fn test_debug_is_implemented_with_no_default_bitrange() {
        format!("{:?}", BitField1(0));
        format!("{:?}", BitField3(0));
        format!("{:?}", BitField4([0; 1]));
        format!("{:?}", BitField6([0; 1]));
        format!("{:?}", BitField7([0; 1]));
        format!("{:?}", BitField9([0; 1]));
    }
}