You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: tests.rs
    path of file: ./repos/bitvec/src/macros
    
    the code of the file until where you have to start completion: //! Invocation tests of each supported constructor-macro syntax.

#![cfg(test)]

use core::{
	cell::Cell,
	sync::atomic::*,
};

use radium::types::*;

use crate::{
	mem::bits_of,
	prelude::*,
};

#[test]
fn compile_bitarr_typedef() {
	#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
	struct Slots {
		all: BitArr!(for 10, in u8, Msb0),
		typ: BitArr!(for 10, in u8),
		def: BitArr!(for 10),
	}

	static SLOTS: Slots = Slots {
		all: bitarr!(const u8, Msb0; 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
		typ: bitarr!(const u8, Lsb0; 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
		def: bitarr!(const           1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
	};

	let slots = Slots {
		all: bitarr!(u8, Msb0; 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
		typ: bitarr!(u8, Lsb0; 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
		def: bitarr!(1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
	};

	assert_eq!(SLOTS, slots);

	assert_eq!(slots.all.into_inner(), [!0u8, 192]);
	assert_eq!(slots.typ.into_inner(), [!0u8, 3]);
	let def: [usize; 1] = slots.def.into_inner();
	assert_eq!(def[0].count_ones(), 10);
}

#[test]
fn constexpr_macros() {
	const A: BitArr!(for 20, in Cell<u8>, Lsb0) =
		bitarr!(const Cell<u8>, Lsb0; 1; 20);
	let a = A;
	assert_eq!(a.len(), 24);
	assert!(a.all());

	const B: BitArr!(for 20) = bitarr!(const 1; 20);
	let b = B;
	assert_eq!(b.len(), bits_of::<usize>());
	assert!(b.all());

	const C: BitArr!(for 5, in Cell<u16>, Msb0) =
		bitarr!(const Cell<u16>, Msb0; 1, 0, 1, 1, 0);
	let c = C;
	assert_eq!(c[.. 5], bits![1, 0, 1, 1, 0]);

	const D: BitArr!(for 5, in u32, Lsb0) =
		bitarr!(const u32, Lsb0; 1, 0, 1, 1, 0);
	let d = D;
	assert_eq!(d[.. 5], bits![1, 0, 1, 1, 0]);

	let _: &'static mut BitSlice<Cell<u16>, Msb0> =
		unsafe { bits!(static mut Cell<u16>, Msb0; 1; 20) };
	let _: &'static mut BitSlice<u32, Lsb0> =
		unsafe { bits!(static mut u32, Lsb0; 1; 20) };
	let _: &'static mut BitSlice = unsafe { bits!(static mut 1; 20) };

	let _: &'static mut BitSlice<Cell<u16>, Msb0> =
		unsafe { bits!(static mut Cell<u16>, Msb0; 1, 0, 1, 1, 0) };
	let _: &'static mut BitSlice<Cell<u32>, Msb0> =
		unsafe { bits!(static mut Cell<u32>, Msb0; 1, 0, 1, 1, 0) };
	let _: &'static mut BitSlice = unsafe { bits!(static mut 1, 0, 1, 1, 0) };

	let _: &'static BitSlice<Cell<u16>, Msb0> =
		bits!(static Cell<u16>, Msb0; 1; 20);
	let _: &'static BitSlice<u32, Lsb0> = bits!(static u32, Lsb0; 1, 0, 1, 1, 0);
	let _: &'static BitSlice = bits!(static 1; 20);

	let _: &'static BitSlice<Cell<u16>, Msb0> =
		bits!(static Cell<u16>, Msb0; 1, 0, 1, 1, 0);
	let _: &'static BitSlice<u32, Msb0> = bits!(static u32, Msb0; 1, 0, 1, 1, 0);
	let _: &'static BitSlice = bits!(static 1, 0, 1, 1, 0);
}

#[test]
fn compile_bitarr() {
	let uint: BitArray<[u8; 1], Lsb0> = bitarr![u8, Lsb0; 1, 0, 1, 0];
	assert_eq!(uint.into_inner(), [5u8]);
	let cell: BitArray<[Cel
    
fn compile_bits() {
	let a: &mut BitSlice<Cell<u8>, Lsb0> = bits![mut Cell<u8>, Lsb0; 1, 0, 1];
	let b: &mut BitSlice<u8, Lsb0> = bits![mut u8, Lsb0; 1, 0, 1];
	let c: &mut BitSlice<Cell<u8>, Msb0> =
		bits![mut Cell<u8>, crate::order::Msb0; 1, 0, 1];
	let d: &mut BitSlice<u8, Msb0> = bits![mut u8, crate::order::Msb0; 1, 0, 1];
	assert_eq!(a, c);
	assert_eq!(b, d);

	let e: &mut BitSlice<Cell<u8>, Lsb0> = bits![mut Cell<u8>, Lsb0; 1; 100];
	let f: &mut BitSlice<u8, Lsb0> = bits![mut u8, Lsb0; 1; 100];
	let g: &mut BitSlice<Cell<u8>, Msb0> =
		bits![mut Cell<u8>, crate::order::Msb0; 1; 100];
	let h: &mut BitSlice<u8, Msb0> = bits![mut u8, crate::order::Msb0; 1; 100];
	assert_eq!(e, g);
	assert_eq!(f, h);
	assert!(h.domain().take(12).all(|e| e == !0));
	assert_eq!(h.domain().next_back().unwrap(), 0b1111_0000);
	assert_eq!(h.domain().len(), 13);

	let i: &mut BitSlice<usize, Lsb0> = bits![mut 1, 0, 1];
	let j: &mut BitSlice<usize, Lsb0> = bits![mut 1; 3];
	j.set(1, false);
	assert_eq!(i, j);

	let _: &BitSlice<Cell<u8>, Lsb0> = bits![Cell<u8>, Lsb0; 1, 0, 1];
	let _: &BitSlice<u8, Lsb0> = bits![u8, Lsb0; 1, 0, 1];
	let _: &BitSlice<Cell<u8>, Msb0> =
		bits![Cell<u8>, crate::order::Msb0; 1, 0, 1];
	let _: &BitSlice<u8, Msb0> = bits![u8, crate::order::Msb0; 1, 0, 1];

	let _: &BitSlice<Cell<u8>, Lsb0> = bits![Cell<u8>, Lsb0; 1; 100];
	let _: &BitSlice<u8, Lsb0> = bits![u8, Lsb0; 1; 100];
	let _: &BitSlice<Cell<u8>, Msb0> =
		bits![Cell<u8>, crate::order::Msb0; 1; 100];
	let _: &BitSlice<u8, Msb0> = bits![u8, crate::order::Msb0; 1; 100];

	let _: &BitSlice<usize, Lsb0> = bits![1, 0, 1];
	let _: &BitSlice<usize, Lsb0> = bits![1; 100];

	let _: &BitSlice<Cell<u16>, Lsb0> = bits![Cell<u16>, Lsb0; 1, 0, 1];
	let _: &BitSlice<u16, Lsb0> = bits![u16, Lsb0; 1, 0, 1];
	let _: &BitSlice<Cell<u16>, Msb0> =
		bits![Cell<u16>, crate::order::Msb0; 1, 0, 1];
	let _: &BitSlice<u16, Msb0> = bits![u16, crate::order::Msb0; 1, 0, 1];

	let _: &BitSlice<Cell<u16>, Lsb0> = bits![Cell<u16>, Lsb0; 1; 100];
	let _: &BitSlice<u16, Lsb0> = bits![u16, Lsb0; 1; 100];
	let _: &BitSlice<Cell<u16>, Msb0> =
		bits![Cell<u16>, crate::order::Msb0; 1; 100];
	let _: &BitSlice<u16, Msb0> = bits![u16, crate::order::Msb0; 1; 100];

	let _: &BitSlice<Cell<u32>, Lsb0> = bits![Cell<u32>, Lsb0; 1, 0, 1];
	let _: &BitSlice<u32, Lsb0> = bits![u32, Lsb0; 1, 0, 1];
	let _: &BitSlice<Cell<u32>, Msb0> =
		bits![Cell<u32>, crate::order::Msb0; 1, 0, 1];
	let _: &BitSlice<u32, Msb0> = bits![u32, crate::order::Msb0; 1, 0, 1];

	let _: &BitSlice<Cell<u32>, Lsb0> = bits![Cell<u32>, Lsb0; 1; 100];
	let _: &BitSlice<u32, Lsb0> = bits![u32, Lsb0; 1; 100];
	let _: &BitSlice<Cell<u32>, Msb0> =
		bits![Cell<u32>, crate::order::Msb0; 1; 100];
	let _: &BitSlice<u32, Msb0> = bits![u32, crate::order::Msb0; 1; 100];

	let _: &BitSlice<Cell<usize>, Lsb0> = bits![Cell<usize>, Lsb0; 1, 0, 1];
	let _: &BitSlice<usize, Lsb0> = bits![usize, Lsb0; 1, 0, 1];
	let _: &BitSlice<Cell<usize>, Msb0> =
		bits![Cell<usize>, crate::order::Msb0; 1, 0, 1];
	let _: &BitSlice<usize, Msb0> = bits![usize, crate::order::Msb0; 1, 0, 1];

	let _: &BitSlice<Cell<usize>, Lsb0> = bits![Cell<usize>, Lsb0; 1; 100];
	let _: &BitSlice<usize, Lsb0> = bits![usize, Lsb0; 1; 100];
	let _: &BitSlice<Cell<usize>, Msb0> =
		bits![Cell<usize>, crate::order::Msb0; 1; 100];
	let _: &BitSlice<usize, Msb0> = bits![usize, crate::order::Msb0; 1; 100];

	#[cfg(target_pointer_width = "64")]
	{
		let _: &BitSlice<Cell<u64>, Lsb0> = bits![Cell<u64>, Lsb0; 1, 0, 1];
		let _: &BitSlice<u64, Lsb0> = bits![u64, Lsb0; 1, 0, 1];
		let _: &BitSlice<Cell<u64>, Msb0> =
			bits![Cell<u64>, crate::order::Msb0; 1, 0, 1];
		let _: &BitSlice<u64, Msb0> = bits![u64, crate::order::Msb0; 1, 0, 1];

		let _: &BitSlice<Cell<u64>, Lsb0> = bits![Cell<u64>, Lsb0; 1; 100];
		let _: &BitSlice<u64, Lsb0> = bits![u64, Lsb0; 1; 100];
		let _: &BitSlice<Cell<u64>, Msb0> =
			bits![Cell<u64>, crate::order::Msb0; 1; 100];
		let _: &BitSlice<u64, Msb0> = bits![u64, crate::order::Msb0; 1; 100];
	}

	radium::if_atomic! {
		if atomic(8) {
			let _: &BitSlice<AtomicU8, LocalBits> = bits![AtomicU8, LocalBits; 0, 1];
			let _: &BitSlice<AtomicU8, Lsb0> = bits![AtomicU8, Lsb0; 0, 1];
			let _: &BitSlice<AtomicU8, Msb0> = bits![AtomicU8, Msb0; 0, 1];
			let _: &BitSlice<RadiumU8, LocalBits> = bits![RadiumU8, LocalBits; 1; 100];
			let _: &BitSlice<RadiumU8, Lsb0> = bits![RadiumU8, Lsb0; 1; 100];
			let _: &BitSlice<RadiumU8, Msb0> = bits![RadiumU8, Msb0; 1; 100];
		}
		if atomic(16) {
			let _: &BitSlice<AtomicU16, LocalBits> = bits![AtomicU16, LocalBits; 0, 1];
			let _: &BitSlice<AtomicU16, Lsb0> = bits![AtomicU16, Lsb0; 0, 1];
			let _: &BitSlice<AtomicU16, Msb0> = bits![AtomicU16, Msb0; 0, 1];
			let _: &BitSlice<RadiumU16, LocalBits> = bits![RadiumU16, LocalBits; 1; 100];
			let _: &BitSlice<RadiumU16, Lsb0> = bits![RadiumU16, Lsb0; 1; 100];
			let _: &BitSlice<RadiumU16, Msb0> = bits![RadiumU16, Msb0; 1; 100];
		}
		if atomic(32) {
			let _: &BitSlice<AtomicU32, LocalBits> = bits![AtomicU32, LocalBits; 0, 1];
			let _: &BitSlice<AtomicU32, Lsb0> = bits![AtomicU32, Lsb0; 0, 1];
			let _: &BitSlice<AtomicU32, Msb0> = bits![AtomicU32, Msb0; 0, 1];
			let _: &BitSlice<RadiumU32, LocalBits> = bits![RadiumU32, LocalBits; 1; 100];
			let _: &BitSlice<RadiumU32, Lsb0> = bits![RadiumU32, Lsb0; 1; 100];
			let _: &BitSlice<RadiumU32, Msb0> = bits![RadiumU32, Msb0; 1; 100];
		}
		if atomic(size) {
			let _: &BitSlice<AtomicUsize, LocalBits> = bits![AtomicUsize, LocalBits; 0, 1];
			let _: &BitSlice<AtomicUsize, Lsb0> = bits![AtomicUsize, Lsb0; 0, 1];
			let _: &BitSlice<AtomicUsize, Msb0> = bits![AtomicUsize, Msb0; 0, 1];
			let _: &BitSlice<RadiumUsize, LocalBits> = bits![RadiumUsize, LocalBits; 1; 100];
			let _: &BitSlice<RadiumUsize, Lsb0> = bits![RadiumUsize, Lsb0; 1; 100];
			let _: &BitSlice<RadiumUsize, Msb0> = bits![RadiumUsize, Msb0; 1; 100];
		}
	}
	#[cfg(target_pointer_width = "64")]
	radium::if_atomic! {
		if atomic(64) {
			let _: &BitSlice<AtomicU64, LocalBits> = bits![AtomicU64, LocalBits; 0, 1];
			let _: &BitSlice<AtomicU64, Lsb0> = bits![AtomicU64, Lsb0; 0, 1];
			let _: &BitSlice<AtomicU64, Msb0> = bits![AtomicU64, Msb0; 0, 1];
			let _: &BitSlice<RadiumU64, LocalBits> = bits![RadiumU64, LocalBits; 1; 100];
			let _: &BitSlice<RadiumU64, Lsb0> = bits![RadiumU64, Lsb0; 1; 100];
			let _: &BitSlice<RadiumU64, Msb0> = bits![RadiumU64, Msb0; 1; 100];
		}
	}
}