1 #![allow(clippy::match_like_matches_macro)]
2
3 use std::process::Command;
4
5 use rustc_version::{
6 version, version_meta, version_meta_for, Channel, Error, LlvmVersion, LlvmVersionParseError,
7 Version, VersionMeta,
8 };
9
10 #[test]
rustc_error()11 fn rustc_error() {
12 let mut cmd = Command::new("rustc");
13 cmd.arg("--FOO");
14 let stderr = match VersionMeta::for_command(cmd) {
15 Err(Error::CommandError { stdout: _, stderr }) => stderr,
16 _ => panic!("command error expected"),
17 };
18 assert_eq!(stderr, "error: Unrecognized option: \'FOO\'\n\n");
19 }
20
21 #[test]
smoketest()22 fn smoketest() {
23 let v = version().unwrap();
24 assert!(v.major >= 1);
25
26 let v = version_meta().unwrap();
27 assert!(v.semver.major >= 1);
28
29 assert!(version().unwrap() >= Version::parse("1.0.0").unwrap());
30 }
31
32 #[test]
parse_1_0_0()33 fn parse_1_0_0() {
34 let version = version_meta_for(
35 "rustc 1.0.0 (a59de37e9 2015-05-13) (built 2015-05-14)
36 binary: rustc
37 commit-hash: a59de37e99060162a2674e3ff45409ac73595c0e
38 commit-date: 2015-05-13
39 build-date: 2015-05-14
40 host: x86_64-unknown-linux-gnu
41 release: 1.0.0",
42 )
43 .unwrap();
44
45 assert_eq!(version.semver, Version::parse("1.0.0").unwrap());
46 assert_eq!(
47 version.commit_hash,
48 Some("a59de37e99060162a2674e3ff45409ac73595c0e".into())
49 );
50 assert_eq!(version.commit_date, Some("2015-05-13".into()));
51 assert_eq!(version.build_date, Some("2015-05-14".into()));
52 assert_eq!(version.channel, Channel::Stable);
53 assert_eq!(version.host, "x86_64-unknown-linux-gnu");
54 assert_eq!(
55 version.short_version_string,
56 "rustc 1.0.0 (a59de37e9 2015-05-13) (built 2015-05-14)"
57 );
58 assert_eq!(version.llvm_version, None);
59 }
60
61 #[test]
parse_unknown()62 fn parse_unknown() {
63 let version = version_meta_for(
64 "rustc 1.3.0
65 binary: rustc
66 commit-hash: unknown
67 commit-date: unknown
68 host: x86_64-unknown-linux-gnu
69 release: 1.3.0",
70 )
71 .unwrap();
72
73 assert_eq!(version.semver, Version::parse("1.3.0").unwrap());
74 assert_eq!(version.commit_hash, None);
75 assert_eq!(version.commit_date, None);
76 assert_eq!(version.channel, Channel::Stable);
77 assert_eq!(version.host, "x86_64-unknown-linux-gnu");
78 assert_eq!(version.short_version_string, "rustc 1.3.0");
79 assert_eq!(version.llvm_version, None);
80 }
81
82 #[test]
parse_nightly()83 fn parse_nightly() {
84 let version = version_meta_for(
85 "rustc 1.5.0-nightly (65d5c0833 2015-09-29)
86 binary: rustc
87 commit-hash: 65d5c083377645a115c4ac23a620d3581b9562b6
88 commit-date: 2015-09-29
89 host: x86_64-unknown-linux-gnu
90 release: 1.5.0-nightly",
91 )
92 .unwrap();
93
94 assert_eq!(version.semver, Version::parse("1.5.0-nightly").unwrap());
95 assert_eq!(
96 version.commit_hash,
97 Some("65d5c083377645a115c4ac23a620d3581b9562b6".into())
98 );
99 assert_eq!(version.commit_date, Some("2015-09-29".into()));
100 assert_eq!(version.channel, Channel::Nightly);
101 assert_eq!(version.host, "x86_64-unknown-linux-gnu");
102 assert_eq!(
103 version.short_version_string,
104 "rustc 1.5.0-nightly (65d5c0833 2015-09-29)"
105 );
106 assert_eq!(version.llvm_version, None);
107 }
108
109 #[test]
parse_stable()110 fn parse_stable() {
111 let version = version_meta_for(
112 "rustc 1.3.0 (9a92aaf19 2015-09-15)
113 binary: rustc
114 commit-hash: 9a92aaf19a64603b02b4130fe52958cc12488900
115 commit-date: 2015-09-15
116 host: x86_64-unknown-linux-gnu
117 release: 1.3.0",
118 )
119 .unwrap();
120
121 assert_eq!(version.semver, Version::parse("1.3.0").unwrap());
122 assert_eq!(
123 version.commit_hash,
124 Some("9a92aaf19a64603b02b4130fe52958cc12488900".into())
125 );
126 assert_eq!(version.commit_date, Some("2015-09-15".into()));
127 assert_eq!(version.channel, Channel::Stable);
128 assert_eq!(version.host, "x86_64-unknown-linux-gnu");
129 assert_eq!(
130 version.short_version_string,
131 "rustc 1.3.0 (9a92aaf19 2015-09-15)"
132 );
133 assert_eq!(version.llvm_version, None);
134 }
135
136 #[test]
parse_1_16_0_nightly()137 fn parse_1_16_0_nightly() {
138 let version = version_meta_for(
139 "rustc 1.16.0-nightly (5d994d8b7 2017-01-05)
140 binary: rustc
141 commit-hash: 5d994d8b7e482e87467d4a521911477bd8284ce3
142 commit-date: 2017-01-05
143 host: x86_64-unknown-linux-gnu
144 release: 1.16.0-nightly
145 LLVM version: 3.9",
146 )
147 .unwrap();
148
149 assert_eq!(version.semver, Version::parse("1.16.0-nightly").unwrap());
150 assert_eq!(
151 version.commit_hash,
152 Some("5d994d8b7e482e87467d4a521911477bd8284ce3".into())
153 );
154 assert_eq!(version.commit_date, Some("2017-01-05".into()));
155 assert_eq!(version.channel, Channel::Nightly);
156 assert_eq!(version.host, "x86_64-unknown-linux-gnu");
157 assert_eq!(
158 version.short_version_string,
159 "rustc 1.16.0-nightly (5d994d8b7 2017-01-05)"
160 );
161 assert_eq!(
162 version.llvm_version,
163 Some(LlvmVersion { major: 3, minor: 9 })
164 );
165 }
166
167 #[test]
parse_1_47_0_stable()168 fn parse_1_47_0_stable() {
169 let version = version_meta_for(
170 "rustc 1.47.0 (18bf6b4f0 2020-10-07)
171 binary: rustc
172 commit-hash: 18bf6b4f01a6feaf7259ba7cdae58031af1b7b39
173 commit-date: 2020-10-07
174 host: powerpc64le-unknown-linux-gnu
175 release: 1.47.0
176 LLVM version: 11.0",
177 )
178 .unwrap();
179
180 assert_eq!(version.semver, Version::parse("1.47.0").unwrap());
181 assert_eq!(
182 version.commit_hash,
183 Some("18bf6b4f01a6feaf7259ba7cdae58031af1b7b39".into())
184 );
185 assert_eq!(version.commit_date, Some("2020-10-07".into()));
186 assert_eq!(version.channel, Channel::Stable);
187 assert_eq!(version.host, "powerpc64le-unknown-linux-gnu");
188 assert_eq!(
189 version.short_version_string,
190 "rustc 1.47.0 (18bf6b4f0 2020-10-07)"
191 );
192 assert_eq!(
193 version.llvm_version,
194 Some(LlvmVersion {
195 major: 11,
196 minor: 0,
197 })
198 );
199 }
200
201 #[test]
parse_llvm_micro()202 fn parse_llvm_micro() {
203 let version = version_meta_for(
204 "rustc 1.51.0-nightly (4253153db 2021-01-17)
205 binary: rustc
206 commit-hash: 4253153db205251f72ea4493687a31e04a2a8ca0
207 commit-date: 2021-01-17
208 host: x86_64-pc-windows-msvc
209 release: 1.51.0-nightly
210 LLVM version: 11.0.1",
211 )
212 .unwrap();
213
214 assert_eq!(version.semver, Version::parse("1.51.0-nightly").unwrap());
215 assert_eq!(
216 version.commit_hash.unwrap(),
217 "4253153db205251f72ea4493687a31e04a2a8ca0"
218 );
219 assert_eq!(version.commit_date.unwrap(), "2021-01-17");
220 assert_eq!(version.host, "x86_64-pc-windows-msvc");
221 assert_eq!(
222 version.short_version_string,
223 "rustc 1.51.0-nightly (4253153db 2021-01-17)"
224 );
225 assert_eq!(
226 version.llvm_version,
227 Some(LlvmVersion {
228 major: 11,
229 minor: 0
230 })
231 );
232 }
233
234 #[test]
parse_debian_buster()235 fn parse_debian_buster() {
236 let version = version_meta_for(
237 "rustc 1.41.1
238 binary: rustc
239 commit-hash: unknown
240 commit-date: unknown
241 host: powerpc64le-unknown-linux-gnu
242 release: 1.41.1
243 LLVM version: 7.0",
244 )
245 .unwrap();
246
247 assert_eq!(version.semver, Version::parse("1.41.1").unwrap());
248 assert_eq!(version.commit_hash, None);
249 assert_eq!(version.commit_date, None);
250 assert_eq!(version.channel, Channel::Stable);
251 assert_eq!(version.host, "powerpc64le-unknown-linux-gnu");
252 assert_eq!(version.short_version_string, "rustc 1.41.1");
253 assert_eq!(
254 version.llvm_version,
255 Some(LlvmVersion { major: 7, minor: 0 })
256 );
257 }
258
259 #[test]
parse_termux()260 fn parse_termux() {
261 let version = version_meta_for(
262 "rustc 1.46.0
263 binary: rustc
264 commit-hash: unknown
265 commit-date: unknown
266 host: aarch64-linux-android
267 release: 1.46.0
268 LLVM version: 10.0",
269 )
270 .unwrap();
271
272 assert_eq!(version.semver, Version::parse("1.46.0").unwrap());
273 assert_eq!(version.commit_hash, None);
274 assert_eq!(version.commit_date, None);
275 assert_eq!(version.channel, Channel::Stable);
276 assert_eq!(version.host, "aarch64-linux-android");
277 assert_eq!(version.short_version_string, "rustc 1.46.0");
278 assert_eq!(
279 version.llvm_version,
280 Some(LlvmVersion {
281 major: 10,
282 minor: 0,
283 })
284 );
285 }
286
287 #[test]
parse_llvm_version_empty()288 fn parse_llvm_version_empty() {
289 let res: Result<LlvmVersion, _> = "".parse();
290 assert!(match res {
291 Err(LlvmVersionParseError::ParseIntError(_)) => true,
292 _ => false,
293 });
294 }
295
296 #[test]
parse_llvm_version_invalid_char()297 fn parse_llvm_version_invalid_char() {
298 let res: Result<LlvmVersion, _> = "A".parse();
299 assert!(match res {
300 Err(LlvmVersionParseError::ParseIntError(_)) => true,
301 _ => false,
302 });
303 }
304
305 #[test]
parse_llvm_version_overflow()306 fn parse_llvm_version_overflow() {
307 let res: Result<LlvmVersion, _> = "9999999999999999999999999999999".parse();
308 assert!(match res {
309 Err(LlvmVersionParseError::ParseIntError(_)) => true,
310 _ => false,
311 });
312 }
313
314 #[test]
parse_llvm_version_leading_zero_on_zero()315 fn parse_llvm_version_leading_zero_on_zero() {
316 let res: Result<LlvmVersion, _> = "00".parse();
317 assert!(match res {
318 Err(LlvmVersionParseError::ComponentMustNotHaveLeadingZeros) => true,
319 _ => false,
320 });
321 }
322
323 #[test]
parse_llvm_version_leading_zero_on_nonzero()324 fn parse_llvm_version_leading_zero_on_nonzero() {
325 let res: Result<LlvmVersion, _> = "01".parse();
326 assert!(match res {
327 Err(LlvmVersionParseError::ComponentMustNotHaveLeadingZeros) => true,
328 _ => false,
329 });
330 }
331
332 #[test]
parse_llvm_version_4_components()333 fn parse_llvm_version_4_components() {
334 let res: Result<LlvmVersion, _> = "4.0.0.0".parse();
335
336 assert!(match res {
337 Err(LlvmVersionParseError::TooManyComponents) => true,
338 _ => false,
339 });
340 }
341
342 #[test]
parse_llvm_version_component_sign_plus()343 fn parse_llvm_version_component_sign_plus() {
344 let res: Result<LlvmVersion, _> = "1.+3".parse();
345
346 assert!(match res {
347 Err(LlvmVersionParseError::ComponentMustNotHaveSign) => true,
348 _ => false,
349 });
350 }
351
352 #[test]
parse_llvm_version_component_sign_minus()353 fn parse_llvm_version_component_sign_minus() {
354 let res: Result<LlvmVersion, _> = "1.-3".parse();
355
356 assert!(match res {
357 Err(LlvmVersionParseError::ComponentMustNotHaveSign) => true,
358 _ => false,
359 });
360 }
361
362 #[test]
parse_llvm_version_3()363 fn parse_llvm_version_3() {
364 let res: Result<LlvmVersion, _> = "3".parse();
365
366 assert!(match res {
367 Err(LlvmVersionParseError::MinorVersionRequiredBefore4) => true,
368 _ => false,
369 });
370 }
371
372 #[test]
parse_llvm_version_5()373 fn parse_llvm_version_5() {
374 let v: LlvmVersion = "5".parse().unwrap();
375 assert_eq!(v, LlvmVersion { major: 5, minor: 0 });
376 }
377
378 #[test]
parse_llvm_version_5_0()379 fn parse_llvm_version_5_0() {
380 let v: LlvmVersion = "5.0".parse().unwrap();
381 assert_eq!(v, LlvmVersion { major: 5, minor: 0 });
382 }
383
384 #[test]
parse_llvm_version_4_0()385 fn parse_llvm_version_4_0() {
386 let v: LlvmVersion = "4.0".parse().unwrap();
387 assert_eq!(v, LlvmVersion { major: 4, minor: 0 });
388 }
389
390 #[test]
parse_llvm_version_3_0()391 fn parse_llvm_version_3_0() {
392 let v: LlvmVersion = "3.0".parse().unwrap();
393 assert_eq!(v, LlvmVersion { major: 3, minor: 0 });
394 }
395
396 #[test]
parse_llvm_version_3_9()397 fn parse_llvm_version_3_9() {
398 let v: LlvmVersion = "3.9".parse().unwrap();
399 assert_eq!(v, LlvmVersion { major: 3, minor: 9 });
400 }
401
402 #[test]
parse_llvm_version_11_0()403 fn parse_llvm_version_11_0() {
404 let v: LlvmVersion = "11.0".parse().unwrap();
405 assert_eq!(
406 v,
407 LlvmVersion {
408 major: 11,
409 minor: 0
410 }
411 );
412 }
413
414 #[test]
parse_llvm_version_11()415 fn parse_llvm_version_11() {
416 let v: LlvmVersion = "11".parse().unwrap();
417 assert_eq!(
418 v,
419 LlvmVersion {
420 major: 11,
421 minor: 0
422 }
423 );
424 }
425
426 #[test]
test_llvm_version_comparison()427 fn test_llvm_version_comparison() {
428 // check that field order is correct
429 assert!(LlvmVersion { major: 3, minor: 9 } < LlvmVersion { major: 4, minor: 0 });
430 }
431
432 /*
433 #[test]
434 fn version_matches_replacement() {
435 let f = |s1: &str, s2: &str| {
436 let a = Version::parse(s1).unwrap();
437 let b = Version::parse(s2).unwrap();
438 println!("{} <= {} : {}", s1, s2, a <= b);
439 };
440
441 println!();
442
443 f("1.5.0", "1.5.0");
444 f("1.5.0-nightly", "1.5.0");
445 f("1.5.0", "1.5.0-nightly");
446 f("1.5.0-nightly", "1.5.0-nightly");
447
448 f("1.5.0", "1.6.0");
449 f("1.5.0-nightly", "1.6.0");
450 f("1.5.0", "1.6.0-nightly");
451 f("1.5.0-nightly", "1.6.0-nightly");
452
453 panic!();
454
455 }
456 */
457