path: root/ffi/tests/c-tests.rs

use anyhow::{Result, Context};
use filetime;

use std::cmp::min;
use std::env::{self, var_os};
use std::ffi::OsStr;
use std::fs;
use std::io::{self, BufRead, Write};
use std::path::{Path, PathBuf};
use std::process::Command;
use std::str::FromStr;
use std::mem::replace;

/// Hooks into Rust's test system to extract, compile and run c tests.
#[test]
fn c_doctests() -> Result<()> {
    let stderr = &mut io::stderr();

    // The location of this crate's (i.e., the ffi crate's) source.
    let manifest_dir = PathBuf::from(
        var_os("CARGO_MANIFEST_DIR")
        .as_ref()
        .expect("CARGO_MANIFEST_DIR not set"));

    let src = manifest_dir.join("src");
    let includes = vec![
        manifest_dir.join("../openpgp-ffi/include"),
        manifest_dir.join("include"),
    ];

    // The top-level directory.
    let toplevel = manifest_dir.parent().unwrap();

    // The location of the binaries.
    let target_dir = if let Some(dir) = var_os("CARGO_TARGET_DIR") {
        PathBuf::from(dir)
    } else {
        toplevel.join("target")
    };

    // The debug target.
    let debug = target_dir.join("debug");
    // Where we put our files.
    let target = target_dir.join("c-tests");
    fs::create_dir_all(&target).unwrap();

    // First of all, make sure the shared object is built.
    build_so(toplevel).unwrap();

    let mut n = 0;
    let mut passed = 0;
    for_all_rs(&src, |path| {
        for_all_tests(path, |src, lineno, name, lines, run_it| {
            n += 1;
            write!(stderr, "  test {} ... ", name)?;
            match build(&includes, &debug, &target, src, lineno, name, lines) {
                Ok(_) if ! run_it => {
                    writeln!(stderr, "ok")?;
                    passed += 1;
                },
                Ok(exe) => match run(&debug, &exe) {
                    Ok(()) => {
                        writeln!(stderr, "ok")?;
                        passed += 1;
                    },
                    Err(e) =>
                        writeln!(stderr, "{}", e)?,
                },
                Err(e) =>
                    writeln!(stderr, "{}", e)?,
            }
            Ok(())
        })
    }).unwrap();
    writeln!(stderr, "  test result: {} passed; {} failed", passed, n - passed)?;
    if n != passed {
        panic!("ffi test failures");
    }
    Ok(())
}

/// Builds the shared object.
fn build_so(base: &Path) -> Result<()> {
    let st = Command::new("cargo")
        .current_dir(base)
        .arg("build")
        .arg("--quiet")
        .arg("--package")
        .arg("sequoia-ffi")
        .status().unwrap();
    if ! st.success() {
        return Err(io::Error::new(io::ErrorKind::Other, "compilation failed")
                   .into());
    }

    Ok(())
}

/// Maps the given function `fun` over all Rust files in `src`.
fn for_all_rs<F>(src: &Path, mut fun: F)
                 -> Result<()>
    where F: FnMut(&Path) -> Result<()> {
    let mut dirs = vec![src.to_path_buf()];

    while let Some(dir) = dirs.pop() {
        for entry in fs::read_dir(dir).unwrap() {
            let entry = entry?;
            let path = entry.path();
            if path.is_file() && path.extension() == Some(OsStr::new("rs")) {
                fun(&path)?;
            }
            if path.is_dir() {
                dirs.push(path.clone());
            }
        }
    }
    Ok(())
}

/// If this looks like an exported function, returns its name.
fn exported_function_name(line: &str) -> Option<&str> {
    if line.starts_with("pub extern \"C\" fn ")
        || line.starts_with("fn pgp_")
    {
        let fn_i = line.find("fn ")?;
        let name_start = fn_i + 3;
        (&line[name_start..]).split(|c| !is_valid_identifier(c)).next()
    } else {
        None
    }
}

fn is_valid_identifier(c: char) -> bool {
    char::is_alphanumeric(c) || c == '_'
}

/// Maps the given function `fun` over all tests found in `path`.
///
/// XXX: We need to parse the file properly with syn.
fn for_all_tests<F>(path: &Path, mut fun: F)
                 -> Result<()>
    where F: FnMut(&Path, usize, &str, Vec<String>, bool) -> Result<()> {
    let mut lineno = 0;
    let mut test_starts_at = 0;
    let f = fs::File::open(path)?;
    let reader = io::BufReader::new(f);

    let mut in_test = false;
    let mut test = Vec::new();
    let mut run = false;
    for line in reader.lines() {
        let line = line?;
        lineno += 1;

        if ! in_test {
            if (line.starts_with("/// ```c") || line.starts_with("//! ```c"))
                && ! line.contains("ignore")
            {
                run = ! line.contains("no-run");
                in_test = true;
                test_starts_at = lineno + 1;
                continue;
            }

            if let Some(name) = exported_function_name(&line) {
                if test.len()