Skip to content

Commit ed0a203

Browse files
OneiricalOneirical
committed
massive refactor of reproducible-build test
1 parent 5015a26 commit ed0a203

File tree

1 file changed

+180
-156
lines changed
  • tests/run-make/reproducible-build

1 file changed

+180
-156
lines changed

‎tests/run-make/reproducible-build/rmake.rs

+180-156
Original file line numberDiff line numberDiff line change
@@ -18,205 +18,229 @@
1818
// - Trait object shims
1919
// - Fn Pointer shims
2020
// See https://github.com/rust-lang/rust/pull/32293
21+
// Tracking Issue: https://github.com/rust-lang/rust/issues/129080
2122

22-
// FIXME(Oneirical): ignore-musl
23-
// FIXME(Oneirical): two of these test blocks will apparently fail on windows
24-
// FIXME(Oneirical): try it on test-various
23+
// FIXME(Oneirical): ignore-windows
2524
// # FIXME: Builds of `bin` crate types are not deterministic with debuginfo=2 on
2625
// # Windows.
2726
// # See: https://github.com/rust-lang/rust/pull/87320#issuecomment-920105533
2827
// # Issue: https://github.com/rust-lang/rust/issues/88982
2928

30-
use run_make_support::{bin_name, cwd, diff, rfs, run_in_tmpdir, rust_lib_name, rustc};
29+
use run_make_support::{
30+
bin_name, cwd, diff, is_darwin, is_windows, rfs, run_in_tmpdir, rust_lib_name, rustc,
31+
};
3132

