Tidy up and pass tests

[rust.git] / tests / target / macros.rs

diff --git a/tests/target/macros.rs b/tests/target/macros.rs
index 47dad382e0af67e60a9019e27a240c09d6a4441a..8db2fbb60ee99ebbd74d77b3322dd738b13b6619 100644 (file)
--- a/tests/target/macros.rs
+++ b/tests/target/macros.rs
@@ -141,7 +141,7 @@ fn issue_1555() {
 
 fn issue1178() {
     macro_rules! foo {
-        (#[$attr:meta] $name:ident) => {}
+        (#[$attr: meta] $name: ident) => {};
     }
 
     foo!(
@@ -207,7 +207,7 @@ fn issue_1921() {
             acc += 1;
             acc += 2;
             acc
-        }
+        };
     }
 }
 
@@ -246,11 +246,15 @@ fn __bindgen_test_layout_HandleWithDtor_open0_int_close0_instantiation() {
 
 // #878
 macro_rules! try_opt {
-    ($expr:expr) => (match $expr {
-        Some(val) => val,
+    ($expr: expr) => {
+        match $expr {
+            Some(val) => val,
 
-        None => { return None; }
-    })
+            None => {
+                return None;
+            }
+        }
+    };
 }
 
 // #2214
@@ -271,6 +275,7 @@ fn issue2214() {
 }
 
 fn special_case_macros() {
+    let p = eprint!();
     let q = eprint!("{}", 1);
     let r = eprint!(
         "{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
@@ -411,6 +416,41 @@ fn special_case_macros() {
         26
     );
 
+    let q = print!("{}", 1);
+    let r = print!(
+        "{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+    );
+    let s = print!(
+        "{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24,
+        25,
+        26
+    );
+
     let q = println!("{}", 1);
     let r = println!(
         "{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
@@ -656,12 +696,177 @@ fn special_case_macros() {
         26
     );
 
-    // assert!
+    assert!();
+    assert!(result == 42);
+    assert!(result == 42, "Ahoy there, {}!", target);
     assert!(
+        result == 42,
+        "Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
         result,
+        input,
+        expected
+    );
+    assert!(
+        result == 42,
+        "{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24,
+        25,
+        26
+    );
+
+    assert_eq!();
+    assert_eq!(left);
+    assert_eq!(left, right);
+    assert_eq!(left, right, "Ahoy there, {}!", target);
+    assert_eq!(
+        left, right,
         "Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
         result, input, expected
     );
+    assert_eq!(
+        first_realllllllllllly_long_variable_that_doesnt_fit_one_one_line,
+        second_reallllllllllly_long_variable_that_doesnt_fit_one_one_line,
+        "Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
+        result,
+        input,
+        expected
+    );
+    assert_eq!(
+        left + 42,
+        right,
+        "Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
+        result,
+        input,
+        expected
+    );
+    assert_eq!(
+        left,
+        right,
+        "{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24,
+        25,
+        26
+    );
+
+    write!(&mut s, "Ahoy there, {}!", target);
+    write!(
+        &mut s,
+        "Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
+        result, input, expected
+    );
+    write!(
+        &mut s,
+        "{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24,
+        25,
+        26
+    );
+
+    writeln!(&mut s, "Ahoy there, {}!", target);
+    writeln!(
+        &mut s,
+        "Arr! While plunderin' the hold, we got '{}' when given '{}' (we expected '{}')",
+        result, input, expected
+    );
+    writeln!(
+        &mut s,
+        "{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24,
+        25,
+        26
+    );
 }
 
 // #1209
@@ -669,3 +874,44 @@ impl Foo {
     /// foo
     pub fn foo(&self) -> Bar<foo!()> {}
 }
+
+// #819
+fn macro_in_pattern_position() {
+    let x = match y {
+        foo!() => (),
+        bar!(a, b, c) => (),
+        bar!(a, b, c,) => (),
+        baz!(1 + 2 + 3, quux.kaas()) => (),
+        quux!(
+            AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA,
+            BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
+        ) => (),
+    };
+}
+
+macro foo() {}
+
+pub macro bar($x: ident + $y: expr;) {
+    fn foo($x: Foo) {
+        long_function(
+            a_long_argument_to_a_long_function_is_what_this_is(AAAAAAAAAAAAAAAAAAAAAAAAAAAA),
+            $x.bar($y),
+        );
+    }
+}
+
+macro foo() {
+    // a comment
+    fn foo() {
+        // another comment
+        bar();
+    }
+}
+
+macro lex_err($kind: ident $(, $body: expr)*) {
+    Err(QlError::LexError(LexError::$kind($($body,)*)))
+}
+
+// Preserve trailing comma on item-level macro with `()` or `[]`.
+methods![get, post, delete,];
+methods!(get, post, delete,);