From 1fe7f52c68cb590fe341294977c599d971b936a7 Mon Sep 17 00:00:00 2001
From: Ian McIntyre <ianpmcintyre@gmail.com>
Date: Sun, 19 Sep 2021 21:34:29 -0400
Subject: Begin testing read, write, modify macros

Ported from the imxrt-ral core test suite.  Demonstrate that there are
no "unused variable" warnings in tests by denying warnings for select
tests. These tests show that #2 is resolved.
---
 tests/macros.rs | 102 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 tests/macros.rs

(limited to 'tests/macros.rs')

diff --git a/tests/macros.rs b/tests/macros.rs
new file mode 100644
index 0000000..8ff36ac
--- /dev/null
+++ b/tests/macros.rs
@@ -0,0 +1,102 @@
+//! Test the read, write, modify macros.
+
+use ral_registers as ral;
+
+struct DummyRegisterBlock {
+    register: ral::RWRegister<u32>,
+}
+
+mod register {
+    #![allow(non_upper_case_globals, non_snake_case)] // Macro conventions.
+
+    pub mod field_foo {
+        pub const offset: u32 = 10;
+        pub const mask: u32 = 0x7 << offset;
+        pub mod RW {}
+        pub mod W {}
+        pub mod R {}
+    }
+}
+
+fn zeroed_register_block() -> DummyRegisterBlock {
+    use core::mem::MaybeUninit;
+    let register_block = MaybeUninit::zeroed();
+    // Safety: 0 is a safe bitpattern
+    unsafe { register_block.assume_init() }
+}
+
+#[test]
+fn register_read() {
+    let register_block = zeroed_register_block();
+    register_block.register.write(0b111 << 10);
+    assert_eq!(
+        0x7,
+        ral::read_reg!(self, &register_block, register, field_foo)
+    );
+}
+
+#[test]
+fn register_write() {
+    let register_block = zeroed_register_block();
+    ral::write_reg!(self, &register_block, register, field_foo: 5);
+    assert_eq!(5 << 10, register_block.register.read());
+}
+
+#[test]
+fn register_modify() {
+    let register_block = zeroed_register_block();
+    register_block.register.write(1 << 10);
+    ral::modify_reg!(self, &register_block, register, field_foo: 6);
+    assert_eq!(6 << 10, register_block.register.read());
+}
+
+/// Demonstrates that a local variable, 'mask'
+/// doesn't affect the macro's behavior.
+///
+/// This is the same test as register_modify(), but
+/// with the number '6' in a variable called 'mask'.
+#[deny(warnings)] // Promotes "unused variable: mask" into an error. Should no longer happen.
+#[test]
+fn register_unused_mask_modify() {
+    let register_block = zeroed_register_block();
+    register_block.register.write(1 << 10);
+    let mask = 6;
+    ral::modify_reg!(self, &register_block, register, field_foo: mask);
+    assert_eq!(6 << 10, register_block.register.read());
+}
+
+/// Same test as above, but with a variable called
+/// 'offset' instead of 'mask'.
+#[deny(warnings)]
+#[test]
+fn register_unused_offset_modify() {
+    let register_block = zeroed_register_block();
+    register_block.register.write(1 << 10);
+    let offset = 6;
+    ral::modify_reg!(self, &register_block, register, field_foo: offset);
+    assert_eq!(6 << 10, register_block.register.read());
+}
+
+/// Same as above test, but using the 'write' macro
+/// instead of 'modify'.
+#[deny(warnings)]
+#[test]
+fn register_unused_mask_write() {
+    let register_block = zeroed_register_block();
+    register_block.register.write(1 << 10);
+    let mask = 6;
+    ral::write_reg!(self, &register_block, register, field_foo: mask);
+    assert_eq!(6 << 10, register_block.register.read());
+}
+
+/// Same test as above, but with a variable called
+/// 'offset' instead of 'mask'.
+#[deny(warnings)]
+#[test]
+fn register_unused_offset_write() {
+    let register_block = zeroed_register_block();
+    register_block.register.write(1 << 10);
+    let offset = 6;
+    ral::write_reg!(self, &register_block, register, field_foo: offset);
+    assert_eq!(6 << 10, register_block.register.read());
+}
-- 
cgit v1.2.3