Expectations struct for output-type-permutations

Author: Oneirical

src/tools/run-make-support/src/lib.rs

@@ -266,14 +266,14 @@ pub fn test_while_readonly<P: AsRef<Path>, F: FnOnce() + std::panic::UnwindSafe>
 #[track_caller]
 pub fn shallow_find_files<P: AsRef<Path>, F: Fn(&PathBuf) -> bool>(
     path: P,
-    closure: F,
+    filter: F,
 ) -> Vec<PathBuf> {
     let mut matching_files = Vec::new();
     for entry in fs_wrapper::read_dir(path) {
         let entry = entry.expect("failed to read directory entry.");
         let path = entry.path();
 
-        if path.is_file() && closure(&path) {
+        if path.is_file() && filter(&path) {
             matching_files.push(path);
         }
     }
@@ -291,8 +291,10 @@ pub fn has_extension<P: AsRef<Path>>(path: P, extension: &str) -> bool {
 }
 
 /// Returns true if the filename at `path` is not in `expected`.
-pub fn name_not_among<P: AsRef<Path>>(path: P, expected: &[&'static str]) -> bool {
-    path.as_ref().file_name().is_some_and(|name| !expected.contains(&name.to_str().unwrap()))
+pub fn filename_not_in_denylist<P: AsRef<Path>>(path: P, expected: &[String]) -> bool {
+    path.as_ref()
+        .file_name()
+        .is_some_and(|name| !expected.contains(&name.to_str().unwrap().to_owned()))
 }
 
 /// Use `cygpath -w` on a path to get a Windows path string back. This assumes that `cygpath` is

tests/run-make/output-type-permutations/rmake.rs

@@ -5,56 +5,80 @@
 // See https://github.com/rust-lang/rust/pull/12020
 
 use run_make_support::{
-    bin_name, cwd, dynamic_lib_name, fs_wrapper, name_not_among, rust_lib_name, rustc,
+    bin_name, dynamic_lib_name, filename_not_in_denylist, fs_wrapper, rust_lib_name, rustc,
     shallow_find_files, static_lib_name,
 };
+use std::path::PathBuf;
 
 // Each test takes 4 arguments:
 // `must_exist`: output files which must be found - if any are absent, the test fails
 // `can_exist`: optional output files which will not trigger a failure
 // `dir`: the name of the directory where the test happens
 // `rustc_invocation`: the rustc command being tested
 // Any unexpected output files not listed in `must_exist` or `can_exist` will cause a failure.
-fn assert_expected_output_files(
-    must_exist: &[&'static str],
-    can_exist: &[&'static str],
-    dir: &str,
-    rustc_invocation: impl Fn(),
-) {
-    fs_wrapper::create_dir(dir);
+fn assert_expected_output_files(expectations: Expectations, rustc_invocation: impl Fn()) {
+    let must_exist = expectations.expected_files;
+    let can_exist = expectations.allowed_files;
+    let dir = expectations.test_dir;
+
+    fs_wrapper::create_dir(&dir);
     rustc_invocation();
     for file in must_exist {
-        fs_wrapper::remove_file(dir.to_owned() + "/" + file);
+        fs_wrapper::remove_file(PathBuf::from(&dir).join(&file));
     }
-    let actual_output_files = shallow_find_files(dir, |path| name_not_among(path, can_exist));
+    let actual_output_files =
+        shallow_find_files(dir, |path| filename_not_in_denylist(path, &can_exist));
     if !&actual_output_files.is_empty() {
         dbg!(&actual_output_files);
         panic!("unexpected output artifacts detected");
     }
 }
 
+struct Expectations {
+    /// Output files which must be found. The test fails if any are absent.
+    expected_files: Vec<String>,
+    /// Allowed output files which will not trigger a failure.
+    allowed_files: Vec<String>,
+    /// Name of the directory where the test happens.
+    test_dir: String,
+}
+
+macro_rules! s {
+    ( $( $x:expr ),* ) => {
+        {
+            let mut temp_vec = Vec::new();
+            $(
+                temp_vec.push($x.to_string());
+            )*
+            temp_vec
+        }
+    };
+}
+
 fn main() {
-    let bin_foo = Box::leak(Box::new(bin_name("foo")));
-    let bin_bar = Box::leak(Box::new(bin_name("bar")));
-    let static_bar = Box::leak(Box::new(static_lib_name("bar")));
-    let dynamic_bar = Box::leak(Box::new(dynamic_lib_name("bar")));
-    let rust_bar = Box::leak(Box::new(rust_lib_name("bar")));
+    let bin_foo = bin_name("foo");
 
     assert_expected_output_files(
-        &[static_bar, dynamic_bar, rust_bar],
-        &[
-            "libbar.ddl.exp",
-            "libbar.dll.lib",
-            "libbar.pdb",
-            "libbar.dll.a",
-            "libbar.exe.a",
-            "bar.ddl.exp",
-            "bar.dll.lib",
-            "bar.pdb",
-            "bar.dll.a",
-            "bar.exe.a",
-        ],
-        "three-crates",
+        Expectations {
+            expected_files: s![
+                static_lib_name("bar"),
+                dynamic_lib_name("bar"),
+                rust_lib_name("bar")
+            ],
+            allowed_files: s![
+                "libbar.dll.exp",
+                "libbar.dll.lib",
+                "libbar.pdb",
+                "libbar.dll.a",
+                "libbar.exe.a",
+                "bar.dll.exp",
+                "bar.dll.lib",
+                "bar.pdb",
+                "bar.dll.a",
+                "bar.exe.a"
+            ],
+            test_dir: "three-crates".to_string(),
+        },
         || {
             rustc()
                 .input("foo.rs")
@@ -64,113 +88,256 @@ fn main() {
         },
     );
 
-    assert_expected_output_files(&[bin_bar], &["bar.pdb"], "bin-crate", || {
-        rustc().input("foo.rs").crate_type("bin").out_dir("bin-crate").run();
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s![bin_name("bar")],
+            allowed_files: s!["bar.pdb"],
+            test_dir: "bin-crate".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").crate_type("bin").out_dir("bin-crate").run();
+        },
+    );
 
     assert_expected_output_files(
-        &["bar.ll", "bar.bc", "bar.s", "bar.o", bin_bar],
-        &["bar.pdb"],
-        "all-emit",
+        Expectations {
+            expected_files: s!["bar.ll", "bar.bc", "bar.s", "bar.o", bin_name("bar")],
+            allowed_files: s!["bar.pdb"],
+            test_dir: "all-emit".to_string(),
+        },
         || {
             rustc().input("foo.rs").emit("asm,llvm-ir,llvm-bc,obj,link").out_dir("all-emit").run();
         },
     );
 
-    assert_expected_output_files(&["foo"], &[], "asm-emit", || {
-        rustc().input("foo.rs").emit("asm").output("asm-emit/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "asm-emit2", || {
-        rustc().input("foo.rs").emit("asm=asm-emit2/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "asm-emit3", || {
-        rustc().input("foo.rs").arg("--emit=asm=asm-emit3/foo").run();
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "asm-emit".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").emit("asm").output("asm-emit/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "asm-emit2".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").emit("asm=asm-emit2/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "asm-emit3".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").arg("--emit=asm=asm-emit3/foo").run();
+        },
+    );
 
-    assert_expected_output_files(&["foo"], &[], "llvm-ir-emit", || {
-        rustc().input("foo.rs").emit("llvm-ir").output("llvm-ir-emit/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "llvm-ir-emit2", || {
-        rustc().input("foo.rs").emit("llvm-ir=llvm-ir-emit2/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "llvm-ir-emit3", || {
-        rustc().input("foo.rs").arg("--emit=llvm-ir=llvm-ir-emit3/foo").run();
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "llvm-ir-emit".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").emit("llvm-ir").output("llvm-ir-emit/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "llvm-ir-emit2".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").emit("llvm-ir=llvm-ir-emit2/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "llvm-ir-emit3".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").arg("--emit=llvm-ir=llvm-ir-emit3/foo").run();
+        },
+    );
 
-    assert_expected_output_files(&["foo"], &[], "llvm-bc-emit", || {
-        rustc().input("foo.rs").emit("llvm-bc").output("llvm-bc-emit/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "llvm-bc-emit2", || {
-        rustc().input("foo.rs").emit("llvm-bc=llvm-bc-emit2/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "llvm-bc-emit3", || {
-        rustc().input("foo.rs").arg("--emit=llvm-bc=llvm-bc-emit3/foo").run();
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "llvm-bc-emit".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").emit("llvm-bc").output("llvm-bc-emit/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "llvm-bc-emit2".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").emit("llvm-bc=llvm-bc-emit2/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "llvm-bc-emit3".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").arg("--emit=llvm-bc=llvm-bc-emit3/foo").run();
+        },
+    );
 
-    assert_expected_output_files(&["foo"], &[], "obj-emit", || {
-        rustc().input("foo.rs").emit("obj").output("obj-emit/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "obj-emit2", || {
-        rustc().input("foo.rs").emit("obj=obj-emit2/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "obj-emit3", || {
-        rustc().input("foo.rs").arg("--emit=obj=obj-emit3/foo").run();
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "obj-emit".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").emit("obj").output("obj-emit/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "obj-emit2".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").emit("obj=obj-emit2/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "obj-emit3".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").arg("--emit=obj=obj-emit3/foo").run();
+        },
+    );
 
-    assert_expected_output_files(&[bin_foo], &[], "link-emit", || {
-        rustc().input("foo.rs").emit("link").output("link-emit/".to_owned() + bin_foo).run();
-    });
-    assert_expected_output_files(&[bin_foo], &[], "link-emit2", || {
-        rustc().input("foo.rs").emit(&format!("link=link-emit2/{bin_foo}")).run();
-    });
-    assert_expected_output_files(&[bin_foo], &[], "link-emit3", || {
-        rustc().input("foo.rs").arg(&format!("--emit=link=link-emit3/{bin_foo}")).run();
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s![&bin_foo],
+            allowed_files: s!["foo.pdb"],
+            test_dir: "link-emit".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").emit("link").output("link-emit/".to_owned() + &bin_foo).run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s![&bin_foo],
+            allowed_files: s!["foo.pdb"],
+            test_dir: "link-emit2".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").emit(&format!("link=link-emit2/{bin_foo}")).run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s![&bin_foo],
+            allowed_files: s!["foo.pdb"],
+            test_dir: "link-emit3".to_string(),
+        },
+        || {
+            rustc().input("foo.rs").arg(&format!("--emit=link=link-emit3/{bin_foo}")).run();
+        },
+    );
 
-    assert_expected_output_files(&["foo"], &[], "rlib", || {
-        rustc().crate_type("rlib").input("foo.rs").output("rlib/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "rlib2", || {
-        rustc().crate_type("rlib").input("foo.rs").emit("link=rlib2/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "rlib3", || {
-        rustc().crate_type("rlib").input("foo.rs").arg("--emit=link=rlib3/foo").run();
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "rlib".to_string(),
+        },
+        || {
+            rustc().crate_type("rlib").input("foo.rs").output("rlib/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "rlib2".to_string(),
+        },
+        || {
+            rustc().crate_type("rlib").input("foo.rs").emit("link=rlib2/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "rlib3".to_string(),
+        },
+        || {
+            rustc().crate_type("rlib").input("foo.rs").arg("--emit=link=rlib3/foo").run();
+        },
+    );
 
     assert_expected_output_files(
-        &[bin_foo],
-        &[
-            "libbar.ddl.exp",
-            "libbar.dll.lib",
-            "libbar.pdb",
-            "libbar.dll.a",
-            "libbar.exe.a",
-            "bar.ddl.exp",
-            "bar.dll.lib",
-            "bar.pdb",
-            "bar.dll.a",
-            "bar.exe.a",
-        ],
-        "dylib",
-        || {
-            rustc().crate_type("dylib").input("foo.rs").output("dylib/".to_owned() + bin_foo).run();
-        },
-    );
-    assert_expected_output_files(
-        &[bin_foo],
-        &[
-            "libbar.ddl.exp",
-            "libbar.dll.lib",
-            "libbar.pdb",
-            "libbar.dll.a",
-            "libbar.exe.a",
-            "bar.ddl.exp",
-            "bar.dll.lib",
-            "bar.pdb",
-            "bar.dll.a",
-            "bar.exe.a",
-        ],
-        "dylib2",
+        Expectations {
+            expected_files: s![bin_foo],
+            allowed_files: s![
+                "libfoo.dll.exp",
+                "libfoo.dll.lib",
+                "libfoo.pdb",
+                "libfoo.dll.a",
+                "libfoo.exe.a",
+                "foo.dll.exp",
+                "foo.dll.lib",
+                "foo.pdb",
+                "foo.dll.a",
+                "foo.exe.a"
+            ],
+            test_dir: "dylib".to_string(),
+        },
+        || {
+            rustc()
+                .crate_type("dylib")
+                .input("foo.rs")
+                .output("dylib/".to_owned() + &bin_foo)
+                .run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s![bin_foo],
+            allowed_files: s![
+                "libfoo.dll.exp",
+                "libfoo.dll.lib",
+                "libfoo.pdb",
+                "libfoo.dll.a",
+                "libfoo.exe.a",
+                "foo.dll.exp",
+                "foo.dll.lib",
+                "foo.pdb",
+                "foo.dll.a",
+                "foo.exe.a"
+            ],
+            test_dir: "dylib2".to_string(),
+        },
         || {
             rustc()
                 .crate_type("dylib")
@@ -180,20 +347,22 @@ fn main() {
         },
     );
     assert_expected_output_files(
-        &[bin_foo],
-        &[
-            "libbar.ddl.exp",
-            "libbar.dll.lib",
-            "libbar.pdb",
-            "libbar.dll.a",
-            "libbar.exe.a",
-            "bar.ddl.exp",
-            "bar.dll.lib",
-            "bar.pdb",
-            "bar.dll.a",
-            "bar.exe.a",
-        ],
-        "dylib3",
+        Expectations {
+            expected_files: s![bin_foo],
+            allowed_files: s![
+                "libfoo.dll.exp",
+                "libfoo.dll.lib",
+                "libfoo.pdb",
+                "libfoo.dll.a",
+                "libfoo.exe.a",
+                "foo.dll.exp",
+                "foo.dll.lib",
+                "foo.pdb",
+                "foo.dll.a",
+                "foo.exe.a"
+            ],
+            test_dir: "dylib3".to_string(),
+        },
         || {
             rustc()
                 .crate_type("dylib")
@@ -203,55 +372,121 @@ fn main() {
         },
     );
 
-    assert_expected_output_files(&["foo"], &[], "staticlib", || {
-        rustc().crate_type("staticlib").input("foo.rs").output("staticlib/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "staticlib2", || {
-        rustc().crate_type("staticlib").input("foo.rs").emit("link=staticlib2/foo").run();
-    });
-    assert_expected_output_files(&["foo"], &[], "staticlib3", || {
-        rustc().crate_type("staticlib").input("foo.rs").arg("--emit=link=staticlib3/foo").run();
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "staticlib".to_string(),
+        },
+        || {
+            rustc().crate_type("staticlib").input("foo.rs").output("staticlib/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "staticlib2".to_string(),
+        },
+        || {
+            rustc().crate_type("staticlib").input("foo.rs").emit("link=staticlib2/foo").run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["foo"],
+            allowed_files: s![],
+            test_dir: "staticlib3".to_string(),
+        },
+        || {
+            rustc().crate_type("staticlib").input("foo.rs").arg("--emit=link=staticlib3/foo").run();
+        },
+    );
 
-    assert_expected_output_files(&["foo"], &["foo.pdb"], "bincrate", || {
-        rustc().crate_type("bin").input("foo.rs").output("bincrate/".to_owned() + bin_foo).run();
-    });
-    assert_expected_output_files(&["foo"], &["foo.pdb"], "bincrate2", || {
-        rustc().crate_type("bin").input("foo.rs").emit(&format!("link=bincrate2/{bin_foo}")).run();
-    });
-    assert_expected_output_files(&["foo"], &["foo.pdb"], "bincrate3", || {
-        rustc()
-            .crate_type("bin")
-            .input("foo.rs")
-            .arg(&format!("--emit=link=bincrate3/{bin_foo}"))
-            .run();
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s![bin_foo],
+            allowed_files: s!["foo.pdb"],
+            test_dir: "bincrate".to_string(),
+        },
+        || {
+            rustc()
+                .crate_type("bin")
+                .input("foo.rs")
+                .output("bincrate/".to_owned() + &bin_foo)
+                .run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s![bin_foo],
+            allowed_files: s!["foo.pdb"],
+            test_dir: "bincrate2".to_string(),
+        },
+        || {
+            rustc()
+                .crate_type("bin")
+                .input("foo.rs")
+                .emit(&format!("link=bincrate2/{bin_foo}"))
+                .run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s![bin_foo],
+            allowed_files: s!["foo.pdb"],
+            test_dir: "bincrate3".to_string(),
+        },
+        || {
+            rustc()
+                .crate_type("bin")
+                .input("foo.rs")
+                .arg(&format!("--emit=link=bincrate3/{bin_foo}"))
+                .run();
+        },
+    );
 
-    assert_expected_output_files(&["ir", rust_bar], &[], "rlib-ir", || {
-        rustc()
-            .input("foo.rs")
-            .emit("llvm-ir=rlib-ir/ir")
-            .emit("link")
-            .crate_type("rlib")
-            .out_dir("rlib-ir")
-            .run();
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["ir", rust_lib_name("bar")],
+            allowed_files: s![],
+            test_dir: "rlib-ir".to_string(),
+        },
+        || {
+            rustc()
+                .input("foo.rs")
+                .emit("llvm-ir=rlib-ir/ir")
+                .emit("link")
+                .crate_type("rlib")
+                .out_dir("rlib-ir")
+                .run();
+        },
+    );
 
-    assert_expected_output_files(&["ir", "asm", "bc", "obj", "link"], &[], "staticlib-all", || {
-        rustc()
-            .input("foo.rs")
-            .emit("asm=staticlib-all/asm")
-            .emit("llvm-ir=staticlib-all/ir")
-            .emit("llvm-bc=staticlib-all/bc")
-            .emit("obj=staticlib-all/obj")
-            .emit("link=staticlib-all/link")
-            .crate_type("staticlib")
-            .run();
-    });
-    assert_expected_output_files(
-        &["ir", "asm", "bc", "obj", "link"],
-        &[],
-        "staticlib-all2",
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["ir", "asm", "bc", "obj", "link"],
+            allowed_files: s![],
+            test_dir: "staticlib-all".to_string(),
+        },
+        || {
+            rustc()
+                .input("foo.rs")
+                .emit("asm=staticlib-all/asm")
+                .emit("llvm-ir=staticlib-all/ir")
+                .emit("llvm-bc=staticlib-all/bc")
+                .emit("obj=staticlib-all/obj")
+                .emit("link=staticlib-all/link")
+                .crate_type("staticlib")
+                .run();
+        },
+    );
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["ir", "asm", "bc", "obj", "link"],
+            allowed_files: s![],
+            test_dir: "staticlib-all2".to_string(),
+        },
         || {
             rustc()
                 .input("foo.rs")
@@ -268,9 +503,10 @@ fn main() {
     );
 
     assert_expected_output_files(
-        &["bar.ll", "bar.s", "bar.o", static_bar],
-        &["bar.bc"], // keep this one for the next test
-        "staticlib-all3",
+        Expectations{ expected_files:
+        s!["bar.ll", "bar.s", "bar.o", static_lib_name("bar")],
+        allowed_files: s!["bar.bc"], test_dir: // keep this one for the next test
+        "staticlib-all3".to_string()},
         || {
             rustc()
                 .input("foo.rs")
@@ -283,9 +519,24 @@ fn main() {
 
     // the .bc file from the previous test should be equivalent to this one, despite the difference
     // in crate type
-    assert_expected_output_files(&["bar.bc", rust_bar, "foo.bc"], &[], "rlib-emits", || {
-        fs_wrapper::rename("staticlib-all3/bar.bc", "rlib-emits/foo.bc");
-        rustc().input("foo.rs").emit("llvm-bc,link").crate_type("rlib").out_dir("rlib-emits").run();
-        assert_eq!(fs_wrapper::read("rlib-emits/foo.bc"), fs_wrapper::read("rlib-emits/bar.bc"));
-    });
+    assert_expected_output_files(
+        Expectations {
+            expected_files: s!["bar.bc", rust_lib_name("bar"), "foo.bc"],
+            allowed_files: s![],
+            test_dir: "rlib-emits".to_string(),
+        },
+        || {
+            fs_wrapper::rename("staticlib-all3/bar.bc", "rlib-emits/foo.bc");
+            rustc()
+                .input("foo.rs")
+                .emit("llvm-bc,link")
+                .crate_type("rlib")
+                .out_dir("rlib-emits")
+                .run();
+            assert_eq!(
+                fs_wrapper::read("rlib-emits/foo.bc"),
+                fs_wrapper::read("rlib-emits/bar.bc")
+            );
+        },
+    );
 }