test.rs - mozsearch

use std::fs;

use std::path::{Path, PathBuf};

use object::coff::CoffFile;

use object::pe::{ImageResourceDataEntry, ImageResourceDirectory, ImageResourceDirectoryEntry, IMAGE_RESOURCE_DATA_IS_DIRECTORY};

use object::{

    pod, Architecture, LittleEndian, Object, ObjectSection, ObjectSymbol, RelocationEncoding, RelocationKind, SectionKind,

};

use tempfile::{tempdir, TempDir};

use crate::embed::coff::MachineType;

use crate::embed::{create_object_file, link_manifest_gnu, link_manifest_msvc, TargetOs};

use crate::new_manifest;

#[test]

fn create_obj() {

    let res = do_embed_file(MachineType::X86_64, TargetOs::WindowsGnu);

    let data = fs::read(&res.object_file()).unwrap();

    let obj = CoffFile::parse(&data[..]).unwrap();

    assert_eq!(obj.architecture(), Architecture::X86_64);

    let expected_manifest = fs::read(&sample_manifest_path()).unwrap();

    check_object_file(obj, &expected_manifest);

#[test]

fn link_lib_gnu() {

    let res = do_embed_file(MachineType::X86_64, TargetOs::WindowsGnu);

    assert!(res.object_file().exists());

    let object_option = format!("cargo:rustc-link-arg-bins={}", res.object_file().display());

    assert_eq!(res.lines(), &[object_option.as_str()]);

#[test]

fn link_file_msvc() {

    let res = do_embed_file(MachineType::X86_64, TargetOs::WindowsMsvc);

    assert!(!res.object_file().exists());

    let mut input_option = String::from("cargo:rustc-link-arg-bins=/MANIFESTINPUT:");

    input_option.push_str(res.manifest_path.canonicalize().unwrap().to_str().unwrap());

    assert_eq!(

        res.lines(),

&[

            "cargo:rustc-link-arg-bins=/MANIFEST:EMBED",

            input_option.as_str(),

            "cargo:rustc-link-arg-bins=/MANIFESTUAC:NO"

);

struct EmbedResult {

    manifest_path: PathBuf,

    out_dir: TempDir,

    output: String,

impl EmbedResult {

    fn object_file(&self) -> PathBuf {

        self.out_dir.path().join("embed-manifest.o")

    fn lines(&self) -> Vec<&str> {

        self.output.lines().collect()

fn sample_manifest_path() -> PathBuf {

    Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/sample.exe.manifest")

fn do_embed_file(arch: MachineType, os: TargetOs) -> EmbedResult {

    let manifest_path = sample_manifest_path();

    let out_dir = tempdir().unwrap();

    let mut buf: Vec<u8> = Vec::new();

    if matches!(os, TargetOs::WindowsMsvc) {

        link_manifest_msvc(&manifest_path, &mut buf).unwrap();

    } else {

        link_manifest_gnu(&fs::read(&manifest_path).unwrap(), out_dir.path(), arch, &mut buf).unwrap();

    EmbedResult {

        manifest_path,

        out_dir,

        output: String::from_utf8(buf).unwrap(),

#[test]

fn object_file_x86() {

    let manifest = new_manifest("Test.X86").to_string().into_bytes();

    let file = create_object_file(&manifest, MachineType::I386).unwrap();

    let obj = CoffFile::parse(&file[..]).unwrap();

    assert_eq!(obj.architecture(), Architecture::I386);

    check_object_file(obj, &manifest);

#[test]

fn object_file_x86_64() {

    let manifest = new_manifest("Test.X86_64").to_string().into_bytes();

    let file = create_object_file(&manifest, MachineType::X86_64).unwrap();

    let obj = CoffFile::parse(&file[..]).unwrap();

    assert_eq!(obj.architecture(), Architecture::X86_64);

    check_object_file(obj, &manifest);

#[test]

fn object_file_aarch64() {

    let manifest = new_manifest("Test.AARCH64").to_string().into_bytes();

    let file = create_object_file(&manifest, MachineType::Aarch64).unwrap();

    let obj = CoffFile::parse(&file[..]).unwrap();

    assert_eq!(obj.architecture(), Architecture::Aarch64);

    check_object_file(obj, &manifest);

fn check_object_file(obj: CoffFile, expected_manifest: &[u8]) {

    // There should be one sections `.rsrc`.

    assert_eq!(

        obj.sections().map(|s| s.name().unwrap().to_string()).collect::<Vec<_>>(),

        &[".rsrc"]

);

    // There should be one section symbol.

    assert_eq!(

        obj.symbols().map(|s| s.name().unwrap().to_string()).collect::<Vec<_>>(),

        &[".rsrc"]

);

    // The resource section must be a data section.

    let rsrc = obj.section_by_name(".rsrc").unwrap();

    assert_eq!(rsrc.address(), 0);

    assert_eq!(rsrc.kind(), SectionKind::Data);

    // The data RVA in the resource data entry must be relocatable.

    let (addr, reloc) = rsrc.relocations().next().unwrap();

    assert_eq!(reloc.kind(), RelocationKind::ImageOffset);

    assert_eq!(reloc.encoding(), RelocationEncoding::Generic);

    assert_eq!(addr, 0x48); // size of the directory table, three directories, and no strings

    assert_eq!(reloc.addend(), 0);

    // The resource directory contains one manifest resource type subdirectory.

    let data = rsrc.data().unwrap();

    let (dir, rest) = pod::from_bytes::<ImageResourceDirectory>(data).unwrap();

    assert_eq!(0, dir.number_of_named_entries.get(LittleEndian));

    assert_eq!(1, dir.number_of_id_entries.get(LittleEndian));

    let (entries, _) = pod::slice_from_bytes::<ImageResourceDirectoryEntry>(rest, 1).unwrap();

    assert_eq!(24, entries[0].name_or_id.get(LittleEndian));

    let offset = entries[0].offset_to_data_or_directory.get(LittleEndian);

    assert_eq!(IMAGE_RESOURCE_DATA_IS_DIRECTORY, offset & IMAGE_RESOURCE_DATA_IS_DIRECTORY);

    let offset = (offset & !IMAGE_RESOURCE_DATA_IS_DIRECTORY) as usize;

    // The manifest subdirectory contains one image (not DLL) manifest subdirectory.

    let (dir, rest) = pod::from_bytes::<ImageResourceDirectory>(&data[offset..]).unwrap();

    assert_eq!(0, dir.number_of_named_entries.get(LittleEndian));

    assert_eq!(1, dir.number_of_id_entries.get(LittleEndian));

    let (entries, _) = pod::slice_from_bytes::<ImageResourceDirectoryEntry>(rest, 1).unwrap();

    assert_eq!(1, entries[0].name_or_id.get(LittleEndian));

    let offset = entries[0].offset_to_data_or_directory.get(LittleEndian);

    assert_eq!(IMAGE_RESOURCE_DATA_IS_DIRECTORY, offset & IMAGE_RESOURCE_DATA_IS_DIRECTORY);

    let offset = (offset & !IMAGE_RESOURCE_DATA_IS_DIRECTORY) as usize;

    // The image manifest subdirectory contains one US English manifest data entry.

    let (dir, rest) = pod::from_bytes::<ImageResourceDirectory>(&data[offset..]).unwrap();

    assert_eq!(0, dir.number_of_named_entries.get(LittleEndian));

    assert_eq!(1, dir.number_of_id_entries.get(LittleEndian));

    let (entries, _) = pod::slice_from_bytes::<ImageResourceDirectoryEntry>(rest, 1).unwrap();

    assert_eq!(0x0409, entries[0].name_or_id.get(LittleEndian));

    let offset = entries[0].offset_to_data_or_directory.get(LittleEndian);

    assert_eq!(0, offset & IMAGE_RESOURCE_DATA_IS_DIRECTORY);

    let offset = offset as usize;

    // The manifest data matches what was added.

    let (entry, resource_data) = pod::from_bytes::<ImageResourceDataEntry>(&data[offset..]).unwrap();

    let end = entry.size.get(LittleEndian) as usize;

    let manifest = &resource_data[..end];

    assert_eq!(manifest, expected_manifest);