99 lines
2.7 KiB
Rust
99 lines
2.7 KiB
Rust
//@ run-pass
|
|
//@ needs-unwind
|
|
#![allow(unused_imports)]
|
|
// Ideally, any macro call with a trailing comma should behave
|
|
// identically to a call without the comma.
|
|
//
|
|
// This checks the behavior of macros with trailing commas in key
|
|
// places where regressions in behavior seem highly possible (due
|
|
// to it being e.g., a place where the addition of an argument
|
|
// causes it to go down a code path with subtly different behavior).
|
|
//
|
|
// There is a companion failing test.
|
|
|
|
//@ compile-flags: --test -C debug_assertions=yes
|
|
//@ revisions: std core
|
|
|
|
#![cfg_attr(core, no_std)]
|
|
|
|
#[cfg(core)]
|
|
use core::fmt;
|
|
#[cfg(std)]
|
|
use std::fmt;
|
|
|
|
// an easy mistake in the implementation of 'assert!'
|
|
// would cause this to say "explicit panic"
|
|
#[test]
|
|
#[should_panic(expected = "assertion failed")]
|
|
fn assert_1arg() {
|
|
assert!(false,);
|
|
}
|
|
|
|
// same as 'assert_1arg'
|
|
#[test]
|
|
#[should_panic(expected = "assertion failed")]
|
|
fn debug_assert_1arg() {
|
|
debug_assert!(false,);
|
|
}
|
|
|
|
// make sure we don't accidentally forward to `write!("text")`
|
|
#[cfg(std)]
|
|
#[test]
|
|
fn writeln_1arg() {
|
|
use fmt::Write;
|
|
|
|
let mut s = String::new();
|
|
writeln!(&mut s,).unwrap();
|
|
assert_eq!(&s, "\n");
|
|
}
|
|
|
|
// A number of format_args-like macros have special-case treatment
|
|
// for a single message string, which is not formatted.
|
|
//
|
|
// This test ensures that the addition of a trailing comma does not
|
|
// suddenly cause these strings to get formatted when they otherwise
|
|
// would not be. This is an easy mistake to make by having such a macro
|
|
// accept ", $($tok:tt)*" instead of ", $($tok:tt)+" after its minimal
|
|
// set of arguments.
|
|
//
|
|
// (Example: Issue #48042)
|
|
#[test]
|
|
#[allow(non_fmt_panics)]
|
|
fn to_format_or_not_to_format() {
|
|
// ("{}" is the easiest string to test because if this gets
|
|
// sent to format_args!, it'll simply fail to compile.
|
|
// "{{}}" is an example of an input that could compile and
|
|
// produce an incorrect program, but testing the panics
|
|
// would be burdensome.)
|
|
let falsum = || false;
|
|
|
|
assert!(true, "{}",);
|
|
|
|
// assert_eq!(1, 1, "{}",); // see check-fail
|
|
// assert_ne!(1, 2, "{}",); // see check-fail
|
|
|
|
debug_assert!(true, "{}",);
|
|
|
|
// debug_assert_eq!(1, 1, "{}",); // see check-fail
|
|
// debug_assert_ne!(1, 2, "{}",); // see check-fail
|
|
// eprint!("{}",); // see check-fail
|
|
// eprintln!("{}",); // see check-fail
|
|
// format!("{}",); // see check-fail
|
|
// format_args!("{}",); // see check-fail
|
|
|
|
if falsum() {
|
|
panic!("{}",);
|
|
}
|
|
|
|
// print!("{}",); // see check-fail
|
|
// println!("{}",); // see check-fail
|
|
// unimplemented!("{}",); // see check-fail
|
|
|
|
if falsum() {
|
|
unreachable!("{}",);
|
|
}
|
|
|
|
// write!(&mut stdout, "{}",); // see check-fail
|
|
// writeln!(&mut stdout, "{}",); // see check-fail
|
|
}
|