#include "helpers.h"
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <uacpi/internal/resources.h> // This is private API, but we have to use it for tests here.
#include <uacpi/resources.h>

struct test_case {
    const char *name;
    uint8_t *aml_bytes;
    size_t num_aml_bytes;
    uint8_t *native_bytes;
    size_t num_native_bytes;
    size_t *pointer_offsets;
    size_t num_pointer_offsets;
};

#define AML_END_TAG 0x79, 0x00
#define NATIVE_END_TAG \
    UACPI_RESOURCE_TYPE_END_TAG, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00

#define NATIVE_OFFSET(name, field) \
    ((sizeof(uint32_t) * 2) + offsetof(uacpi_resource_##name, field))

#define TEST_CASE_AML(name, ...) static uint8_t res_aml_##name[] = __VA_ARGS__;
#define TEST_CASE_NATIVE(name, ...) \
    static uint8_t res_native_##name[] = __VA_ARGS__;
#define TEST_CASE_POINTERS(name, ...) \
    static size_t res_pointers_##name[] = __VA_ARGS__;

TEST_CASE_AML(
    IRQ,
    {
        /*
         * IRQNoFlags ()
         *     {2, 3}
         */
        0x22, 0x0C, 0x00,

        /*
         * IRQ (Level, ActiveLow, ExclusiveAndWake, NAM0)
         *     {1, 4, 5, 10}
         */
        0x23, 0x32, 0x04, 0x28,

        /*
         * IRQ (Edge, ActiveHigh, SharedAndWake, NAM1)
         *     {1}
         */
        0x23, 0x02, 0x00, 0x31,

        /*
         * IRQNoFlags ()
         *     {15}
         */
        0x22, 0x00, 0x80,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    IRQ,
    {
        UACPI_RESOURCE_TYPE_IRQ,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x01, 0x01, 0x00, 0x00, 0x00, 0x02, 0x02, 0x03,

        UACPI_RESOURCE_TYPE_IRQ,
        0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
        0x02, 0x00, 0x01, 0x00, 0x01, 0x04, 0x01, 0x04,
        0x05, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_IRQ,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x02, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00,

        UACPI_RESOURCE_TYPE_IRQ,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x0F, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    DMA,
    {
        /*
         * DMA (Compatibility, NotBusMaster, Transfer8_16, NAM0)
         *     { 1, 2, 3 }
         */
        0x2A, 0x0E, 0x01,

        /*
         * DMA (TypeA, BusMaster, Transfer8, NAM1)
         *     { 0 }
         */
        0x2A, 0x01, 0x24,

        /*
         * DMA (TypeF, BusMaster, Transfer16, NAM2)
         *     { 1, 2, 3, 4, 5, 6, 7 }
         */
        0x2A, 0xFE, 0x66,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    DMA,
    {
        UACPI_RESOURCE_TYPE_DMA,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x03, 0x01, 0x02, 0x03, 0x00,

        UACPI_RESOURCE_TYPE_DMA,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_DMA,
        0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
        0x02, 0x01, 0x03, 0x07, 0x01, 0x02, 0x03, 0x04,
        0x05, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    Start_End_DependentFn,
    {
        /*
         * StartDependentFn(2, 2) {
         *     IRQ (Level, ActiveLow, ExclusiveAndWake, NAM0)
         *         {1, 4, 5, 10}
         * }
         */
        0x31, 0x0A,
        0x23, 0x32, 0x04, 0x28,

        /*
         * StartDependentFnNoPri() {
         *     DMA (TypeF, BusMaster, Transfer16, NAM1)
         *         { 1, 2, 3, 4, 5, 6, 7 }
         * }
         */
        0x30,
        0x2A, 0xFE, 0x66,

        /*
         * StartDependentFn(0, 0) {
         *     IRQNoFlags ()
         *         {15}
         * }
         */
        0x31, 0x00,
        0x22, 0x00, 0x80,

        // EndDependentFn()
        0x38,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    Start_End_DependentFn,
    {
        UACPI_RESOURCE_TYPE_START_DEPENDENT,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_IRQ,
        0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
        0x02, 0x00, 0x01, 0x00, 0x01, 0x04, 0x01, 0x04,
        0x05, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_START_DEPENDENT,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_AML_RESOURCE_DMA,
        0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
        0x02, 0x01, 0x03, 0x07, 0x01, 0x02, 0x03, 0x04,
        0x05, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_START_DEPENDENT,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_IRQ,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x0F, 0x00,

        UACPI_RESOURCE_TYPE_END_DEPENDENT,
        0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    IO,
    {
        // IO (Decode10, 0xBEEF, 0xDEAD, 0x22, 0xEE, NAM0)
        0x47, 0x00, 0xEF, 0xBE, 0xAD, 0xDE, 0x22, 0xEE,

        // IO (Decode16, 0xBABE, 0xCAFE, 0xCC, 0x33, NAM1)
        0x47, 0x01, 0xBE, 0xBA, 0xFE, 0xCA, 0xCC, 0x33,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    IO,
    {
        UACPI_RESOURCE_TYPE_IO,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x00, 0x00, 0xEF, 0xBE, 0xAD, 0xDE, 0x22, 0xEE,

        UACPI_RESOURCE_TYPE_IO,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x01, 0x00, 0xBE, 0xBA, 0xFE, 0xCA, 0xCC, 0x33,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    FixedIO,
    {
        // FixedIO (0xBEEF, 0xDE, NAM0)
        0x4B, 0xEF, 0xBE, 0xAD,

        // FixedIO (0xCAFE, 0xBA, NAM1)
        0x4B, 0xFE, 0xCA, 0xBE,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    FixedIO,
    {
        UACPI_RESOURCE_TYPE_FIXED_IO,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0xEF, 0xBE, 0xAD, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_FIXED_IO,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0xFE, 0xCA, 0xBE, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    FixedDMA,
    {
        // FixedDMA (0xBEEF, 0xDEAD, Width8Bit, NAM0)
        0x55, 0xEF, 0xBE, 0xAD, 0xDE, 0x00,

        // FixedDMA (0xCAFE, 0xBABE, Width64Bit, NAM1)
        0x55, 0xFE, 0xCA, 0xBE, 0xBA, 0x03,

        // FixedDMA (0xDEAD, 0xC0DE, Width256Bit, NAM2)
        0x55, 0xAD, 0xDE, 0xDE, 0xC0, 0x05,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    FixedDMA,
    {
        UACPI_RESOURCE_TYPE_FIXED_DMA,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0xEF, 0xBE, 0xAD, 0xDE, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_FIXED_DMA,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0xFE, 0xCA, 0xBE, 0xBA, 0x03, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_FIXED_DMA,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0xAD, 0xDE, 0xDE, 0xC0, 0x05, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    Vendor_Short_Long,
    {
        /*
         * VendorShort(NAM0)
         *     { 0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA }
         */
        0x77, 0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA,

        /*
         * VendorShort(NAM1)
         *     { 0xFF }
         */
        0x71, 0xFF,

        /*
         * VendorLong(NAM1) {
         *     0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0x0C,
         *     0x65, 0x90, 0xB0, 0xE0, 0x10, 0xC8, 0x96, 0xA6,
         *     0x96, 0x80, 0x5A, 0xA8, 0xA7, 0x06, 0xC5, 0x77,
         *     0xD8, 0xA7, 0x67, 0x53, 0xE3, 0x86, 0x03, 0x39,
         *     0xDC
         * }
         */
        0x84, 0x21, 0x00, 0x44, 0xA6, 0x5A, 0x82, 0x83,
        0x57, 0x7D, 0x0C, 0x65, 0x90, 0xB0, 0xE0, 0x10,
        0xC8, 0x96, 0xA6, 0x96, 0x80, 0x5A, 0xA8, 0xA7,
        0x06, 0xC5, 0x77, 0xD8, 0xA7, 0x67, 0x53, 0xE3,
        0x86, 0x03, 0x39, 0xDC,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    Vendor_Short_Long,
    {
        UACPI_RESOURCE_TYPE_VENDOR_SMALL,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x07, 0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA,

        UACPI_RESOURCE_TYPE_VENDOR_SMALL,
        0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
        0x01, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_VENDOR_LARGE,
        0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
        0x21, 0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D,
        0x0C, 0x65, 0x90, 0xB0, 0xE0, 0x10, 0xC8, 0x96,
        0xA6, 0x96, 0x80, 0x5A, 0xA8, 0xA7, 0x06, 0xC5,
        0x77, 0xD8, 0xA7, 0x67, 0x53, 0xE3, 0x86, 0x03,
        0x39, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    Memory_24_32_Fixed32,
    {
        // Memory24(ReadWrite, 0xBEEF, 0xDEAD, 0xCAFE, 0xBABE, NAM0)
        0x81, 0x09, 0x00, 0x01, 0xEF, 0xBE, 0xAD, 0xDE,
        0xFE, 0xCA, 0xBE, 0xBA,

        // Memory32(ReadOnly, 0xC0DE9876, 0x1234FEFE, 0x65653F4F, 0x33449988, NAM1)
        0x85, 0x11, 0x00, 0x00, 0x76, 0x98, 0xDE, 0xC0,
        0xFE, 0xFE, 0x34, 0x12, 0x4F, 0x3F, 0x65, 0x65,
        0x88, 0x99, 0x44, 0x33,

        // Memory32Fixed(ReadWrite, 0xC0DEDEAD, 0xFEFEBABE, NAM2)
        0x86, 0x09, 0x00, 0x01, 0xAD, 0xDE, 0xDE, 0xC0,
        0xBE, 0xBA, 0xFE, 0xFE,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    Memory_24_32_Fixed32,
    {
        UACPI_RESOURCE_TYPE_MEMORY24,
        0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
        0x01, 0x00, 0xEF, 0xBE, 0xAD, 0xDE, 0xFE, 0xCA,
        0xBE, 0xBA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_MEMORY32,
        0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x76, 0x98, 0xDE, 0xC0,
        0xFE, 0xFE, 0x34, 0x12, 0x4F, 0x3F, 0x65, 0x65,
        0x88, 0x99, 0x44, 0x33, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_FIXED_MEMORY32,
        0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0xAD, 0xDE, 0xDE, 0xC0,
        0xBE, 0xBA, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    Register,
    {
        // Register(SMBus, 0xDE, 0xBE, 0xC0DE9876CAFEBABE, 0, NAM0)
        0x82, 0x0C, 0x00, 0x04, 0xDE, 0xBE, 0x00, 0xBE,
        0xBA, 0xFE, 0xCA, 0x76, 0x98, 0xDE, 0xC0,


        // Register(SystemCMOS, 0xFF, 0x22, 0x11DE12345AFEDDBB, 4, NAM1)
        0x82, 0x0C, 0x00, 0x05, 0xFF, 0x22, 0x04, 0xBB,
        0xDD, 0xFE, 0x5A, 0x34, 0x12, 0xDE, 0x11,


        // Register(FFixedHW, 0x11, 0x33, 0x452199FFAADCCDFF, 3, NAM2)
        0x82, 0x0C, 0x00, 0x7F, 0x11, 0x33, 0x03, 0xFF,
        0xCD, 0xDC, 0xAA, 0xFF, 0x99, 0x21, 0x45,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    Register,
    {
        UACPI_RESOURCE_TYPE_GENERIC_REGISTER,
        0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
        0x04, 0xDE, 0xBE, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xBE, 0xBA, 0xFE, 0xCA, 0x76, 0x98, 0xDE, 0xC0,

        UACPI_RESOURCE_TYPE_GENERIC_REGISTER,
        0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
        0x05, 0xFF, 0x22, 0x04, 0x00, 0x00, 0x00, 0x00,
        0xBB, 0xDD, 0xFE, 0x5A, 0x34, 0x12, 0xDE, 0x11,

        UACPI_RESOURCE_TYPE_GENERIC_REGISTER,
        0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
        0x7F, 0x11, 0x33, 0x03, 0x00, 0x00, 0x00, 0x00,
        0xFF, 0xCD, 0xDC, 0xAA, 0xFF, 0x99, 0x21, 0x45,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    ExtendedIO,
    {
        /*
         * ExtendedIO(
         *     ResourceProducer, MinFixed, MaxNotFixed, PosDecode,
         *     EntireRange, 0x2E2F2E122CFA72B2, 0x567A6752EB92115A,
         *     0x57BE4E08FE66A14C, 0x43E98758F80FBC69,
         *     0xD6BD146354CC792C, 0x6D6A7C021238A28D, NAM0,
         *     TypeStatic, SparseTranslation
         * )
         */
        0x8B, 0x35, 0x00, 0x01, 0x04, 0x23, 0x01, 0x00,
        0xB2, 0x72, 0xFA, 0x2C, 0x12, 0x2E, 0x2F, 0x2E,
        0x5A, 0x11, 0x92, 0xEB, 0x52, 0x67, 0x7A, 0x56,
        0x4C, 0xA1, 0x66, 0xFE, 0x08, 0x4E, 0xBE, 0x57,
        0x69, 0xBC, 0x0F, 0xF8, 0x58, 0x87, 0xE9, 0x43,
        0x2C, 0x79, 0xCC, 0x54, 0x63, 0x14, 0xBD, 0xD6,
        0x8D, 0xA2, 0x38, 0x12, 0x02, 0x7C, 0x6A, 0x6D,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    ExtendedIO,
    {
        UACPI_RESOURCE_TYPE_ADDRESS64_EXTENDED,
        0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
        0x03, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
        0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xB2, 0x72, 0xFA, 0x2C, 0x12, 0x2E, 0x2F, 0x2E,
        0x5A, 0x11, 0x92, 0xEB, 0x52, 0x67, 0x7A, 0x56,
        0x4C, 0xA1, 0x66, 0xFE, 0x08, 0x4E, 0xBE, 0x57,
        0x69, 0xBC, 0x0F, 0xF8, 0x58, 0x87, 0xE9, 0x43,
        0x2C, 0x79, 0xCC, 0x54, 0x63, 0x14, 0xBD, 0xD6,
        0x8D, 0xA2, 0x38, 0x12, 0x02, 0x7C, 0x6A, 0x6D,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    ExtendedMemory,
    {
        /*
         * ExtendedMemory(
         *     ResourceConsumer, SubDecode, MinNotFixed, MaxFixed,
         *     WriteCombining, ReadOnly, 0x567A6752EB92115A,
         *     0x43E98758F80FBC69, 0xD6BD146354CC792C, 0x57BE4E08FE66A14C,
         *     0x2E2F2E122CFA72B2, 0x4DE81A9EEA660878, NAM0,
         *     AddressRangeACPI, TypeStatic
         * )
         */
        0x8B, 0x35, 0x00, 0x00, 0x0B, 0x14, 0x01, 0x00,
        0x5A, 0x11, 0x92, 0xEB, 0x52, 0x67, 0x7A, 0x56,
        0x69, 0xBC, 0x0F, 0xF8, 0x58, 0x87, 0xE9, 0x43,
        0x2C, 0x79, 0xCC, 0x54, 0x63, 0x14, 0xBD, 0xD6,
        0x4C, 0xA1, 0x66, 0xFE, 0x08, 0x4E, 0xBE, 0x57,
        0xB2, 0x72, 0xFA, 0x2C, 0x12, 0x2E, 0x2F, 0x2E,
        0x78, 0x08, 0x66, 0xEA, 0x9E, 0x1A, 0xE8, 0x4D,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    ExtendedMemory,
    {
        UACPI_RESOURCE_TYPE_ADDRESS64_EXTENDED,
        0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
        0x00, 0x02, 0x02, 0x00, 0x00, 0x01, 0x01, 0x00,
        0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x5A, 0x11, 0x92, 0xEB, 0x52, 0x67, 0x7A, 0x56,
        0x69, 0xBC, 0x0F, 0xF8, 0x58, 0x87, 0xE9, 0x43,
        0x2C, 0x79, 0xCC, 0x54, 0x63, 0x14, 0xBD, 0xD6,
        0x4C, 0xA1, 0x66, 0xFE, 0x08, 0x4E, 0xBE, 0x57,
        0xB2, 0x72, 0xFA, 0x2C, 0x12, 0x2E, 0x2F, 0x2E,
        0x78, 0x08, 0x66, 0xEA, 0x9E, 0x1A, 0xE8, 0x4D,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    ExtendedSpace,
    {
        /*
         *  ExtendedSpace(
         *      0xCD, ResourceConsumer, PosDecode, MinFixed,
         *      MaxFixed, 0xEE, 0x13B531F2DEB2F64C, 0x261C82678FE9F9FE,
         *      0xB32DF50E542CF6B2, 0x51FE96DA6EC52143, 0x5DA63B2994D3652E,
         *      0x2EEE774C18842CC7, NAM0
         *  )
         */
        0x8B, 0x35, 0x00, 0xCD, 0x0D, 0xEE, 0x01, 0x00,
        0x4C, 0xF6, 0xB2, 0xDE, 0xF2, 0x31, 0xB5, 0x13,
        0xFE, 0xF9, 0xE9, 0x8F, 0x67, 0x82, 0x1C, 0x26,
        0xB2, 0xF6, 0x2C, 0x54, 0x0E, 0xF5, 0x2D, 0xB3,
        0x43, 0x21, 0xC5, 0x6E, 0xDA, 0x96, 0xFE, 0x51,
        0x2E, 0x65, 0xD3, 0x94, 0x29, 0x3B, 0xA6, 0x5D,
        0xC7, 0x2C, 0x84, 0x18, 0x4C, 0x77, 0xEE, 0x2E,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    ExtendedSpace,
    {
        UACPI_RESOURCE_TYPE_ADDRESS64_EXTENDED,
        0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
        0xEE, 0x00, 0x00, 0x00, 0xCD, 0x01, 0x00, 0x01,
        0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x4C, 0xF6, 0xB2, 0xDE, 0xF2, 0x31, 0xB5, 0x13,
        0xFE, 0xF9, 0xE9, 0x8F, 0x67, 0x82, 0x1C, 0x26,
        0xB2, 0xF6, 0x2C, 0x54, 0x0E, 0xF5, 0x2D, 0xB3,
        0x43, 0x21, 0xC5, 0x6E, 0xDA, 0x96, 0xFE, 0x51,
        0x2E, 0x65, 0xD3, 0x94, 0x29, 0x3B, 0xA6, 0x5D,
        0xC7, 0x2C, 0x84, 0x18, 0x4C, 0x77, 0xEE, 0x2E,

        NATIVE_END_TAG,
    }
)
TEST_CASE_AML(
    WordBusNumber,
    {
        /*
         * WordBusNumber(
         *     ResourceProducer, MinNotFixed, MaxFixed, PosDecode,
         *     0xDEAD, 0xBEEF, 0xCAFE, 0xBABE, 0xFEFE, 4,
         *     "\\SOME.PATH", NAM0
         * )
         */
        0x88, 0x19, 0x00, 0x02, 0x08, 0x00, 0xAD, 0xDE,
        0xEF, 0xBE, 0xFE, 0xCA, 0xBE, 0xBA, 0xFE, 0xFE,
        0x04, 0x5C, 0x53, 0x4F, 0x4D, 0x45, 0x2E, 0x50,
        0x41, 0x54, 0x48, 0x00,

        /*
         * WordBusNumber(
         *     ResourceConsumer, MinFixed, MaxNotFixed, SubDecode,
         *     0xC0DE, 0xDEAD, 0xFEFE, 0xCAFE, 0xBABE, , , NAM1
         * )
         */
        0x88, 0x0D, 0x00, 0x02, 0x07, 0x00, 0xDE, 0xC0,
        0xAD, 0xDE, 0xFE, 0xFE, 0xFE, 0xCA, 0xBE, 0xBA,
        0x79, 0x00,
    }
)
TEST_CASE_NATIVE(
    WordBusNumber,
    {
        UACPI_RESOURCE_TYPE_ADDRESS16,
        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
        0x01, 0x00, 0xAD, 0xDE, 0xEF, 0xBE, 0xFE, 0xCA,
        0xBE, 0xBA, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00,
        0x04, 0x01, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x5C, 0x53, 0x4F, 0x4D, 0x45, 0x2E, 0x50, 0x41,
        0x54, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,


        UACPI_RESOURCE_TYPE_ADDRESS16,
        0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x01, 0x01,
        0x00, 0x00, 0xDE, 0xC0, 0xAD, 0xDE, 0xFE, 0xFE,
        0xFE, 0xCA, 0xBE, 0xBA, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    WordBusNumber,
    {
        NATIVE_OFFSET(address16, source.string),
    }
)
TEST_CASE_AML(
    WordIO,
    {
        /*
         * WordIO(
         *     ResourceProducer, MinNotFixed, MaxFixed, PosDecode,
         *     EntireRange, 0xDEAD, 0xBEEF, 0xCAFE, 0xBABE, 0xFEFE, 123,
         *     "^^^^^^^VERY.LONG.PATH.THAT.SHOU.LD.WORK", NAM0, TypeStatic,
         *     SparseTranslation
         * )
         */
        0x88, 0x36, 0x00, 0x01, 0x08, 0x23, 0xAD, 0xDE,
        0xEF, 0xBE, 0xFE, 0xCA, 0xBE, 0xBA, 0xFE, 0xFE,
        0x7B, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x56, 0x45, 0x52, 0x59, 0x2E, 0x4C, 0x4F, 0x4E,
        0x47, 0x2E, 0x50, 0x41, 0x54, 0x48, 0x2E, 0x54,
        0x48, 0x41, 0x54, 0x2E, 0x53, 0x48, 0x4F, 0x55,
        0x2E, 0x4C, 0x44, 0x2E, 0x57, 0x4F, 0x52, 0x4B,
        0x00,

        /*
         * WordIO(
         *     ResourceConsumer, MinFixed, MaxNotFixed, SubDecode,
         *     EntireRange, 0xC0DE, 0xDEAD, 0xFEFE, 0xCAFE, 0xBABE, , , NAM1,
         *     TypeTranslation, DenseTranslation
         * )
         */
        0x88, 0x0D, 0x00, 0x01, 0x07, 0x13, 0xDE, 0xC0,
        0xAD, 0xDE, 0xFE, 0xFE, 0xFE, 0xCA, 0xBE, 0xBA,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    WordIO,
    {
        UACPI_RESOURCE_TYPE_ADDRESS16,
        0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
        0x03, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
        0x01, 0x00, 0xAD, 0xDE, 0xEF, 0xBE, 0xFE, 0xCA,
        0xBE, 0xBA, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00,
        0x7B, 0x01, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x56,
        0x45, 0x52, 0x59, 0x2E, 0x4C, 0x4F, 0x4E, 0x47,
        0x2E, 0x50, 0x41, 0x54, 0x48, 0x2E, 0x54, 0x48,
        0x41, 0x54, 0x2E, 0x53, 0x48, 0x4F, 0x55, 0x2E,
        0x4C, 0x44, 0x2E, 0x57, 0x4F, 0x52, 0x4B, 0x00,

        UACPI_RESOURCE_TYPE_ADDRESS16,
        0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
        0x03, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01,
        0x00, 0x00, 0xDE, 0xC0, 0xAD, 0xDE, 0xFE, 0xFE,
        0xFE, 0xCA, 0xBE, 0xBA, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    WordIO,
    {
        NATIVE_OFFSET(address16, source.string),
    }
)
TEST_CASE_AML(
    WordSpace,
    {
        /*
         * WordSpace(
         *     0xCC, ResourceProducer, PosDecode, MinNotFixed, MaxFixed,
         *     0xFF, 0xDEAD, 0xBEEF, 0xCAFE, 0xBABE, 0xFEFE, 222,
         *     "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^NAME",
         *     NAM0
         * )
         */
        0x88, 0x58, 0x00, 0xCC, 0x08, 0xFF, 0xAD, 0xDE,
        0xEF, 0xBE, 0xFE, 0xCA, 0xBE, 0xBA, 0xFE, 0xFE,
        0xDE, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x4E, 0x41,
        0x4D, 0x45, 0x00,

        /*
         * WordSpace(
         *     0xFF, ResourceConsumer, SubDecode, MinFixed, MaxNotFixed,
         *     0xFE, 0xC0DE, 0xDEAD, 0xFEFE, 0xCAFE, 0xBABE, , , NAM1
         * )
         */
        0x88, 0x0D, 0x00, 0xFF, 0x07, 0xFE, 0xDE, 0xC0,
        0xAD, 0xDE, 0xFE, 0xFE, 0xFE, 0xCA, 0xBE, 0xBA,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    WordSpace,
    {
        UACPI_RESOURCE_TYPE_ADDRESS16,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
        0xFF, 0x00, 0x00, 0x00, 0xCC, 0x00, 0x00, 0x00,
        0x01, 0x00, 0xAD, 0xDE, 0xEF, 0xBE, 0xFE, 0xCA,
        0xBE, 0xBA, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00,
        0xDE, 0x01, 0x4A, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x4E, 0x41, 0x4D,
        0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_ADDRESS16,
        0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
        0xFE, 0x00, 0x00, 0x00, 0xFF, 0x01, 0x01, 0x01,
        0x00, 0x00, 0xDE, 0xC0, 0xAD, 0xDE, 0xFE, 0xFE,
        0xFE, 0xCA, 0xBE, 0xBA, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    WordSpace,
    {
        NATIVE_OFFSET(address16, source.string),
    }
)
TEST_CASE_AML(
    DWordIO,
    {
        /*
         * DWordIO(
         *     ResourceProducer, MinNotFixed, MaxFixed, PosDecode,
         *     EntireRange, 0x2AE24C2F, 0x10F2D54B, 0x848D3687,
         *     0x38A29766, 0x7F1205E0, 111, "X", NAM0, TypeStatic,
         *     SparseTranslation
         * )
         */
        0x87, 0x1A, 0x00, 0x01, 0x08, 0x23, 0x2F, 0x4C,
        0xE2, 0x2A, 0x4B, 0xD5, 0xF2, 0x10, 0x87, 0x36,
        0x8D, 0x84, 0x66, 0x97, 0xA2, 0x38, 0xE0, 0x05,
        0x12, 0x7F, 0x6F, 0x58, 0x00,

        /*
         * DWordIO(
         *     ResourceConsumer, MinFixed, MaxNotFixed, SubDecode,
         *     EntireRange, 0xEA7A787E, 0x5F3C8592, 0xD42E05FD,
         *     0xC889C763, 0xA078F607, , , NAM1, TypeTranslation,
         *     DenseTranslation
         * )
         */
        0x87, 0x17, 0x00, 0x01, 0x07, 0x13, 0x7E, 0x78,
        0x7A, 0xEA, 0x92, 0x85, 0x3C, 0x5F, 0xFD, 0x05,
        0x2E, 0xD4, 0x63, 0xC7, 0x89, 0xC8, 0x07, 0xF6,
        0x78, 0xA0,

        /*
         * NOTE:
         * This one is technically buggy as it doesn't include a source
         * string but still has a valid source index. We support this
         * use case as well.
         *
         * DWordIO(
         *     ResourceConsumer, MinFixed, MaxNotFixed, SubDecode,
         *     EntireRange, 0xEA7A787E, 0x5F3C8592, 0xD42E05FD,
         *     0xC889C763, 0xA078F607, 222, , NAM1, TypeTranslation,
         *     DenseTranslation
         * )
         */
        0x87, 0x18, 0x00, 0x01, 0x07, 0x13, 0x7E, 0x78,
        0x7A, 0xEA, 0x92, 0x85, 0x3C, 0x5F, 0xFD, 0x05,
        0x2E, 0xD4, 0x63, 0xC7, 0x89, 0xC8, 0x07, 0xF6,
        0x78, 0xA0, 0xDE,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    DWordIO,
    {
        UACPI_RESOURCE_TYPE_ADDRESS32,
        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
        0x03, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x2F, 0x4C, 0xE2, 0x2A,
        0x4B, 0xD5, 0xF2, 0x10, 0x87, 0x36, 0x8D, 0x84,
        0x66, 0x97, 0xA2, 0x38, 0xE0, 0x05, 0x12, 0x7F,
        0x6F, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_ADDRESS32,
        0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
        0x03, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x7E, 0x78, 0x7A, 0xEA,
        0x92, 0x85, 0x3C, 0x5F, 0xFD, 0x05, 0x2E, 0xD4,
        0x63, 0xC7, 0x89, 0xC8, 0x07, 0xF6, 0x78, 0xA0,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_ADDRESS32,
        0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
        0x03, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x7E, 0x78, 0x7A, 0xEA,
        0x92, 0x85, 0x3C, 0x5F, 0xFD, 0x05, 0x2E, 0xD4,
        0x63, 0xC7, 0x89, 0xC8, 0x07, 0xF6, 0x78, 0xA0,
        0xDE, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    DWordIO,
    {
        NATIVE_OFFSET(address32, source.string),
    }
)
TEST_CASE_AML(
    DWordMemory,
    {
        /*
         * DWordMemory(
         *     ResourceConsumer, SubDecode, MinFixed, MaxNotFixed, NonCacheable,
         *     ReadOnly, 0xEA7A787E, 0x5F3C8592, 0xD42E05FD, 0xC889C763,
         *     0xA078F607, , , NAM0, AddressRangeMemory, TypeStatic
         * )
         */
        0x87, 0x17, 0x00, 0x00, 0x07, 0x00, 0x7E, 0x78,
        0x7A, 0xEA, 0x92, 0x85, 0x3C, 0x5F, 0xFD, 0x05,
        0x2E, 0xD4, 0x63, 0xC7, 0x89, 0xC8, 0x07, 0xF6,
        0x78, 0xA0,

        /*
         * DWordMemory(
         *     ResourceProducer, PosDecode, MinNotFixed, MaxFixed, Prefetchable,
         *     ReadWrite, 0x2AE24C2F, 0x10F2D54B, 0x848D3687, 0x38A29766,
         *     0x2AE24C2F, 5, "XXXX.YYYY.ZZZZ.VVVV.YYYY", NAM1,
         *     AddressRangeNVS, TypeTranslation
         * )
         */
        0x87, 0x31, 0x00, 0x00, 0x08, 0x3F, 0x2F, 0x4C,
        0xE2, 0x2A, 0x4B, 0xD5, 0xF2, 0x10, 0x87, 0x36,
        0x8D, 0x84, 0x66, 0x97, 0xA2, 0x38, 0x2F, 0x4C,
        0xE2, 0x2A, 0x05, 0x58, 0x58, 0x58, 0x58, 0x2E,
        0x59, 0x59, 0x59, 0x59, 0x2E, 0x5A, 0x5A, 0x5A,
        0x5A, 0x2E, 0x56, 0x56, 0x56, 0x56, 0x2E, 0x59,
        0x59, 0x59, 0x59, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    DWordMemory,
    {
        UACPI_RESOURCE_TYPE_ADDRESS32,
        0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x7E, 0x78, 0x7A, 0xEA,
        0x92, 0x85, 0x3C, 0x5F, 0xFD, 0x05, 0x2E, 0xD4,
        0x63, 0xC7, 0x89, 0xC8, 0x07, 0xF6, 0x78, 0xA0,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_ADDRESS32,
        0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
        0x01, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x2F, 0x4C, 0xE2, 0x2A,
        0x4B, 0xD5, 0xF2, 0x10, 0x87, 0x36, 0x8D, 0x84,
        0x66, 0x97, 0xA2, 0x38, 0x2F, 0x4C, 0xE2, 0x2A,
        0x05, 0x01, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x58, 0x58, 0x58, 0x58, 0x2E, 0x59, 0x59, 0x59,
        0x59, 0x2E, 0x5A, 0x5A, 0x5A, 0x5A, 0x2E, 0x56,
        0x56, 0x56, 0x56, 0x2E, 0x59, 0x59, 0x59, 0x59,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    DWordMemory,
    {
        0x38 + NATIVE_OFFSET(address32, source.string),
    }
)
TEST_CASE_AML(
    DWordSpace,
    {
        /*
         * DWordSpace(
         *     0xEE, ResourceProducer, PosDecode, MinNotFixed, MaxFixed,
         *     0xFF, 0x38A29766, 0x7F1205E0, 0x2AE24C2F, 0x10F2D54B,
         *     0x848D3687, 99, "\\_ABC.DEFG.HIJK.LMNO.PQRS.T123", NAM0
         * )
         */
        0x87, 0x37, 0x00, 0xEE, 0x08, 0xFF, 0x66, 0x97,
        0xA2, 0x38, 0xE0, 0x05, 0x12, 0x7F, 0x2F, 0x4C,
        0xE2, 0x2A, 0x4B, 0xD5, 0xF2, 0x10, 0x87, 0x36,
        0x8D, 0x84, 0x63, 0x5C, 0x5F, 0x41, 0x42, 0x43,
        0x2E, 0x44, 0x45, 0x46, 0x47, 0x2E, 0x48, 0x49,
        0x4A, 0x4B, 0x2E, 0x4C, 0x4D, 0x4E, 0x4F, 0x2E,
        0x50, 0x51, 0x52, 0x53, 0x2E, 0x54, 0x31, 0x32,
        0x33, 0x00,

        /*
         * DWordSpace(
         *     0xAA, ResourceConsumer, SubDecode, MinFixed, MaxNotFixed,
         *     0xFE, 0xEA7A787E, 0xD42E05FD, 0x5F3C8592, 0xC889C763,
         *     0xA078F607, , , NAM1
         * )
         */
        0x87, 0x17, 0x00, 0xAA, 0x07, 0xFE, 0x7E, 0x78,
        0x7A, 0xEA, 0xFD, 0x05, 0x2E, 0xD4, 0x92, 0x85,
        0x3C, 0x5F, 0x63, 0xC7, 0x89, 0xC8, 0x07, 0xF6,
        0x78, 0xA0,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    DWordSpace,
    {
        UACPI_RESOURCE_TYPE_ADDRESS32,
        0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
        0xFF, 0x00, 0x00, 0x00, 0xEE, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x66, 0x97, 0xA2, 0x38,
        0xE0, 0x05, 0x12, 0x7F, 0x2F, 0x4C, 0xE2, 0x2A,
        0x4B, 0xD5, 0xF2, 0x10, 0x87, 0x36, 0x8D, 0x84,
        0x63, 0x01, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x5C, 0x5F, 0x41, 0x42, 0x43, 0x2E, 0x44, 0x45,
        0x46, 0x47, 0x2E, 0x48, 0x49, 0x4A, 0x4B, 0x2E,
        0x4C, 0x4D, 0x4E, 0x4F, 0x2E, 0x50, 0x51, 0x52,
        0x53, 0x2E, 0x54, 0x31, 0x32, 0x33, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_ADDRESS32,
        0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
        0xFE, 0x00, 0x00, 0x00, 0xAA, 0x01, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x7E, 0x78, 0x7A, 0xEA,
        0xFD, 0x05, 0x2E, 0xD4, 0x92, 0x85, 0x3C, 0x5F,
        0x63, 0xC7, 0x89, 0xC8, 0x07, 0xF6, 0x78, 0xA0,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    DWordSpace,
    {
        NATIVE_OFFSET(address32, source.string),
    }
)
TEST_CASE_AML(
    QWordIO,
    {
        /*
         * QWordIO(
         *      ResourceProducer, MinNotFixed, MaxFixed, PosDecode,
         *      EntireRange, 0xD401ABB6C6048FA9, 0xF3F20E18BD15E1D5,
         *      0x31BBE56235B1AB20, 0xA43E084A1A3BC70C,
         *      0xCC3968467E68A405, 22, "1234.5678.9101.1112.1314.1516",
         *      NAM0, TypeStatic, SparseTranslation
         * )
         */
        0x8A, 0x4A, 0x00, 0x01, 0x08, 0x23, 0xA9, 0x8F,
        0x04, 0xC6, 0xB6, 0xAB, 0x01, 0xD4, 0xD5, 0xE1,
        0x15, 0xBD, 0x18, 0x0E, 0xF2, 0xF3, 0x20, 0xAB,
        0xB1, 0x35, 0x62, 0xE5, 0xBB, 0x31, 0x0C, 0xC7,
        0x3B, 0x1A, 0x4A, 0x08, 0x3E, 0xA4, 0x05, 0xA4,
        0x68, 0x7E, 0x46, 0x68, 0x39, 0xCC, 0x16, 0x31,
        0x32, 0x33, 0x34, 0x2E, 0x35, 0x36, 0x37, 0x38,
        0x2E, 0x39, 0x31, 0x30, 0x31, 0x2E, 0x31, 0x31,
        0x31, 0x32, 0x2E, 0x31, 0x33, 0x31, 0x34, 0x2E,
        0x31, 0x35, 0x31, 0x36, 0x00,

        /*
         * QWordIO(
         *     ResourceConsumer, MinFixed, MaxNotFixed, SubDecode,
         *     EntireRange, 0xC7EBB6149085DF40, 0x837954DC2A5C8993,
         *     0xEBEBB9FBC5BCE78E, 0x5EE869DAFB934632,
         *     0xB39AD97AB253D0ED, , , NAM1, TypeTranslation,
         *     DenseTranslation
         * )
         */
        0x8A, 0x2B, 0x00, 0x01, 0x07, 0x13, 0x40, 0xDF,
        0x85, 0x90, 0x14, 0xB6, 0xEB, 0xC7, 0x93, 0x89,
        0x5C, 0x2A, 0xDC, 0x54, 0x79, 0x83, 0x8E, 0xE7,
        0xBC, 0xC5, 0xFB, 0xB9, 0xEB, 0xEB, 0x32, 0x46,
        0x93, 0xFB, 0xDA, 0x69, 0xE8, 0x5E, 0xED, 0xD0,
        0x53, 0xB2, 0x7A, 0xD9, 0x9A, 0xB3,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    QWordIO,
    {
        UACPI_RESOURCE_TYPE_ADDRESS64,
        0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
        0x03, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xA9, 0x8F, 0x04, 0xC6, 0xB6, 0xAB, 0x01, 0xD4,
        0xD5, 0xE1, 0x15, 0xBD, 0x18, 0x0E, 0xF2, 0xF3,
        0x20, 0xAB, 0xB1, 0x35, 0x62, 0xE5, 0xBB, 0x31,
        0x0C, 0xC7, 0x3B, 0x1A, 0x4A, 0x08, 0x3E, 0xA4,
        0x05, 0xA4, 0x68, 0x7E, 0x46, 0x68, 0x39, 0xCC,
        0x16, 0x01, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x31, 0x32, 0x33, 0x34, 0x2E, 0x35, 0x36, 0x37,
        0x38, 0x2E, 0x39, 0x31, 0x30, 0x31, 0x2E, 0x31,
        0x31, 0x31, 0x32, 0x2E, 0x31, 0x33, 0x31, 0x34,
        0x2E, 0x31, 0x35, 0x31, 0x36, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_ADDRESS64,
        0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
        0x03, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x40, 0xDF, 0x85, 0x90, 0x14, 0xB6, 0xEB, 0xC7,
        0x93, 0x89, 0x5C, 0x2A, 0xDC, 0x54, 0x79, 0x83,
        0x8E, 0xE7, 0xBC, 0xC5, 0xFB, 0xB9, 0xEB, 0xEB,
        0x32, 0x46, 0x93, 0xFB, 0xDA, 0x69, 0xE8, 0x5E,
        0xED, 0xD0, 0x53, 0xB2, 0x7A, 0xD9, 0x9A, 0xB3,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    QWordIO,
    {
        NATIVE_OFFSET(address64, source.string),
    }
)
TEST_CASE_AML(
    QWordMemory,
    {
        /*
         * QWordMemory(
         *     ResourceConsumer, SubDecode, MinFixed, MaxNotFixed, NonCacheable,
         *     ReadOnly, 0xB89195AC379E0043, 0xB149B98A0A8B4D0D, 0x2DF22DCD9553E2F9,
         *     0x7F5CD9F6D6598FC1, 0xE3D4EF59D1C7A0A0, , , NAM0,
         *     AddressRangeMemory, TypeStatic
         * )
         */
        0x8A, 0x2B, 0x00, 0x00, 0x07, 0x00, 0x43, 0x00,
        0x9E, 0x37, 0xAC, 0x95, 0x91, 0xB8, 0x0D, 0x4D,
        0x8B, 0x0A, 0x8A, 0xB9, 0x49, 0xB1, 0xF9, 0xE2,
        0x53, 0x95, 0xCD, 0x2D, 0xF2, 0x2D, 0xC1, 0x8F,
        0x59, 0xD6, 0xF6, 0xD9, 0x5C, 0x7F, 0xA0, 0xA0,
        0xC7, 0xD1, 0x59, 0xEF, 0xD4, 0xE3,

        /*
         * QWordMemory(
         *     ResourceProducer, PosDecode, MinNotFixed, MaxFixed,
         *     Prefetchable, ReadWrite, 0xAA0E73E09AE07CF2,
         *     0x6C1F50103DD99E4F, 0xF8C74B28E1868B3A, 0x685F884F24BC550B,
         *     0x881CF673FE4DA1A6, 15, "^^^^^VVVV.VVVV.VVVV", NAM1,
         *     AddressRangeReserved, TypeTranslation
         * )
         */
        0x8A, 0x40, 0x00, 0x00, 0x08, 0x2F, 0xF2, 0x7C,
        0xE0, 0x9A, 0xE0, 0x73, 0x0E, 0xAA, 0x4F, 0x9E,
        0xD9, 0x3D, 0x10, 0x50, 0x1F, 0x6C, 0x3A, 0x8B,
        0x86, 0xE1, 0x28, 0x4B, 0xC7, 0xF8, 0x0B, 0x55,
        0xBC, 0x24, 0x4F, 0x88, 0x5F, 0x68, 0xA6, 0xA1,
        0x4D, 0xFE, 0x73, 0xF6, 0x1C, 0x88, 0x0F, 0x5E,
        0x5E, 0x5E, 0x5E, 0x5E, 0x56, 0x56, 0x56, 0x56,
        0x2E, 0x56, 0x56, 0x56, 0x56, 0x2E, 0x56, 0x56,
        0x56, 0x56, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    QWordMemory,
    {
        UACPI_RESOURCE_TYPE_ADDRESS64,
        0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x43, 0x00, 0x9E, 0x37, 0xAC, 0x95, 0x91, 0xB8,
        0x0D, 0x4D, 0x8B, 0x0A, 0x8A, 0xB9, 0x49, 0xB1,
        0xF9, 0xE2, 0x53, 0x95, 0xCD, 0x2D, 0xF2, 0x2D,
        0xC1, 0x8F, 0x59, 0xD6, 0xF6, 0xD9, 0x5C, 0x7F,
        0xA0, 0xA0, 0xC7, 0xD1, 0x59, 0xEF, 0xD4, 0xE3,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_ADDRESS64,
        0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
        0x01, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xF2, 0x7C, 0xE0, 0x9A, 0xE0, 0x73, 0x0E, 0xAA,
        0x4F, 0x9E, 0xD9, 0x3D, 0x10, 0x50, 0x1F, 0x6C,
        0x3A, 0x8B, 0x86, 0xE1, 0x28, 0x4B, 0xC7, 0xF8,
        0x0B, 0x55, 0xBC, 0x24, 0x4F, 0x88, 0x5F, 0x68,
        0xA6, 0xA1, 0x4D, 0xFE, 0x73, 0xF6, 0x1C, 0x88,
        0x0F, 0x01, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x5E, 0x5E, 0x5E, 0x5E, 0x5E, 0x56, 0x56, 0x56,
        0x56, 0x2E, 0x56, 0x56, 0x56, 0x56, 0x2E, 0x56,
        0x56, 0x56, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    QWordMemory,
    {
        0x50 + NATIVE_OFFSET(address64, source.string),
    }
)
TEST_CASE_AML(
    QWordSpace,
    {
        /*
         * QWordSpace(
         *     0xFA, ResourceProducer, PosDecode, MinNotFixed, MaxFixed,
         *     0xFF, 0x3FC5C670EA0D6EC7, 0xC892FC19A82058A7,
         *     0x38DD3AB3668E965B, 0xD03B1D464E9B869C,
         *     0xB10BD395D90D5F21, 232, "\\", NAM0
         * )
         */
        0x8A, 0x2E, 0x00, 0xFA, 0x08, 0xFF, 0xC7, 0x6E,
        0x0D, 0xEA, 0x70, 0xC6, 0xC5, 0x3F, 0xA7, 0x58,
        0x20, 0xA8, 0x19, 0xFC, 0x92, 0xC8, 0x5B, 0x96,
        0x8E, 0x66, 0xB3, 0x3A, 0xDD, 0x38, 0x9C, 0x86,
        0x9B, 0x4E, 0x46, 0x1D, 0x3B, 0xD0, 0x21, 0x5F,
        0x0D, 0xD9, 0x95, 0xD3, 0x0B, 0xB1, 0xE8, 0x5C,
        0x00,

        /*
         * QWordSpace(
         *     0xCF, ResourceConsumer, SubDecode, MinFixed, MaxNotFixed,
         *     0xFE, 0xB8201019AA9411D8, 0x80E930538B5BAC9D,
         *     0xAD10C2465E6A44E2, 0x1D3221B49795163F,
         *     0x5D3B10D8FB2F1760, , , NAM1
         * )
         */
        0x8A, 0x2B, 0x00, 0xCF, 0x07, 0xFE, 0xD8, 0x11,
        0x94, 0xAA, 0x19, 0x10, 0x20, 0xB8, 0x9D, 0xAC,
        0x5B, 0x8B, 0x53, 0x30, 0xE9, 0x80, 0xE2, 0x44,
        0x6A, 0x5E, 0x46, 0xC2, 0x10, 0xAD, 0x3F, 0x16,
        0x95, 0x97, 0xB4, 0x21, 0x32, 0x1D, 0x60, 0x17,
        0x2F, 0xFB, 0xD8, 0x10, 0x3B, 0x5D,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    QWordSpace,
    {
        UACPI_RESOURCE_TYPE_ADDRESS64,
        0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
        0xFF, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xC7, 0x6E, 0x0D, 0xEA, 0x70, 0xC6, 0xC5, 0x3F,
        0xA7, 0x58, 0x20, 0xA8, 0x19, 0xFC, 0x92, 0xC8,
        0x5B, 0x96, 0x8E, 0x66, 0xB3, 0x3A, 0xDD, 0x38,
        0x9C, 0x86, 0x9B, 0x4E, 0x46, 0x1D, 0x3B, 0xD0,
        0x21, 0x5F, 0x0D, 0xD9, 0x95, 0xD3, 0x0B, 0xB1,
        0xE8, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_ADDRESS64,
        0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
        0xFE, 0x00, 0x00, 0x00, 0xCF, 0x01, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xD8, 0x11, 0x94, 0xAA, 0x19, 0x10, 0x20, 0xB8,
        0x9D, 0xAC, 0x5B, 0x8B, 0x53, 0x30, 0xE9, 0x80,
        0xE2, 0x44, 0x6A, 0x5E, 0x46, 0xC2, 0x10, 0xAD,
        0x3F, 0x16, 0x95, 0x97, 0xB4, 0x21, 0x32, 0x1D,
        0x60, 0x17, 0x2F, 0xFB, 0xD8, 0x10, 0x3B, 0x5D,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    QWordSpace,
    {
        NATIVE_OFFSET(address64, source.string),
    }
)
TEST_CASE_AML(
    ClockInput,
    {
        /*
         * ClockInput(0xDEADBEEF, 0xC0DE, MHz, Variable,
         *            "\\PATH.XXXX.YYYY", 123)
         */
        0x93, 0x1A, 0x00, 0x01, 0x05, 0x00, 0xDE, 0xC0,
        0xEF, 0xBE, 0xAD, 0xDE, 0x7B, 0x5C, 0x50, 0x41,
        0x54, 0x48, 0x2E, 0x58, 0x58, 0x58, 0x58, 0x2E,
        0x59, 0x59, 0x59, 0x59, 0x00,

        // ClockInput(0xCAFEBABE, 0xBABA, kHz, Fixed, , )
        0x93, 0x0A, 0x00, 0x01, 0x02, 0x00, 0xBA, 0xBA,
        0xBE, 0xBA, 0xFE, 0xCA, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    ClockInput,
    {
        UACPI_RESOURCE_TYPE_CLOCK_INPUT,
        0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
        0x01, 0x01, 0x02, 0x00, 0xDE, 0xC0, 0x00, 0x00,
        0xEF, 0xBE, 0xAD, 0xDE, 0x00, 0x00, 0x00, 0x00,
        0x7B, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x5C, 0x50, 0x41, 0x54, 0x48, 0x2E, 0x58, 0x58,
        0x58, 0x58, 0x2E, 0x59, 0x59, 0x59, 0x59, 0x00,

        UACPI_RESOURCE_TYPE_CLOCK_INPUT,
        0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x01, 0x00, 0xBA, 0xBA, 0x00, 0x00,
        0xBE, 0xBA, 0xFE, 0xCA, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    ClockInput,
    {
        NATIVE_OFFSET(clock_input, source.string),
    }
)
TEST_CASE_AML(
    Interrupt,
    {
        /*
         * Interrupt (ResourceConsumer, Level, ActiveHigh, ExclusiveAndWake,
         *            0xFF, "\\1234.5678.AAAA.BBBB", NAM0)
         *     { 1, 2, 3, 4, 0xDEADBEEF, 0xFFFFFFFF, 0 }
         */
        0x89, 0x34, 0x00, 0x11, 0x07, 0x01, 0x00, 0x00,
        0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
        0x00, 0x04, 0x00, 0x00, 0x00, 0xEF, 0xBE, 0xAD,
        0xDE, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
        0x00, 0xFF, 0x5C, 0x31, 0x32, 0x33, 0x34, 0x2E,
        0x35, 0x36, 0x37, 0x38, 0x2E, 0x41, 0x41, 0x41,
        0x41, 0x2E, 0x42, 0x42, 0x42, 0x42, 0x00,

        /*
         * NOTE:
         * This one is buggy as well, but should be supported as iasl allows
         * generating it just fine.
         *
         * Interrupt (ResourceProducer, Edge, ActiveLow, SharedAndWake,
         *            0xEE, , NAM1)
         *     { 1 }
         */
        0x89, 0x07, 0x00, 0x1E, 0x01, 0x01, 0x00, 0x00,
        0x00, 0xEE,

        /*
         * Interrupt (ResourceProducer, Edge, ActiveLow, Exclusive,
         *            , , NAM2)
         *     { 0xFFFFFFFF }
         */
        0x89, 0x06, 0x00, 0x06, 0x01, 0xFF, 0xFF, 0xFF,
        0xFF,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    Interrupt,
    {
        UACPI_RESOURCE_TYPE_EXTENDED_IRQ,
        0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x01, 0x07, 0x00, 0x00,
        0xFF, 0x01, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
        0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
        0xEF, 0xBE, 0xAD, 0xDE, 0xFF, 0xFF, 0xFF, 0xFF,
        0x00, 0x00, 0x00, 0x00, 0x5C, 0x31, 0x32, 0x33,
        0x34, 0x2E, 0x35, 0x36, 0x37, 0x38, 0x2E, 0x41,
        0x41, 0x41, 0x41, 0x2E, 0x42, 0x42, 0x42, 0x42,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_EXTENDED_IRQ,
        0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
        0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
        0xEE, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_EXTENDED_IRQ,
        0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
        0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    Interrupt,
    {
        NATIVE_OFFSET(extended_irq, source.string),
    }
)
TEST_CASE_AML(
    GpioIO,
    {
        /*
         * GpioIo(Shared, PullUp, 0xCAFE, 0xBABE, IoRestrictionOutputOnly,
         *        "\\1234.5678.AAAA.BBBB", 0xFA, ResourceConsumer, NAM0,
         *        RawDataBuffer (34) {
         *             0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0x0C,
         *             0x65, 0x90, 0xB0, 0xE0, 0x10, 0xC8, 0x96, 0xA6,
         *             0x96, 0x80, 0x5A, 0xA8, 0xA7, 0x06, 0xC5, 0x77,
         *             0xD8, 0xA7, 0x67, 0x53, 0xE3, 0x86, 0x03, 0x39,
         *             0xDC, 0xBE,
         *         })
         *     { 0xACDC, 0, 1, 0xFFFF, 0xDEAD }
         */
        0x8C, 0x55, 0x00, 0x01, 0x01, 0x01, 0x00, 0x0A,
        0x00, 0x01, 0xBE, 0xBA, 0xFE, 0xCA, 0x17, 0x00,
        0xFA, 0x21, 0x00, 0x36, 0x00, 0x22, 0x00, 0xDC,
        0xAC, 0x00, 0x00, 0x01, 0x00, 0xFF, 0xFF, 0xAD,
        0xDE, 0x5C, 0x31, 0x32, 0x33, 0x34, 0x2E, 0x35,
        0x36, 0x37, 0x38, 0x2E, 0x41, 0x41, 0x41, 0x41,
        0x2E, 0x42, 0x42, 0x42, 0x42, 0x00, 0x44, 0xA6,
        0x5A, 0x82, 0x83, 0x57, 0x7D, 0x0C, 0x65, 0x90,
        0xB0, 0xE0, 0x10, 0xC8, 0x96, 0xA6, 0x96, 0x80,
        0x5A, 0xA8, 0xA7, 0x06, 0xC5, 0x77, 0xD8, 0xA7,
        0x67, 0x53, 0xE3, 0x86, 0x03, 0x39, 0xDC, 0xBE,

        /*
         * GpioIo(Exclusive, PullNone, 0xDEAD, 0xBEEF,
         *        IORestrictionNoneAndPreserve, "\\BBBB",
         *        0xDD, ResourceConsumer, NAM0, )
         *     { 0xACDC, 0, 1, 0xFFFF, 0xDEAD }
         */
        0x8C, 0x24, 0x00, 0x01, 0x01, 0x01, 0x00, 0x03,
        0x00, 0x03, 0xEF, 0xBE, 0xAD, 0xDE, 0x17, 0x00,
        0xDD, 0x21, 0x00, 0x27, 0x00, 0x00, 0x00, 0xDC,
        0xAC, 0x00, 0x00, 0x01, 0x00, 0xFF, 0xFF, 0xAD,
        0xDE, 0x5C, 0x42, 0x42, 0x42, 0x42, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    GpioIO,
    {
        UACPI_RESOURCE_TYPE_GPIO_CONNECTION,
        0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00,
        0x01, 0x01, 0x01, 0x00, 0x02, 0x01, 0x00, 0x00,
        0x01, 0x00, 0xBE, 0xBA, 0xFE, 0xCA, 0x22, 0x00,
        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xFA, 0x01, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pin_table
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // vendor_data
        0xDC, 0xAC, 0x00, 0x00, 0x01, 0x00, 0xFF, 0xFF,
        0xAD, 0xDE, 0x5C, 0x31, 0x32, 0x33, 0x34, 0x2E,
        0x35, 0x36, 0x37, 0x38, 0x2E, 0x41, 0x41, 0x41,
        0x41, 0x2E, 0x42, 0x42, 0x42, 0x42, 0x00, 0x44,
        0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0x0C, 0x65,
        0x90, 0xB0, 0xE0, 0x10, 0xC8, 0x96, 0xA6, 0x96,
        0x80, 0x5A, 0xA8, 0xA7, 0x06, 0xC5, 0x77, 0xD8,
        0xA7, 0x67, 0x53, 0xE3, 0x86, 0x03, 0x39, 0xDC,
        0xBE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_GPIO_CONNECTION,
        0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
        0x01, 0x01, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00,
        0x03, 0x00, 0xEF, 0xBE, 0xAD, 0xDE, 0x00, 0x00,
        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xDD, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pin_table
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xDC, 0xAC, 0x00, 0x00, 0x01, 0x00, 0xFF, 0xFF,
        0xAD, 0xDE, 0x5C, 0x42, 0x42, 0x42, 0x42, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    GpioIO,
    {
        NATIVE_OFFSET(gpio_connection, source.string),
        NATIVE_OFFSET(gpio_connection, pin_table),
        NATIVE_OFFSET(gpio_connection, vendor_data),

        0x88 + NATIVE_OFFSET(gpio_connection, source.string),
        0x88 + NATIVE_OFFSET(gpio_connection, pin_table),
    }
)
TEST_CASE_AML(
    GpioInt,
    {
        /*
         * GpioInt (Edge , ActiveBoth, ExclusiveAndWake, PullUp, 0xAABB,
         *          "^^^ABCD.EFGH.IJKL", 0xFE, ResourceConsumer, NAM0,
         *          RawDataBuffer (34) {
         *               0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0x0C,
         *               0x65, 0x90, 0xB0, 0xE0, 0x10, 0xC8, 0x96, 0xA6,
         *               0x96, 0x80, 0x5A, 0xA8, 0xA7, 0x06, 0xC5, 0x77,
         *               0xD8, 0xA7, 0x67, 0x53, 0xE3, 0x86, 0x03, 0x39,
         *               0xDC, 0xBE,
         *         })
         *     { 0xC0DE }
         */
        0x8C, 0x4A, 0x00, 0x01, 0x00, 0x01, 0x00, 0x15,
        0x00, 0x01, 0x00, 0x00, 0xBB, 0xAA, 0x17, 0x00,
        0xFE, 0x19, 0x00, 0x2B, 0x00, 0x22, 0x00, 0xDE,
        0xC0, 0x5E, 0x5E, 0x5E, 0x41, 0x42, 0x43, 0x44,
        0x2E, 0x45, 0x46, 0x47, 0x48, 0x2E, 0x49, 0x4A,
        0x4B, 0x4C, 0x00, 0x44, 0xA6, 0x5A, 0x82, 0x83,
        0x57, 0x7D, 0x0C, 0x65, 0x90, 0xB0, 0xE0, 0x10,
        0xC8, 0x96, 0xA6, 0x96, 0x80, 0x5A, 0xA8, 0xA7,
        0x06, 0xC5, 0x77, 0xD8, 0xA7, 0x67, 0x53, 0xE3,
        0x86, 0x03, 0x39, 0xDC, 0xBE,

        /*
         * GpioInt (Edge, ActiveBoth, ExclusiveAndWake, PullUp, 0xAABB,
         *          "X", 0xAB, ResourceConsumer, NAM0)
         *     { 0xDEAD }
         */
        0x8C, 0x18, 0x00, 0x01, 0x00, 0x01, 0x00, 0x15,
        0x00, 0x01, 0x00, 0x00, 0xBB, 0xAA, 0x17, 0x00,
        0xAB, 0x19, 0x00, 0x1B, 0x00, 0x00, 0x00, 0xAD,
        0xDE, 0x58, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    GpioInt,
    {
        UACPI_RESOURCE_TYPE_GPIO_CONNECTION,
        0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x01,
        0x01, 0x00, 0x00, 0x00, 0xBB, 0xAA, 0x22, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xFE, 0x01, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x32, 0x86, 0x64, 0xE2, 0xCD, 0x01, 0x00, 0x00,
        0x30, 0x86, 0x64, 0xE2, 0xCD, 0x01, 0x00, 0x00,
        0x44, 0x86, 0x64, 0xE2, 0xCD, 0x01, 0x00, 0x00,
        0xDE, 0xC0, 0x5E, 0x5E, 0x5E, 0x41, 0x42, 0x43,
        0x44, 0x2E, 0x45, 0x46, 0x47, 0x48, 0x2E, 0x49,
        0x4A, 0x4B, 0x4C, 0x00, 0x44, 0xA6, 0x5A, 0x82,
        0x83, 0x57, 0x7D, 0x0C, 0x65, 0x90, 0xB0, 0xE0,
        0x10, 0xC8, 0x96, 0xA6, 0x96, 0x80, 0x5A, 0xA8,
        0xA7, 0x06, 0xC5, 0x77, 0xD8, 0xA7, 0x67, 0x53,
        0xE3, 0x86, 0x03, 0x39, 0xDC, 0xBE, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_GPIO_CONNECTION,
        0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x01,
        0x01, 0x00, 0x00, 0x00, 0xBB, 0xAA, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xAB, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xAA, 0x86, 0x64, 0xE2, 0xCD, 0x01, 0x00, 0x00,
        0xA8, 0x86, 0x64, 0xE2, 0xCD, 0x01, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xAD, 0xDE, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    GpioInt,
    {
        NATIVE_OFFSET(gpio_connection, source.string),
        NATIVE_OFFSET(gpio_connection, pin_table),
        NATIVE_OFFSET(gpio_connection, vendor_data),

        0x78 + NATIVE_OFFSET(gpio_connection, source.string),
        0x78 + NATIVE_OFFSET(gpio_connection, pin_table),
    }
)
TEST_CASE_AML(
    PinFunction,
    {
        /*
         * PinFunction(
         *     Exclusive, PullDefault, 0xDEAD,
         *     "string which uniquely identifies the GPIO controller
         *      referred to by this descriptor", , ResourceConsumer, , )
         *     {
         *         0x4453, 0x4454, 0x4A02, 0xF075,
         *         0x5445, 0x5354, 0x5453, 0x5454,
         *         0x41
         *     }
         */
        0x8D, 0x75, 0x00, 0x01, 0x00, 0x00, 0x00, 0xAD,
        0xDE, 0x12, 0x00, 0x00, 0x24, 0x00, 0x78, 0x00,
        0x00, 0x00, 0x53, 0x44, 0x54, 0x44, 0x02, 0x4A,
        0x75, 0xF0, 0x45, 0x54, 0x54, 0x53, 0x53, 0x54,
        0x54, 0x54, 0x41, 0x00, 0x73, 0x74, 0x72, 0x69,
        0x6E, 0x67, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68,
        0x20, 0x75, 0x6E, 0x69, 0x71, 0x75, 0x65, 0x6C,
        0x79, 0x20, 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69,
        0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65,
        0x20, 0x47, 0x50, 0x49, 0x4F, 0x20, 0x63, 0x6F,
        0x6E, 0x74, 0x72, 0x6F, 0x6C, 0x6C, 0x65, 0x72,
        0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72, 0x65,
        0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x79, 0x20,
        0x74, 0x68, 0x69, 0x73, 0x20, 0x64, 0x65, 0x73,
        0x63, 0x72, 0x69, 0x70, 0x74, 0x6F, 0x72, 0x00,

        /*
         * PinFunction(
         *     Exclusive, PullDefault, 0xDEAD,
         *     "", 0xFF, ResourceConsumer, ,
         *     RawDataBuffer (9) {
         *         0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D,
         *         0xDC, 0xBE,
         *      })
         *     {
         *         0xDEAD, 0xC0DE, 0xBEEF, 0xCAFE
         *     }
         */
        0x8D, 0x21, 0x00, 0x01, 0x00, 0x00, 0x00, 0xAD,
        0xDE, 0x12, 0x00, 0xFF, 0x1A, 0x00, 0x1B, 0x00,
        0x09, 0x00, 0xAD, 0xDE, 0xDE, 0xC0, 0xEF, 0xBE,
        0xFE, 0xCA, 0x00, 0x44, 0xA6, 0x5A, 0x82, 0x83,
        0x57, 0x7D, 0xDC, 0xBE,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    PinFunction,
    {
        UACPI_RESOURCE_TYPE_PIN_FUNCTION,
        0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0xAD, 0xDE, 0x09, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x01, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pin_table
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x53, 0x44, 0x54, 0x44, 0x02, 0x4A, 0x75, 0xF0,
        0x45, 0x54, 0x54, 0x53, 0x53, 0x54, 0x54, 0x54,
        0x41, 0x00, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67,
        0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x75,
        0x6E, 0x69, 0x71, 0x75, 0x65, 0x6C, 0x79, 0x20,
        0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x66, 0x69,
        0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x47,
        0x50, 0x49, 0x4F, 0x20, 0x63, 0x6F, 0x6E, 0x74,
        0x72, 0x6F, 0x6C, 0x6C, 0x65, 0x72, 0x20, 0x72,
        0x65, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x20,
        0x74, 0x6F, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68,
        0x69, 0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72,
        0x69, 0x70, 0x74, 0x6F, 0x72, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_PIN_FUNCTION,
        0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00, 0x00, 0xAD, 0xDE, 0x04, 0x00,
        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xFF, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pin_table
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // vendor_data
        0xAD, 0xDE, 0xDE, 0xC0, 0xEF, 0xBE, 0xFE, 0xCA,
        0x00, 0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D,
        0xDC, 0xBE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    PinFunction,
    {
        NATIVE_OFFSET(pin_function, source.string),
        NATIVE_OFFSET(pin_function, pin_table),

        0xA0 + NATIVE_OFFSET(pin_function, source.string),
        0xA0 + NATIVE_OFFSET(pin_function, pin_table),
        0xA0 + NATIVE_OFFSET(pin_function, vendor_data),
    }
)
TEST_CASE_AML(
    PinConfig,
    {
        /*
         * PinConfig(
         *     Exclusive, 0x0B, 0xDEADBEEF,
         *     "\\DEAD.BEEF", 0xAB, ResourceConsumer, ,
         *     RawDataBuffer (9) {
         *         0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D,
         *         0xDC, 0xBE,
         *      })
         *     {
         *         0xDEAD, 0xC0DE
         *     }
         */
        0x8F, 0x29, 0x00, 0x01, 0x02, 0x00, 0x0B, 0xEF,
        0xBE, 0xAD, 0xDE, 0x14, 0x00, 0xAB, 0x18, 0x00,
        0x23, 0x00, 0x09, 0x00, 0xAD, 0xDE, 0xDE, 0xC0,
        0x5C, 0x44, 0x45, 0x41, 0x44, 0x2E, 0x42, 0x45,
        0x45, 0x46, 0x00, 0x44, 0xA6, 0x5A, 0x82, 0x83,
        0x57, 0x7D, 0xDC, 0xBE,

        /*
         * PinConfig(
         *     Shared, 0x05, 0xCAFEBABE,
         *     "123", 0xCD, ResourceConsumer, , )
         *     {
         *         0
         *     }
         */
        0x8F, 0x17, 0x00, 0x01, 0x03, 0x00, 0x05, 0xBE,
        0xBA, 0xFE, 0xCA, 0x14, 0x00, 0xCD, 0x16, 0x00,
        0x1A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x32,
        0x33, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    PinConfig,
    {
        UACPI_RESOURCE_TYPE_PIN_CONFIGURATION,
        0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x01, 0x0B, 0xEF, 0xBE, 0xAD, 0xDE,
        0x02, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xAB, 0x01, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pin_table
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // vendor_data
        0xAD, 0xDE, 0xDE, 0xC0, 0x5C, 0x44, 0x45, 0x41,
        0x44, 0x2E, 0x42, 0x45, 0x45, 0x46, 0x00, 0x44,
        0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0xDC, 0xBE,

        UACPI_RESOURCE_TYPE_PIN_CONFIGURATION,
        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
        0x01, 0x01, 0x01, 0x05, 0xBE, 0xBA, 0xFE, 0xCA,
        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xCD, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pin_table
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    PinConfig,
    {
        NATIVE_OFFSET(pin_configuration, source.string),
        NATIVE_OFFSET(pin_configuration, pin_table),
        NATIVE_OFFSET(pin_configuration, vendor_data),

        0x50 + NATIVE_OFFSET(pin_function, source.string),
        0x50 + NATIVE_OFFSET(pin_function, pin_table),
    }
)
TEST_CASE_AML(
    PinGroup,
    {
        /*
         * PinGroup(
         *     "arbitrary, non-empty string that uniquely identifies this
         *      particular PinGroup",
         *     ResourceProducer , , RawDataBuffer (9) {
         *         0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D,
         *         0xDC, 0xBE,
         *      })
         *     { 0xDEAD }
         */
        0x90, 0x64, 0x00, 0x01, 0x00, 0x00, 0x0E, 0x00,
        0x10, 0x00, 0x5E, 0x00, 0x09, 0x00, 0xAD, 0xDE,
        0x61, 0x72, 0x62, 0x69, 0x74, 0x72, 0x61, 0x72,
        0x79, 0x2C, 0x20, 0x6E, 0x6F, 0x6E, 0x2D, 0x65,
        0x6D, 0x70, 0x74, 0x79, 0x20, 0x73, 0x74, 0x72,
        0x69, 0x6E, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74,
        0x20, 0x75, 0x6E, 0x69, 0x71, 0x75, 0x65, 0x6C,
        0x79, 0x20, 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69,
        0x66, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x69,
        0x73, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
        0x75, 0x6C, 0x61, 0x72, 0x20, 0x50, 0x69, 0x6E,
        0x47, 0x72, 0x6F, 0x75, 0x70, 0x00, 0x44, 0xA6,
        0x5A, 0x82, 0x83, 0x57, 0x7D, 0xDC, 0xBE,

        /*
         * PinGroup("PinGroup", ResourceProducer , , )
         *     { 0xDEAD, 0xBEEF, 0xCAFE, 0xBABE }
         */
        0x90, 0x1C, 0x00, 0x01, 0x00, 0x00, 0x0E, 0x00,
        0x16, 0x00, 0x1F, 0x00, 0x00, 0x00, 0xAD, 0xDE,
        0xEF, 0xBE, 0xFE, 0xCA, 0xBE, 0xBA, 0x50, 0x69,
        0x6E, 0x47, 0x72, 0x6F, 0x75, 0x70, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    PinGroup,
    {
        UACPI_RESOURCE_TYPE_PIN_GROUP,
        0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x01, 0x00, 0x09, 0x00, 0x00, 0x00,
        0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // label.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pin_table
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // vendor_data
        0xAD, 0xDE, 0x61, 0x72, 0x62, 0x69, 0x74, 0x72,
        0x61, 0x72, 0x79, 0x2C, 0x20, 0x6E, 0x6F, 0x6E,
        0x2D, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x73,
        0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x68,
        0x61, 0x74, 0x20, 0x75, 0x6E, 0x69, 0x71, 0x75,
        0x65, 0x6C, 0x79, 0x20, 0x69, 0x64, 0x65, 0x6E,
        0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74,
        0x68, 0x69, 0x73, 0x20, 0x70, 0x61, 0x72, 0x74,
        0x69, 0x63, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x50,
        0x69, 0x6E, 0x47, 0x72, 0x6F, 0x75, 0x70, 0x00,
        0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0xDC,
        0xBE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_PIN_GROUP,
        0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // label.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pin_table
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xAD, 0xDE, 0xEF, 0xBE, 0xFE, 0xCA, 0xBE, 0xBA,
        0x50, 0x69, 0x6E, 0x47, 0x72, 0x6F, 0x75, 0x70,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    PinGroup,
    {
        NATIVE_OFFSET(pin_group, label.string),
        NATIVE_OFFSET(pin_group, pin_table),
        NATIVE_OFFSET(pin_group, vendor_data),

        0x90 + NATIVE_OFFSET(pin_group, label.string),
        0x90 + NATIVE_OFFSET(pin_group, pin_table),
    }
)
TEST_CASE_AML(
    PinGroupFunction,
    {
        /*
         * PinGroupFunction(
         *     Exclusive, 0xDEAD,
         *     "string that uniquely identifies the GPIO controller", 0xFE,
         *     "non-empty string argument that matches ResourceLabel
         *      of a PinGroup",
         *     ResourceConsumer, , RawDataBuffer (9) {
         *         0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D,
         *         0xDC, 0xBE,
         * })
         */
        0x91, 0x8E, 0x00, 0x01, 0x02, 0x00, 0xAD, 0xDE,
        0xFE, 0x11, 0x00, 0x45, 0x00, 0x88, 0x00, 0x09,
        0x00, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20,
        0x74, 0x68, 0x61, 0x74, 0x20, 0x75, 0x6E, 0x69,
        0x71, 0x75, 0x65, 0x6C, 0x79, 0x20, 0x69, 0x64,
        0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65, 0x73,
        0x20, 0x74, 0x68, 0x65, 0x20, 0x47, 0x50, 0x49,
        0x4F, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x72, 0x6F,
        0x6C, 0x6C, 0x65, 0x72, 0x00, 0x6E, 0x6F, 0x6E,
        0x2D, 0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x73,
        0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x72,
        0x67, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74,
        0x68, 0x61, 0x74, 0x20, 0x6D, 0x61, 0x74, 0x63,
        0x68, 0x65, 0x73, 0x20, 0x52, 0x65, 0x73, 0x6F,
        0x75, 0x72, 0x63, 0x65, 0x4C, 0x61, 0x62, 0x65,
        0x6C, 0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x50,
        0x69, 0x6E, 0x47, 0x72, 0x6F, 0x75, 0x70, 0x00,
        0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0xDC,
        0xBE,

        /*
         * PinGroupFunction(
         *     Shared, 0xBEEF, "asdisdfp", 0xCA, "dsadfodp",
         *     ResourceConsumer, ,
         * )
         */
        0x91, 0x20, 0x00, 0x01, 0x03, 0x00, 0xEF, 0xBE,
        0xCA, 0x11, 0x00, 0x1A, 0x00, 0x23, 0x00, 0x00,
        0x00, 0x61, 0x73, 0x64, 0x69, 0x73, 0x64, 0x66,
        0x70, 0x00, 0x64, 0x73, 0x61, 0x64, 0x66, 0x6F,
        0x64, 0x70, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    PinGroupFunction,
    {
        UACPI_RESOURCE_TYPE_PIN_GROUP_FUNCTION,
        0x00, 0x00, 0x00, 0xB8, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x01, 0x00, 0xAD, 0xDE, 0x09, 0x00,
        0xFE, 0x01, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // label.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // vendor_data
        0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x74,
        0x68, 0x61, 0x74, 0x20, 0x75, 0x6E, 0x69, 0x71,
        0x75, 0x65, 0x6C, 0x79, 0x20, 0x69, 0x64, 0x65,
        0x6E, 0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20,
        0x74, 0x68, 0x65, 0x20, 0x47, 0x50, 0x49, 0x4F,
        0x20, 0x63, 0x6F, 0x6E, 0x74, 0x72, 0x6F, 0x6C,
        0x6C, 0x65, 0x72, 0x00, 0x6E, 0x6F, 0x6E, 0x2D,
        0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x73, 0x74,
        0x72, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x72, 0x67,
        0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x68,
        0x61, 0x74, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68,
        0x65, 0x73, 0x20, 0x52, 0x65, 0x73, 0x6F, 0x75,
        0x72, 0x63, 0x65, 0x4C, 0x61, 0x62, 0x65, 0x6C,
        0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x50, 0x69,
        0x6E, 0x47, 0x72, 0x6F, 0x75, 0x70, 0x00, 0x44,
        0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0xDC, 0xBE,

        UACPI_RESOURCE_TYPE_PIN_GROUP_FUNCTION,
        0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
        0x01, 0x01, 0x01, 0x00, 0xEF, 0xBE, 0x00, 0x00,
        0xCA, 0x01, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // label.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x61, 0x73, 0x64, 0x69, 0x73, 0x64, 0x66, 0x70,
        0x00, 0x64, 0x73, 0x61, 0x64, 0x66, 0x6F, 0x64,
        0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    PinGroupFunction,
    {
        NATIVE_OFFSET(pin_group_function, source.string),
        NATIVE_OFFSET(pin_group_function, label.string),
        NATIVE_OFFSET(pin_group_function, vendor_data),

        0xB8 + NATIVE_OFFSET(pin_group_function, source.string),
        0xB8 + NATIVE_OFFSET(pin_group_function, label.string),
    }
)
TEST_CASE_AML(
    PinGroupConfig,
    {
        /*
         * PinGroupConfig(
         *     Exclusive, 0x06, 0xDEADBEEF,
         *     "string that uniquely identifies the GPIO controller", 0xAB,
         *     "non-empty string argument that matches ResourceLabel
         *      of a PinGroup",
         *     ResourceConsumer, , RawDataBuffer (2) {
         *         0x44, 0xA6
         * })
         */
        0x92, 0x8A, 0x00, 0x01, 0x02, 0x00, 0x06, 0xEF,
        0xBE, 0xAD, 0xDE, 0xAB, 0x14, 0x00, 0x48, 0x00,
        0x8B, 0x00, 0x02, 0x00, 0x73, 0x74, 0x72, 0x69,
        0x6E, 0x67, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20,
        0x75, 0x6E, 0x69, 0x71, 0x75, 0x65, 0x6C, 0x79,
        0x20, 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x66,
        0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20,
        0x47, 0x50, 0x49, 0x4F, 0x20, 0x63, 0x6F, 0x6E,
        0x74, 0x72, 0x6F, 0x6C, 0x6C, 0x65, 0x72, 0x00,
        0x6E, 0x6F, 0x6E, 0x2D, 0x65, 0x6D, 0x70, 0x74,
        0x79, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67,
        0x20, 0x61, 0x72, 0x67, 0x75, 0x6D, 0x65, 0x6E,
        0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6D,
        0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x52,
        0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x4C,
        0x61, 0x62, 0x65, 0x6C, 0x20, 0x6F, 0x66, 0x20,
        0x61, 0x20, 0x50, 0x69, 0x6E, 0x47, 0x72, 0x6F,
        0x75, 0x70, 0x00, 0x44, 0xA6,

        /*
         * PinGroupConfig(
         *     Shared, 0x0D, 0xCAFEBABE, "dsadfodp", 0xDF, "x",
         *     ResourceConsumer, ,
         * )
         */
        0x92, 0x1C, 0x00, 0x01, 0x03, 0x00, 0x0D, 0xBE,
        0xBA, 0xFE, 0xCA, 0xDF, 0x14, 0x00, 0x1D, 0x00,
        0x1F, 0x00, 0x00, 0x00, 0x64, 0x73, 0x61, 0x64,
        0x66, 0x6F, 0x64, 0x70, 0x00, 0x78, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    PinGroupConfig,
    {
        UACPI_RESOURCE_TYPE_PIN_GROUP_CONFIGURATION,
        0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x01, 0x06, 0xEF, 0xBE, 0xAD, 0xDE,
        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xAB, 0x01, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // label.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // vendor_data
        0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x74,
        0x68, 0x61, 0x74, 0x20, 0x75, 0x6E, 0x69, 0x71,
        0x75, 0x65, 0x6C, 0x79, 0x20, 0x69, 0x64, 0x65,
        0x6E, 0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20,
        0x74, 0x68, 0x65, 0x20, 0x47, 0x50, 0x49, 0x4F,
        0x20, 0x63, 0x6F, 0x6E, 0x74, 0x72, 0x6F, 0x6C,
        0x6C, 0x65, 0x72, 0x00, 0x6E, 0x6F, 0x6E, 0x2D,
        0x65, 0x6D, 0x70, 0x74, 0x79, 0x20, 0x73, 0x74,
        0x72, 0x69, 0x6E, 0x67, 0x20, 0x61, 0x72, 0x67,
        0x75, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x74, 0x68,
        0x61, 0x74, 0x20, 0x6D, 0x61, 0x74, 0x63, 0x68,
        0x65, 0x73, 0x20, 0x52, 0x65, 0x73, 0x6F, 0x75,
        0x72, 0x63, 0x65, 0x4C, 0x61, 0x62, 0x65, 0x6C,
        0x20, 0x6F, 0x66, 0x20, 0x61, 0x20, 0x50, 0x69,
        0x6E, 0x47, 0x72, 0x6F, 0x75, 0x70, 0x00, 0x44,
        0xA6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_PIN_GROUP_CONFIGURATION,
        0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
        0x01, 0x01, 0x01, 0x0D, 0xBE, 0xBA, 0xFE, 0xCA,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xDF, 0x01, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // label.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x64, 0x73, 0x61, 0x64, 0x66, 0x6F, 0x64, 0x70,
        0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    PinGroupConfig,
    {
        NATIVE_OFFSET(pin_group_configuration, source.string),
        NATIVE_OFFSET(pin_group_configuration, label.string),
        NATIVE_OFFSET(pin_group_configuration, vendor_data),

        0xC0 + NATIVE_OFFSET(pin_group_configuration, source.string),
        0xC0 + NATIVE_OFFSET(pin_group_configuration, label.string),

    }
)
TEST_CASE_AML(
    I2CSerialBusV2,
    {
        /*
         * I2cSerialBusV2(
         *     0xFF68, ControllerInitiated, 0xABC61A8F,
         *     AddressingMode7Bit,
         *     "string which uniquely identifies the I2C bus controller",
         *     0x11, ResourceConsumer, , Exclusive,
         *     RawDataBuffer (9) {
         *         0x44, 0xA6, 0x5A, 0x82,
         *         0x83, 0x57, 0x7D, 0xDC,
         *         0xBE,
         *     }
         * )
         */
        0x8E, 0x50, 0x00, 0x02, 0x11, 0x01, 0x02, 0x00,
        0x00, 0x01, 0x0F, 0x00, 0x8F, 0x1A, 0xC6, 0xAB,
        0x68, 0xFF, 0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57,
        0x7D, 0xDC, 0xBE, 0x73, 0x74, 0x72, 0x69, 0x6E,
        0x67, 0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20,
        0x75, 0x6E, 0x69, 0x71, 0x75, 0x65, 0x6C, 0x79,
        0x20, 0x69, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x66,
        0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20,
        0x49, 0x32, 0x43, 0x20, 0x62, 0x75, 0x73, 0x20,
        0x63, 0x6F, 0x6E, 0x74, 0x72, 0x6F, 0x6C, 0x6C,
        0x65, 0x72, 0x00,

        /*
         * I2cSerialBusV2(
         *     0x1199, DeviceInitiated, 0x23456789,
         *     AddressingMode10Bit, "",
         *     0x22, ResourceConsumer, , Shared,
         * )
         */
        0x8E, 0x10, 0x00, 0x02, 0x22, 0x01, 0x07, 0x01,
        0x00, 0x01, 0x06, 0x00, 0x89, 0x67, 0x45, 0x23,
        0x99, 0x11, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    I2CSerialBusV2,
    {
        UACPI_RESOURCE_TYPE_SERIAL_I2C_CONNECTION,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
        0x02, 0x01, 0x00, 0x01, 0x00, 0x01, 0x0F, 0x00,
        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x11, 0x01, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // vendor_data
        0x00, 0x00, 0x68, 0xFF, 0x8F, 0x1A, 0xC6, 0xAB,
        0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0xDC,
        0xBE, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20,
        0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x75, 0x6E,
        0x69, 0x71, 0x75, 0x65, 0x6C, 0x79, 0x20, 0x69,
        0x64, 0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65,
        0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x49, 0x32,
        0x43, 0x20, 0x62, 0x75, 0x73, 0x20, 0x63, 0x6F,
        0x6E, 0x74, 0x72, 0x6F, 0x6C, 0x6C, 0x65, 0x72,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_SERIAL_I2C_CONNECTION,
        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
        0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x22, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x99, 0x11, 0x89, 0x67, 0x45, 0x23,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    I2CSerialBusV2,
    {
        NATIVE_OFFSET(serial_bus_common, source.string),
        NATIVE_OFFSET(serial_bus_common, vendor_data),

        0x80 + NATIVE_OFFSET(serial_bus_common, source.string),
    }
)
TEST_CASE_AML(
    SPISerialBusV2,
    {
        /*
         * SPISerialBusV2(
         *     0xFF68, PolarityHigh, ThreeWireMode,
         *     0xFE, DeviceInitiated, 0xDEADBEEF,
         *     ClockPolarityLow, ClockPhaseFirst,
         *     "string which uniquely identifies the SPI bus controller",
         *     0xCA, ResourceConsumer, , Exclusive,
         *     RawDataBuffer (9) {
         *         0x44, 0xA6, 0x5A, 0x82,
         *         0x83, 0x57, 0x7D, 0xDC,
         *         0xBE,
         *     }
         * )
         */
        0x8E, 0x53, 0x00, 0x02, 0xCA, 0x02, 0x03, 0x03,
        0x00, 0x01, 0x12, 0x00, 0xEF, 0xBE, 0xAD, 0xDE,
        0xFE, 0x00, 0x00, 0x68, 0xFF, 0x44, 0xA6, 0x5A,
        0x82, 0x83, 0x57, 0x7D, 0xDC, 0xBE, 0x73, 0x74,
        0x72, 0x69, 0x6E, 0x67, 0x20, 0x77, 0x68, 0x69,
        0x63, 0x68, 0x20, 0x75, 0x6E, 0x69, 0x71, 0x75,
        0x65, 0x6C, 0x79, 0x20, 0x69, 0x64, 0x65, 0x6E,
        0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74,
        0x68, 0x65, 0x20, 0x53, 0x50, 0x49, 0x20, 0x62,
        0x75, 0x73, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x72,
        0x6F, 0x6C, 0x6C, 0x65, 0x72, 0x00,

        /*
         * SPISerialBusV2(
         *     0xDABE, PolarityLow, FourWireMode,
         *     0x13, ControllerInitiated, 0x87341812,
         *     ClockPolarityHigh, ClockPhaseSecond, "",
         *     0xCB, ResourceConsumer, , Shared,
         * )
         */
        0x8E, 0x13, 0x00, 0x02, 0xCB, 0x02, 0x06, 0x00,
        0x00, 0x01, 0x09, 0x00, 0x12, 0x18, 0x34, 0x87,
        0x13, 0x01, 0x01, 0xBE, 0xDA, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    SPISerialBusV2,
    {
        UACPI_RESOURCE_TYPE_SERIAL_SPI_CONNECTION,
        0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00,
        0x02, 0x02, 0x01, 0x01, 0x00, 0x01, 0x12, 0x00,
        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xCA, 0x01, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // vendor_data
        0x01, 0x01, 0xFE, 0x00, 0x00, 0x68, 0xFF, 0x00,
        0xEF, 0xBE, 0xAD, 0xDE, 0x00, 0x00, 0x00, 0x00,
        0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0xDC,
        0xBE, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20,
        0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x75, 0x6E,
        0x69, 0x71, 0x75, 0x65, 0x6C, 0x79, 0x20, 0x69,
        0x64, 0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65,
        0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x50,
        0x49, 0x20, 0x62, 0x75, 0x73, 0x20, 0x63, 0x6F,
        0x6E, 0x74, 0x72, 0x6F, 0x6C, 0x6C, 0x65, 0x72,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_SERIAL_SPI_CONNECTION,
        0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
        0x02, 0x02, 0x00, 0x01, 0x01, 0x01, 0x09, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xCB, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x13, 0x01, 0x01, 0xBE, 0xDA, 0x00,
        0x12, 0x18, 0x34, 0x87, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        0x1D, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
    }
)
TEST_CASE_POINTERS(
    SPISerialBusV2,
    {
        NATIVE_OFFSET(serial_bus_common, source.string),
        NATIVE_OFFSET(serial_bus_common, vendor_data),

        0x88 + NATIVE_OFFSET(serial_bus_common, source.string),
    }
)
TEST_CASE_AML(
    UARTSerialBusV2,
    {
        /*
         * UARTSerialBusV2(
         *     0xCAFEBABE, DataBitsFive, StopBitsZero, 0x19,
         *     LittleEndian, ParityTypeMark, FlowControlHardware, 0xABEC,
         *     0xC3BB, "?", 0xCA, ResourceConsumer, , Exclusive,
         * )
         */
        0x8E, 0x15, 0x00, 0x02, 0xCA, 0x03, 0x02, 0x01,
        0x00, 0x01, 0x0A, 0x00, 0xBE, 0xBA, 0xFE, 0xCA,
        0xEC, 0xAB, 0xBB, 0xC3, 0x03, 0x19, 0x3F, 0x00,

        /*
         * UARTSerialBusV2(
         *     0xDEADBEEF, DataBitsNine, StopBitsOnePlusHalf, 0x70,
         *     BigEndian, ParityTypeEven, FlowControlXON, 0xBACE,
         *     0xC1AB, "string which uniquely identifies the UART",
         *     0xB2, ResourceConsumer, , Shared, RawDataBuffer (16) {
         *         0x44, 0xA6, 0x5A, 0x82,
         *         0x83, 0x57, 0x7D, 0xDC,
         *         0x84, 0x56, 0x7A, 0xDD,
         *         0x85, 0x58, 0x7E, 0xDB,
         * })
         */
        0x8E, 0x4D, 0x00, 0x02, 0xB2, 0x03, 0x06, 0xCA,
        0x00, 0x01, 0x1A, 0x00, 0xEF, 0xBE, 0xAD, 0xDE,
        0xCE, 0xBA, 0xAB, 0xC1, 0x01, 0x70, 0x44, 0xA6,
        0x5A, 0x82, 0x83, 0x57, 0x7D, 0xDC, 0x84, 0x56,
        0x7A, 0xDD, 0x85, 0x58, 0x7E, 0xDB, 0x73, 0x74,
        0x72, 0x69, 0x6E, 0x67, 0x20, 0x77, 0x68, 0x69,
        0x63, 0x68, 0x20, 0x75, 0x6E, 0x69, 0x71, 0x75,
        0x65, 0x6C, 0x79, 0x20, 0x69, 0x64, 0x65, 0x6E,
        0x74, 0x69, 0x66, 0x69, 0x65, 0x73, 0x20, 0x74,
        0x68, 0x65, 0x20, 0x55, 0x41, 0x52, 0x54, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    UARTSerialBusV2,
    {
        UACPI_RESOURCE_TYPE_SERIAL_UART_CONNECTION,
        0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
        0x02, 0x03, 0x00, 0x01, 0x00, 0x01, 0x0A, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xCA, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x03, 0x19, 0x01, 0x00, 0x00,
        0xBE, 0xBA, 0xFE, 0xCA, 0xEC, 0xAB, 0xBB, 0xC3,
        0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_SERIAL_UART_CONNECTION,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
        0x02, 0x03, 0x00, 0x01, 0x01, 0x01, 0x1A, 0x00,
        0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xB2, 0x01, 0x2A, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // vendor_data
        0x02, 0x04, 0x01, 0x01, 0x70, 0x02, 0x00, 0x00,
        0xEF, 0xBE, 0xAD, 0xDE, 0xCE, 0xBA, 0xAB, 0xC1,
        0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0xDC,
        0x84, 0x56, 0x7A, 0xDD, 0x85, 0x58, 0x7E, 0xDB,
        0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x77,
        0x68, 0x69, 0x63, 0x68, 0x20, 0x75, 0x6E, 0x69,
        0x71, 0x75, 0x65, 0x6C, 0x79, 0x20, 0x69, 0x64,
        0x65, 0x6E, 0x74, 0x69, 0x66, 0x69, 0x65, 0x73,
        0x20, 0x74, 0x68, 0x65, 0x20, 0x55, 0x41, 0x52,
        0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    UARTSerialBusV2,
    {
        NATIVE_OFFSET(serial_bus_common, source.string),

        0x48 + NATIVE_OFFSET(serial_bus_common, source.string),
        0x48 + NATIVE_OFFSET(serial_bus_common, vendor_data),
    }
)
TEST_CASE_AML(
    CSI2Bus,
    {
        /*
         * CSI2Bus(
         *     DeviceInitiated, 3, 0x2D,
         *     "the remote CSI-2 receiver referred to by this descriptor.",
         *     0x38, ResourceConsumer, ,
         *     RawDataBuffer (16) {
         *         0x44, 0xA6, 0x5A, 0x82,
         *         0x83, 0x57, 0x7D, 0xDC,
         *         0x84, 0x56, 0x7A, 0xDD,
         *         0x85, 0x58, 0x7E, 0xDB,
         * })
         */
        0x8E, 0x53, 0x00, 0x01, 0x38, 0x04, 0x03, 0x2F,
        0x00, 0x01, 0x10, 0x00, 0x44, 0xA6, 0x5A, 0x82,
        0x83, 0x57, 0x7D, 0xDC, 0x84, 0x56, 0x7A, 0xDD,
        0x85, 0x58, 0x7E, 0xDB, 0x74, 0x68, 0x65, 0x20,
        0x72, 0x65, 0x6D, 0x6F, 0x74, 0x65, 0x20, 0x43,
        0x53, 0x49, 0x2D, 0x32, 0x20, 0x72, 0x65, 0x63,
        0x65, 0x69, 0x76, 0x65, 0x72, 0x20, 0x72, 0x65,
        0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x20, 0x74,
        0x6F, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x69,
        0x73, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69,
        0x70, 0x74, 0x6F, 0x72, 0x2E, 0x00,

        /*
         * CSI2Bus(
         *     ControllerInitiated, 2, 0x11, " ",
         *     0x29, ResourceConsumer, ,
         * )
         */
        0x8E, 0x0B, 0x00, 0x01, 0x29, 0x04, 0x02, 0x13,
        0x00, 0x01, 0x00, 0x00, 0x20, 0x00,

        AML_END_TAG,
    }
)
TEST_CASE_NATIVE(
    CSI2Bus,
    {
        UACPI_RESOURCE_TYPE_SERIAL_CSI2_CONNECTION,
        0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00,
        0x01, 0x04, 0x01, 0x01, 0x00, 0x01, 0x10, 0x00,
        0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x38, 0x01, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // vendor_data
        0x03, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x44, 0xA6, 0x5A, 0x82, 0x83, 0x57, 0x7D, 0xDC,
        0x84, 0x56, 0x7A, 0xDD, 0x85, 0x58, 0x7E, 0xDB,
        0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x6D, 0x6F,
        0x74, 0x65, 0x20, 0x43, 0x53, 0x49, 0x2D, 0x32,
        0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65,
        0x72, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72, 0x72,
        0x65, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x79,
        0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x64, 0x65,
        0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6F, 0x72,
        0x2E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        UACPI_RESOURCE_TYPE_SERIAL_CSI2_CONNECTION,
        0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
        0x01, 0x04, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x29, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // source.string
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        NATIVE_END_TAG,
    }
)
TEST_CASE_POINTERS(
    CSI2Bus,
    {
        NATIVE_OFFSET(serial_bus_common, source.string),
        NATIVE_OFFSET(serial_bus_common, vendor_data),

        0x88 + NATIVE_OFFSET(serial_bus_common, source.string),
    }
)

#define TEST_CASE(name)                      \
    {                                        \
        #name,                               \
        res_aml_##name,                      \
        UACPI_ARRAY_SIZE(res_aml_##name),    \
        res_native_##name,                   \
        UACPI_ARRAY_SIZE(res_native_##name), \
        NULL,                                \
        0,                                   \
    }
#define TEST_CASE_PTRS(name)                   \
    {                                          \
        #name,                                 \
        res_aml_##name,                        \
        UACPI_ARRAY_SIZE(res_aml_##name),      \
        res_native_##name,                     \
        UACPI_ARRAY_SIZE(res_native_##name),   \
        res_pointers_##name,                   \
        UACPI_ARRAY_SIZE(res_pointers_##name), \
    }

static const struct test_case test_cases[] = {
    TEST_CASE(IRQ),
    TEST_CASE(DMA),
    TEST_CASE(Start_End_DependentFn),
    TEST_CASE(IO),
    TEST_CASE(FixedIO),
    TEST_CASE(FixedDMA),
    TEST_CASE(Vendor_Short_Long),
    TEST_CASE(Memory_24_32_Fixed32),
    TEST_CASE(Register),
    TEST_CASE(ExtendedIO),
    TEST_CASE(ExtendedMemory),
    TEST_CASE(ExtendedSpace),
    TEST_CASE_PTRS(WordBusNumber),
    TEST_CASE_PTRS(WordIO),
    TEST_CASE_PTRS(WordSpace),
    TEST_CASE_PTRS(DWordIO),
    TEST_CASE_PTRS(DWordMemory),
    TEST_CASE_PTRS(DWordSpace),
    TEST_CASE_PTRS(QWordIO),
    TEST_CASE_PTRS(QWordMemory),
    TEST_CASE_PTRS(QWordSpace),
    TEST_CASE_PTRS(ClockInput),
    TEST_CASE_PTRS(Interrupt),
    TEST_CASE_PTRS(GpioIO),
    TEST_CASE_PTRS(GpioInt),
    TEST_CASE_PTRS(PinFunction),
    TEST_CASE_PTRS(PinConfig),
    TEST_CASE_PTRS(PinGroup),
    TEST_CASE_PTRS(PinGroupFunction),
    TEST_CASE_PTRS(PinGroupConfig),
    TEST_CASE_PTRS(I2CSerialBusV2),
    TEST_CASE_PTRS(SPISerialBusV2),
    TEST_CASE_PTRS(UARTSerialBusV2),
    TEST_CASE_PTRS(CSI2Bus),
};

static bool have_offset(const struct test_case *test, size_t offset)
{
    size_t i;

    for (i = 0; i < test->num_pointer_offsets; i++)
        if (test->pointer_offsets[i] == offset)
            return true;

    return false;
}

void run_resource_tests(void)
{
    size_t fail_count = 0;
    size_t i;

    if (sizeof(void*) == 4) {
        /*
         * Since resource tests do byte-by-byte memcmps it's too much work to
         * make them support multiple bit widths. The current implementation
         * is targeting 64-bit platforms.
         */
        printf("Resource tests only support 64-bit platforms\n");
        return;
    }

    for (i = 0; i < UACPI_ARRAY_SIZE(test_cases); i++) {
        const struct test_case *test = &test_cases[i];
        uacpi_resources *resources;
        uacpi_data_view aml_buffer;
        uint8_t *bytes;
        uacpi_status ret;
        uacpi_object *resource_template = NULL;
        size_t i;

        printf("Running resource test '%s'...", test->name);

        aml_buffer.bytes = test->aml_bytes;
        aml_buffer.length = test->num_aml_bytes;

        ret = uacpi_native_resources_from_aml(aml_buffer, &resources);
        if (uacpi_unlikely_error(ret)) {
            printf("from_aml error: %s\n", uacpi_status_to_string(ret));
            fail_count++;
            goto next_test;
        }

        if (resources->length != test->num_native_bytes) {
            printf(
                "unexpected native length %zu (expected %zu)\n",
                resources->length, test->num_native_bytes
            );
            fail_count++;
            goto next_test;
        }

        bytes = (uint8_t*)resources->entries;
        for (i = 0; i < resources->length; ++i) {
            if ((i & (sizeof(void*) - 1)) == 0 && have_offset(test, i)) {
                i += sizeof(void*) - 1;
                continue;
            }

            if (bytes[i] != test->native_bytes[i]) {
                printf(
                    "native byte[%zu] mismatch, expected 0x%02X, got 0x%02X\n",
                    i, test->native_bytes[i], bytes[i]
                );
                fail_count++;
                goto next_test;
            }
        }

        ret = uacpi_native_resources_to_aml(resources, &resource_template);
        if (uacpi_unlikely_error(ret)) {
            printf("to_aml error: %s\n", uacpi_status_to_string(ret));
            fail_count++;
            goto next_test;
        }

        if (resource_template->buffer->size != test->num_aml_bytes) {
            printf(
                "unexpected AML length %zu (expected %zu)\n",
                resource_template->buffer->size, test->num_aml_bytes
            );
            fail_count++;
            goto next_test;
        }

        for (i = 0; i < resource_template->buffer->size; ++i)
            if (resource_template->buffer->byte_data[i] != test->aml_bytes[i]) {
                printf(
                    "AML byte[%zu] mismatch, expected 0x%02X, got 0x%02X\n",
                    i, test->aml_bytes[i],
                    resource_template->buffer->byte_data[i]
                );
                fail_count++;
                goto next_test;
            }

        puts("OK");

    next_test:
        uacpi_free_resources(resources);
        uacpi_object_unref(resource_template);
    }

    if (fail_count)
        error("one or more resource tests failed");
}