3233
fn main() {
33-
run_in_tmpdir(|| {
34-
rustc().input("linker.rs").opt().run();
35-
rustc().input("reproducible-build-aux.rs").run();
36-
rustc()
37-
.input("reproducible-build.rs")
38-
.linker(&cwd().join(bin_name("linker")).display().to_string())
39-
.run();
40-
rustc()
41-
.input("reproducible-build.rs")
42-
.linker(&cwd().join(bin_name("linker")).display().to_string())
43-
.run();
44-
diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
45-
});
34+
// Smoke tests. Simple flags, build should be reproducible.
35+
eprintln!("smoke_test => None");
36+
smoke_test(None);
37+
eprintln!("smoke_test => SmokeFlag::Debug");
38+
smoke_test(Some(SmokeFlag::Debug));
39+
eprintln!("smoke_test => SmokeFlag::Opt");
40+
smoke_test(Some(SmokeFlag::Opt));
4641

47-
run_in_tmpdir(|| {
48-
rustc().input("linker.rs").opt().run();
49-
rustc().arg("-g").input("reproducible-build-aux.rs").run();
50-
rustc()
51-
.arg("-g")
52-
.input("reproducible-build.rs")
53-
.linker(&cwd().join(bin_name("linker")).display().to_string())
54-
.run();
55-
rustc()
56-
.arg("-g")
57-
.input("reproducible-build.rs")
58-
.linker(&cwd().join(bin_name("linker")).display().to_string())
59-
.run();
60-
diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
61-
});
42+
// Builds should be reproducible even through custom library search paths
43+
// or remap path prefixes.
44+
eprintln!("paths_test => PathsFlag::Link");
45+
paths_test(PathsFlag::Link);
46+
eprintln!("paths_test => PathsFlag::Remap");
47+
paths_test(PathsFlag::Remap);
6248

63-
run_in_tmpdir(|| {
64-
rustc().input("linker.rs").opt().run();
65-
rustc().opt().input("reproducible-build-aux.rs").run();
66-
rustc()
67-
.opt()
68-
.input("reproducible-build.rs")
69-
.linker(&cwd().join(bin_name("linker")).display().to_string())
70-
.run();
71-
rustc()
72-
.opt()
73-
.input("reproducible-build.rs")
74-
.linker(&cwd().join(bin_name("linker")).display().to_string())
75-
.run();
76-
diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
77-
});
49+
// Builds should be reproducible even if each build is done in a different directory,
50+
// with both --remap-path-prefix and -Z remap-cwd-prefix.
7851

79-
run_in_tmpdir(|| {
80-
rustc().input("reproducible-build-aux.rs").run();
81-
rustc().input("reproducible-build.rs").crate_type("rlib").library_search_path("b").run();
82-
rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
83-
rustc().input("reproducible-build.rs").crate_type("rlib").library_search_path("a").run();
84-
assert_eq!(rfs::read(rust_lib_name("reproducible_build")), rfs::read(rust_lib_name("foo")));
85-
});
52+
// FIXME(Oneirical): Building with crate type set to `bin` AND having -Cdebuginfo=2
53+
// (or `-g`, the shorthand form) enabled will cause reproducibility failures.
54+
// See https://github.com/rust-lang/rust/issues/89911
55+
56+
if !is_darwin() && !is_windows() {
57+
// FIXME(Oneirical): Bin builds are not reproducible on non-Linux targets.
58+
eprintln!("diff_dir_test => Bin, Path");
59+
diff_dir_test(CrateType::Bin, RemapType::Path);
60+
}
61+
62+
eprintln!("diff_dir_test => Rlib, Path");
63+
diff_dir_test(CrateType::Rlib, RemapType::Path);
64+
65+
// FIXME(Oneirical): This specific case would fail on Linux, should -Cdebuginfo=2
66+
// be added.
67+
// FIXME(Oneirical): Bin builds are not reproducible on non-Linux targets.
68+
// See https://github.com/rust-lang/rust/issues/89911
69+
if !is_darwin() && !is_windows() {
70+
eprintln!("diff_dir_test => Bin, Cwd false");
71+
diff_dir_test(CrateType::Bin, RemapType::Cwd { is_empty: false });
72+
}
73+
74+
eprintln!("diff_dir_test => Rlib, Cwd false");
75+
diff_dir_test(CrateType::Rlib, RemapType::Cwd { is_empty: false });
76+
eprintln!("diff_dir_test => Rlib, Cwd true");
77+
diff_dir_test(CrateType::Rlib, RemapType::Cwd { is_empty: true });
8678

79+
eprintln!("final extern test");
80+
// Builds should be reproducible when using the --extern flag.
8781
run_in_tmpdir(|| {
8882
rustc().input("reproducible-build-aux.rs").run();
8983
rustc()
9084
.input("reproducible-build.rs")
9185
.crate_type("rlib")
92-
.arg("--remap-path-prefix=/a=/c")
86+
.extern_("reproducible_build_aux", rust_lib_name("reproducible_build_aux"))
9387
.run();
9488
rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
89+
rfs::copy(rust_lib_name("reproducible_build_aux"), rust_lib_name("bar"));
9590
rustc()
9691
.input("reproducible-build.rs")
9792
.crate_type("rlib")
98-
.arg("--remap-path-prefix=/b=/c")
93+
.extern_("reproducible_build_aux", rust_lib_name("bar"))
9994
.run();
100-
assert_eq!(rfs::read(rust_lib_name("reproducible_build")), rfs::read(rust_lib_name("foo")));
95+
assert!(rfs::read(rust_lib_name("foo")) == rfs::read(rust_lib_name("reproducible_build")))
10196
});
97+
}
10298

99+
#[track_caller]
100+
fn smoke_test(flag: Option<SmokeFlag>) {
103101
run_in_tmpdir(|| {
102+
rustc().input("linker.rs").opt().run();
104103
rustc().input("reproducible-build-aux.rs").run();
105-
rfs::create_dir("test");
106-
rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
107-
rustc()
104+
let mut compiler1 = rustc();
105+
let mut compiler2 = rustc();
106+
if let Some(flag) = flag {
107+
match flag {
108+
SmokeFlag::Debug => {
109+
compiler1.arg("-g");
110+
compiler2.arg("-g");
111+
}
112+
SmokeFlag::Opt => {
113+
compiler1.opt();
114+
compiler2.opt();
115+
}
116+
};
117+
};
118+
compiler1
108119
.input("reproducible-build.rs")
109-
.crate_type("bin")
110-
.arg(&format!("--remap-path-prefix={}=/b", cwd().display()))
111-
.run();
112-
eprintln!("{:#?}", rfs::shallow_find_dir_entries(cwd()));
113-
rfs::copy(bin_name("reproducible_build"), bin_name("foo"));
114-
rustc()
115-
.input("test/reproducible-build.rs")
116-
.crate_type("bin")
117-
.arg("--remap-path-prefix=/test=/b")
120+
.linker(&cwd().join(bin_name("linker")).display().to_string())
118121
.run();
119-
assert_eq!(rfs::read(bin_name("reproducible_build")), rfs::read(bin_name("foo")));
120-
});
121-
122-
run_in_tmpdir(|| {
123-
rustc().input("reproducible-build-aux.rs").run();
124-
rfs::create_dir("test");
125-
rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
126-
rustc()
122+
compiler2
127123
.input("reproducible-build.rs")
128-
.crate_type("rlib")
129-
.arg(&format!("--remap-path-prefix={}=/b", cwd().display()))
130-
.run();
131-
rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
132-
rustc()
133-
.input("test/reproducible-build.rs")
134-
.crate_type("rlib")
135-
.arg("--remap-path-prefix=/test=/b")
124+
.linker(&cwd().join(bin_name("linker")).display().to_string())
136125
.run();
137-
assert_eq!(rfs::read(rust_lib_name("reproducible_build")), rfs::read(rust_lib_name("foo")));
126+
diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
138127
});
128+
}
139129

