use crate::{parser::Propagate, AmlContext, AmlValue, Handler};
use alloc::boxed::Box;
struct TestHandler;
impl Handler for TestHandler {
fn read_u8(&self, _address: usize) -> u8 {
unimplemented!()
}
fn read_u16(&self, _address: usize) -> u16 {
unimplemented!()
}
fn read_u32(&self, _address: usize) -> u32 {
unimplemented!()
}
fn read_u64(&self, _address: usize) -> u64 {
unimplemented!()
}
fn write_u8(&mut self, _address: usize, _value: u8) {
unimplemented!()
}
fn write_u16(&mut self, _address: usize, _value: u16) {
unimplemented!()
}
fn write_u32(&mut self, _address: usize, _value: u32) {
unimplemented!()
}
fn write_u64(&mut self, _address: usize, _value: u64) {
unimplemented!()
}
fn read_io_u8(&self, _port: u16) -> u8 {
unimplemented!()
}
fn read_io_u16(&self, _port: u16) -> u16 {
unimplemented!()
}
fn read_io_u32(&self, _port: u16) -> u32 {
unimplemented!()
}
fn write_io_u8(&self, _port: u16, _value: u8) {
unimplemented!()
}
fn write_io_u16(&self, _port: u16, _value: u16) {
unimplemented!()
}
fn write_io_u32(&self, _port: u16, _value: u32) {
unimplemented!()
}
fn read_pci_u8(&self, _segment: u16, _bus: u8, device: u8, _function: u8, _offset: u16) -> u8 {
unimplemented!()
}
fn read_pci_u16(&self, _segment: u16, _bus: u8, device: u8, _function: u8, _offset: u16) -> u16 {
unimplemented!()
}
fn read_pci_u32(&self, _segment: u16, _bus: u8, device: u8, _function: u8, _offset: u16) -> u32 {
unimplemented!()
}
fn write_pci_u8(&self, _segment: u16, _bus: u8, device: u8, _function: u8, _offset: u16, _value: u8) {
unimplemented!()
}
fn write_pci_u16(&self, _segment: u16, _bus: u8, device: u8, _function: u8, _offset: u16, _value: u16) {
unimplemented!()
}
fn write_pci_u32(&self, _segment: u16, _bus: u8, device: u8, _function: u8, _offset: u16, _value: u32) {
unimplemented!()
}
}
pub(crate) fn make_test_context() -> AmlContext {
AmlContext::new(Box::new(TestHandler), crate::DebugVerbosity::None)
}
pub(crate) macro check_err($parse: expr, $error: pat, $remains: expr) {
match $parse {
Ok((remains, _, result)) => panic!("Expected Err, got {:#?}. Remaining = {:#x?}", result, remains),
Err((remains, _, Propagate::Err($error))) if *remains == *$remains => (),
Err((remains, _, Propagate::Err($error))) => {
panic!("Correct error, incorrect stream returned: {:#x?}", remains)
}
Err((_, _, err)) => panic!("Got wrong error: {:?}", err),
}
}
pub(crate) macro check_ok($parse: expr, $expected: expr, $remains: expr) {
match $parse {
Ok((remains, _, ref result)) if remains == *$remains && result == &$expected => (),
Ok((remains, _, ref result)) if result == &$expected => {
panic!("Correct result, incorrect slice returned: {:x?}", remains)
}
Ok((_, _, ref result)) => panic!("Successfully parsed Ok, but it was wrong: {:#?}", result),
Err((_, _, err)) => panic!("Expected Ok, got {:#?}", err),
}
}
pub(crate) macro check_ok_value($parse: expr, $expected: expr, $remains: expr) {
match $parse {
Ok((remains, _, ref result)) if remains == *$remains && crudely_cmp_values(result, &$expected) => (),
Ok((remains, _, ref result)) if crudely_cmp_values(result, &$expected) => {
panic!("Correct result, incorrect slice returned: {:x?}", remains)
}
Ok((_, _, ref result)) => panic!("Successfully parsed Ok, but it was wrong: {:#?}", result),
Err((_, _, err)) => panic!("Expected Ok, got {:#?}", err),
}
}
pub(crate) fn crudely_cmp_values(a: &AmlValue, b: &AmlValue) -> bool {
use crate::value::MethodCode;
match a {
AmlValue::Boolean(a) => match b {
AmlValue::Boolean(b) => a == b,
_ => false,
},
AmlValue::Integer(a) => match b {
AmlValue::Integer(b) => a == b,
_ => false,
},
AmlValue::String(ref a) => match b {
AmlValue::String(ref b) => a == b,
_ => false,
},
AmlValue::OpRegion { region, offset, length, parent_device } => match b {
AmlValue::OpRegion {
region: b_region,
offset: b_offset,
length: b_length,
parent_device: b_parent_device,
} => {
region == b_region && offset == b_offset && length == b_length && parent_device == b_parent_device
}
_ => false,
},
AmlValue::Field { region, flags, offset, length } => match b {
AmlValue::Field { region: b_region, flags: b_flags, offset: b_offset, length: b_length } => {
region == b_region && flags == b_flags && offset == b_offset && length == b_length
}
_ => false,
},
AmlValue::Method { flags, code } => match b {
AmlValue::Method { flags: b_flags, code: b_code } => {
if flags != b_flags {
return false;
}
match (code, b_code) {
(MethodCode::Aml(a), MethodCode::Aml(b)) => a == b,
(MethodCode::Aml(_), MethodCode::Native(_)) => false,
(MethodCode::Native(_), MethodCode::Aml(_)) => false,
(MethodCode::Native(_), MethodCode::Native(_)) => panic!("Can't compare two native methods"),
}
}
_ => false,
},
AmlValue::Buffer(a) => match b {
AmlValue::Buffer(b) => a == b,
_ => false,
},
AmlValue::Processor { id, pblk_address, pblk_len } => match b {
AmlValue::Processor { id: b_id, pblk_address: b_pblk_address, pblk_len: b_pblk_len } => {
id == b_id && pblk_address == b_pblk_address && pblk_len == b_pblk_len
}
_ => false,
},
AmlValue::Mutex { sync_level } => match b {
AmlValue::Mutex { sync_level: b_sync_level } => sync_level == b_sync_level,
_ => false,
},
AmlValue::Package(a) => match b {
AmlValue::Package(b) => {
for (a, b) in a.iter().zip(b) {
if crudely_cmp_values(a, b) == false {
return false;
}
}
true
}
_ => false,
},
}
}