Add support for running the tests from uACPI. (#285)

Author: martin-hughes

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["tools/aml_tester", "tools/acpi_dumper", "tools/aml_test_tools"]
+members = ["tools/aml_tester", "tools/acpi_dumper", "tools/aml_test_tools", "tools/uacpi_test_adapter"]
 resolver = "2"
 
 [package]

src/sdt/facs.rs

@@ -11,7 +11,7 @@ pub struct Facs {
     pub flags: u32,
     pub x_firmware_waking_vector: u64,
     pub version: u8,
-    _reserved0: [u8; 3],
+    pub _reserved0: [u8; 3],
     pub ospm_flags: u32,
-    reserved1: [u8; 24],
+    pub reserved1: [u8; 24],
 }

tests/README.md

@@ -0,0 +1,57 @@
+# Tests in the ACPI crate.
+
+There are 4 categories of tests:
+
+1. Unit tests in the main crate source.
+2. Integration tests in the `tests` directory - these all have the extension `.rs`.
+3. Raw ASL files that can be checked using `aml_tester`
+4. Support for running tests from the `uacpi` project.
+
+## Unit tests
+
+These are standard Rust unit tests. Run them using `cargo test` (which will also run the integration tests). There are
+relatively few unit tests at present - feel free to send PRs with more!
+
+## Integration tests
+
+These are the `.rs` files in the `tests` directory. They largely consist of snippets of ASL code that are parsed and
+then executed using the `aml_test_tools` sub-crate. Most of the tests specify the expected output from the provided
+`Handler`, which provides reasonable confidence the parser is working correctly.
+
+The `aml_test_tools` sub-crate provides various utilities for writing this style of test.
+
+Like the unit tests, they can be run using `cargo test`.
+
+## Raw ASL files
+
+Various ASL files are provided in the `tests` directory. They can be parsed and executed by running 
+`cargo run_tests -p tests` from the root of the repository. This cargo alias runs the `aml_tester` tool.
+
+The `aml_tester` tool provides a command-line way to run ASL files - similar to `acpiexec`.
+
+## Running tests from the `uacpi` project
+
+> See the documentation for `uacpi_test_adapter` for more detailed information. Note that a large proportion of the
+> tests in the `uacpi` project do not yet pass in this crate.
+ 
+The `uacpi` project has a fairly extensive test suite. It makes sense for us to be able to check against their test
+suite as well as our own. This can be done by:
+
+1. Checking out the [`uacpi` repository.](https://github.com/uACPI/uACPI)
+2. Navigating to the root of that repo.
+3. Running something like: 
+   ```shell
+   python3 tests/run_tests.py --test-runner ../acpi/target/debug/uacpi_test_adapter
+   ```
+   Adjusting the paths as necessary. See the `uacpi_test_adapter` documentation for details on how it finds
+   `aml_tester`.
+
+Note that, at present, several of the uACPI tests run indefinitely. You may want to skip these! The easiest way to do so
+is probably just to delete them... The relevant tests are:
+
+* `global-lock.asl`
+* `hanging-while.asl`
+* `infinite-recursion.asl`
+* `mutex-1.asl`
+* `mutex-2.asl`
+* `mutex-3.asl`

tests/test_infra/mod.rs

@@ -14,6 +14,6 @@ pub fn run_aml_test(asl: &'static str, handler: impl Handler) {
     let logged_handler = LoggingHandler::new(handler);
     let interpreter = new_interpreter(logged_handler);
 
-    let result = run_test_for_string(asl, interpreter);
+    let result = run_test_for_string(asl, interpreter, &None);
     assert!(matches!(result, RunTestResult::Pass(_)), "Test failed with: {:?}", TestResult::from(&result));
 }

tests/uacpi_examples.rs

@@ -0,0 +1,191 @@
+//! These examples have been adapted from the Readme of the [uACPI](https://github.com/uACPI/uACPI)
+//! project at commit 1ca45f3.
+//!
+//! At present most of these tests probably won't work, but it'll help to guide us towards better
+//! compatibility.
+//!
+//! The comments demonstrate some of the differences between the NT "real world" interpreter and
+//! the ACPI reference standard.
+
+mod test_infra;
+
+use aml_test_tools::{handlers::null_handler::NullHandler};
+
+#[test]
+#[ignore] // Fails with ObjectNotOfExpectedType { expected: Reference, got: Integer }
+fn expressions_with_package() {
+    const ASL: &str = r#"
+DefinitionBlock("", "DSDT", 1, "RSACPI", "UACPI", 1) {
+    Method (TEST) {
+        Local0 = 10
+        Local1 = Package { Local0 * 5 }
+        Return (DerefOf(Local1[0]))
+    }
+
+    // ACPICA: AE_SUPPORT, Expressions within package elements are not supported
+    // Windows, uACPI: Local0 = 50
+    Local0 = TEST()
+}
+    "#;
+
+    let handler = NullHandler;
+    test_infra::run_aml_test(ASL, handler);
+}
+
+#[test]
+fn package_outside_of_control_method() {
+    const ASL: &str = r#"
+DefinitionBlock("", "DSDT", 1, "RSACPI", "UACPI", 1) {
+    // ACPICA: internal error
+    // Windows, uACPI: ok
+    Local0 = Package { 1 }
+
+    // I don't have a good way of testing this, but if it completes without errors it's probably OK.
+    Debug = Local0[0]
+}"#;
+
+    let handler = NullHandler;
+    test_infra::run_aml_test(ASL, handler);
+}
+
+#[test]
+#[ignore] // Local0 is set to 123 - we follow the ACPICA way, not the Windows way.
+fn reference_rebind_semantics() {
+    const ASL: &str = r#"
+DefinitionBlock("", "DSDT", 1, "RSACPI", "UACPI", 1) {
+    Method (MAIN, 0, NotSerialized) {
+        Local0 = 123
+        Local1 = RefOf(Local0)
+
+        // ACPICA: Local1 = 321, Local0 = 123
+        // Windows, uACPI: Local1 = reference->Local0, Local0 = 321
+        Local1 = 321
+
+        Return (Local0 == 123)
+    }
+}"#;
+
+    let handler = NullHandler;
+    test_infra::run_aml_test(ASL, handler);
+}
+
+#[test]
+#[ignore] // ParseFail(ObjectNotOfExpectedType { expected: Integer, got: Integer } (a referencing failure)
+fn increment_decrement() {
+    const ASL: &str = r#"
+DefinitionBlock("", "DSDT", 1, "RSACPI", "UACPI", 1) {
+    Local0 = 123
+    Local1 = RefOf(Local0)
+
+    // ACPICA: error
+    // Windows, uACPI: Local0 = 124
+    Local1++
+}"#;
+
+    let handler = NullHandler;
+    test_infra::run_aml_test(ASL, handler);
+}
+
+#[test]
+#[ignore] // ParseFail(ObjectNotOfExpectedType { expected: Reference, got: Integer })
+fn multilevel_references() {
+    const ASL: &str = r#"
+DefinitionBlock("", "DSDT", 1, "RSACPI", "UACPI", 1) {
+    Local0 = 123
+    Local1 = RefOf(Local0)
+    Local2 = RefOf(Local1)
+
+    // ACPICA: Local3 = reference->Local0
+    // Windows, uACPI: Local3 = 123
+    Local3 = DerefOf(Local2)
+}"#;
+
+    let handler = NullHandler;
+    test_infra::run_aml_test(ASL, handler);
+}
+
+#[test]
+#[ignore] // "Stores to objects like WrappedObject(UnsafeCell { .. }) are not yet supported"
+fn implicit_case_semantics() {
+    const ASL: &str = r#"
+DefinitionBlock("", "DSDT", 1, "RSACPI", "UACPI", 1) {
+    Name (TEST, "BAR")
+
+    // ACPICA: TEST = "00000000004F4F46"
+    // Windows, uACPI: TEST = "FOO"
+    TEST = 0x4F4F46
+}"#;
+
+    let handler = NullHandler;
+    test_infra::run_aml_test(ASL, handler);
+}
+
+#[test]
+#[ignore] // "Stores to objects like WrappedObject(UnsafeCell { .. }) are not yet supported"
+fn buffer_size_mutability() {
+    const ASL: &str = r#"
+DefinitionBlock("", "DSDT", 1, "RSACPI", "UACPI", 1) {
+    Name (TEST, "XXXX")
+    Name (VAL, "")
+
+    // ACPICA: TEST = "LONGSTRING"
+    // Windows, UACPI: TEST = "LONG"
+    TEST = "LONGSTRING"
+
+    // ACPICA: VAL = "FOO"
+    // Windows, UACPI: VAL = ""
+    VAL = "FOO"
+}"#;
+
+    let handler = NullHandler;
+    test_infra::run_aml_test(ASL, handler);
+}
+
+#[test]
+fn ref_to_local() {
+    const ASL: &str = r#"
+DefinitionBlock("", "DSDT", 1, "RSACPI", "UACPI", 1) {
+    Method (TEST) {
+        Local0 = 123
+
+        // Use-after-free in ACPICA, perfectly fine in uACPI
+        Return (RefOf(Local0))
+    }
+
+    Method (FOO) {
+        Name (TEST, 123)
+
+        // Use-after-free in ACPICA, object lifetime prolonged in uACPI (node is still removed from the namespace)
+        Return (RefOf(TEST))
+    }
+
+    Method (MAIN) {
+        FOO ()
+        Return (0)
+    }
+}"#;
+
+    let handler = NullHandler;
+    test_infra::run_aml_test(ASL, handler);
+}
+
+#[test]
+#[ignore] // CopyObject not yet implemented
+fn copy_object_to_self() {
+    const ASL: &str = r#"
+DefinitionBlock("", "DSDT", 1, "RSACPI", "UACPI", 1) {
+    Method (TEST) {
+        CopyObject(123, TEST)
+        Return (1)
+    }
+
+    // Segfault in ACPICA, prints 1 in uACPI
+    Debug = TEST()
+
+    // Unreachable in ACPICA, prints 123 in uACPI
+    Debug = TEST
+}"#;
+
+    let handler = NullHandler;
+    test_infra::run_aml_test(ASL, handler);
+}