crate::kernel_test!(
    fn hhdm_offset_nonzero_and_aligned() {
        let offset = crate::arch::boot::hhdm_offset();
        assert!(offset != 0, "HHDM offset is zero");
        assert!(
            offset.is_multiple_of(4096),
            "HHDM offset not 4K-aligned: {:#x}",
            offset
        );
    }
);

crate::kernel_test!(
    fn memory_map_has_usable() {
        use limine::memory_map::EntryType;
        let map = crate::arch::boot::memory_map();
        let usable_count = map
            .iter()
            .filter(|e| e.entry_type == EntryType::USABLE)
            .count();
        assert!(usable_count > 0, "no usable memory regions in memory map");
    }
);

crate::kernel_test!(
    fn tsc_frequency_plausible() {
        let freq = crate::wcet::tsc::freq_hz();
        assert!(
            (100_000_000..=10_000_000_000).contains(&freq),
            "TSC freq {} outside plausible range (100MHz-10GHz)",
            freq
        );
    }
);

crate::kernel_test!(
    fn kernel_virt_base_high_half() {
        let (_, virt_base) = crate::arch::boot::executable_address();
        assert!(
            virt_base >= 0xFFFF_8000_0000_0000,
            "kernel virtual base {:#x} is not in high half",
            virt_base
        );
    }
);

crate::kernel_test!(
    fn phys_virt_round_trip() {
        let phys = x86_64::PhysAddr::new(0x1000);
        let virt = crate::mem::addr::phys_to_virt(phys);
        let back = crate::mem::addr::virt_to_phys(virt)
            .expect("virt_to_phys returned None for valid HHDM address");
        assert!(
            back == phys,
            "round trip failed: phys {:#x} -> virt {:#x} -> phys {:#x}",
            phys.as_u64(),
            virt.as_u64(),
            back.as_u64()
        );
    }
);