hyperledger-solang_solang/tests/imports.rs

// SPDX-License-Identifier: Apache-2.0

use assert_cmd::Command;

#[test]
fn import_map_dup() {
    let mut cmd = Command::cargo_bin("solang").unwrap();
    let dup = cmd
        .args([
            "compile",
            "--target",
            "solana",
            "--importmap",
            "foo=tests",
            "--importmap",
            "foo=tests",
            "foo.sol",
        ])
        .env("exit", "1")
        .assert();

    let output = dup.get_output();
    let stderr = String::from_utf8_lossy(&output.stderr);

    println!("stderr: {stderr}");

    assert_eq!(
        stderr,
        "error: import path 'tests': duplicate mapping for 'foo'\n"
    );
}

#[test]
fn import_map_badpath() {
    let mut cmd = Command::cargo_bin("solang").unwrap();
    let badpath = cmd
        .args([
            "compile",
            "--target",
            "solana",
            "--importmap",
            "foo=/does/not/exist",
            "bar.sol",
        ])
        .env("exit", "1")
        .assert();

    let output = badpath.get_output();
    let stderr = String::from_utf8_lossy(&output.stderr);

    println!("stderr: {stderr}");

    assert!(stderr.contains("error: import path '/does/not/exist': "));
}

#[test]
fn import_map() {
    let mut cmd = Command::cargo_bin("solang").unwrap();
    let assert = cmd
        .args([
            "compile",
            "--target",
            "solana",
            "--importmap",
            "foo=imports/",
            "import_map.sol",
        ])
        .current_dir("tests/imports_testcases")
        .assert();

    let output = assert.get_output();

    assert_eq!(String::from_utf8_lossy(&output.stderr), "");

    let mut cmd = Command::cargo_bin("solang").unwrap();
    let badpath = cmd
        .args(["compile", "import_map.sol", "--target", "solana"])
        .current_dir("tests/imports_testcases")
        .assert();

    let output = badpath.get_output();
    let stderr = String::from_utf8_lossy(&output.stderr);

    println!("stderr: {stderr}");

    assert!(stderr.contains("file not found 'foo/bar.sol'"));
}

#[test]
fn import() {
    let mut cmd = Command::cargo_bin("solang").unwrap();
    let assert = cmd
        .args([
            "compile",
            "--target",
            "solana",
            "--importpath",
            "./imports_testcases/imports",
            "imports_testcases/import.sol",
        ])
        .current_dir("tests")
        .assert();

    let output = assert.get_output();

    assert_eq!(String::from_utf8_lossy(&output.stderr), "");

    let mut cmd = Command::cargo_bin("solang").unwrap();
    let badpath = cmd
        .args(["compile", "--target", "solana", "import.sol"])
        .current_dir("tests/imports_testcases")
        .assert();

    let output = badpath.get_output();
    let stderr = String::from_utf8_lossy(&output.stderr);

    println!("stderr: {stderr}");

    assert!(stderr.contains("file not found 'bar.sol'"));
}

#[test]
fn contract_name_defined_twice() {
    let mut cmd = Command::cargo_bin("solang").unwrap();

    let ok = cmd
        .args(["compile", "--target", "solana", "bar.sol", "rel.sol"])
        .current_dir("tests/imports_testcases/imports")
        .assert();

    let output = ok.get_output();

    assert_eq!(String::from_utf8_lossy(&output.stderr), "");

    let mut cmd = Command::cargo_bin("solang").unwrap();

    let not_ok = cmd
        .args([
            "compile",
            "--target",
            "solana",
            "relative_import.sol",
            "rel.sol",
        ])
        .current_dir("tests/imports_testcases/imports")
        .assert();

    let output = not_ok.get_output();
    let err = String::from_utf8_lossy(&output.stderr);

    println!("{}", err);

    // The error contains the absolute paths, so we cannot assert the whole string
    assert!(err.starts_with("error: contract rel defined at "));
    assert!(err.contains("relative_import.sol:1:1-6:2 and "));
    assert!(err.ends_with("rel.sol:2:1-16\n"));
}

#[test]
fn bad_escape() {
    let mut cmd = Command::cargo_bin("solang").unwrap();

    let not_ok = cmd
        .args([
            "compile",
            "--target",
            "solana",
            "tests/imports_testcases/bad_escape.sol",
        ])
        .assert();

    let output = not_ok.get_output();
    let err = String::from_utf8_lossy(&output.stderr);

    println!("{}", err);

    // The error contains the absolute paths, so we cannot assert the whole string
    assert!(err.contains(": \\x escape should be followed by two hex digits"));
    #[cfg(windows)]
    assert!(err.contains(": string is not a valid filename"));
    #[cfg(not(windows))]
    assert!(err.contains(": file not found 'bar�.sol'"));
}

// Ensure that .\ and ..\ are not interpreted as relative paths on Unix/MacOS
// Note Windows allows these as relative paths, but we do not.
#[test]
fn backslash_path() {
    let mut cmd = Command::cargo_bin("solang").unwrap();

    let not_ok = cmd
        .args([
            "compile",
            "--target",
            "solana",
            "tests/imports_testcases/imports/bar_backslash.sol",
        ])
        .assert();

    let output = not_ok.get_output();
    let err = String::from_utf8_lossy(&output.stderr);

    println!("{}", err);

    #[cfg(windows)]
    assert!(err.is_empty());

    #[cfg(not(windows))]
    assert!(err.contains(": file not found '.\\relative_import.sol'"));
    #[cfg(not(windows))]
    assert!(err.contains(": file not found '..\\import.sol'"));
}