bitfields-0.12.4/.cargo_vcs_info.json0000644000000001470000000000100130670ustar { "git": { "sha1": "2bc9aa611dd4c8302f5ef05b137ac4b3dc9d327d" }, "path_in_vcs": "bitfields" }bitfields-0.12.4/Cargo.lock0000644000000203720000000000100110440ustar # This file is automatically @generated by Cargo. # It is not intended for manual editing. version = 4 [[package]] name = "bitfields" version = "0.12.4" dependencies = [ "bitfields-impl", "trybuild", ] [[package]] name = "bitfields-impl" version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "07c93edde7bb4416c35c85048e34f78999dcb47d199bde3b1d79286156f3e2fb" dependencies = [ "proc-macro2", "quote", "syn", "thiserror", ] [[package]] name = "equivalent" version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" [[package]] name = "glob" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" [[package]] name = "hashbrown" version = "0.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" [[package]] name = "indexmap" version = "2.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f" dependencies = [ "equivalent", "hashbrown", ] [[package]] name = "itoa" version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674" [[package]] name = "memchr" version = "2.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "proc-macro2" version = "1.0.92" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" dependencies = [ "unicode-ident", ] [[package]] name = "quote" version = "1.0.38" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc" dependencies = [ "proc-macro2", ] [[package]] name = "ryu" version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" [[package]] name = "serde" version = "1.0.215" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" version = "1.0.215" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0" dependencies = [ "proc-macro2", "quote", "syn", ] [[package]] name = "serde_json" version = "1.0.133" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377" dependencies = [ "itoa", "memchr", "ryu", "serde", ] [[package]] name = "serde_spanned" version = "0.6.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1" dependencies = [ "serde", ] [[package]] name = "syn" version = "2.0.93" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c786062daee0d6db1132800e623df74274a0a87322d8e183338e01b3d98d058" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] [[package]] name = "target-triple" version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42a4d50cdb458045afc8131fd91b64904da29548bcb63c7236e0844936c13078" [[package]] name = "termcolor" version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" dependencies = [ "winapi-util", ] [[package]] name = "thiserror" version = "2.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f072643fd0190df67a8bab670c20ef5d8737177d6ac6b2e9a236cb096206b2cc" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" version = "2.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b50fa271071aae2e6ee85f842e2e28ba8cd2c5fb67f11fcb1fd70b276f9e7d4" dependencies = [ "proc-macro2", "quote", "syn", ] [[package]] name = "toml" version = "0.8.19" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e" dependencies = [ "serde", "serde_spanned", "toml_datetime", "toml_edit", ] [[package]] name = "toml_datetime" version = "0.6.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41" dependencies = [ "serde", ] [[package]] name = "toml_edit" version = "0.22.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5" dependencies = [ "indexmap", "serde", "serde_spanned", "toml_datetime", "winnow", ] [[package]] name = "trybuild" version = "1.0.101" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8dcd332a5496c026f1e14b7f3d2b7bd98e509660c04239c58b0ba38a12daded4" dependencies = [ "glob", "serde", "serde_derive", "serde_json", "target-triple", "termcolor", "toml", ] [[package]] name = "unicode-ident" version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" [[package]] name = "winapi-util" version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" dependencies = [ "windows-sys", ] [[package]] name = "windows-sys" version = "0.59.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" dependencies = [ "windows-targets", ] [[package]] name = "windows-targets" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" dependencies = [ "windows_aarch64_gnullvm", "windows_aarch64_msvc", "windows_i686_gnu", "windows_i686_gnullvm", "windows_i686_msvc", "windows_x86_64_gnu", "windows_x86_64_gnullvm", "windows_x86_64_msvc", ] [[package]] name = "windows_aarch64_gnullvm" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" [[package]] name = "windows_aarch64_msvc" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" [[package]] name = "windows_i686_gnu" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" [[package]] name = "windows_i686_gnullvm" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" [[package]] name = "windows_i686_msvc" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" [[package]] name = "windows_x86_64_gnu" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" [[package]] name = "windows_x86_64_gnullvm" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" [[package]] name = "windows_x86_64_msvc" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" [[package]] name = "winnow" version = "0.6.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b" dependencies = [ "memchr", ] bitfields-0.12.4/Cargo.toml0000644000000031060000000000100110630ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" name = "bitfields" version = "0.12.4" authors = ["Gregory Gaines "] build = false autolib = false autobins = false autoexamples = false autotests = false autobenches = false description = "Macro for generating flexible bitfields. Useful for low-level code (embedded or emulators)." readme = "README.md" keywords = [ "bit", "bitfield", "bitfields", "struct", ] categories = [ "data-structures", "embedded", "emulators", "encoding", "no-std", ] license = "MIT" repository = "https://github.com/gregorygaines/bitfields-rs" [lib] name = "bitfields" path = "src/lib.rs" [[example]] name = "basic" path = "examples/basic.rs" [[example]] name = "builder" path = "examples/builder.rs" [[example]] name = "defaults" path = "examples/defaults.rs" [[example]] name = "from_bits" path = "examples/from_bits.rs" [[example]] name = "from_bits_with_defaults" path = "examples/from_bits_with_defaults.rs" [[test]] name = "lib_tests" path = "tests/lib_tests.rs" [dependencies.bitfields-impl] version = "0.9.4" [dev-dependencies.trybuild] version = "1.0.101" bitfields-0.12.4/Cargo.toml.orig000064400000000000000000000011141046102023000145410ustar 00000000000000[package] name = "bitfields" version = "0.12.4" authors = ["Gregory Gaines "] description = "Macro for generating flexible bitfields. Useful for low-level code (embedded or emulators)." keywords = ["bit" ,"bitfield", "bitfields", "struct"] edition = "2021" license = "MIT" repository = "https://github.com/gregorygaines/bitfields-rs" readme = "../README.md" categories = ["data-structures", "embedded", "emulators", "encoding", "no-std"] [dependencies] bitfields-impl = { path = "../bitfields_impl", version = "0.9.4" } [dev-dependencies] trybuild = "1.0.101" bitfields-0.12.4/README.md000064400000000000000000000000421046102023000131300ustar 00000000000000# Bitfields Public Bitfields API.bitfields-0.12.4/examples/basic.rs000064400000000000000000000003501046102023000151200ustar 00000000000000use bitfields::bitfield; fn main() { #[bitfield(u32)] pub struct Bitfield { a: u8, b: u8, c: u8, d: u8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.into_bits(), 0); } bitfields-0.12.4/examples/builder.rs000064400000000000000000000004741046102023000154740ustar 00000000000000use bitfields::bitfield; fn main() { #[bitfield(u32)] pub struct Bitfield { a: u8, b: u8, c: u8, d: u8, } let bitfield = BitfieldBuilder::new().with_a(0x12).with_b(0x34).with_c(0x56).with_d(0x78).build(); assert_eq!(bitfield.into_bits(), 0x78563412); } bitfields-0.12.4/examples/defaults.rs000064400000000000000000000005611046102023000156520ustar 00000000000000use bitfields::bitfield; fn main() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.into_bits(), 0x78563412); } bitfields-0.12.4/examples/from_bits.rs000064400000000000000000000004011046102023000160200ustar 00000000000000use bitfields::bitfield; fn main() { #[bitfield(u32)] pub struct Bitfield { a: u8, b: u8, c: u8, d: u8, } let bitfield = Bitfield::from_bits(0x78563412); assert_eq!(bitfield.into_bits(), 0x78563412); } bitfields-0.12.4/examples/from_bits_with_defaults.rs000064400000000000000000000005171046102023000207520ustar 00000000000000use bitfields::bitfield; fn main() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0xFF)] a: u8, b: u8, c: u8, #[bits(default = 0xFF)] d: u8, } let bitfield = Bitfield::from_bits_with_defaults(0x78563412); assert_eq!(bitfield.into_bits(), 0xFF5634FF); } bitfields-0.12.4/src/lib.rs000064400000000000000000000000551046102023000135600ustar 00000000000000#![no_std] pub use bitfields_impl::bitfield; bitfields-0.12.4/tests/compile_error_cases/bitfield_attribute_non_struct.rs000064400000000000000000000001271046102023000255270ustar 00000000000000use bitfields::bitfield; #[bitfield] pub enum NonStruct { A = 1, } fn main() {} bitfields-0.12.4/tests/compile_error_cases/bitfield_attribute_non_struct.stderr000064400000000000000000000002071046102023000264050ustar 00000000000000error: expected `struct` --> tests/compile_error_cases/bitfield_attribute_non_struct.rs:4:5 | 4 | pub enum NonStruct { | ^^^^ bitfields-0.12.4/tests/compile_error_cases/bitfield_bit_ops_disabled.rs000064400000000000000000000002741046102023000245370ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { a: u8, b: u8, c: u8, d: u8, } fn main() { let bitfield = Bitfield::new(); bitfield.get_bit(0); } bitfields-0.12.4/tests/compile_error_cases/bitfield_bit_ops_disabled.stderr000064400000000000000000000006571046102023000254230ustar 00000000000000error[E0599]: no method named `get_bit` found for struct `Bitfield` in the current scope --> tests/compile_error_cases/bitfield_bit_ops_disabled.rs:14:14 | 3 | #[bitfield(u32)] | ---------------- method `get_bit` not found for this struct ... 14 | bitfield.get_bit(0); | ^^^^^^^ | help: there is a method `set_bits` with a similar name | 14 | bitfield.set_bits(0); | ~~~~~~~~ bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_builder.rs000064400000000000000000000003651046102023000243630ustar 00000000000000use bitfields::bitfield; #[bitfield(u64, builder = false)] pub struct Bitfield { #[bits(4, default = 0x1)] a: u8, #[bits(60, default = 0xFFFF_FFFF_FFFF)] _padding: u64 } fn main() { let bitfield = BitfieldBuilder::new(); } bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_builder.stderr000064400000000000000000000004221046102023000252340ustar 00000000000000error[E0433]: failed to resolve: use of undeclared type `BitfieldBuilder` --> tests/compile_error_cases/bitfield_disable_builder.rs:12:20 | 12 | let bitfield = BitfieldBuilder::new(); | ^^^^^^^^^^^^^^^ use of undeclared type `BitfieldBuilder` bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_debug.rs000064400000000000000000000004141046102023000240160ustar 00000000000000use bitfields::bitfield; #[bitfield(u64, debug = false)] pub struct Bitfield { #[bits(4, default = 0x1)] a: u8, #[bits(60, default = 0xFFFF_FFFF_FFFF)] _padding: u64 } fn main() { let bitfield = Bitfield::new(); println!("{:?}", bitfield); } bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_debug.stderr000064400000000000000000000013041046102023000246740ustar 00000000000000error[E0277]: `Bitfield` doesn't implement `Debug` --> tests/compile_error_cases/bitfield_disable_debug.rs:13:22 | 13 | println!("{:?}", bitfield); | ^^^^^^^^ `Bitfield` cannot be formatted using `{:?}` | = help: the trait `Debug` is not implemented for `Bitfield` = note: add `#[derive(Debug)]` to `Bitfield` or manually `impl Debug for Bitfield` = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) help: consider annotating `Bitfield` with `#[derive(Debug)]` | 3 + #[derive(Debug)] 4 | #[bitfield(u64, debug = false)] | bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_default.rs000064400000000000000000000003621046102023000243560ustar 00000000000000use bitfields::bitfield; #[bitfield(u64, default = false)] pub struct Bitfield { #[bits(4, default = 0x1)] a: u8, #[bits(60, default = 0xFFFF_FFFF_FFFF)] _padding: u64 } fn main() { let bitfield = Bitfield::default(); } bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_default.stderr000064400000000000000000000022501046102023000252330ustar 00000000000000error[E0599]: no function or associated item named `default` found for struct `Bitfield` in the current scope --> tests/compile_error_cases/bitfield_disable_default.rs:12:30 | 3 | #[bitfield(u64, default = false)] | --------------------------------- function or associated item `default` not found for this struct ... 12 | let bitfield = Bitfield::default(); | ^^^^^^^ function or associated item not found in `Bitfield` | note: if you're trying to build a new `Bitfield` consider using one of the following associated functions: Bitfield::new Bitfield::new_without_defaults Bitfield::from_bits Bitfield::from_bits_with_defaults --> tests/compile_error_cases/bitfield_disable_default.rs:3:1 | 3 | #[bitfield(u64, default = false)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = help: items from traits can only be used if the trait is implemented and in scope = note: the following trait defines an item `default`, perhaps you need to implement it: candidate #1: `Default` = note: this error originates in the attribute macro `bitfield` (in Nightly builds, run with -Z macro-backtrace for more info) bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_from_bits.rs000064400000000000000000000003671046102023000247230ustar 00000000000000use bitfields::bitfield; #[bitfield(u64, from_bits = false)] pub struct Bitfield { #[bits(4, default = 0x1)] a: u8, #[bits(60, default = 0xFFFF_FFFF_FFFF)] _padding: u64 } fn main() { let bitfield = Bitfield::from_bits(0); } bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_from_bits.stderr000064400000000000000000000016451046102023000256020ustar 00000000000000error[E0599]: no function or associated item named `from_bits` found for struct `Bitfield` in the current scope --> tests/compile_error_cases/bitfield_disable_from_bits.rs:12:30 | 3 | #[bitfield(u64, from_bits = false)] | ----------------------------------- function or associated item `from_bits` not found for this struct ... 12 | let bitfield = Bitfield::from_bits(0); | ^^^^^^^^^ function or associated item not found in `Bitfield` | note: if you're trying to build a new `Bitfield` consider using one of the following associated functions: Bitfield::new Bitfield::new_without_defaults --> tests/compile_error_cases/bitfield_disable_from_bits.rs:3:1 | 3 | #[bitfield(u64, from_bits = false)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: this error originates in the attribute macro `bitfield` (in Nightly builds, run with -Z macro-backtrace for more info) bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_from_trait.rs000064400000000000000000000004271046102023000251020ustar 00000000000000use bitfields::bitfield; #[bitfield(u64, from = false)] pub struct Bitfield { #[bits(4, default = 0x1)] a: u8, #[bits(60, default = 0xFFFF_FFFF_FFFF)] _padding: u64 } fn main() { let bitfield = BitfieldBuilder::new(); let val: u64 = bitfield.into(); } bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_from_trait.stderr000064400000000000000000000012521046102023000257560ustar 00000000000000error[E0277]: the trait bound `u64: From` is not satisfied --> tests/compile_error_cases/bitfield_disable_from_trait.rs:14:29 | 14 | let val: u64 = bitfield.into(); | ^^^^ the trait `From` is not implemented for `u64` | = help: the following other types implement trait `From`: `u64` implements `From` `u64` implements `From` `u64` implements `From` `u64` implements `From` `u64` implements `From` `u64` implements `From` = note: required for `BitfieldBuilder` to implement `Into` bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_into_bits.rs000064400000000000000000000004321046102023000247220ustar 00000000000000use bitfields::bitfield; #[bitfield(u64, into_bits = false)] pub struct Bitfield { #[bits(4, default = 0x1)] a: u8, #[bits(60, default = 0xFFFF_FFFF_FFFF)] _padding: u64 } fn main() { let bitfield = Bitfield::new(); let val: u64 = bitfield.into_bits(); } bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_into_bits.stderr000064400000000000000000000013651046102023000256070ustar 00000000000000error[E0599]: no method named `into_bits` found for struct `Bitfield` in the current scope --> tests/compile_error_cases/bitfield_disable_into_bits.rs:14:29 | 3 | #[bitfield(u64, into_bits = false)] | ----------------------------------- method `into_bits` not found for this struct ... 14 | let val: u64 = bitfield.into_bits(); | ^^^^^^^^^ | help: there is a method `set_bits` with a similar name, but with different arguments --> tests/compile_error_cases/bitfield_disable_into_bits.rs:3:1 | 3 | #[bitfield(u64, into_bits = false)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: this error originates in the attribute macro `bitfield` (in Nightly builds, run with -Z macro-backtrace for more info) bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_new.rs000064400000000000000000000003531046102023000235230ustar 00000000000000use bitfields::bitfield; #[bitfield(u64, new = false)] pub struct Bitfield { #[bits(4, default = 0x1)] a: u8, #[bits(60, default = 0xFFFF_FFFF_FFFF)] _padding: u64 } fn main() { let bitfield = Bitfield::new(0); } bitfields-0.12.4/tests/compile_error_cases/bitfield_disable_new.stderr000064400000000000000000000015621046102023000244050ustar 00000000000000error[E0599]: no function or associated item named `new` found for struct `Bitfield` in the current scope --> tests/compile_error_cases/bitfield_disable_new.rs:12:30 | 3 | #[bitfield(u64, new = false)] | ----------------------------- function or associated item `new` not found for this struct ... 12 | let bitfield = Bitfield::new(0); | ^^^ function or associated item not found in `Bitfield` | note: if you're trying to build a new `Bitfield` consider using one of the following associated functions: Bitfield::from_bits Bitfield::from_bits_with_defaults --> tests/compile_error_cases/bitfield_disable_new.rs:3:1 | 3 | #[bitfield(u64, new = false)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: this error originates in the attribute macro `bitfield` (in Nightly builds, run with -Z macro-backtrace for more info) bitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_padding_value.rs000064400000000000000000000005441046102023000265370ustar 00000000000000use bitfields::bitfield; #[bitfield(u64)] pub struct Bitfield { #[bits(4, default = 0x1)] a: u8, #[bits(60, default = 0xFFFF_FFFF_FFFF)] _padding: u64 } fn main() { let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x1); assert_eq!(bitfield.into_bits(), 0xF_FFFF_FFFF_FFF1); assert_eq!(bitfield._padding(), 0x1); } bitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_padding_value.stderr000064400000000000000000000005741046102023000274210ustar 00000000000000error[E0599]: no method named `_padding` found for struct `Bitfield` in the current scope --> tests/compile_error_cases/bitfield_field_access_padding_value.rs:15:25 | 3 | #[bitfield(u64)] | ---------------- method `_padding` not found for this struct ... 15 | assert_eq!(bitfield._padding(), 0x1); | ^^^^^^^^ method not found in `Bitfield` bitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_read_only_can_not_write.rs000064400000000000000000000003151046102023000306200ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12, access = ro)] a: u32, } fn main() { let mut bitfield = Bitfield::default(); bitfield.set_a(0x34); } bitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_read_only_can_not_write.stderr000064400000000000000000000005421046102023000315010ustar 00000000000000error[E0599]: no method named `set_a` found for struct `Bitfield` in the current scope --> tests/compile_error_cases/bitfield_field_access_read_only_can_not_write.rs:11:14 | 3 | #[bitfield(u32)] | ---------------- method `set_a` not found for this struct ... 11 | bitfield.set_a(0x34); | ^^^^^ method not found in `Bitfield` bitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_read_only_can_not_write_builder.rs000064400000000000000000000003201046102023000323220ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12, access = ro)] a: u32, } fn main() { let mut bitfield = BitfieldBuilder::new(); bitfield.set_a(0x34); } ././@LongLink00006440000000000000000000000150000000000000007767Lustar bitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_read_only_can_not_write_builder.stderrbitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_read_only_can_not_write_builder.std000064400000000000000000000005701046102023000324770ustar 00000000000000error[E0599]: no method named `set_a` found for struct `BitfieldBuilder` in the current scope --> tests/compile_error_cases/bitfield_field_access_read_only_can_not_write_builder.rs:11:14 | 3 | #[bitfield(u32)] | ---------------- method `set_a` not found for this struct ... 11 | bitfield.set_a(0x34); | ^^^^^ method not found in `BitfieldBuilder` bitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_write_only.rs000064400000000000000000000003371046102023000261300ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12, access = wo)] a: u32, } fn main() { let bitfield = Bitfield::default(); bitfield.a(); // Error, field is write-only } bitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_write_only.stderr000064400000000000000000000005371046102023000270110ustar 00000000000000error[E0599]: no method named `a` found for struct `Bitfield` in the current scope --> tests/compile_error_cases/bitfield_field_access_write_only.rs:11:14 | 3 | #[bitfield(u32)] | ---------------- method `a` not found for this struct ... 11 | bitfield.a(); // Error, field is write-only | ^ method not found in `Bitfield` bitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_write_only_builder.rs000064400000000000000000000003421046102023000276320ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12, access = wo)] a: u32, } fn main() { let bitfield = BitfieldBuilder::new(); bitfield.a(); // Error, field is write-only } bitfields-0.12.4/tests/compile_error_cases/bitfield_field_access_write_only_builder.stderr000064400000000000000000000005651046102023000305200ustar 00000000000000error[E0599]: no method named `a` found for struct `BitfieldBuilder` in the current scope --> tests/compile_error_cases/bitfield_field_access_write_only_builder.rs:11:14 | 3 | #[bitfield(u32)] | ---------------- method `a` not found for this struct ... 11 | bitfield.a(); // Error, field is write-only | ^ method not found in `BitfieldBuilder` bitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_0.rs000064400000000000000000000002721046102023000252500ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { #[bits(0)] a: u8, #[bits(7)] b: u8, #[bits(5)] c: u8, #[bits(9)] d: u16, } fn main() {} bitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_0.stderr000064400000000000000000000002331046102023000261240ustar 00000000000000error: The field bits must be greater than 0. --> tests/compile_error_cases/bitfield_field_defined_bits_0.rs:5:7 | 5 | #[bits(0)] | ^^^^^^^ ././@LongLink00006440000000000000000000000147000000000000007775Lustar bitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_less_than_bitfield_type_size.rsbitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_less_than_bitfield_type_size.000064400000000000000000000002721046102023000324610ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { #[bits(8)] a: u8, #[bits(7)] b: u8, #[bits(5)] c: u8, #[bits(9)] d: u16, } fn main() {} ././@LongLink00006440000000000000000000000153000000000000007772Lustar bitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_less_than_bitfield_type_size.stderrbitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_less_than_bitfield_type_size.000064400000000000000000000005321046102023000324600ustar 00000000000000error: The total number of bits of the fields (29 bits) is less than the number of bits of the bitfield type 'u32' (32 bits), you can add a padding field (prefixed with '_') to fill the remaining '3 bits'. --> tests/compile_error_cases/bitfield_field_defined_bits_less_than_bitfield_type_size.rs:3:12 | 3 | #[bitfield(u32)] | ^^^ ././@LongLink00006440000000000000000000000147000000000000007775Lustar bitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_more_than_bitfield_type_size.rsbitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_more_than_bitfield_type_size.000064400000000000000000000002731046102023000324560ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { #[bits(8)] a: u8, #[bits(7)] b: u8, #[bits(5)] c: u8, #[bits(16)] d: u16, } fn main() {} ././@LongLink00006440000000000000000000000153000000000000007772Lustar bitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_more_than_bitfield_type_size.stderrbitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_more_than_bitfield_type_size.000064400000000000000000000004151046102023000324540ustar 00000000000000error: The total number of bits of the fields (36 bits) is greater than the number of bits of the bitfield type 'u32' (32 bits). --> tests/compile_error_cases/bitfield_field_defined_bits_more_than_bitfield_type_size.rs:3:12 | 3 | #[bitfield(u32)] | ^^^ ././@LongLink00006440000000000000000000000146000000000000007774Lustar bitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_too_small_for_default_value.rsbitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_too_small_for_default_value.r000064400000000000000000000002451046102023000324650ustar 00000000000000use bitfields::bitfield; #[bitfield(u16)] pub struct Bitfield { #[bits(3, default = 0xFFF)] a: u8, #[bits(13, default = 1)] b: u16, } fn main() {} ././@LongLink00006440000000000000000000000152000000000000007771Lustar bitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_too_small_for_default_value.stderrbitfields-0.12.4/tests/compile_error_cases/bitfield_field_defined_bits_too_small_for_default_value.s000064400000000000000000000003721046102023000324670ustar 00000000000000error: The default value '4095' is too large to fit into the specified '3 bits'. --> tests/compile_error_cases/bitfield_field_defined_bits_too_small_for_default_value.rs:5:25 | 5 | #[bits(3, default = 0xFFF)] | ^^^^^ bitfields-0.12.4/tests/compile_error_cases/bitfield_field_duplicate_name.rs000064400000000000000000000001471046102023000253650ustar 00000000000000use bitfields::bitfield; #[bitfield(u16)] pub struct Bitfield { a: u8, a: u8, } fn main() {} bitfields-0.12.4/tests/compile_error_cases/bitfield_field_duplicate_name.stderr000064400000000000000000000002561046102023000262450ustar 00000000000000error: The field name 'a' is duplicated, each field must have a unique name. --> tests/compile_error_cases/bitfield_field_duplicate_name.rs:6:5 | 6 | a: u8, | ^ bitfields-0.12.4/tests/compile_error_cases/bitfield_field_float32_identifier_default_value.rs000064400000000000000000000003441046102023000307660ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0f32)] a: u8, #[bits(default = 1)] b: u8, #[bits(default = 2)] c: u8, #[bits(default = 3)] d: u8, } fn main() {} bitfields-0.12.4/tests/compile_error_cases/bitfield_field_float32_identifier_default_value.stderr000064400000000000000000000003141046102023000316420ustar 00000000000000error: Floats are not supported as default values. --> tests/compile_error_cases/bitfield_field_float32_identifier_default_value.rs:5:22 | 5 | #[bits(default = 0f32)] | ^^^^ bitfields-0.12.4/tests/compile_error_cases/bitfield_field_float64_identifier_default_value.rs000064400000000000000000000003441046102023000307730ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0f64)] a: u8, #[bits(default = 1)] b: u8, #[bits(default = 2)] c: u8, #[bits(default = 3)] d: u8, } fn main() {} bitfields-0.12.4/tests/compile_error_cases/bitfield_field_float64_identifier_default_value.stderr000064400000000000000000000003141046102023000316470ustar 00000000000000error: Floats are not supported as default values. --> tests/compile_error_cases/bitfield_field_float64_identifier_default_value.rs:5:22 | 5 | #[bits(default = 0f64)] | ^^^^ bitfields-0.12.4/tests/compile_error_cases/bitfield_field_float_default_value.rs000064400000000000000000000003431046102023000264160ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { #[bits(default = 3.1)] a: u8, #[bits(default = 1)] b: u8, #[bits(default = 2)] c: u8, #[bits(default = 3)] d: u8, } fn main() {} bitfields-0.12.4/tests/compile_error_cases/bitfield_field_float_default_value.stderr000064400000000000000000000002751046102023000273010ustar 00000000000000error: Floats are not supported as default values. --> tests/compile_error_cases/bitfield_field_float_default_value.rs:5:22 | 5 | #[bits(default = 3.1)] | ^^^ bitfields-0.12.4/tests/compile_error_cases/bitfield_field_nested_bitfield_without_defined_bits.rs000064400000000000000000000005111046102023000320140ustar 00000000000000use bitfields::bitfield; #[bitfield(u16)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = NestedBitfield::new())] nested_field: NestedBitfield, } #[bitfield(u8)] pub struct NestedBitfield { #[bits(4, default = 0x3)] a: u8, #[bits(4, default = 0x4)] b: u16, } fn main() {} ././@LongLink00006440000000000000000000000146000000000000007774Lustar bitfields-0.12.4/tests/compile_error_cases/bitfield_field_nested_bitfield_without_defined_bits.stderrbitfields-0.12.4/tests/compile_error_cases/bitfield_field_nested_bitfield_without_defined_bits.stder000064400000000000000000000005251046102023000325160ustar 00000000000000error: Custom and nested field types require a defined bit size, otherwise we can't determine the size of the field. --> tests/compile_error_cases/bitfield_field_nested_bitfield_without_defined_bits.rs:7:5 | 7 | / #[bits(default = NestedBitfield::new())] 8 | | nested_field: NestedBitfield, | |________________________________^ bitfields-0.12.4/tests/compile_error_cases/bitfield_field_too_small_for_default_value.rs000064400000000000000000000002361046102023000301510ustar 00000000000000use bitfields::bitfield; #[bitfield(u16)] pub struct Bitfield { #[bits(default = 0xFFFF)] a: u8, #[bits(default = 1)] b: u8, } fn main() {} bitfields-0.12.4/tests/compile_error_cases/bitfield_field_too_small_for_default_value.stderr000064400000000000000000000003521046102023000310270ustar 00000000000000error: The default value '65535' is too large to fit into the specified '8 bits'. --> tests/compile_error_cases/bitfield_field_too_small_for_default_value.rs:5:22 | 5 | #[bits(default = 0xFFFF)] | ^^^^^^ bitfields-0.12.4/tests/compile_error_cases/bitfield_field_types_bits_less_than_bitfield_type_size.rs000064400000000000000000000001621046102023000325720ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { a: u8, b: u8, c: u8, } fn main() {} ././@LongLink00006440000000000000000000000151000000000000007770Lustar bitfields-0.12.4/tests/compile_error_cases/bitfield_field_types_bits_less_than_bitfield_type_size.stderrbitfields-0.12.4/tests/compile_error_cases/bitfield_field_types_bits_less_than_bitfield_type_size.st000064400000000000000000000005301046102023000325730ustar 00000000000000error: The total number of bits of the fields (24 bits) is less than the number of bits of the bitfield type 'u32' (32 bits), you can add a padding field (prefixed with '_') to fill the remaining '8 bits'. --> tests/compile_error_cases/bitfield_field_types_bits_less_than_bitfield_type_size.rs:3:12 | 3 | #[bitfield(u32)] | ^^^ bitfields-0.12.4/tests/compile_error_cases/bitfield_field_types_bits_more_than_bitfield_type_size.rs000064400000000000000000000001761046102023000325730ustar 00000000000000use bitfields::bitfield; #[bitfield(u32)] pub struct Bitfield { a: u8, b: u8, c: u8, d: u16, } fn main() {} ././@LongLink00006440000000000000000000000151000000000000007770Lustar bitfields-0.12.4/tests/compile_error_cases/bitfield_field_types_bits_more_than_bitfield_type_size.stderrbitfields-0.12.4/tests/compile_error_cases/bitfield_field_types_bits_more_than_bitfield_type_size.st000064400000000000000000000004131046102023000325670ustar 00000000000000error: The total number of bits of the fields (40 bits) is greater than the number of bits of the bitfield type 'u32' (32 bits). --> tests/compile_error_cases/bitfield_field_types_bits_more_than_bitfield_type_size.rs:3:12 | 3 | #[bitfield(u32)] | ^^^ bitfields-0.12.4/tests/compile_error_cases/bitfield_no_std.rs000064400000000000000000000001661046102023000225370ustar 00000000000000 use bitfields::bitfield; #[bitfield(u32)] struct Reg { a: u8, b: u8, c: u8, d: u8, } fn main() { } bitfields-0.12.4/tests/compile_error_cases/bitfield_padding_field_with_access.rs000064400000000000000000000001671046102023000263770ustar 00000000000000use bitfields::bitfield; #[bitfield(u8)] struct Bitfield { #[bits(access = ro)] _padding: u8, } fn main() {} bitfields-0.12.4/tests/compile_error_cases/bitfield_padding_field_with_access.stderr000064400000000000000000000002731046102023000272540ustar 00000000000000error: Padding fields can't have a specified access. --> tests/compile_error_cases/bitfield_padding_field_with_access.rs:5:7 | 5 | #[bits(access = ro)] | ^^^^^^^^^^^^^^^^^ bitfields-0.12.4/tests/compile_error_cases/bitfield_unsupported_type.rs000064400000000000000000000001621046102023000246760ustar 00000000000000use bitfields::bitfield; #[bitfield(i32)] pub struct Bitfield { a: u8, b: u8, c: u8, } fn main() {} bitfields-0.12.4/tests/compile_error_cases/bitfield_unsupported_type.stderr000064400000000000000000000003751046102023000255630ustar 00000000000000error: The 'bitfield' attribute must have an unsigned integer type as its first argument. --> tests/compile_error_cases/bitfield_unsupported_type.rs:4:1 | 4 | / pub struct Bitfield { 5 | | a: u8, 6 | | b: u8, 7 | | c: u8, 8 | | } | |_^ bitfields-0.12.4/tests/lib_tests.rs000064400000000000000000001505261046102023000153660ustar 00000000000000#![allow(clippy::unnecessary_cast)] #[cfg(test)] mod tests { use bitfields::bitfield; #[test] #[cfg_attr(miri, ignore)] fn bitfield_attribute_non_struct_compile_fail() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_attribute_non_struct.rs"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_std_compile_pass() { let t = trybuild::TestCases::new(); t.pass("tests/compile_error_cases/bitfield_no_std.rs"); } #[test] fn bitfield_u8() { #[bitfield(u8)] pub struct Bitfield { a: u8, } } #[test] fn bitfield_u16() { #[bitfield(u16)] pub struct Bitfield { a: u16, } } #[test] fn bitfield_u32() { #[bitfield(u32)] pub struct Bitfield { a: u32, } } #[test] fn bitfield_u64() { #[bitfield(u64)] pub struct Bitfield { a: u64, } } #[test] fn bitfield_u128() { #[bitfield(u128)] pub struct Bitfield { a: u128, } } #[test] fn bitfield_i8() { #[bitfield(u8)] pub struct Bitfield { a: i8, } } #[test] fn bitfield_i8_default_value() { #[bitfield(u8)] pub struct Bitfield { #[bits(default = -1)] a: i8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), -1); } #[test] fn bitfield_i8_default_value_binary() { #[bitfield(u8)] pub struct Bitfield { #[bits(default = -0b101)] a: i8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), -5); } #[test] fn bitfield_i8_default_value_hex() { #[bitfield(u8)] pub struct Bitfield { #[bits(default = -0x5)] a: i8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), -5); } #[test] fn bitfield_i8_default_value_octal() { #[bitfield(u8)] pub struct Bitfield { #[bits(default = -0o5)] a: i8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), -5); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_unsupported_type() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_unsupported_type.rs"); } #[test] fn bitfield_field_type_bits_sum_to_type_size() { #[bitfield(u32)] pub struct Bitfield { a: u8, b: u8, c: u8, d: u8, } } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_types_bits_less_than_bitfield_type_size() { let t = trybuild::TestCases::new(); t.compile_fail( "tests/compile_error_cases/bitfield_field_types_bits_less_than_bitfield_type_size.rs", ); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_types_bits_more_than_bitfield_type_size() { let t = trybuild::TestCases::new(); t.compile_fail( "tests/compile_error_cases/bitfield_field_types_bits_more_than_bitfield_type_size.rs", ); } #[test] fn bitfield_field_defined_bits_sum_to_type_size() { #[bitfield(u32)] pub struct Bitfield { a: u8, #[bits(7)] b: u8, #[bits(5)] c: u8, #[bits(12)] d: u16, } } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_defined_bits_less_than_bitfield_type_size() { let t = trybuild::TestCases::new(); t.compile_fail( "tests/compile_error_cases/bitfield_field_defined_bits_less_than_bitfield_type_size.rs", ); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_defined_bits_more_than_bitfield_type_size() { let t = trybuild::TestCases::new(); t.compile_fail( "tests/compile_error_cases/bitfield_field_defined_bits_more_than_bitfield_type_size.rs", ); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_defined_bits_0() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_field_defined_bits_0.rs"); } #[test] fn bitfield_fields_default_value() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0)] a: u8, #[bits(default = 1)] b: u8, #[bits(default = 2)] c: u8, #[bits(default = 3)] d: u8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0); assert_eq!(bitfield.b(), 1); assert_eq!(bitfield.c(), 2); assert_eq!(bitfield.d(), 3); } #[test] fn bitfield_fields_integer_identifiers_default_value() { #[bitfield(u64)] pub struct Bitfield { #[bits(5, default = 10u8)] a: u8, #[bits(5, default = 20u16)] b: u16, #[bits(5, default = 30u32)] c: u32, #[bits(6, default = 40u64)] d: u64, #[bits(6, default = 50u128)] e: u128, #[bits(5, default = 10i8)] f: i8, #[bits(8, default = 20i16)] g: i16, #[bits(8, default = 30i32)] h: i32, #[bits(8, default = 40i64)] i: i64, #[bits(8, default = 50i128)] j: i128, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 10); assert_eq!(bitfield.b(), 20); assert_eq!(bitfield.c(), 30); assert_eq!(bitfield.d(), 40); assert_eq!(bitfield.e(), 50); assert_eq!(bitfield.f(), 10); assert_eq!(bitfield.g(), 20); assert_eq!(bitfield.h(), 30); assert_eq!(bitfield.i(), 40); assert_eq!(bitfield.j(), 50); } #[test] fn bitfield_field_boolean_default_value() { #[bitfield(u8)] pub struct Bitfield { #[bits(default = true)] a: bool, #[bits(default = false)] b: bool, #[bits(default = true)] c: bool, #[bits(default = false)] d: bool, #[bits(default = true)] e: bool, #[bits(default = false)] f: bool, #[bits(default = true)] g: bool, #[bits(default = false)] h: bool, } let bitfield = Bitfield::new(); assert!(bitfield.a()); assert!(!bitfield.b()); assert!(bitfield.c()); assert!(!bitfield.d()); assert!(bitfield.e()); assert!(!bitfield.f()); assert!(bitfield.g()); assert!(!bitfield.h()); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_float_default_value() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_field_float_default_value.rs"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_float32_identifier_default_value() { let t = trybuild::TestCases::new(); t.compile_fail( "tests/compile_error_cases/bitfield_field_float32_identifier_default_value.rs", ); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_float64_identifier_default_value() { let t = trybuild::TestCases::new(); t.compile_fail( "tests/compile_error_cases/bitfield_field_float64_identifier_default_value.rs", ); } #[test] fn bitfield_field_hex_default_value() { #[bitfield(u64)] pub struct Bitfield { #[bits(5, default = 0x1)] a: u8, #[bits(5, default = 0x2)] b: u16, #[bits(5, default = 0x3)] c: u32, #[bits(6, default = 0x4)] d: u64, #[bits(6, default = 0x5)] e: u128, #[bits(5, default = 0x10)] f: i8, #[bits(8, default = 0xF_F)] g: i16, #[bits(8, default = 0x23)] h: i32, #[bits(8, default = 0x7_F)] i: i64, #[bits(8, default = 0x3F)] j: i128, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x1); assert_eq!(bitfield.b(), 0x2); assert_eq!(bitfield.c(), 0x3); assert_eq!(bitfield.d(), 0x4); assert_eq!(bitfield.e(), 0x5); assert_eq!(bitfield.f(), -16); assert_eq!(bitfield.g(), -1); assert_eq!(bitfield.h(), 0x23); assert_eq!(bitfield.i(), 0x7F); assert_eq!(bitfield.j(), 0x3F); } #[test] fn bitfield_field_hex_has_float_identifier_default_value() { #[bitfield(u64)] pub struct Bitfield { #[bits(default = 0xF32)] a: u32, #[bits(default = 0xF64)] b: u32, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0xF32); assert_eq!(bitfield.b(), 0xF64); } #[test] fn bitfield_field_octal_default_value() { #[bitfield(u64)] pub struct Bitfield { #[bits(5, default = 0o1)] a: u8, #[bits(5, default = 0o2)] b: u16, #[bits(5, default = 0o3)] c: u32, #[bits(6, default = 0o4)] d: u64, #[bits(6, default = 0o5)] e: u128, #[bits(5, default = 0o6)] f: i8, #[bits(8, default = 0o11)] g: i16, #[bits(8, default = 0o12)] h: i32, #[bits(8, default = 0o1_3)] i: i64, #[bits(8, default = 0o1_4)] j: i128, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 1); assert_eq!(bitfield.b(), 2); assert_eq!(bitfield.c(), 3); assert_eq!(bitfield.d(), 4); assert_eq!(bitfield.e(), 5); assert_eq!(bitfield.f(), 6); assert_eq!(bitfield.g(), 9); assert_eq!(bitfield.h(), 10); assert_eq!(bitfield.i(), 11); assert_eq!(bitfield.j(), 12); } #[test] fn bitfield_field_binary_default_value() { #[bitfield(u64)] pub struct Bitfield { #[bits(5, default = 0b01)] a: u8, #[bits(5, default = 0b10)] b: u16, #[bits(5, default = 0b11)] c: u32, #[bits(6, default = 0b100)] d: u64, #[bits(6, default = 0b101)] e: u128, #[bits(5, default = 0b110)] f: i8, #[bits(8, default = 0b111)] g: i16, #[bits(8, default = 0b1000)] h: i32, #[bits(8, default = 0b10_01)] i: i64, #[bits(8, default = 0b10_10)] j: i128, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 1); assert_eq!(bitfield.b(), 2); assert_eq!(bitfield.c(), 3); assert_eq!(bitfield.d(), 4); assert_eq!(bitfield.e(), 5); assert_eq!(bitfield.f(), 6); assert_eq!(bitfield.g(), 7); assert_eq!(bitfield.h(), 8); assert_eq!(bitfield.i(), 9); assert_eq!(bitfield.j(), 10); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_duplicate_name() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_field_duplicate_name.rs"); } #[test] fn bitfield_field_duplicate_padding_name() { #[bitfield(u16)] pub struct Bitfield { a: u8, #[bits(4)] __: u8, #[bits(4)] __: u8, } } #[test] fn bitfield_field_padding() { #[bitfield(u64)] pub struct Bitfield { #[bits(4, default = 0x1)] a: u8, #[bits(60)] _padding: u64, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x1); } #[test] fn bitfield_field_padding_default_value() { #[bitfield(u64)] pub struct Bitfield { #[bits(4, default = 0x1)] a: u8, #[bits(60, default = 0xFFFF_FFFF_FFFF)] _padding: u64, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x1); assert_eq!(bitfield.into_bits(), 0xF_FFFF_FFFF_FFF1); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_access_padding_value() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_field_access_padding_value.rs"); } #[test] fn bitfield_field_multiple_attributes() { #[bitfield(u64)] pub struct Bitfield { #[serde(skip)] #[bits(4, default = 0x1)] a: u8, #[bits(60, default = 0xFFFF_FFFF_FFFF)] _padding: u64, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x1); assert_eq!(bitfield.into_bits(), 0xF_FFFF_FFFF_FFF1); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_too_small_for_default_value() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_field_too_small_for_default_value.rs"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_defined_bits_too_small_for_default_value() { let t = trybuild::TestCases::new(); t.compile_fail( "tests/compile_error_cases/bitfield_field_defined_bits_too_small_for_default_value.rs", ); } #[test] fn bitfield_getters() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.b(), 0x34); assert_eq!(bitfield.c(), 0x56); assert_eq!(bitfield.d(), 0x78); assert_eq!(bitfield.into_bits(), 0x78_56_34_12); } #[test] fn bitfield_signed_values_getters() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = -127)] a: i8, #[bits(default = 0x7F)] b: i8, #[bits(5, default = 0xF)] c: i8, #[bits(5, default = 0x1F)] d: i8, #[bits(6)] _padding: u16, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), -127); assert_eq!(bitfield.b(), 127); assert_eq!(bitfield.c(), 15); assert_eq!(bitfield.d(), -1); assert_eq!(bitfield.into_bits(), 0x3EF7F81); } #[test] fn bitfield_setters() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let mut bitfield = Bitfield::new(); bitfield.set_a(0x11); bitfield.set_b(0x22); bitfield.set_c(0x33); bitfield.set_d(0x44); assert_eq!(bitfield.a(), 0x11); assert_eq!(bitfield.b(), 0x22); assert_eq!(bitfield.c(), 0x33); assert_eq!(bitfield.d(), 0x44); assert_eq!(bitfield.into_bits(), 0x44332211); } #[test] fn bitfield_signed_setters() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: i8, #[bits(default = 0x34)] b: i8, #[bits(default = 0x56)] c: i8, #[bits(default = 0x78)] d: i8, } let mut bitfield = Bitfield::new(); bitfield.set_a(-1); bitfield.set_b(-127); bitfield.set_c(-15); bitfield.set_d(-44); assert_eq!(bitfield.a(), -1); assert_eq!(bitfield.b(), -127); assert_eq!(bitfield.c(), -15); assert_eq!(bitfield.d(), -44); assert_eq!(bitfield.into_bits(), 0xD4F181FF); } #[test] fn bitfield_checked_setters() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: i8, #[bits(default = 0x34)] b: u8, #[bits(4, default = 12)] c: u8, #[bits(12, default = 0x78)] d: i16, } let mut bitfield = Bitfield::new(); let a_ok = bitfield.checked_set_a(-1); let b_ok = bitfield.checked_set_b(0xFF); let c_ok = bitfield.checked_set_c(0xFF); let d_ok = bitfield.checked_set_d(0x1FFF); assert!(a_ok.is_ok()); assert!(b_ok.is_ok()); assert!(c_ok.is_err()); assert!(c_ok.unwrap_err().contains("Value is too big to fit within the field bits.")); assert!(d_ok.is_err()); assert!(d_ok.unwrap_err().contains("Value is too big to fit within the field bits.")); assert_eq!(bitfield.a(), -1); assert_eq!(bitfield.b(), 255); assert_eq!(bitfield.c(), 12); assert_eq!(bitfield.d(), 120); assert_eq!(bitfield.into_bits(), 0x78CFFFF); } #[test] fn bitfield_field_nested_bitfield() { #[bitfield(u16)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(8, default = NestedBitfield::new())] nested_field: NestedBitfield, } #[bitfield(u8)] pub struct NestedBitfield { #[bits(4, default = 0x3)] a: u8, #[bits(4, default = 0x4)] b: u16, } let bitfield = Bitfield::new(); assert_eq!(bitfield.into_bits(), 0x4312) } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_nested_bitfield_without_defined_bits() { let t = trybuild::TestCases::new(); t.compile_fail( "tests/compile_error_cases/bitfield_field_nested_bitfield_without_defined_bits.rs", ); } #[test] fn bitfield_field_enum_custom_type() { #[bitfield(u16)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(8, default = CustomType::A)] nested_field: CustomType, } pub enum CustomType { A = 0x3, B = 0x4, } impl CustomType { const fn from_bits(bits: u8) -> Self { match bits { 0x3 => Self::A, 0x4 => Self::B, _ => unreachable!(), } } const fn into_bits(self) -> u8 { match self { Self::A => 0x3, Self::B => 0x4, } } } let bitfield = Bitfield::new(); assert_eq!(bitfield.into_bits(), 0x312) } #[allow(dead_code)] #[test] fn bitfield_field_struct_custom_type() { #[bitfield(u16)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(8, default = CustomType::new())] nested_field: CustomType, } pub struct CustomType { a: i8, b: u8, } impl CustomType { const fn new() -> Self { Self { a: 3, b: 4 } } const fn from_bits(bits: u8) -> Self { Self { a: bits as i8, b: bits } } const fn into_bits(self) -> u8 { self.b } } let bitfield = Bitfield::new(); assert_eq!(bitfield.into_bits(), 0x412) } #[allow(dead_code)] #[test] fn bitfield_field_padding_struct_custom_type() { #[bitfield(u16)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(8, default = CustomType::new())] _nested_field: CustomType, } pub struct CustomType { a: i8, b: u8, } impl CustomType { const fn new() -> Self { Self { a: 3, b: 4 } } const fn from_bits(bits: u8) -> Self { Self { a: bits as i8, b: bits } } const fn into_bits(self) -> u8 { self.b } } let bitfield = Bitfield::new(); assert_eq!(bitfield.into_bits(), 0x412) } #[test] fn bitfield_default() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(8, default = CustomType::B)] d: CustomType, } #[derive(Debug, PartialEq)] pub enum CustomType { A = 0x3, B = 0x4, } impl CustomType { const fn from_bits(bits: u8) -> Self { match bits { 0x3 => Self::A, 0x4 => Self::B, _ => Self::A, } } const fn into_bits(self) -> u8 { match self { Self::A => 0x3, Self::B => 0x4, } } } let bitfield = Bitfield::default(); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.b(), 0x34); assert_eq!(bitfield.c(), 0x56); assert_eq!(bitfield.d(), CustomType::B); assert_eq!(bitfield.into_bits(), 0x4563412); } #[test] fn bitfield_new() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(8, default = CustomType::B)] d: CustomType, } #[derive(Debug, PartialEq)] pub enum CustomType { A = 0x3, B = 0x4, } impl CustomType { const fn from_bits(bits: u8) -> Self { match bits { 0x3 => Self::A, 0x4 => Self::B, _ => Self::A, } } const fn into_bits(self) -> u8 { match self { Self::A => 0x3, Self::B => 0x4, } } } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.b(), 0x34); assert_eq!(bitfield.c(), 0x56); assert_eq!(bitfield.d(), CustomType::B); assert_eq!(bitfield.into_bits(), 0x4563412); } #[test] fn bitfield_new_without_defaults() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(8, default = CustomType::B)] d: CustomType, } #[derive(Debug, PartialEq)] pub enum CustomType { A = 0x3, B = 0x4, } impl CustomType { const fn from_bits(bits: u8) -> Self { match bits { 0x3 => Self::A, 0x4 => Self::B, _ => Self::A, } } const fn into_bits(self) -> u8 { match self { Self::A => 0x3, Self::B => 0x4, } } } let bitfield = Bitfield::new_without_defaults(); assert_eq!(bitfield.a(), 0); assert_eq!(bitfield.b(), 0); assert_eq!(bitfield.c(), 0); assert_eq!(bitfield.d(), CustomType::A); assert_eq!(bitfield.into_bits(), 0x3000000); } #[test] fn bitfield_builder_new_default_values() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = BitfieldBuilder::new().build(); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.b(), 0x34); assert_eq!(bitfield.c(), 0x56); assert_eq!(bitfield.d(), 0x78); assert_eq!(bitfield.into_bits(), 0x78_56_34_12); } #[test] fn bitfield_builder_new() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = BitfieldBuilder::new().with_a(0x11).with_b(0x22).with_c(0x33).with_d(0x44).build(); assert_eq!(bitfield.a(), 0x11); assert_eq!(bitfield.b(), 0x22); assert_eq!(bitfield.c(), 0x33); assert_eq!(bitfield.d(), 0x44); assert_eq!(bitfield.into_bits(), 0x44332211); } #[test] fn bitfield_builder_new_without_defaults_default_values() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(8)] d: CustomType, } #[derive(Debug, PartialEq)] pub enum CustomType { A = 0x3, B = 0x4, } impl CustomType { const fn from_bits(bits: u8) -> Self { match bits { 0x3 => Self::A, 0x4 => Self::B, _ => Self::A, } } const fn into_bits(self) -> u8 { match self { Self::A => 0x3, Self::B => 0x4, } } } let bitfield = BitfieldBuilder::new_without_defaults().build(); assert_eq!(bitfield.a(), 0); assert_eq!(bitfield.b(), 0); assert_eq!(bitfield.c(), 0); assert_eq!(bitfield.d(), CustomType::A); assert_eq!(bitfield.into_bits(), 0x3000000); } #[test] fn bitfield_from_bits() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::from_bits(0x11_22_33_44); assert_eq!(bitfield.a(), 0x44); assert_eq!(bitfield.b(), 0x33); assert_eq!(bitfield.c(), 0x22); assert_eq!(bitfield.d(), 0x11); } #[test] fn bitfield_from_bits_with_defaults() { #[bitfield(u32)] pub struct Bitfield { a: u8, #[bits(default = 0x34)] b: u8, c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::from_bits_with_defaults(0x11_22_33_44); assert_eq!(bitfield.a(), 0x44); assert_eq!(bitfield.b(), 0x34); assert_eq!(bitfield.c(), 0x22); assert_eq!(bitfield.d(), 0x78); } #[test] fn bitfield_from_bits_with_defaults_all_fields_have_defaults() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::from_bits_with_defaults(0x11_22_33_44); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.b(), 0x34); assert_eq!(bitfield.c(), 0x56); assert_eq!(bitfield.d(), 0x78); } #[test] fn bitfield_from_bits_booleans() { #[bitfield(u8)] pub struct Bitfield { a: bool, #[bits(default = false)] b: bool, c: bool, d: bool, #[bits(default = false)] e: bool, f: bool, #[bits(default = true)] g: bool, h: bool, } let bitfield = Bitfield::from_bits(0xFF); assert!(bitfield.a()); assert!(bitfield.b()); assert!(bitfield.c()); assert!(bitfield.d()); assert!(bitfield.e()); assert!(bitfield.f()); assert!(bitfield.g()); assert!(bitfield.h()); } #[test] fn bitfield_from_bits_with_defaults_booleans() { #[bitfield(u8)] pub struct Bitfield { a: bool, #[bits(default = false)] b: bool, c: bool, d: bool, #[bits(default = false)] e: bool, f: bool, #[bits(default = true)] g: bool, h: bool, } let bitfield = Bitfield::from_bits_with_defaults(0xFF); assert!(bitfield.a()); assert!(!bitfield.b()); assert!(bitfield.c()); assert!(bitfield.d()); assert!(!bitfield.e()); assert!(bitfield.f()); assert!(bitfield.g()); assert!(bitfield.h()); } #[test] fn bitfield_lsb() { #[bitfield(u32, order = Lsb)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.b(), 0x34); assert_eq!(bitfield.c(), 0x56); assert_eq!(bitfield.d(), 0x78); assert_eq!(bitfield.into_bits(), 0x78_56_34_12); } #[test] fn bitfield_msb() { #[bitfield(u32, order = Msb)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.b(), 0x34); assert_eq!(bitfield.c(), 0x56); assert_eq!(bitfield.d(), 0x78); assert_eq!(bitfield.into_bits(), 0x12_34_56_78); } #[test] fn bitfield_lsb_by_default() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.b(), 0x34); assert_eq!(bitfield.c(), 0x56); assert_eq!(bitfield.d(), 0x78); assert_eq!(bitfield.into_bits(), 0x78_56_34_12); } #[test] fn bitfield_debug() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::new(); let debug_str = format!("{:?}", bitfield); assert_eq!(debug_str, "Bitfield { d: 120, c: 86, b: 52, a: 18 }"); } #[test] fn bitfield_debug_msb() { #[bitfield(u32, order = Msb)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::new(); let debug_str = format!("{:?}", bitfield); assert_eq!(debug_str, "Bitfield { a: 18, b: 52, c: 86, d: 120 }"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_access_write_only() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_field_access_write_only.rs"); } #[test] fn bitfield_field_access_write_only_can_write() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12, access = wo)] a: u32, } Bitfield::new().set_a(0x34); BitfieldBuilder::new().with_a(0x34).build(); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_access_write_only_builder() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_field_access_write_only_builder.rs"); } #[test] fn bitfield_field_access_read_only_can_read() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12, access = ro)] a: u32, } assert_eq!(Bitfield::new().a(), 0x12); assert_eq!(BitfieldBuilder::new().build().a(), 0x12) } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_access_read_only_can_not_write() { let t = trybuild::TestCases::new(); t.compile_fail( "tests/compile_error_cases/bitfield_field_access_read_only_can_not_write.rs", ); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_field_access_read_only_can_not_write_builder() { let t = trybuild::TestCases::new(); t.compile_fail( "tests/compile_error_cases/bitfield_field_access_read_only_can_not_write_builder.rs", ); } #[test] fn bitfield_field_access_none() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12, access = none)] a: u32, } let bitfield = Bitfield::new(); assert_eq!(bitfield.into_bits(), 0x12); } #[test] fn bitfield_from_type() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::from(0x11_22_33_44); assert_eq!(bitfield.a(), 0x44); assert_eq!(bitfield.b(), 0x33); assert_eq!(bitfield.c(), 0x22); assert_eq!(bitfield.d(), 0x11); assert_eq!(bitfield.into_bits(), 0x11_22_33_44); } #[test] fn bitfield_into_type() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::new(); let val: u32 = bitfield.into(); assert_eq!(val, 0x78_56_34_12); } #[test] fn bitfield_from_bits_little_endian() { // The data 0x11223344 is stored in little-endian memory as [0x44, 0x33, 0x22, // 0x11]. #[bitfield(u32, from_endian = little)] pub struct Bitfield { // Lsb a: u8, b: u8, c: u8, d: u8, // Msb } // Raw data from memory. let bitfield = Bitfield::from_bits(0x44_33_22_11); assert_eq!(bitfield.a(), 0x44); assert_eq!(bitfield.b(), 0x33); assert_eq!(bitfield.c(), 0x22); assert_eq!(bitfield.d(), 0x11); assert_eq!(bitfield.into_bits(), 0x11_22_33_44); } #[test] fn bitfield_from_bits_little_endian_msb_field_order() { // The data 0x11223344 is stored in little-endian memory as [0x44, 0x33, 0x22, // 0x11]. #[bitfield(u32, from_endian = little, order = msb)] pub struct Bitfield { // Msb a: u8, b: u8, c: u8, d: u8, // Lsb } // Raw data from memory. let bitfield = Bitfield::from_bits(0x44_33_22_11); assert_eq!(bitfield.d(), 0x44); assert_eq!(bitfield.c(), 0x33); assert_eq!(bitfield.b(), 0x22); assert_eq!(bitfield.a(), 0x11); assert_eq!(bitfield.into_bits(), 0x11_22_33_44); } #[test] fn bitfield_from_bits_big_endian() { // The data 0x11223344 is stored in big-endian memory as [0x11, 0x22, 0x33, // 0x44]. #[bitfield(u32, from_endian = big)] pub struct Bitfield { // Lsb a: u8, b: u8, c: u8, d: u8, // Msb } // Raw data from memory. let bitfield = Bitfield::from_bits(0x11_22_33_44); assert_eq!(bitfield.a(), 0x44); assert_eq!(bitfield.b(), 0x33); assert_eq!(bitfield.c(), 0x22); assert_eq!(bitfield.d(), 0x11); assert_eq!(bitfield.into_bits(), 0x11_22_33_44); } #[test] fn bitfield_from_bits_big_endian_msb_order() { // The data 0x11223344 is stored in big-endian memory as [0x11, 0x22, 0x33, // 0x44]. #[bitfield(u32, from_endian = big, order = msb)] pub struct Bitfield { // Msb a: u8, b: u8, c: u8, d: u8, // Lsb } // Raw data from memory. let bitfield = Bitfield::from_bits(0x11_22_33_44); assert_eq!(bitfield.d(), 0x44); assert_eq!(bitfield.c(), 0x33); assert_eq!(bitfield.b(), 0x22); assert_eq!(bitfield.a(), 0x11); assert_eq!(bitfield.into_bits(), 0x11_22_33_44); } #[test] fn bitfield_into_bits_little_endian() { // Represents 0x11223344 #[bitfield(u32, into_endian = little)] pub struct Bitfield { // Lsb #[bits(default = 0x44)] a: u8, #[bits(default = 0x33)] b: u8, #[bits(default = 0x22)] c: u8, #[bits(default = 0x11)] d: u8, // Msb } let bitfield = Bitfield::default(); assert_eq!(bitfield.into_bits(), 0x44332211); } #[test] fn bitfield_into_bits_big_endian() { // Represents 0x11223344 #[bitfield(u32, into_endian = big)] pub struct Bitfield { // Lsb #[bits(default = 0x44)] a: u8, #[bits(default = 0x33)] b: u8, #[bits(default = 0x22)] c: u8, #[bits(default = 0x11)] d: u8, // Msb } let bitfield = Bitfield::default(); assert_eq!(bitfield.into_bits(), 0x11223344); } #[test] fn bitfield_field_visibility() { #[bitfield(u32)] pub(crate) struct Bitfield { #[bits(default = 0x12)] pub a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] pub c: u8, #[bits(default = 0x78)] d: u8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.c(), 0x56); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_disable_from_trait_compile_error() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_disable_from_trait.rs"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_disable_builder_compile_error() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_disable_builder.rs"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_disable_debug_compile_error() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_disable_debug.rs"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_disable_default_compile_error() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_disable_default.rs"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_disable_from_bits_compile_error() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_disable_from_bits.rs"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_disable_into_bits_compile_error() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_disable_into_bits.rs"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_disable_new_compile_error() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_disable_new.rs"); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_padding_field_with_access_compile_error() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_padding_field_with_access.rs"); } #[test] fn bitfield_const_default_value() { const A_VAL: u8 = 0x12; #[bitfield(u8)] pub struct Bitfield { #[bits(default = A_VAL)] a: u8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0x12); } #[test] fn bitfield_const_func_default_value() { const fn generate_val() -> u8 { 0xFF } #[bitfield(u8)] pub struct Bitfield { #[bits(default = generate_val())] a: u8, } let bitfield = Bitfield::new(); assert_eq!(bitfield.a(), 0xFF); } #[test] fn bitfield_get_bit() { #[bitfield(u8, bit_ops = true)] #[derive(Copy, Clone)] pub struct Bitfield { #[bits(2, default = 0b11)] a: u8, #[bits(2, default = 0b00)] b: u8, #[bits(2, default = 0b10, access = wo)] c: u8, #[bits(2, default = 0b01)] _d: u8, } let bitfield = Bitfield::new(); assert!(bitfield.get_bit(0)); assert!(bitfield.get_bit(1)); assert!(!bitfield.get_bit(2)); assert!(!bitfield.get_bit(3)); assert!(!bitfield.get_bit(4)); assert!(!bitfield.get_bit(5)); assert!(bitfield.get_bit(6)); assert!(!bitfield.get_bit(7)); } #[test] fn bitfield_get_bit_out_of_bounds() { #[bitfield(u8, bit_ops = true)] #[derive(Copy, Clone)] pub struct Bitfield { #[bits(2, default = 0b11)] a: u8, #[bits(2, default = 0b00)] b: u8, #[bits(2, default = 0b10, access = wo)] c: u8, #[bits(2, default = 0b01)] _d: u8, } let bitfield = Bitfield::new(); assert!(!bitfield.get_bit(50)); } #[test] fn bitfield_checked_get_bit() { #[bitfield(u8, bit_ops = true)] #[derive(Copy, Clone)] pub struct Bitfield { #[bits(2, default = 0b11)] a: u8, #[bits(2, default = 0b00)] b: u8, #[bits(2, default = 0b10, access = wo)] c: u8, #[bits(2, default = 0b01)] _d: u8, } let bitfield = Bitfield::new(); assert!(bitfield.checked_get_bit(0).unwrap()); assert!(bitfield.checked_get_bit(1).unwrap()); assert!(!bitfield.checked_get_bit(2).unwrap()); assert!(!bitfield.checked_get_bit(3).unwrap()); assert!(bitfield.checked_get_bit(4).is_err()); assert!(bitfield.checked_get_bit(5).is_err()); assert!(bitfield.get_bit(6)); assert!(!bitfield.get_bit(7)); } #[test] fn bitfield_checked_get_bit_none_access() { #[bitfield(u8, bit_ops = true)] #[derive(Copy, Clone)] pub struct Bitfield { #[bits(2, default = 0b11)] a: u8, #[bits(2, default = 0b00)] b: u8, #[bits(2, default = 0b10, access = none)] c: u8, #[bits(2, default = 0b01)] _d: u8, } let bitfield = Bitfield::new(); assert!(bitfield.checked_get_bit(0).unwrap()); assert!(bitfield.checked_get_bit(1).unwrap()); assert!(!bitfield.checked_get_bit(2).unwrap()); assert!(!bitfield.checked_get_bit(3).unwrap()); assert!(bitfield.checked_get_bit(4).is_err()); assert!(bitfield.checked_get_bit(5).is_err()); assert!(bitfield.get_bit(6)); assert!(!bitfield.get_bit(7)); } #[test] fn bitfield_checked_get_bit_rw_access() { #[bitfield(u8, bit_ops = true)] #[derive(Copy, Clone)] pub struct Bitfield { #[bits(2, default = 0b11)] a: u8, #[bits(2, default = 0b00)] b: u8, #[bits(2, default = 0b10, access = rw)] c: u8, #[bits(2, default = 0b01)] _d: u8, } let bitfield = Bitfield::new(); assert!(bitfield.checked_get_bit(0).unwrap()); assert!(bitfield.checked_get_bit(1).unwrap()); assert!(!bitfield.checked_get_bit(2).unwrap()); assert!(!bitfield.checked_get_bit(3).unwrap()); assert!(!bitfield.checked_get_bit(4).unwrap()); assert!(bitfield.checked_get_bit(5).unwrap()); assert!(bitfield.get_bit(6)); assert!(!bitfield.get_bit(7)); } #[test] fn bitfield_set_bit() { #[bitfield(u8, bit_ops = true)] #[derive(Copy, Clone)] pub struct Bitfield { #[bits(2)] a: u8, #[bits(2, default = 0b11)] b: u8, #[bits(2, default = 0b11, access = ro)] c: u8, #[bits(2, default = 0b00)] _d: u8, } let mut bitfield = Bitfield::new(); bitfield.set_bit(0, true); bitfield.set_bit(1, true); bitfield.set_bit(2, false); bitfield.set_bit(3, false); bitfield.set_bit(4, false); bitfield.set_bit(5, false); bitfield.set_bit(6, true); bitfield.set_bit(7, true); assert_eq!(bitfield.into_bits(), 0b110011); } #[test] fn bitfield_checked_set_bit() { #[bitfield(u8, bit_ops = true)] #[derive(Copy, Clone)] pub struct Bitfield { #[bits(2)] a: u8, #[bits(2, default = 0b11)] b: u8, #[bits(2, default = 0b11, access = ro)] c: u8, #[bits(2, default = 0b00)] _d: u8, } let mut bitfield = Bitfield::new(); assert!(bitfield.checked_set_bit(0, true).is_ok()); assert!(bitfield.checked_set_bit(1, true).is_ok()); assert!(bitfield.checked_set_bit(2, false).is_ok()); assert!(bitfield.checked_set_bit(3, false).is_ok()); assert!(bitfield.checked_set_bit(4, false).is_err()); assert!(bitfield.checked_set_bit(5, false).is_err()); assert!(bitfield.checked_set_bit(6, true).is_err()); assert!(bitfield.checked_set_bit(7, true).is_err()); assert_eq!(bitfield.into_bits(), 0b110011); } #[test] #[cfg_attr(miri, ignore)] fn bitfield_bit_ops_disabled() { let t = trybuild::TestCases::new(); t.compile_fail("tests/compile_error_cases/bitfield_bit_ops_disabled.rs"); } #[test] fn bitfield_ignored_field() { #[bitfield(u8)] pub struct Bitfield { #[bits(2, ignore = true)] ignored: char, #[bits(99, ignore = true)] ignored1: Custom, #[bits(4, default = 0b11)] b: u8, #[bits(2, default = 0b11, access = ro)] c: u8, #[bits(2, default = 0b00)] _d: u8, } #[derive(Debug, Default, PartialEq)] enum Custom { #[default] A = 0, } let bitfield = Bitfield::new(); assert_eq!(bitfield.ignored1, Custom::A); } #[test] fn bitfield_set_bits() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let mut bitfield = Bitfield::new(); bitfield.set_bits(0x11223344); assert_eq!(bitfield.a(), 0x44); assert_eq!(bitfield.b(), 0x33); assert_eq!(bitfield.c(), 0x22); assert_eq!(bitfield.d(), 0x11); assert_eq!(bitfield.into_bits(), 0x11223344); } #[test] fn bitfield_set_bits_non_writable() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34, access = ro)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] _d: u8, } let mut bitfield = Bitfield::new(); bitfield.set_bits(0x11223344); assert_eq!(bitfield.a(), 0x44); assert_eq!(bitfield.b(), 0); assert_eq!(bitfield.c(), 0x22); assert_eq!(bitfield.into_bits(), 0x78220044); } #[test] fn bitfield_set_bits_with_defaults() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, b: u8, c: u8, #[bits(default = 0x78)] d: u8, } let mut bitfield = Bitfield::new(); bitfield.set_bits_with_defaults(0x11223344); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.b(), 0x33); assert_eq!(bitfield.c(), 0x22); assert_eq!(bitfield.d(), 0x78); assert_eq!(bitfield.into_bits(), 0x78223312); } #[test] fn bitfield_clear_bits() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let mut bitfield = Bitfield::new(); bitfield.clear_bits(); assert_eq!(bitfield.a(), 0); assert_eq!(bitfield.b(), 0); assert_eq!(bitfield.c(), 0); assert_eq!(bitfield.d(), 0); assert_eq!(bitfield.into_bits(), 0); } #[test] fn bitfield_clear_bits_with_defaults() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12)] a: u8, b: u8, c: u8, #[bits(default = 0x78)] d: u8, } let mut bitfield = Bitfield::new(); bitfield.clear_bits_with_defaults(); assert_eq!(bitfield.a(), 0x12); assert_eq!(bitfield.b(), 0); assert_eq!(bitfield.c(), 0); assert_eq!(bitfield.d(), 0x78); assert_eq!(bitfield.into_bits(), 0x78000012); } #[test] fn bitfield_field_access_read_only_can_build() { #[bitfield(u32)] pub struct Bitfield { #[bits(default = 0x12, access = ro)] a: u32, } assert_eq!(Bitfield::new().a(), 0x12); assert_eq!(BitfieldBuilder::new().with_a(0x22).build().a(), 0x22); } #[test] fn bitfield_to_builder() { #[bitfield(u32, to_builder = true)] #[derive(Clone)] pub struct Bitfield { #[bits(ignore = true)] ignore: u8, #[bits(default = 0x12)] a: u8, #[bits(default = 0x34)] b: u8, #[bits(default = 0x56)] c: u8, #[bits(default = 0x78)] d: u8, } let builder = Bitfield::new().to_builder().build(); assert_eq!(builder.ignore, 0); assert_eq!(builder.a(), 0x12); assert_eq!(builder.b(), 0x34); assert_eq!(builder.c(), 0x56); assert_eq!(builder.d(), 0x78); } #[test] fn bitfield_bool_fields() { #[bitfield(u8)] #[derive(Copy, Clone)] pub struct PxiCnt { #[bits(access = ro)] a: bool, b: bool, c: bool, d: bool, #[bits(4)] __: u32, } } }