Begin the bitfield test suite

Author: dtolnay

bitfield/tests/01-parse.rs

@@ -0,0 +1,64 @@
+// Our design for #[bitfield] (see the readme) involves marker types B1 through
+// B64 to indicate the bit width of each field.
+//
+// It would be possible to implement this without having any actual types B1
+// through B64 -- the attribute macro could recognize the names "B1" through
+// "B64" and deduce the bit width from the number in the name. But this hurts
+// composability! Later we'll want to make bitfield members out of other things,
+// like enums or type aliases which won't necessarily have a width in their
+// name:
+//
+//     #[bitfield]
+//     struct RedirectionTableEntry {
+//         vector: B8,
+//         dest_mode: DestinationMode,
+//         trigger_mode: TriggerMode,
+//         destination: Destination,
+//     }
+//
+//     #[bitfield]
+//     enum DestinationMode {
+//         Physical = 0,
+//         Logical = 1,
+//     }
+//
+//     #[bitfield]
+//     enum TriggerMode {
+//         Edge = 0,
+//         Level = 1,
+//     }
+//
+//     #[target_pointer_width = "64"]
+//     type Destination = B30;
+//
+//     #[target_pointer_width = "32"]
+//     type Destination = B22;
+//
+// So instead of parsing a bit width from the type name, the approach we will
+// follow will hold bit widths in an associated constant of a trait that is
+// implemented for legal bitfield specifier types, including B1 through B64.
+//
+// Create a trait called bitfield::Specifier with an associated constant BITS,
+// and write a function-like procedural macro to define some types B1 through
+// B64 with corresponding impls of the Specifier trait.
+//
+// Be aware that crates that have the "proc-macro" crate type are not allowed to
+// export anything other than procedural macros. The project skeleton for this
+// project has been set up with two crates, one for procedural macros and the
+// other an ordinary library crate for the Specifier trait and B types which
+// also re-exports from the procedural macro crate so that users can get
+// everything through one library.
+
+use bitfield::*;
+
+//#[bitfield]
+pub struct MyFourBytes {
+    a: B1,
+    b: B3,
+    c: B4,
+    d: B24,
+}
+
+fn main() {
+    assert_eq!(<B24 as Specifier>::BITS, 24);
+}

bitfield/tests/01-specifier-types.rs

@@ -0,0 +1,26 @@
+// Write an attribute macro that replaces the struct in its input with a byte
+// array representation of the correct size. For example the invocation in the
+// test case below might expand to the following where the `size` expression is
+// computed by summing the Specifier::BITS constant of each field type.
+//
+//     #[repr(C)]
+//     pub struct MyFourBytes {
+//         data: [u8; #size],
+//     }
+//
+// Don't worry for now what happens if the total bit size is not a multiple of
+// 8 bits. We will come back to that later to make it a compile-time error.
+
+use bitfield::*;
+
+#[bitfield]
+pub struct MyFourBytes {
+    a: B1,
+    b: B3,
+    c: B4,
+    d: B24,
+}
+
+fn main() {
+    assert_eq!(std::mem::size_of::<MyFourBytes>(), 4);
+}

bitfield/tests/02-storage.rs

@@ -1,5 +1,6 @@
 #[test]
 fn tests() {
     let t = workshop::TestCases::new();
-    //t.pass("tests/01-parse.rs");
+    //t.pass("tests/01-specifier-types.rs");
+    //t.pass("tests/02-storage.rs");
 }