macros: Add base for execution tests for macros

3 files changed, 107 insertions, 0 deletions

diff --git a/gcc/testsuite/rust/execute/xfail/macro1.rs b/gcc/testsuite/rust/execute/xfail/macro1.rs
new file mode 100644
index 0000000..eab5a02
--- /dev/null
+++ b/gcc/testsuite/rust/execute/xfail/macro1.rs
@@ -0,0 +1,32 @@
+// { dg-output "macro\nmacro\nmacro\nmacro\n" }
+extern "C" {
+    fn printf(s: *const i8, ...);
+}
+
+fn f() {
+    let r_s = "macro\n\0";
+    let s_p = r_s as *const str;
+    let c_p = s_p as *const i8;
+
+    printf(c_p);
+}
+
+macro_rules! empty0 {
+    () => ( f() );
+}
+
+macro_rules! empty1 {
+    {} => { f() };
+}
+
+macro_rules! empty2 {
+    [] => [ f() ];
+}
+
+// using multiple parens/brackets/curlies variants allows us to make sure we
+// parse everything properly
+fn main() {
+    empty0!();
+    empty1!{};
+    empty2![];
+}
diff --git a/gcc/testsuite/rust/execute/xfail/macro2.rs b/gcc/testsuite/rust/execute/xfail/macro2.rs
new file mode 100644
index 0000000..49bd6a8
--- /dev/null
+++ b/gcc/testsuite/rust/execute/xfail/macro2.rs
@@ -0,0 +1,30 @@
+// { dg-output "arg\narg\n" }
+extern "C" {
+    fn printf(s: *const i8, ...);
+}
+
+fn f() {
+    let r_s = "arg\n\0";
+    let s_p = r_s as *const str;
+    let c_p = s_p as *const i8;
+
+    printf(c_p);
+}
+
+macro_rules! kw0 {
+    (keyword) => { f() };
+}
+
+macro_rules! kw1 {
+    (fn) => { f() };
+}
+
+macro_rules! kw2 {
+    (kw0 kw1 kw3) => { f() };
+}
+
+fn main() {
+    kw0!(keyword);
+    kw1!(fn);
+    kw2!(kw0 kw1 kw3);
+}
diff --git a/gcc/testsuite/rust/execute/xfail/macro3.rs b/gcc/testsuite/rust/execute/xfail/macro3.rs
new file mode 100644
index 0000000..0d99d716
--- /dev/null
+++ b/gcc/testsuite/rust/execute/xfail/macro3.rs
@@ -0,0 +1,45 @@
+// { dg-output "invok\ninvok\ninvok\ninvok\ninvok\n" }
+extern "C" {
+    fn printf(s: *const i8, ...);
+}
+
+fn f() {
+    let r_s = "invok\n\0";
+    let s_p = r_s as *const str;
+    let c_p = s_p as *const i8;
+
+    printf(c_p);
+}
+
+macro_rules! invocation0 {
+    (valid) => { f() };
+    () => { };
+}
+
+macro_rules! invocation1 {
+    (valid) => { };
+    () => { f() };
+}
+
+macro_rules! invocation2 {
+    (valid) => { f() };
+    (invalid) => { };
+}
+
+macro_rules! invocation3 {
+    (this is a valid invocation) => { f() };
+    (not this one) => { };
+}
+
+macro_rules! invocation4 {
+    (fn f() {}) => { f() };
+    (not a keyword) => { };
+}
+
+fn main() {
+    invocation0!(valid);
+    invocation1!();
+    invocation2!(valid);
+    invocation3!(this is a valid invocation);
+    invocation4!(fn f() {});
+}