130+
#[track_caller]
131+
fn paths_test(flag: PathsFlag) {
140132
run_in_tmpdir(|| {
141133
rustc().input("reproducible-build-aux.rs").run();
142-
rfs::create_dir("test");
143-
rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
144-
rustc()
145-
.input("reproducible-build.rs")
146-
.crate_type("bin")
147-
.arg("-Zremap-path-prefix=.")
148-
.arg("-Cdebuginfo=2")
149-
.run();
150-
rfs::copy(bin_name("reproducible_build"), bin_name("first"));
151-
rustc()
152-
.input("test/reproducible-build.rs")
153-
.crate_type("bin")
154-
.arg("-Zremap-path-prefix=.")
155-
.arg("-Cdebuginfo=2")
156-
.run();
157-
assert_eq!(rfs::read(bin_name("first")), rfs::read(bin_name("reproducible_build")));
134+
let mut compiler1 = rustc();
135+
let mut compiler2 = rustc();
136+
match flag {
137+
PathsFlag::Link => {
138+
compiler1.library_search_path("a");
139+
compiler2.library_search_path("b");
140+
}
141+
PathsFlag::Remap => {
142+
compiler1.arg("--remap-path-prefix=/a=/c");
143+
compiler2.arg("--remap-path-prefix=/b=/c");
144+
}
145+
}
146+
compiler1.input("reproducible-build.rs").crate_type("rlib").run();
147+
rfs::rename(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
148+
compiler2.input("reproducible-build.rs").crate_type("rlib").run();
149+
assert!(rfs::read(rust_lib_name("foo")) == rfs::read(rust_lib_name("reproducible_build")))
158150
});
151+
}
159152

153+
#[track_caller]
154+
fn diff_dir_test(crate_type: CrateType, remap_type: RemapType) {
160155
run_in_tmpdir(|| {
156+
let base_dir = cwd();
161157
rustc().input("reproducible-build-aux.rs").run();
162158
rfs::create_dir("test");
163159
rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
164-
rustc()
160+
let mut compiler1 = rustc();
161+
let mut compiler2 = rustc();
162+
match crate_type {
163+
CrateType::Bin => {
164+
compiler1.crate_type("bin");
165+
compiler2.crate_type("bin");
166+
}
167+
CrateType::Rlib => {
168+
compiler1.crate_type("rlib");
169+
compiler2.crate_type("rlib");
170+
}
171+
}
172+
match remap_type {
173+
RemapType::Path => {
174+
compiler1.arg(&format!("--remap-path-prefix={}=/b", cwd().display()));
175+
compiler2
176+
.arg(format!("--remap-path-prefix={}=/b", base_dir.join("test").display()));
177+
}
178+
RemapType::Cwd { is_empty } => {
179+
// FIXME(Oneirical): Building with crate type set to `bin` AND having -Cdebuginfo=2
180+
// (or `-g`, the shorthand form) enabled will cause reproducibility failures
181+
// for multiple platforms.
182+
// See https://github.com/rust-lang/rust/issues/89911
183+
// FIXME(#129117): Windows rlib + `-Cdebuginfo=2` + `-Z remap-cwd-prefix=.` seems
184+
// to be unreproducible.
185+
if !matches!(crate_type, CrateType::Bin) && !is_windows() {
186+
compiler1.arg("-Cdebuginfo=2");
187+
compiler2.arg("-Cdebuginfo=2");
188+
}
189+
if is_empty {
190+
compiler1.arg("-Zremap-cwd-prefix=");
191+
compiler2.arg("-Zremap-cwd-prefix=");
192+
} else {
193+
compiler1.arg("-Zremap-cwd-prefix=.");
194+
compiler2.arg("-Zremap-cwd-prefix=.");
195+
}
196+
}
197+
}
198+
compiler1.input("reproducible-build.rs").run();
199+
match crate_type {
200+
CrateType::Bin => {
201+
rfs::rename(bin_name("reproducible-build"), bin_name("foo"));
202+
}
203+
CrateType::Rlib => {
204+
rfs::rename(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
205+
}
206+
}
207+
std::env::set_current_dir("test").unwrap();
208+
compiler2
165209
.input("reproducible-build.rs")
166-
.crate_type("rlib")
167-
.arg("-Zremap-path-prefix=.")
168-
.arg("-Cdebuginfo=2")
169-
.run();
170-
rfs::copy("reproducible_build", "first");
171-
rustc()
172-
.input("test/reproducible-build.rs")
173-
.crate_type("rlib")
174-
.arg("-Zremap-path-prefix=.")
175-
.arg("-Cdebuginfo=2")
176-
.run();
177-
assert_eq!(
178-
rfs::read(rust_lib_name("first")),
179-
rfs::read(rust_lib_name("reproducible_build"))
180-
);
210+
.library_search_path(&base_dir)
211+
.out_dir(&base_dir)
212+
.run();
213+
std::env::set_current_dir(&base_dir).unwrap();
214+
match crate_type {
215+
CrateType::Bin => {
216+
assert!(rfs::read(bin_name("reproducible-build")) == rfs::read(bin_name("foo")));
217+
}
218+
CrateType::Rlib => {
219+
assert!(
220+
rfs::read(rust_lib_name("foo"))
221+
== rfs::read(rust_lib_name("reproducible_build"))
222+
);
223+
}
224+
}
181225
});
226+
}
182227

183-
run_in_tmpdir(|| {
184-
rustc().input("reproducible-build-aux.rs").run();
185-
rfs::create_dir("test");
186-
rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
187-
rustc()
188-
.input("reproducible-build.rs")
189-
.crate_type("rlib")
190-
.arg("-Zremap-path-prefix=")
191-
.arg("-Cdebuginfo=2")
192-
.run();
193-
rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("first"));
194-
rustc()
195-
.input("test/reproducible-build.rs")
196-
.crate_type("rlib")
197-
.arg("-Zremap-path-prefix=")
198-
.arg("-Cdebuginfo=2")
199-
.run();
200-
assert_eq!(
201-
rfs::read(rust_lib_name("first")),
202-
rfs::read(rust_lib_name("reproducible_build"))
203-
);
204-
});
228+
enum SmokeFlag {
229+
Debug,
230+
Opt,
231+
}
205232

206-
run_in_tmpdir(|| {
207-
rustc().input("reproducible-build-aux.rs").run();
208-
rustc()
209-
.input("reproducible-build.rs")
210-
.crate_type("rlib")
211-
.extern_("reproducible_build_aux", rust_lib_name("reproducible_build_aux"))
212-
.run();
213-
rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
214-
rfs::copy(rust_lib_name("reproducible_build_aux"), rust_lib_name("bar"));
215-
rustc()
216-
.input("reproducible-build.rs")
217-
.crate_type("rlib")
218-
.extern_("reproducible_build_aux", rust_lib_name("bar"))
219-
.run();
220-
assert_eq!(rfs::read(rust_lib_name("foo")), rfs::read(rust_lib_name("reproducible_build")));
221-
});
233+
enum PathsFlag {
234+
Link,
235+
Remap,
236+
}
237+
238+
enum CrateType {
239+
Bin,
240+
Rlib,
241+
}
242+
243+
enum RemapType {
244+
Path,
245+
Cwd { is_empty: bool },
222246
}

0 commit comments

Comments
 (0)