diff --git a/src/lib.rs b/src/lib.rs index 5d4e33f..e6cd5fa 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -25,7 +25,7 @@ //! [`RtlCheckBit`]: ntrtl/fn.RtlCheckBit.html //! [fn_ptr]: https://doc.rust-lang.org/reference/types.html#function-pointer-types //! [`Default`]: https://doc.rust-lang.org/std/default/trait.Default.html#tymethod.default -#![cfg(all(windows, any(target_arch = "x86", target_arch = "x86_64")))] +#![cfg(all(windows, any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64")))] #![no_std] #![deny(unused, unused_qualifications)] #![warn(unused_attributes)] diff --git a/src/ntexapi.rs b/src/ntexapi.rs index fe73b64..a478f0c 100644 --- a/src/ntexapi.rs +++ b/src/ntexapi.rs @@ -1738,7 +1738,7 @@ STRUCT!{struct SYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION { }} pub type PSYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION = *mut SYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION; -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] STRUCT!{struct SYSTEM_VERIFIER_INFORMATION_EX { VerifyMode: ULONG, OptionChanges: ULONG, @@ -2780,7 +2780,7 @@ pub const USER_SHARED_DATA: *const KUSER_SHARED_DATA = 0x7ffe0000 as *const _; pub unsafe fn NtGetTickCount64() -> ULONGLONG { #[allow(deprecated)] //fixme let mut tick_count: ULARGE_INTEGER = uninitialized(); - #[cfg(target_arch = "x86_64")] { + #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] { *tick_count.QuadPart_mut() = (*USER_SHARED_DATA).u.TickCountQuad; } #[cfg(target_arch = "x86")] { @@ -2801,7 +2801,7 @@ pub unsafe fn NtGetTickCount64() -> ULONGLONG { } #[inline] pub unsafe fn NtGetTickCount() -> ULONG { - #[cfg(target_arch = "x86_64")] { + #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] { (((*USER_SHARED_DATA).u.TickCountQuad * (*USER_SHARED_DATA).TickCountMultiplier as u64) >> 24) as u32 } diff --git a/src/ntlpcapi.rs b/src/ntlpcapi.rs index 423c6ae..012c905 100644 --- a/src/ntlpcapi.rs +++ b/src/ntlpcapi.rs @@ -68,7 +68,7 @@ pub const LPC_CONNECTION_REQUEST: ULONG = 10; pub const LPC_KERNELMODE_MESSAGE: CSHORT = 0x8000; pub const LPC_NO_IMPERSONATE: CSHORT = 0x4000; pub const PORT_VALID_OBJECT_ATTRIBUTES: u32 = OBJ_CASE_INSENSITIVE; -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] pub const PORT_MAXIMUM_MESSAGE_LENGTH: u32 = 512; #[cfg(target_arch = "x86")] pub const PORT_MAXIMUM_MESSAGE_LENGTH: u32 = 256; @@ -269,7 +269,7 @@ pub type ALPC_HANDLE = HANDLE; pub const ALPC_PORFLG_ALLOW_LPC_REQUESTS: ULONG = 0x20000; pub const ALPC_PORFLG_WAITABLE_PORT: ULONG = 0x40000; pub const ALPC_PORFLG_SYSTEM_PROCESS: ULONG = 0x100000; -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] STRUCT!{struct ALPC_PORT_ATTRIBUTES { Flags: ULONG, SecurityQos: SECURITY_QUALITY_OF_SERVICE, diff --git a/src/ntmmapi.rs b/src/ntmmapi.rs index b173eab..7cae677 100644 --- a/src/ntmmapi.rs +++ b/src/ntmmapi.rs @@ -23,7 +23,7 @@ ENUM!{enum MEMORY_INFORMATION_CLASS { STRUCT!{struct MEMORY_WORKING_SET_BLOCK { Bitfields: ULONG_PTR, }} -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] BITFIELD!{MEMORY_WORKING_SET_BLOCK Bitfields: ULONG_PTR [ Protection set_Protection[0..5], ShareCount set_ShareCount[5..8], @@ -78,7 +78,7 @@ UNION!{union MEMORY_WORKING_SET_EX_BLOCK_u { STRUCT!{struct MEMORY_WORKING_SET_EX_BLOCK { u: MEMORY_WORKING_SET_EX_BLOCK_u, }} -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Bitfields: ULONG_PTR [ Valid set_Valid[0..1], ShareCount set_ShareCount[1..4], @@ -93,7 +93,7 @@ BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Bitfields: ULONG_PTR [ Bad set_Bad[31..32], ReservedUlong set_ReservedUlong[32..64], ]} -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Invalid: ULONG_PTR [ Invalid_Valid set_Invalid_Valid[0..1], Invalid_Reserved0 set_Invalid_Reserved0[1..15], diff --git a/src/ntpebteb.rs b/src/ntpebteb.rs index ef1ca5d..b517058 100644 --- a/src/ntpebteb.rs +++ b/src/ntpebteb.rs @@ -213,7 +213,7 @@ UNION!{union TEB_u { IdealProcessorValue: ULONG, s: TEB_u_s, }} -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] STRUCT!{struct TEB { NtTib: NT_TIB, EnvironmentPointer: PVOID, diff --git a/src/ntpsapi.rs b/src/ntpsapi.rs index 16ad439..938d2ee 100644 --- a/src/ntpsapi.rs +++ b/src/ntpsapi.rs @@ -19,11 +19,11 @@ use winapi::um::winnt::{ PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY, PSECURITY_QUALITY_OF_SERVICE, }; -#[cfg(feature = "nightly")] +#[cfg(all(feature = "nightly", not(target_arch = "aarch64")))] use crate::winapi_local::um::winnt::NtCurrentTeb; pub const GDI_HANDLE_BUFFER_SIZE32: usize = 34; pub const GDI_HANDLE_BUFFER_SIZE64: usize = 60; -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] pub const GDI_HANDLE_BUFFER_SIZE: usize = GDI_HANDLE_BUFFER_SIZE64; #[cfg(target_arch = "x86")] pub const GDI_HANDLE_BUFFER_SIZE: usize = GDI_HANDLE_BUFFER_SIZE32; @@ -792,7 +792,7 @@ STRUCT!{struct THREAD_PROFILING_INFORMATION { PerformanceData: PTHREAD_PERFORMANCE_DATA, }} pub type PTHREAD_PROFILING_INFORMATION = *mut THREAD_PROFILING_INFORMATION; -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] STRUCT!{#[repr(align(16))] struct RTL_UMS_CONTEXT { Link: SINGLE_LIST_ENTRY, __padding: u64, @@ -932,7 +932,7 @@ pub const NtCurrentThread: HANDLE = -2isize as *mut c_void; pub const ZwCurrentThread: HANDLE = NtCurrentThread; pub const NtCurrentSession: HANDLE = -3isize as *mut c_void; pub const ZwCurrentSession: HANDLE = NtCurrentSession; -#[inline] #[cfg(feature = "nightly")] +#[inline] #[cfg(all(feature = "nightly", not(target_arch = "aarch64")))] pub unsafe fn NtCurrentPeb() -> PPEB { (*NtCurrentTeb()).ProcessEnvironmentBlock } @@ -940,11 +940,11 @@ pub const NtCurrentProcessToken: HANDLE = -4isize as *mut c_void; pub const NtCurrentThreadToken: HANDLE = -5isize as *mut c_void; pub const NtCurrentEffectiveToken: HANDLE = -6isize as *mut c_void; pub const NtCurrentSilo: HANDLE = -1isize as *mut c_void; -#[inline] #[cfg(feature = "nightly")] +#[inline] #[cfg(all(feature = "nightly", not(target_arch = "aarch64")))] pub unsafe fn NtCurrentProcessId() -> HANDLE { (*NtCurrentTeb()).ClientId.UniqueProcess } -#[inline] #[cfg(feature = "nightly")] +#[inline] #[cfg(all(feature = "nightly", not(target_arch = "aarch64")))] pub unsafe fn NtCurrentThreadId() -> HANDLE { (*NtCurrentTeb()).ClientId.UniqueThread } diff --git a/src/ntrtl.rs b/src/ntrtl.rs index 6afa9c6..9ef6cbc 100644 --- a/src/ntrtl.rs +++ b/src/ntrtl.rs @@ -15,7 +15,7 @@ use winapi::shared::guiddef::GUID; use winapi::shared::in6addr::in6_addr; use winapi::shared::inaddr::in_addr; use winapi::shared::minwindef::{BOOL, DWORD, PBOOL}; -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] use winapi::shared::ntdef::{LARGE_INTEGER, RTL_BALANCED_NODE}; use winapi::shared::ntdef::{ BOOLEAN, CCHAR, CHAR, CLONG, CSHORT, HANDLE, LCID, LIST_ENTRY, LOGICAL, LONG, LUID, NTSTATUS, @@ -26,7 +26,7 @@ use winapi::shared::ntdef::{ STRING, UCHAR, ULONG, ULONGLONG, UNICODE_STRING, USHORT, VOID, WCHAR, }; use winapi::um::minwinbase::PTHREAD_START_ROUTINE; -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] use winapi::um::winnt::{PGET_RUNTIME_FUNCTION_CALLBACK, PRUNTIME_FUNCTION, PWOW64_CONTEXT}; use winapi::um::winnt::{ ACCESS_MASK, ACL_INFORMATION_CLASS, APC_CALLBACK_FUNCTION, HEAP_INFORMATION_CLASS, @@ -1673,7 +1673,7 @@ EXTERN!{extern "system" { FeatureMask: ULONG64, ); }} -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] EXTERN!{extern "system" { fn RtlWow64GetThreadContext( ThreadHandle: HANDLE, @@ -1727,7 +1727,7 @@ EXTERN!{extern "system" { ExceptionPointers: PEXCEPTION_POINTERS, ) -> LONG; }} -#[cfg(target_arch = "x86_64")] +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] IFDEF!{ ENUM!{enum FUNCTION_TABLE_TYPE { RF_SORTED = 0, @@ -2196,7 +2196,7 @@ EXTERN!{extern "system" { MakeReadOnly: BOOLEAN, ); }} -#[inline] #[cfg(feature = "nightly")] +#[inline] #[cfg(all(feature = "nightly", not(target_arch = "aarch64")))] pub unsafe fn RtlProcessHeap() -> PVOID { use crate::ntpsapi::NtCurrentPeb; (*NtCurrentPeb()).ProcessHeap @@ -2948,7 +2948,7 @@ pub unsafe fn RtlCheckBit(BitMapHeader: &RTL_BITMAP, BitPosition: ULONG) -> u8 { use crate::winapi_local::um::winnt::_bittest64; _bittest64(BitMapHeader.Buffer as *const i64, BitPosition as i64) } - #[cfg(any(target_arch = "x86", all(target_arch = "x86_64", not(feature = "nightly"))))] { + #[cfg(any(target_arch = "x86", all(target_arch = "x86_64", not(feature = "nightly")), target_arch = "aarch64"))] { (*BitMapHeader.Buffer.offset(BitPosition as isize / 32) >> (BitPosition % 32) & 1) as u8 } } diff --git a/src/winapi_local/um/winnt.rs b/src/winapi_local/um/winnt.rs index f2793cf..66a4c2a 100644 --- a/src/winapi_local/um/winnt.rs +++ b/src/winapi_local/um/winnt.rs @@ -6,7 +6,7 @@ use winapi::um::winnt::{HANDLE, PVOID}; pub const fn UInt32x32To64(a: u32, b: u32) -> u64 { a as u64 * b as u64 } -#[cfg(feature = "nightly")] +#[cfg(all(feature = "nightly", not(target_arch = "aarch64")))] IFDEF!{ use crate::ntpebteb::TEB; #[inline] diff --git a/tests/layout_aarch64.rs b/tests/layout_aarch64.rs new file mode 100644 index 0000000..b99d799 --- /dev/null +++ b/tests/layout_aarch64.rs @@ -0,0 +1,2437 @@ +#![cfg(all(windows, target_arch = "aarch64"))] +#[macro_use] +extern crate ntapi; +use std::mem::{align_of, size_of}; +#[test] +fn ntapi_base() { + use ntapi::ntapi_base::*; + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); +} +#[test] +fn ntdbg() { + use ntapi::ntdbg::*; + assert_eq!(size_of::(), 160); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 184); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntexapi() { + use ntapi::ntexapi::*; + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 36); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 120); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 344); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 80); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 136); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 336); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 272); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 288); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 80); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 2); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 128); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 80); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 176); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 264); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 2); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 272); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 272); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 544); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 368); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 3); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 3); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 328); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 144); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 36); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1800); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountLowDeprecated), 0); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountMultiplier), 4); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, InterruptTime), 8); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SystemTime), 20); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBias), 32); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ImageNumberLow), 44); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ImageNumberHigh), 46); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtSystemRoot), 48); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, MaxStackTraceDepth), 568); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, CryptoExponent), 572); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneId), 576); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, LargePageMinimum), 580); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AitSamplingValue), 584); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AppCompatFlag), 588); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, RNGSeedVersion), 592); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, GlobalValidationRunlevel), 600); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasStamp), 604); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtBuildNumber), 608); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtProductType), 612); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ProductTypeIsValid), 616); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved0), 617); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NativeProcessorArchitecture), 618); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtMajorVersion), 620); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtMinorVersion), 624); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ProcessorFeatures), 628); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved1), 692); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved3), 696); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeSlip), 700); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AlternativeArchitecture), 704); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BootId), 708); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SystemExpirationDate), 712); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SuiteMask), 720); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, KdDebuggerEnabled), 724); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, MitigationPolicies), 725); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved6), 726); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ActiveConsoleId), 728); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, DismountCount), 732); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ComPlusPackage), 736); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, LastSystemRITEventTickCount), 740); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NumberOfPhysicalPages), 744); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SafeBootMode), 748); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, VirtualizationFlags), 749); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved12), 750); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SharedDataFlags), 752); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, DataFlagsPad), 756); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TestRetInstruction), 760); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcFrequency), 768); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SystemCall), 776); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SystemCallPad0), 780); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SystemCallPad), 784); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, u), 800); + // assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountPad), 812); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Cookie), 816); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, CookiePad), 820); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ConsoleSessionForegroundProcessId), 824); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeUpdateLock), 832); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineSystemTimeQpc), 840); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineInterruptTimeQpc), 848); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrement), 856); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrement), 864); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrementShift), 872); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrementShift), 873); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, UnparkedProcessorCount), 874); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, EnclaveFeatureMask), 876); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TelemetryCoverageRound), 892); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, UserModeGlobalLogger), 896); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ImageFileExecutionOptions), 928); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, LangGenerationCount), 932); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved4), 936); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, InterruptTimeBias), 944); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcBias), 952); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ActiveProcessorCount), 960); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ActiveGroupCount), 964); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved9), 965); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcData), 966); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveStart), 968); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveEnd), 976); + assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, XState), 984); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); +} +#[test] +fn ntgdi() { + use ntapi::ntgdi::*; + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 393216); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntioapi() { + use ntapi::ntioapi::*; + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 2); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 116); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 120); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); +} +#[test] +fn ntldr() { + use ntapi::ntldr::*; + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 80); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 288); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 224); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 296); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 304); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 320); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntlpcapi() { + use ntapi::ntlpcapi::*; + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 768); + assert_eq!(align_of::(), 128); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, StartMagic), 0); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, TotalSize), 8); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, ListOffset), 12); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, ListSize), 16); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, BitmapOffset), 20); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, BitmapSize), 24); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, DataOffset), 28); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, DataSize), 32); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeFlags), 36); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeSize), 40); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, State), 128); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastMessageId), 136); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastCallbackId), 140); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, PostCount), 256); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, ReturnCount), 384); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LogSequenceNumber), 512); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, UserLock), 640); + assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, EndMagic), 648); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 44); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); +} +#[test] +fn ntmmapi() { + use ntapi::ntmmapi::*; + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 240); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntnls() { + use ntapi::ntnls::*; + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 144); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntobapi() { + use ntapi::ntobapi::*; + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 2); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntpebteb() { + use ntapi::ntpebteb::*; + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1992); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(PEB, InheritedAddressSpace), 0); + assert_eq!(FIELD_OFFSET!(PEB, ReadImageFileExecOptions), 1); + assert_eq!(FIELD_OFFSET!(PEB, BeingDebugged), 2); + assert_eq!(FIELD_OFFSET!(PEB, BitField), 3); + assert_eq!(FIELD_OFFSET!(PEB, Mutant), 8); + assert_eq!(FIELD_OFFSET!(PEB, ImageBaseAddress), 16); + assert_eq!(FIELD_OFFSET!(PEB, Ldr), 24); + assert_eq!(FIELD_OFFSET!(PEB, ProcessParameters), 32); + assert_eq!(FIELD_OFFSET!(PEB, SubSystemData), 40); + assert_eq!(FIELD_OFFSET!(PEB, ProcessHeap), 48); + assert_eq!(FIELD_OFFSET!(PEB, FastPebLock), 56); + assert_eq!(FIELD_OFFSET!(PEB, IFEOKey), 64); + assert_eq!(FIELD_OFFSET!(PEB, AtlThunkSListPtr), 72); + assert_eq!(FIELD_OFFSET!(PEB, CrossProcessFlags), 80); + assert_eq!(FIELD_OFFSET!(PEB, u), 88); + assert_eq!(FIELD_OFFSET!(PEB, SystemReserved), 96); + assert_eq!(FIELD_OFFSET!(PEB, AtlThunkSListPtr32), 100); + assert_eq!(FIELD_OFFSET!(PEB, ApiSetMap), 104); + assert_eq!(FIELD_OFFSET!(PEB, TlsExpansionCounter), 112); + assert_eq!(FIELD_OFFSET!(PEB, TlsBitmap), 120); + assert_eq!(FIELD_OFFSET!(PEB, TlsBitmapBits), 128); + assert_eq!(FIELD_OFFSET!(PEB, ReadOnlySharedMemoryBase), 136); + assert_eq!(FIELD_OFFSET!(PEB, SharedData), 144); + assert_eq!(FIELD_OFFSET!(PEB, AnsiCodePageData), 160); + assert_eq!(FIELD_OFFSET!(PEB, OemCodePageData), 168); + assert_eq!(FIELD_OFFSET!(PEB, UnicodeCaseTableData), 176); + assert_eq!(FIELD_OFFSET!(PEB, NumberOfProcessors), 184); + assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag), 188); + assert_eq!(FIELD_OFFSET!(PEB, CriticalSectionTimeout), 192); + assert_eq!(FIELD_OFFSET!(PEB, HeapSegmentReserve), 200); + assert_eq!(FIELD_OFFSET!(PEB, HeapSegmentCommit), 208); + assert_eq!(FIELD_OFFSET!(PEB, HeapDeCommitTotalFreeThreshold), 216); + assert_eq!(FIELD_OFFSET!(PEB, HeapDeCommitFreeBlockThreshold), 224); + assert_eq!(FIELD_OFFSET!(PEB, NumberOfHeaps), 232); + assert_eq!(FIELD_OFFSET!(PEB, MaximumNumberOfHeaps), 236); + assert_eq!(FIELD_OFFSET!(PEB, GdiSharedHandleTable), 248); + assert_eq!(FIELD_OFFSET!(PEB, ProcessStarterHelper), 256); + assert_eq!(FIELD_OFFSET!(PEB, GdiDCAttributeList), 264); + assert_eq!(FIELD_OFFSET!(PEB, LoaderLock), 272); + assert_eq!(FIELD_OFFSET!(PEB, OSMajorVersion), 280); + assert_eq!(FIELD_OFFSET!(PEB, OSMinorVersion), 284); + assert_eq!(FIELD_OFFSET!(PEB, OSBuildNumber), 288); + assert_eq!(FIELD_OFFSET!(PEB, OSCSDVersion), 290); + assert_eq!(FIELD_OFFSET!(PEB, OSPlatformId), 292); + assert_eq!(FIELD_OFFSET!(PEB, ImageSubsystem), 296); + assert_eq!(FIELD_OFFSET!(PEB, ImageSubsystemMajorVersion), 300); + assert_eq!(FIELD_OFFSET!(PEB, ImageSubsystemMinorVersion), 304); + assert_eq!(FIELD_OFFSET!(PEB, ActiveProcessAffinityMask), 312); + assert_eq!(FIELD_OFFSET!(PEB, GdiHandleBuffer), 320); + assert_eq!(FIELD_OFFSET!(PEB, PostProcessInitRoutine), 560); + assert_eq!(FIELD_OFFSET!(PEB, TlsExpansionBitmap), 568); + assert_eq!(FIELD_OFFSET!(PEB, TlsExpansionBitmapBits), 576); + assert_eq!(FIELD_OFFSET!(PEB, SessionId), 704); + assert_eq!(FIELD_OFFSET!(PEB, AppCompatFlags), 712); + assert_eq!(FIELD_OFFSET!(PEB, AppCompatFlagsUser), 720); + assert_eq!(FIELD_OFFSET!(PEB, pShimData), 728); + assert_eq!(FIELD_OFFSET!(PEB, AppCompatInfo), 736); + assert_eq!(FIELD_OFFSET!(PEB, CSDVersion), 744); + assert_eq!(FIELD_OFFSET!(PEB, ActivationContextData), 760); + assert_eq!(FIELD_OFFSET!(PEB, ProcessAssemblyStorageMap), 768); + assert_eq!(FIELD_OFFSET!(PEB, SystemDefaultActivationContextData), 776); + assert_eq!(FIELD_OFFSET!(PEB, SystemAssemblyStorageMap), 784); + assert_eq!(FIELD_OFFSET!(PEB, MinimumStackCommit), 792); + assert_eq!(FIELD_OFFSET!(PEB, FlsListHead), 808); + assert_eq!(FIELD_OFFSET!(PEB, FlsBitmap), 824); + assert_eq!(FIELD_OFFSET!(PEB, FlsBitmapBits), 832); + assert_eq!(FIELD_OFFSET!(PEB, FlsHighIndex), 848); + assert_eq!(FIELD_OFFSET!(PEB, WerRegistrationData), 856); + assert_eq!(FIELD_OFFSET!(PEB, WerShipAssertPtr), 864); + assert_eq!(FIELD_OFFSET!(PEB, pUnused), 872); + assert_eq!(FIELD_OFFSET!(PEB, pImageHeaderHash), 880); + assert_eq!(FIELD_OFFSET!(PEB, TracingFlags), 888); + assert_eq!(FIELD_OFFSET!(PEB, CsrServerReadOnlySharedMemoryBase), 896); + assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpListLock), 904); + assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpList), 912); + assert_eq!(FIELD_OFFSET!(PEB, WaitOnAddressHashTable), 928); + assert_eq!(FIELD_OFFSET!(PEB, TelemetryCoverageHeader), 1952); + assert_eq!(FIELD_OFFSET!(PEB, CloudFileFlags), 1960); + assert_eq!(FIELD_OFFSET!(PEB, CloudFileDiagFlags), 1964); + assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityMode), 1968); + assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityModeReserved), 1969); + assert_eq!(FIELD_OFFSET!(PEB, LeapSecondData), 1976); + assert_eq!(FIELD_OFFSET!(PEB, LeapSecondFlags), 1984); + assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag2), 1988); + assert_eq!(size_of::(), 1256); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 6200); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(TEB, NtTib), 0); + assert_eq!(FIELD_OFFSET!(TEB, EnvironmentPointer), 56); + assert_eq!(FIELD_OFFSET!(TEB, ClientId), 64); + assert_eq!(FIELD_OFFSET!(TEB, ActiveRpcHandle), 80); + assert_eq!(FIELD_OFFSET!(TEB, ThreadLocalStoragePointer), 88); + assert_eq!(FIELD_OFFSET!(TEB, ProcessEnvironmentBlock), 96); + assert_eq!(FIELD_OFFSET!(TEB, LastErrorValue), 104); + assert_eq!(FIELD_OFFSET!(TEB, CountOfOwnedCriticalSections), 108); + assert_eq!(FIELD_OFFSET!(TEB, CsrClientThread), 112); + assert_eq!(FIELD_OFFSET!(TEB, Win32ThreadInfo), 120); + assert_eq!(FIELD_OFFSET!(TEB, User32Reserved), 128); + assert_eq!(FIELD_OFFSET!(TEB, UserReserved), 232); + assert_eq!(FIELD_OFFSET!(TEB, WOW32Reserved), 256); + assert_eq!(FIELD_OFFSET!(TEB, CurrentLocale), 264); + assert_eq!(FIELD_OFFSET!(TEB, FpSoftwareStatusRegister), 268); + assert_eq!(FIELD_OFFSET!(TEB, ReservedForDebuggerInstrumentation), 272); + assert_eq!(FIELD_OFFSET!(TEB, SystemReserved1), 400); + assert_eq!(FIELD_OFFSET!(TEB, SystemReserved1), 400); + assert_eq!(FIELD_OFFSET!(TEB, PlaceholderCompatibilityMode), 640); + assert_eq!(FIELD_OFFSET!(TEB, PlaceholderReserved), 641); + assert_eq!(FIELD_OFFSET!(TEB, ProxiedProcessId), 652); + assert_eq!(FIELD_OFFSET!(TEB, ActivationStack), 656); + assert_eq!(FIELD_OFFSET!(TEB, WorkingOnBehalfTicket), 696); + assert_eq!(FIELD_OFFSET!(TEB, ExceptionCode), 704); + assert_eq!(FIELD_OFFSET!(TEB, ActivationContextStackPointer), 712); + assert_eq!(FIELD_OFFSET!(TEB, InstrumentationCallbackSp), 720); + assert_eq!(FIELD_OFFSET!(TEB, InstrumentationCallbackPreviousPc), 728); + assert_eq!(FIELD_OFFSET!(TEB, InstrumentationCallbackPreviousSp), 736); + assert_eq!(FIELD_OFFSET!(TEB, TxFsContext), 744); + assert_eq!(FIELD_OFFSET!(TEB, InstrumentationCallbackDisabled), 748); + assert_eq!(FIELD_OFFSET!(TEB, TxFsContext), 744); + assert_eq!(FIELD_OFFSET!(TEB, GdiTebBatch), 752); + assert_eq!(FIELD_OFFSET!(TEB, RealClientId), 2008); + assert_eq!(FIELD_OFFSET!(TEB, GdiCachedProcessHandle), 2024); + assert_eq!(FIELD_OFFSET!(TEB, GdiClientPID), 2032); + assert_eq!(FIELD_OFFSET!(TEB, GdiClientTID), 2036); + assert_eq!(FIELD_OFFSET!(TEB, GdiThreadLocalInfo), 2040); + assert_eq!(FIELD_OFFSET!(TEB, Win32ClientInfo), 2048); + assert_eq!(FIELD_OFFSET!(TEB, glDispatchTable), 2544); + assert_eq!(FIELD_OFFSET!(TEB, glReserved1), 4408); + assert_eq!(FIELD_OFFSET!(TEB, glReserved2), 4640); + assert_eq!(FIELD_OFFSET!(TEB, glSectionInfo), 4648); + assert_eq!(FIELD_OFFSET!(TEB, glSection), 4656); + assert_eq!(FIELD_OFFSET!(TEB, glTable), 4664); + assert_eq!(FIELD_OFFSET!(TEB, glCurrentRC), 4672); + assert_eq!(FIELD_OFFSET!(TEB, glContext), 4680); + assert_eq!(FIELD_OFFSET!(TEB, LastStatusValue), 4688); + assert_eq!(FIELD_OFFSET!(TEB, StaticUnicodeString), 4696); + assert_eq!(FIELD_OFFSET!(TEB, StaticUnicodeBuffer), 4712); + assert_eq!(FIELD_OFFSET!(TEB, DeallocationStack), 5240); + assert_eq!(FIELD_OFFSET!(TEB, TlsSlots), 5248); + assert_eq!(FIELD_OFFSET!(TEB, TlsLinks), 5760); + assert_eq!(FIELD_OFFSET!(TEB, Vdm), 5776); + assert_eq!(FIELD_OFFSET!(TEB, ReservedForNtRpc), 5784); + assert_eq!(FIELD_OFFSET!(TEB, DbgSsReserved), 5792); + assert_eq!(FIELD_OFFSET!(TEB, HardErrorMode), 5808); + assert_eq!(FIELD_OFFSET!(TEB, Instrumentation), 5816); + assert_eq!(FIELD_OFFSET!(TEB, Instrumentation), 5816); + assert_eq!(FIELD_OFFSET!(TEB, ActivityId), 5904); + assert_eq!(FIELD_OFFSET!(TEB, SubProcessTag), 5920); + assert_eq!(FIELD_OFFSET!(TEB, PerflibData), 5928); + assert_eq!(FIELD_OFFSET!(TEB, EtwTraceData), 5936); + assert_eq!(FIELD_OFFSET!(TEB, WinSockData), 5944); + assert_eq!(FIELD_OFFSET!(TEB, GdiBatchCount), 5952); + assert_eq!(FIELD_OFFSET!(TEB, u), 5956); + assert_eq!(FIELD_OFFSET!(TEB, u.s.ReservedPad0), 5956); + assert_eq!(FIELD_OFFSET!(TEB, u.s.ReservedPad1), 5957); + assert_eq!(FIELD_OFFSET!(TEB, u.s.ReservedPad2), 5958); + assert_eq!(FIELD_OFFSET!(TEB, u.s.IdealProcessor), 5959); + assert_eq!(FIELD_OFFSET!(TEB, GuaranteedStackBytes), 5960); + assert_eq!(FIELD_OFFSET!(TEB, ReservedForPerf), 5968); + assert_eq!(FIELD_OFFSET!(TEB, ReservedForOle), 5976); + assert_eq!(FIELD_OFFSET!(TEB, WaitingOnLoaderLock), 5984); + assert_eq!(FIELD_OFFSET!(TEB, SavedPriorityState), 5992); + assert_eq!(FIELD_OFFSET!(TEB, ReservedForCodeCoverage), 6000); + assert_eq!(FIELD_OFFSET!(TEB, ThreadPoolData), 6008); + assert_eq!(FIELD_OFFSET!(TEB, DeallocationBStore), 6024); + assert_eq!(FIELD_OFFSET!(TEB, BStoreLimit), 6032); + assert_eq!(FIELD_OFFSET!(TEB, MuiGeneration), 6040); + assert_eq!(FIELD_OFFSET!(TEB, IsImpersonating), 6044); + assert_eq!(FIELD_OFFSET!(TEB, NlsCache), 6048); + assert_eq!(FIELD_OFFSET!(TEB, pShimData), 6056); + assert_eq!(FIELD_OFFSET!(TEB, HeapVirtualAffinity), 6064); + assert_eq!(FIELD_OFFSET!(TEB, LowFragHeapDataSlot), 6066); + assert_eq!(FIELD_OFFSET!(TEB, CurrentTransactionHandle), 6072); + assert_eq!(FIELD_OFFSET!(TEB, ActiveFrame), 6080); + assert_eq!(FIELD_OFFSET!(TEB, FlsData), 6088); + assert_eq!(FIELD_OFFSET!(TEB, PreferredLanguages), 6096); + assert_eq!(FIELD_OFFSET!(TEB, UserPrefLanguages), 6104); + assert_eq!(FIELD_OFFSET!(TEB, MergedPrefLanguages), 6112); + assert_eq!(FIELD_OFFSET!(TEB, MuiImpersonation), 6120); + assert_eq!(FIELD_OFFSET!(TEB, CrossTebFlags), 6124); + assert_eq!(FIELD_OFFSET!(TEB, SameTebFlags), 6126); + assert_eq!(FIELD_OFFSET!(TEB, TxnScopeEnterCallback), 6128); + assert_eq!(FIELD_OFFSET!(TEB, TxnScopeExitCallback), 6136); + assert_eq!(FIELD_OFFSET!(TEB, TxnScopeContext), 6144); + assert_eq!(FIELD_OFFSET!(TEB, LockCount), 6152); + assert_eq!(FIELD_OFFSET!(TEB, WowTebOffset), 6156); + assert_eq!(FIELD_OFFSET!(TEB, ResourceRetValue), 6160); + assert_eq!(FIELD_OFFSET!(TEB, ReservedForWdf), 6168); + assert_eq!(FIELD_OFFSET!(TEB, ReservedForCrt), 6176); + assert_eq!(FIELD_OFFSET!(TEB, EffectiveContainerId), 6184); +} +#[test] +fn ntpfapi() { + use ntapi::ntpfapi::*; + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 368); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 6336); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntpnpapi() { + use ntapi::ntpnpapi::*; + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntpoapi() { + use ntapi::ntpoapi::*; + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); +} +#[test] +fn ntpsapi() { + use ntapi::ntpsapi::*; + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 2); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 160); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 176); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 3); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 144); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 448); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1024); + assert_eq!(align_of::(), 16); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, Link), 0); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, Context), 16); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, Teb), 928); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, UserContext), 936); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, ScheduledThread), 944); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, Suspended), 948); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, VolatileContext), 952); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, Terminated), 956); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, DebugActive), 960); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, RunningOnSelfThread), 964); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, DenyRunningOnSelfThread), 968); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, Flags), 972); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, KernelUpdateLock), 976); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, PrimaryClientID), 984); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, ContextLock), 992); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, PrimaryUmsContext), 1000); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, SwitchCount), 1008); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, KernelYieldCount), 1012); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, MixedYieldCount), 1016); + assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, YieldCount), 1020); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 432); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 592); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntregapi() { + use ntapi::ntregapi::*; + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntrtl() { + use ntapi::ntrtl::*; + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1040); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 36); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 128); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 208); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 172); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 92); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntsam() { + use ntapi::ntsam::*; + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ForceLogoff), 0); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, OemInformation), 8); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainName), 24); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ReplicaSourceNodeName), 40); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainModifiedCount), 56); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerState), 64); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerRole), 68); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UasCompatibilityRequired), 72); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UserCount), 76); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, GroupCount), 80); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, AliasCount), 84); + assert_eq!(size_of::(), 108); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, I1), 0); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutDuration), 88); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutObservationWindow), 96); + assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutThreshold), 104); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 184); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, UserName), 0); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, FullName), 16); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, UserId), 32); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PrimaryGroupId), 36); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectory), 40); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectoryDrive), 56); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, ScriptPath), 72); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, ProfilePath), 88); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, WorkStations), 104); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LastLogon), 120); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LastLogoff), 128); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordLastSet), 136); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordCanChange), 144); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordMustChange), 152); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LogonHours), 160); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, BadPasswordCount), 176); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LogonCount), 178); + assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, UserAccountControl), 180); + assert_eq!(size_of::(), 192); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserName), 0); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, FullName), 16); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserId), 32); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PrimaryGroupId), 36); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectory), 40); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectoryDrive), 56); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, ScriptPath), 72); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, ProfilePath), 88); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, AdminComment), 104); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, WorkStations), 120); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LastLogon), 136); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LastLogoff), 144); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LogonHours), 152); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, BadPasswordCount), 168); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LogonCount), 170); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PasswordLastSet), 172); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, AccountExpires), 180); + assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserAccountControl), 188); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 2); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); +} +#[test] +fn ntseapi() { + use ntapi::ntseapi::*; + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); +} +#[test] +fn ntwow64() { + use ntapi::ntwow64::*; + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(RTL_BALANCED_NODE32, u), 0); + assert_eq!(FIELD_OFFSET!(RTL_BALANCED_NODE32, u.s.Left), 0); + assert_eq!(FIELD_OFFSET!(RTL_BALANCED_NODE32, u.s.Right), 4); + assert_eq!(FIELD_OFFSET!(RTL_BALANCED_NODE32, ParentValue), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(RTL_RB_TREE32, Root), 0); + assert_eq!(FIELD_OFFSET!(RTL_RB_TREE32, Min), 4); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, Length), 0); + assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, Initialized), 4); + assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, SsHandle), 8); + assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InLoadOrderModuleList), 12); + assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InMemoryOrderModuleList), 20); + assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InInitializationOrderModuleList), 28); + assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, EntryInProgress), 36); + assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, ShutdownInProgress), 40); + assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, ShutdownThreadId), 44); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(LDR_SERVICE_TAG_RECORD32, Next), 0); + assert_eq!(FIELD_OFFSET!(LDR_SERVICE_TAG_RECORD32, ServiceTag), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(LDRP_CSLIST32, Tail), 0); + assert_eq!(size_of::(), 44); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(LDR_DDAG_NODE32, Modules), 0); + assert_eq!(FIELD_OFFSET!(LDR_DDAG_NODE32, ServiceTagList), 8); + assert_eq!(FIELD_OFFSET!(LDR_DDAG_NODE32, LoadCount), 12); + assert_eq!(FIELD_OFFSET!(LDR_DDAG_NODE32, LoadWhileUnloadingCount), 16); + assert_eq!(FIELD_OFFSET!(LDR_DDAG_NODE32, LowestLink), 20); + assert_eq!(FIELD_OFFSET!(LDR_DDAG_NODE32, u), 24); + assert_eq!(FIELD_OFFSET!(LDR_DDAG_NODE32, IncomingDependencies), 28); + assert_eq!(FIELD_OFFSET!(LDR_DDAG_NODE32, State), 32); + assert_eq!(FIELD_OFFSET!(LDR_DDAG_NODE32, CondenseLink), 36); + assert_eq!(FIELD_OFFSET!(LDR_DDAG_NODE32, PreorderNumber), 40); + assert_eq!(size_of::(), 168); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, InLoadOrderLinks), 0); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, InMemoryOrderLinks), 8); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InInitializationOrderLinks), 16); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InProgressLinks), 16); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DllBase), 24); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPoint), 28); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SizeOfImage), 32); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, FullDllName), 36); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseDllName), 44); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u2.FlagGroup), 52); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u2.Flags), 52); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ObsoleteLoadCount), 56); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, TlsIndex), 58); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, HashLinks), 60); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, TimeDateStamp), 68); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPointActivationContext), 72); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, Lock), 76); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DdagNode), 80); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, NodeModuleLink), 84); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadContext), 92); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ParentDllBase), 96); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SwitchBackContext), 100); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseAddressIndexNode), 104); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, MappingInfoIndexNode), 116); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, OriginalBase), 128); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadTime), 136); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseNameHashValue), 144); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadReason), 148); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ImplicitPathOptions), 152); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ReferenceCount), 156); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DependentLoadFlags), 160); + assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SigningLevel), 164); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(CURDIR32, DosPath), 0); + assert_eq!(FIELD_OFFSET!(CURDIR32, Handle), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(RTL_DRIVE_LETTER_CURDIR32, Flags), 0); + assert_eq!(FIELD_OFFSET!(RTL_DRIVE_LETTER_CURDIR32, Length), 2); + assert_eq!(FIELD_OFFSET!(RTL_DRIVE_LETTER_CURDIR32, TimeStamp), 4); + assert_eq!(FIELD_OFFSET!(RTL_DRIVE_LETTER_CURDIR32, DosPath), 8); + assert_eq!(size_of::(), 676); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, MaximumLength), 0); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Length), 4); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Flags), 8); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DebugFlags), 12); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleHandle), 16); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleFlags), 20); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardInput), 24); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardOutput), 28); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardError), 32); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectory), 36); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DllPath), 48); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ImagePathName), 56); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CommandLine), 64); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Environment), 72); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StartingX), 76); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StartingY), 80); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountX), 84); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountY), 88); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsX), 92); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsY), 96); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, FillAttribute), 100); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowFlags), 104); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShowWindowFlags), 108); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowTitle), 112); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DesktopInfo), 120); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShellInfo), 128); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, RuntimeData), 136); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectories), 144); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentSize), 656); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentVersion), 660); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, PackageDependencyData), 664); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ProcessGroupId), 668); + assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, LoaderThreads), 672); + assert_eq!(size_of::(), 1136); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(PEB32, InheritedAddressSpace), 0); + assert_eq!(FIELD_OFFSET!(PEB32, ReadImageFileExecOptions), 1); + assert_eq!(FIELD_OFFSET!(PEB32, BeingDebugged), 2); + assert_eq!(FIELD_OFFSET!(PEB32, BitField), 3); + assert_eq!(FIELD_OFFSET!(PEB32, Mutant), 4); + assert_eq!(FIELD_OFFSET!(PEB32, ImageBaseAddress), 8); + assert_eq!(FIELD_OFFSET!(PEB32, Ldr), 12); + assert_eq!(FIELD_OFFSET!(PEB32, ProcessParameters), 16); + assert_eq!(FIELD_OFFSET!(PEB32, SubSystemData), 20); + assert_eq!(FIELD_OFFSET!(PEB32, ProcessHeap), 24); + assert_eq!(FIELD_OFFSET!(PEB32, FastPebLock), 28); + assert_eq!(FIELD_OFFSET!(PEB32, AtlThunkSListPtr), 32); + assert_eq!(FIELD_OFFSET!(PEB32, IFEOKey), 36); + assert_eq!(FIELD_OFFSET!(PEB32, CrossProcessFlags), 40); + assert_eq!(FIELD_OFFSET!(PEB32, u), 44); + assert_eq!(FIELD_OFFSET!(PEB32, SystemReserved), 48); + assert_eq!(FIELD_OFFSET!(PEB32, AtlThunkSListPtr32), 52); + assert_eq!(FIELD_OFFSET!(PEB32, ApiSetMap), 56); + assert_eq!(FIELD_OFFSET!(PEB32, TlsExpansionCounter), 60); + assert_eq!(FIELD_OFFSET!(PEB32, TlsBitmap), 64); + assert_eq!(FIELD_OFFSET!(PEB32, TlsBitmapBits), 68); + assert_eq!(FIELD_OFFSET!(PEB32, ReadOnlySharedMemoryBase), 76); + assert_eq!(FIELD_OFFSET!(PEB32, HotpatchInformation), 80); + assert_eq!(FIELD_OFFSET!(PEB32, ReadOnlyStaticServerData), 84); + assert_eq!(FIELD_OFFSET!(PEB32, AnsiCodePageData), 88); + assert_eq!(FIELD_OFFSET!(PEB32, OemCodePageData), 92); + assert_eq!(FIELD_OFFSET!(PEB32, UnicodeCaseTableData), 96); + assert_eq!(FIELD_OFFSET!(PEB32, NumberOfProcessors), 100); + assert_eq!(FIELD_OFFSET!(PEB32, NtGlobalFlag), 104); + assert_eq!(FIELD_OFFSET!(PEB32, CriticalSectionTimeout), 112); + assert_eq!(FIELD_OFFSET!(PEB32, HeapSegmentReserve), 120); + assert_eq!(FIELD_OFFSET!(PEB32, HeapSegmentCommit), 124); + assert_eq!(FIELD_OFFSET!(PEB32, HeapDeCommitTotalFreeThreshold), 128); + assert_eq!(FIELD_OFFSET!(PEB32, HeapDeCommitFreeBlockThreshold), 132); + assert_eq!(FIELD_OFFSET!(PEB32, NumberOfHeaps), 136); + assert_eq!(FIELD_OFFSET!(PEB32, MaximumNumberOfHeaps), 140); + assert_eq!(FIELD_OFFSET!(PEB32, ProcessHeaps), 144); + assert_eq!(FIELD_OFFSET!(PEB32, GdiSharedHandleTable), 148); + assert_eq!(FIELD_OFFSET!(PEB32, ProcessStarterHelper), 152); + assert_eq!(FIELD_OFFSET!(PEB32, GdiDCAttributeList), 156); + assert_eq!(FIELD_OFFSET!(PEB32, LoaderLock), 160); + assert_eq!(FIELD_OFFSET!(PEB32, OSMajorVersion), 164); + assert_eq!(FIELD_OFFSET!(PEB32, OSMinorVersion), 168); + assert_eq!(FIELD_OFFSET!(PEB32, OSBuildNumber), 172); + assert_eq!(FIELD_OFFSET!(PEB32, OSCSDVersion), 174); + assert_eq!(FIELD_OFFSET!(PEB32, OSPlatformId), 176); + assert_eq!(FIELD_OFFSET!(PEB32, ImageSubsystem), 180); + assert_eq!(FIELD_OFFSET!(PEB32, ImageSubsystemMajorVersion), 184); + assert_eq!(FIELD_OFFSET!(PEB32, ImageSubsystemMinorVersion), 188); + assert_eq!(FIELD_OFFSET!(PEB32, ActiveProcessAffinityMask), 192); + assert_eq!(FIELD_OFFSET!(PEB32, GdiHandleBuffer), 196); + assert_eq!(FIELD_OFFSET!(PEB32, PostProcessInitRoutine), 332); + assert_eq!(FIELD_OFFSET!(PEB32, TlsExpansionBitmap), 336); + assert_eq!(FIELD_OFFSET!(PEB32, TlsExpansionBitmapBits), 340); + assert_eq!(FIELD_OFFSET!(PEB32, SessionId), 468); + assert_eq!(FIELD_OFFSET!(PEB32, AppCompatFlags), 472); + assert_eq!(FIELD_OFFSET!(PEB32, AppCompatFlagsUser), 480); + assert_eq!(FIELD_OFFSET!(PEB32, pShimData), 488); + assert_eq!(FIELD_OFFSET!(PEB32, AppCompatInfo), 492); + assert_eq!(FIELD_OFFSET!(PEB32, CSDVersion), 496); + assert_eq!(FIELD_OFFSET!(PEB32, ActivationContextData), 504); + assert_eq!(FIELD_OFFSET!(PEB32, ProcessAssemblyStorageMap), 508); + assert_eq!(FIELD_OFFSET!(PEB32, SystemDefaultActivationContextData), 512); + assert_eq!(FIELD_OFFSET!(PEB32, SystemAssemblyStorageMap), 516); + assert_eq!(FIELD_OFFSET!(PEB32, MinimumStackCommit), 520); + assert_eq!(FIELD_OFFSET!(PEB32, FlsCallback), 524); + assert_eq!(FIELD_OFFSET!(PEB32, FlsListHead), 528); + assert_eq!(FIELD_OFFSET!(PEB32, FlsBitmap), 536); + assert_eq!(FIELD_OFFSET!(PEB32, FlsBitmapBits), 540); + assert_eq!(FIELD_OFFSET!(PEB32, FlsHighIndex), 556); + assert_eq!(FIELD_OFFSET!(PEB32, WerRegistrationData), 560); + assert_eq!(FIELD_OFFSET!(PEB32, WerShipAssertPtr), 564); + assert_eq!(FIELD_OFFSET!(PEB32, pContextData), 568); + assert_eq!(FIELD_OFFSET!(PEB32, pImageHeaderHash), 572); + assert_eq!(FIELD_OFFSET!(PEB32, TracingFlags), 576); + assert_eq!(FIELD_OFFSET!(PEB32, CsrServerReadOnlySharedMemoryBase), 584); + assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpListLock), 592); + assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpList), 596); + assert_eq!(FIELD_OFFSET!(PEB32, WaitOnAddressHashTable), 604); + assert_eq!(FIELD_OFFSET!(PEB32, TelemetryCoverageHeader), 1116); + assert_eq!(FIELD_OFFSET!(PEB32, CloudFileFlags), 1120); + assert_eq!(FIELD_OFFSET!(PEB32, CloudFileDiagFlags), 1124); + assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityMode), 1128); + assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityModeReserved), 1129); + assert_eq!(size_of::(), 1248); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(GDI_TEB_BATCH32, Offset), 0); + assert_eq!(FIELD_OFFSET!(GDI_TEB_BATCH32, HDC), 4); + assert_eq!(FIELD_OFFSET!(GDI_TEB_BATCH32, Buffer), 8); + assert_eq!(size_of::(), 4096); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(TEB32, NtTib), 0); + assert_eq!(FIELD_OFFSET!(TEB32, EnvironmentPointer), 28); + assert_eq!(FIELD_OFFSET!(TEB32, ClientId), 32); + assert_eq!(FIELD_OFFSET!(TEB32, ActiveRpcHandle), 40); + assert_eq!(FIELD_OFFSET!(TEB32, ThreadLocalStoragePointer), 44); + assert_eq!(FIELD_OFFSET!(TEB32, ProcessEnvironmentBlock), 48); + assert_eq!(FIELD_OFFSET!(TEB32, LastErrorValue), 52); + assert_eq!(FIELD_OFFSET!(TEB32, CountOfOwnedCriticalSections), 56); + assert_eq!(FIELD_OFFSET!(TEB32, CsrClientThread), 60); + assert_eq!(FIELD_OFFSET!(TEB32, Win32ThreadInfo), 64); + assert_eq!(FIELD_OFFSET!(TEB32, User32Reserved), 68); + assert_eq!(FIELD_OFFSET!(TEB32, UserReserved), 172); + assert_eq!(FIELD_OFFSET!(TEB32, WOW32Reserved), 192); + assert_eq!(FIELD_OFFSET!(TEB32, CurrentLocale), 196); + assert_eq!(FIELD_OFFSET!(TEB32, FpSoftwareStatusRegister), 200); + assert_eq!(FIELD_OFFSET!(TEB32, ReservedForDebuggerInstrumentation), 204); + assert_eq!(FIELD_OFFSET!(TEB32, SystemReserved1), 268); + assert_eq!(FIELD_OFFSET!(TEB32, WorkingOnBehalfTicket), 412); + assert_eq!(FIELD_OFFSET!(TEB32, ExceptionCode), 420); + assert_eq!(FIELD_OFFSET!(TEB32, ActivationContextStackPointer), 424); + assert_eq!(FIELD_OFFSET!(TEB32, InstrumentationCallbackSp), 428); + assert_eq!(FIELD_OFFSET!(TEB32, InstrumentationCallbackPreviousPc), 432); + assert_eq!(FIELD_OFFSET!(TEB32, InstrumentationCallbackPreviousSp), 436); + assert_eq!(FIELD_OFFSET!(TEB32, InstrumentationCallbackDisabled), 440); + assert_eq!(FIELD_OFFSET!(TEB32, SpareBytes), 441); + assert_eq!(FIELD_OFFSET!(TEB32, TxFsContext), 464); + assert_eq!(FIELD_OFFSET!(TEB32, GdiTebBatch), 468); + assert_eq!(FIELD_OFFSET!(TEB32, RealClientId), 1716); + assert_eq!(FIELD_OFFSET!(TEB32, GdiCachedProcessHandle), 1724); + assert_eq!(FIELD_OFFSET!(TEB32, GdiClientPID), 1728); + assert_eq!(FIELD_OFFSET!(TEB32, GdiClientTID), 1732); + assert_eq!(FIELD_OFFSET!(TEB32, GdiThreadLocalInfo), 1736); + assert_eq!(FIELD_OFFSET!(TEB32, Win32ClientInfo), 1740); + assert_eq!(FIELD_OFFSET!(TEB32, glDispatchTable), 1988); + assert_eq!(FIELD_OFFSET!(TEB32, glReserved1), 2920); + assert_eq!(FIELD_OFFSET!(TEB32, glReserved2), 3036); + assert_eq!(FIELD_OFFSET!(TEB32, glSectionInfo), 3040); + assert_eq!(FIELD_OFFSET!(TEB32, glSection), 3044); + assert_eq!(FIELD_OFFSET!(TEB32, glTable), 3048); + assert_eq!(FIELD_OFFSET!(TEB32, glCurrentRC), 3052); + assert_eq!(FIELD_OFFSET!(TEB32, glContext), 3056); + assert_eq!(FIELD_OFFSET!(TEB32, LastStatusValue), 3060); + assert_eq!(FIELD_OFFSET!(TEB32, StaticUnicodeString), 3064); + assert_eq!(FIELD_OFFSET!(TEB32, StaticUnicodeBuffer), 3072); + assert_eq!(FIELD_OFFSET!(TEB32, DeallocationStack), 3596); + assert_eq!(FIELD_OFFSET!(TEB32, TlsSlots), 3600); + assert_eq!(FIELD_OFFSET!(TEB32, TlsLinks), 3856); + assert_eq!(FIELD_OFFSET!(TEB32, Vdm), 3864); + assert_eq!(FIELD_OFFSET!(TEB32, ReservedForNtRpc), 3868); + assert_eq!(FIELD_OFFSET!(TEB32, DbgSsReserved), 3872); + assert_eq!(FIELD_OFFSET!(TEB32, HardErrorMode), 3880); + assert_eq!(FIELD_OFFSET!(TEB32, Instrumentation), 3884); + assert_eq!(FIELD_OFFSET!(TEB32, ActivityId), 3920); + assert_eq!(FIELD_OFFSET!(TEB32, SubProcessTag), 3936); + assert_eq!(FIELD_OFFSET!(TEB32, PerflibData), 3940); + assert_eq!(FIELD_OFFSET!(TEB32, EtwTraceData), 3944); + assert_eq!(FIELD_OFFSET!(TEB32, WinSockData), 3948); + assert_eq!(FIELD_OFFSET!(TEB32, GdiBatchCount), 3952); + assert_eq!(FIELD_OFFSET!(TEB32, u), 3956); + assert_eq!(FIELD_OFFSET!(TEB32, u.s.ReservedPad0), 3956); + assert_eq!(FIELD_OFFSET!(TEB32, u.s.ReservedPad1), 3957); + assert_eq!(FIELD_OFFSET!(TEB32, u.s.ReservedPad2), 3958); + assert_eq!(FIELD_OFFSET!(TEB32, u.s.IdealProcessor), 3959); + assert_eq!(FIELD_OFFSET!(TEB32, GuaranteedStackBytes), 3960); + assert_eq!(FIELD_OFFSET!(TEB32, ReservedForPerf), 3964); + assert_eq!(FIELD_OFFSET!(TEB32, ReservedForOle), 3968); + assert_eq!(FIELD_OFFSET!(TEB32, WaitingOnLoaderLock), 3972); + assert_eq!(FIELD_OFFSET!(TEB32, SavedPriorityState), 3976); + assert_eq!(FIELD_OFFSET!(TEB32, ReservedForCodeCoverage), 3980); + assert_eq!(FIELD_OFFSET!(TEB32, ThreadPoolData), 3984); + assert_eq!(FIELD_OFFSET!(TEB32, TlsExpansionSlots), 3988); + assert_eq!(FIELD_OFFSET!(TEB32, MuiGeneration), 3992); + assert_eq!(FIELD_OFFSET!(TEB32, IsImpersonating), 3996); + assert_eq!(FIELD_OFFSET!(TEB32, NlsCache), 4000); + assert_eq!(FIELD_OFFSET!(TEB32, pShimData), 4004); + assert_eq!(FIELD_OFFSET!(TEB32, HeapVirtualAffinity), 4008); + assert_eq!(FIELD_OFFSET!(TEB32, LowFragHeapDataSlot), 4010); + assert_eq!(FIELD_OFFSET!(TEB32, CurrentTransactionHandle), 4012); + assert_eq!(FIELD_OFFSET!(TEB32, ActiveFrame), 4016); + assert_eq!(FIELD_OFFSET!(TEB32, FlsData), 4020); + assert_eq!(FIELD_OFFSET!(TEB32, PreferredLanguages), 4024); + assert_eq!(FIELD_OFFSET!(TEB32, UserPrefLanguages), 4028); + assert_eq!(FIELD_OFFSET!(TEB32, MergedPrefLanguages), 4032); + assert_eq!(FIELD_OFFSET!(TEB32, MuiImpersonation), 4036); + assert_eq!(FIELD_OFFSET!(TEB32, CrossTebFlags), 4040); + assert_eq!(FIELD_OFFSET!(TEB32, SameTebFlags), 4042); + assert_eq!(FIELD_OFFSET!(TEB32, TxnScopeEnterCallback), 4044); + assert_eq!(FIELD_OFFSET!(TEB32, TxnScopeExitCallback), 4048); + assert_eq!(FIELD_OFFSET!(TEB32, TxnScopeContext), 4052); + assert_eq!(FIELD_OFFSET!(TEB32, LockCount), 4056); + assert_eq!(FIELD_OFFSET!(TEB32, WowTebOffset), 4060); + assert_eq!(FIELD_OFFSET!(TEB32, ResourceRetValue), 4064); + assert_eq!(FIELD_OFFSET!(TEB32, ReservedForWdf), 4068); + assert_eq!(FIELD_OFFSET!(TEB32, ReservedForCrt), 4072); + assert_eq!(FIELD_OFFSET!(TEB32, EffectiveContainerId), 4080); +} +#[test] +fn subprocesstag() { + use ntapi::subprocesstag::*; + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); +} +#[test] +fn winsta() { + use ntapi::winsta::*; + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 2); + assert_eq!(FIELD_OFFSET!(VARDATA_WIRE, Size), 0); + assert_eq!(FIELD_OFFSET!(VARDATA_WIRE, Offset), 2); + assert_eq!(size_of::(), 76); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(SESSIONIDW, u), 0); + assert_eq!(FIELD_OFFSET!(SESSIONIDW, WinStationName), 4); + assert_eq!(FIELD_OFFSET!(SESSIONIDW, State), 72); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONCREATE, Bitfields), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONCREATE, MaxInstanceCount), 4); + assert_eq!(size_of::(), 134); + assert_eq!(align_of::(), 2); + assert_eq!(FIELD_OFFSET!(WINSTACONFIGWIRE, Comment), 0); + assert_eq!(FIELD_OFFSET!(WINSTACONFIGWIRE, OEMId), 122); + assert_eq!(FIELD_OFFSET!(WINSTACONFIGWIRE, UserConfig), 126); + assert_eq!(FIELD_OFFSET!(WINSTACONFIGWIRE, NewFields), 130); + assert_eq!(size_of::(), 2536); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(USERCONFIG, Bitfields), 0); + assert_eq!(FIELD_OFFSET!(USERCONFIG, Bitfields2), 4); + assert_eq!(FIELD_OFFSET!(USERCONFIG, UserName), 8); + assert_eq!(FIELD_OFFSET!(USERCONFIG, Domain), 50); + assert_eq!(FIELD_OFFSET!(USERCONFIG, Password), 86); + assert_eq!(FIELD_OFFSET!(USERCONFIG, WorkDirectory), 116); + assert_eq!(FIELD_OFFSET!(USERCONFIG, InitialProgram), 630); + assert_eq!(FIELD_OFFSET!(USERCONFIG, CallbackNumber), 1144); + assert_eq!(FIELD_OFFSET!(USERCONFIG, Callback), 1248); + assert_eq!(FIELD_OFFSET!(USERCONFIG, Shadow), 1252); + assert_eq!(FIELD_OFFSET!(USERCONFIG, MaxConnectionTime), 1256); + assert_eq!(FIELD_OFFSET!(USERCONFIG, MaxDisconnectionTime), 1260); + assert_eq!(FIELD_OFFSET!(USERCONFIG, MaxIdleTime), 1264); + assert_eq!(FIELD_OFFSET!(USERCONFIG, KeyboardLayout), 1268); + assert_eq!(FIELD_OFFSET!(USERCONFIG, MinEncryptionLevel), 1272); + assert_eq!(FIELD_OFFSET!(USERCONFIG, NWLogonServer), 1274); + assert_eq!(FIELD_OFFSET!(USERCONFIG, PublishedName), 1370); + assert_eq!(FIELD_OFFSET!(USERCONFIG, WFProfilePath), 1500); + assert_eq!(FIELD_OFFSET!(USERCONFIG, WFHomeDir), 2014); + assert_eq!(FIELD_OFFSET!(USERCONFIG, WFHomeDirDrive), 2528); + assert_eq!(size_of::(), 268); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(NETWORKCONFIG, LanAdapter), 0); + assert_eq!(FIELD_OFFSET!(NETWORKCONFIG, NetworkName), 4); + assert_eq!(FIELD_OFFSET!(NETWORKCONFIG, Flags), 264); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(FLOWCONTROLCONFIG, Bitfields), 0); + assert_eq!(FIELD_OFFSET!(FLOWCONTROLCONFIG, XonChar), 4); + assert_eq!(FIELD_OFFSET!(FLOWCONTROLCONFIG, XoffChar), 5); + assert_eq!(FIELD_OFFSET!(FLOWCONTROLCONFIG, Type), 8); + assert_eq!(FIELD_OFFSET!(FLOWCONTROLCONFIG, HardwareReceive), 12); + assert_eq!(FIELD_OFFSET!(FLOWCONTROLCONFIG, HardwareTransmit), 16); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(CONNECTCONFIG, Type), 0); + assert_eq!(FIELD_OFFSET!(CONNECTCONFIG, Bitfields), 4); + assert_eq!(size_of::(), 564); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(ASYNCCONFIG, DeviceName), 0); + assert_eq!(FIELD_OFFSET!(ASYNCCONFIG, ModemName), 258); + assert_eq!(FIELD_OFFSET!(ASYNCCONFIG, BaudRate), 516); + assert_eq!(FIELD_OFFSET!(ASYNCCONFIG, Parity), 520); + assert_eq!(FIELD_OFFSET!(ASYNCCONFIG, StopBits), 524); + assert_eq!(FIELD_OFFSET!(ASYNCCONFIG, ByteSize), 528); + assert_eq!(FIELD_OFFSET!(ASYNCCONFIG, Bitfields), 532); + assert_eq!(FIELD_OFFSET!(ASYNCCONFIG, FlowControl), 536); + assert_eq!(FIELD_OFFSET!(ASYNCCONFIG, Connect), 556); + assert_eq!(size_of::(), 308); + assert_eq!(align_of::(), 2); + assert_eq!(FIELD_OFFSET!(NASICONFIG, SpecificName), 0); + assert_eq!(FIELD_OFFSET!(NASICONFIG, UserName), 30); + assert_eq!(FIELD_OFFSET!(NASICONFIG, PassWord), 126); + assert_eq!(FIELD_OFFSET!(NASICONFIG, SessionName), 176); + assert_eq!(FIELD_OFFSET!(NASICONFIG, FileServer), 210); + assert_eq!(FIELD_OFFSET!(NASICONFIG, GlobalSession), 306); + assert_eq!(size_of::(), 268); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(OEMTDCONFIG, Adapter), 0); + assert_eq!(FIELD_OFFSET!(OEMTDCONFIG, DeviceName), 4); + assert_eq!(FIELD_OFFSET!(OEMTDCONFIG, Flags), 264); + assert_eq!(size_of::(), 568); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(PDPARAMS, SdClass), 0); + assert_eq!(FIELD_OFFSET!(PDPARAMS, u), 4); + assert_eq!(size_of::(), 300); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(WDCONFIG, WdName), 0); + assert_eq!(FIELD_OFFSET!(WDCONFIG, WdDLL), 66); + assert_eq!(FIELD_OFFSET!(WDCONFIG, WsxDLL), 132); + assert_eq!(FIELD_OFFSET!(WDCONFIG, WdFlag), 200); + assert_eq!(FIELD_OFFSET!(WDCONFIG, WdInputBufferLength), 204); + assert_eq!(FIELD_OFFSET!(WDCONFIG, CfgDLL), 208); + assert_eq!(FIELD_OFFSET!(WDCONFIG, WdPrefix), 274); + assert_eq!(size_of::(), 168); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(PDCONFIG2, PdName), 0); + assert_eq!(FIELD_OFFSET!(PDCONFIG2, SdClass), 68); + assert_eq!(FIELD_OFFSET!(PDCONFIG2, PdDLL), 72); + assert_eq!(FIELD_OFFSET!(PDCONFIG2, PdFlag), 140); + assert_eq!(FIELD_OFFSET!(PDCONFIG2, OutBufLength), 144); + assert_eq!(FIELD_OFFSET!(PDCONFIG2, OutBufCount), 148); + assert_eq!(FIELD_OFFSET!(PDCONFIG2, OutBufDelay), 152); + assert_eq!(FIELD_OFFSET!(PDCONFIG2, InteractiveDelay), 156); + assert_eq!(FIELD_OFFSET!(PDCONFIG2, PortNumber), 160); + assert_eq!(FIELD_OFFSET!(PDCONFIG2, KeepAliveTimeout), 164); + assert_eq!(size_of::(), 2296); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, Bitfields), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientName), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, Domain), 46); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, UserName), 82); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, Password), 124); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, WorkDirectory), 154); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, InitialProgram), 668); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, SerialNumber), 1184); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, EncryptionLevel), 1188); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientAddressFamily), 1192); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientAddress), 1196); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, HRes), 1258); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, VRes), 1260); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ColorDepth), 1262); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ProtocolType), 1264); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, KeyboardLayout), 1268); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, KeyboardType), 1272); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, KeyboardSubType), 1276); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, KeyboardFunctionKey), 1280); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ImeFileName), 1284); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientDirectory), 1350); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientLicense), 1864); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientModem), 1930); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientBuildNumber), 2012); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientHardwareId), 2016); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientProductId), 2020); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, OutBufCountHost), 2022); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, OutBufCountClient), 2024); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, OutBufLength), 2026); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, AudioDriverName), 2028); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientTimeZone), 2048); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientSessionId), 2220); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ClientDigProductId), 2224); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, PerformanceFlags), 2288); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENT, ActiveInputLocale), 2292); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(TSHARE_COUNTERS, Reserved), 0); + assert_eq!(size_of::(), 460); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, WdBytes), 0); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, WdFrames), 4); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, WaitForOutBuf), 8); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, Frames), 12); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, Bytes), 16); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, CompressedBytes), 20); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, CompressFlushes), 24); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, Errors), 28); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, Timeouts), 32); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, AsyncFramingError), 36); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, AsyncOverrunError), 40); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, AsyncOverflowError), 44); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, AsyncParityError), 48); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, TdErrors), 52); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, ProtocolType), 56); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, Length), 58); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, Specific.TShareCounters), 60); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, Specific.Reserved), 60); + assert_eq!(FIELD_OFFSET!(PROTOCOLCOUNTERS, Specific), 60); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(THINWIRECACHE, CacheReads), 0); + assert_eq!(FIELD_OFFSET!(THINWIRECACHE, CacheHits), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(RESERVED_CACHE, ThinWireCache), 0); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(TSHARE_CACHE, Reserved), 0); + assert_eq!(size_of::(), 84); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, ProtocolType), 0); + assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Length), 2); + assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.ReservedCacheStats), 4); + assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.TShareCacheStats), 4); + assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.Reserved), 4); + assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific), 4); + assert_eq!(size_of::(), 1012); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(PROTOCOLSTATUS, Output), 0); + assert_eq!(FIELD_OFFSET!(PROTOCOLSTATUS, Input), 460); + assert_eq!(FIELD_OFFSET!(PROTOCOLSTATUS, Cache), 920); + assert_eq!(FIELD_OFFSET!(PROTOCOLSTATUS, AsyncSignal), 1004); + assert_eq!(FIELD_OFFSET!(PROTOCOLSTATUS, AsyncSignalMask), 1008); + assert_eq!(size_of::(), 1216); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, ConnectState), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, WinStationName), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, LogonId), 72); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, ConnectTime), 80); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, DisconnectTime), 88); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, LastInputTime), 96); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, LogonTime), 104); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, Status), 112); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, Domain), 1124); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, UserName), 1160); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATION, CurrentTime), 1208); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONUSERTOKEN, ProcessId), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONUSERTOKEN, ThreadId), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONUSERTOKEN, UserToken), 16); + assert_eq!(size_of::(), 6); + assert_eq!(align_of::(), 2); + assert_eq!(FIELD_OFFSET!(WINSTATIONVIDEODATA, HResolution), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONVIDEODATA, VResolution), 2); + assert_eq!(FIELD_OFFSET!(WINSTATIONVIDEODATA, fColorDepth), 4); + assert_eq!(size_of::(), 140); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(CDCONFIG, CdClass), 0); + assert_eq!(FIELD_OFFSET!(CDCONFIG, CdName), 4); + assert_eq!(FIELD_OFFSET!(CDCONFIG, CdDLL), 70); + assert_eq!(FIELD_OFFSET!(CDCONFIG, CdFlag), 136); + assert_eq!(size_of::(), 9); + assert_eq!(align_of::(), 1); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENTDATA, DataName), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENTDATA, fUnicodeData), 8); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RemainingSessionCapacity), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, LoadFactor), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, TotalSessions), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, DisconnectedSessions), 12); + assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, IdleCPU), 16); + assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, TotalCPU), 24); + assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RawSessionCapacity), 32); + assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, reserved), 36); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONSHADOW, ShadowState), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONSHADOW, ShadowClass), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONSHADOW, SessionId), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONSHADOW, ProtocolType), 12); + assert_eq!(size_of::(), 204); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONPRODID, DigProductId), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONPRODID, ClientDigProductId), 64); + assert_eq!(FIELD_OFFSET!(WINSTATIONPRODID, OuterMostDigProductId), 128); + assert_eq!(FIELD_OFFSET!(WINSTATIONPRODID, CurrentSessionId), 192); + assert_eq!(FIELD_OFFSET!(WINSTATIONPRODID, ClientSessionId), 196); + assert_eq!(FIELD_OFFSET!(WINSTATIONPRODID, OuterMostSessionId), 200); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, sin_family), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv4.sin_port), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv4.sin_addr), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv4.sin_zero), 12); + assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_port), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_flowinfo), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_addr), 12); + assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_scope_id), 28); + assert_eq!(size_of::(), 1216); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionId), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionState), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionFlags), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, WinStationName), 12); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, UserName), 78); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DomainName), 120); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LogonTime), 160); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ConnectTime), 168); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DisconnectTime), 176); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LastInputTime), 184); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, CurrentTime), 192); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ProtocolStatus), 200); + assert_eq!(size_of::(), 2240); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionId), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionState), 4); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionFlags), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, WinStationName), 12); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleUserName), 78); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleDomainName), 120); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LogonTime), 160); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ConnectTime), 168); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DisconnectTime), 176); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LastInputTime), 184); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, CurrentTime), 192); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ProtocolStatus), 200); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, UserName), 1212); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DomainName), 1726); + assert_eq!(size_of::(), 2248); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX, Level), 0); + assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX, Data), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(TS_PROCESS_INFORMATION_NT4, MagicNumber), 0); + assert_eq!(FIELD_OFFSET!(TS_PROCESS_INFORMATION_NT4, LogonId), 4); + assert_eq!(FIELD_OFFSET!(TS_PROCESS_INFORMATION_NT4, ProcessSid), 8); + assert_eq!(FIELD_OFFSET!(TS_PROCESS_INFORMATION_NT4, Pad), 16); + assert_eq!(size_of::(), 184); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NextEntryOffset), 0); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NumberOfThreads), 4); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi1), 8); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi2), 16); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi3), 24); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, CreateTime), 32); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, UserTime), 40); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, KernelTime), 48); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, ImageName), 56); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, BasePriority), 72); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, UniqueProcessId), 76); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, InheritedFromUniqueProcessId), 80); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, HandleCount), 84); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SessionId), 88); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareUl3), 92); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakVirtualSize), 96); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, VirtualSize), 104); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PageFaultCount), 112); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakWorkingSetSize), 116); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, WorkingSetSize), 120); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakPagedPoolUsage), 128); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPagedPoolUsage), 136); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakNonPagedPoolUsage), 144); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaNonPagedPoolUsage), 152); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PagefileUsage), 160); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakPagefileUsage), 168); + assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PrivatePageCount), 176); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(TS_ALL_PROCESSES_INFO, pTsProcessInfo), 0); + assert_eq!(FIELD_OFFSET!(TS_ALL_PROCESSES_INFO, SizeOfSid), 8); + assert_eq!(FIELD_OFFSET!(TS_ALL_PROCESSES_INFO, pSid), 16); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(FIELD_OFFSET!(TS_COUNTER_HEADER, dwCounterID), 0); + assert_eq!(FIELD_OFFSET!(TS_COUNTER_HEADER, bResult), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(FIELD_OFFSET!(TS_COUNTER, CounterHead), 0); + assert_eq!(FIELD_OFFSET!(TS_COUNTER, dwValue), 8); + assert_eq!(FIELD_OFFSET!(TS_COUNTER, StartTime), 16); +}