tests: use raw string literals for checking output contains certain Rust code

This should be much easier to read.

Author: kkysen

tests/items/src/test_fn_attrs.rs

@@ -28,42 +28,152 @@ pub fn test_fn_attrs() {
     // static __attribute__((always_inline)) void always_inline_static(void) {}
     // static __attribute__((__noinline__)) void noinline_static(void) {}
     // static void inline inline_static(void) {}
-    assert!(src.contains("#[inline(always)]\nunsafe extern \"C\" fn rust_always_inline_static"));
-    assert!(src.contains("#[inline(never)]\nunsafe extern \"C\" fn rust_noinline_static"));
-    assert!(src.contains("#[inline]\nunsafe extern \"C\" fn rust_inline_static"));
-    assert!(src.contains("#[inline]\nunsafe extern \"C\" fn rust_alt_kw_inline_static"));
-    assert!(src.contains("#[inline]\nunsafe extern \"C\" fn rust_gnu_inline_static"));
-    assert!(src.contains("#[cold]\nunsafe extern \"C\" fn rust_cold_used_attrs"));
+    assert!(src.contains(
+        r#"
+#[inline(always)]
+unsafe extern "C" fn rust_always_inline_static
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline(never)]
+unsafe extern "C" fn rust_noinline_static
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline]
+unsafe extern "C" fn rust_inline_static
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline]
+unsafe extern "C" fn rust_alt_kw_inline_static
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline]
+unsafe extern "C" fn rust_gnu_inline_static
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[cold]
+unsafe extern "C" fn rust_cold_used_attrs
+"#
+        .trim(),
+    ));
 
     // __attribute__((__always_inline__)) void always_inline_nonstatic(void) {}
     // __attribute__((noinline)) void noinline_nonstatic(void) {}
     // void inline inline_nonstatic(void) {}
-    assert!(src.contains("#[inline(always)]\nunsafe extern \"C\" fn rust_always_inline_nonstatic"));
-    assert!(src.contains("#[inline(never)]\npub unsafe extern \"C\" fn rust_noinline_nonstatic"));
-    assert!(src.contains("#[inline]\nunsafe extern \"C\" fn rust_inline_nonstatic"));
-    assert!(src.contains("#[inline]\nunsafe extern \"C\" fn rust_alt_kw_inline_nonstatic"));
-    assert!(src.contains("#[inline]\nunsafe extern \"C\" fn rust_gnu_inline_nonstatic"));
+    assert!(src.contains(
+        r#"
+#[inline(always)]
+unsafe extern "C" fn rust_always_inline_nonstatic
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline(never)]
+pub unsafe extern "C" fn rust_noinline_nonstatic
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline]
+unsafe extern "C" fn rust_inline_nonstatic
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline]
+unsafe extern "C" fn rust_alt_kw_inline_nonstatic
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline]
+unsafe extern "C" fn rust_gnu_inline_nonstatic
+"#
+        .trim(),
+    ));
 
     // extern void inline inline_extern(void) {}
     // extern void inline __attribute__((always_inline)) always_inline_extern(void) {}
     // extern void inline __attribute__((__gnu_inline__)) gnu_inline_extern(void) {}
     // extern void inline __attribute__((gnu_inline, always_inline)) always_inline_gnu_inline_extern(void) {}
     assert!(src.contains(
-        "#[inline]\n#[linkage = \"external\"]\npub unsafe extern \"C\" fn rust_inline_extern"
+        r#"
+#[inline]
+#[linkage = "external"]
+pub unsafe extern "C" fn rust_inline_extern
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline]
+#[linkage = "external"]
+pub unsafe extern "C" fn rust_alt_kw_inline_extern
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline(always)]
+pub unsafe extern "C" fn rust_always_inline_extern
+"#
+        .trim(),
+    ));
+    assert!(src.contains(
+        r#"
+#[inline]
+unsafe extern "C" fn rust_gnu_inline_extern
+"#
+        .trim(),
     ));
-    assert!(src.contains("#[inline]\n#[linkage = \"external\"]\npub unsafe extern \"C\" fn rust_alt_kw_inline_extern"));
-    assert!(src.contains("#[inline(always)]\npub unsafe extern \"C\" fn rust_always_inline_extern"));
-    assert!(src.contains("#[inline]\nunsafe extern \"C\" fn rust_gnu_inline_extern"));
     assert!(src.contains(
-        "#[inline(always)]\nunsafe extern \"C\" fn rust_always_inline_gnu_inline_extern"
+        r#"
+#[inline(always)]
+unsafe extern "C" fn rust_always_inline_gnu_inline_extern
+"#
+        .trim(),
     ));
     assert!(src.contains(
-        "#[inline]\nunsafe extern \"C\" fn rust_gnu_inline_non_canonical_definition_extern"
+        r#"
+#[inline]
+unsafe extern "C" fn rust_gnu_inline_non_canonical_definition_extern
+"#
+        .trim(),
     ));
 
     if cfg!(not(target_os = "macos")) {
         // aliased_fn is aliased to the inline_extern function
-        let aliased_fn_syntax = |public| format!("extern \"C\" {{\n    #[link_name = \"inline_extern\"]\n    {}fn aliased_fn();", public);
-        assert!(src.contains(&aliased_fn_syntax("")) || src.contains(&aliased_fn_syntax("pub ")));
+        let aliased_fn_syntax = |public| {
+            format!(
+                r#"
+extern "C" {{
+    #[link_name = "inline_extern"]
+    {}fn aliased_fn();
+"#,
+                public
+            )
+        };
+        assert!(
+            src.contains(aliased_fn_syntax("").trim())
+                || src.contains(aliased_fn_syntax("pub ").trim())
+        );
     }
 }

tests/statics/src/test_sections.rs

@@ -56,9 +56,27 @@ pub fn test_sectioned_used_static() {
         );
 
         // This static is pub, but we want to ensure it has attributes applied
-        assert!(src.contains("#[link_section = \"fb\"]\npub static mut rust_initialized_extern: ::core::ffi::c_int = 1 as ::core::ffi::c_int;"));
+        assert!(src.contains(
+            r#"
+#[link_section = "fb"]
+pub static mut rust_initialized_extern: ::core::ffi::c_int = 1 as ::core::ffi::c_int;
+"#
+            .trim(),
+        ));
         // This static is pub only with --reorganize-definitions
-        let aliased_static_syntax = |public| format!("extern \"C\" {{\n    #[link_name = \"no_attrs\"]\n    {}static mut rust_aliased_static: ::core::ffi::c_int;", public);
-        assert!(src.contains(&aliased_static_syntax("")) || src.contains(&aliased_static_syntax("pub ")))
+        let aliased_static_syntax = |public| {
+            format!(
+                r#"
+extern "C" {{
+    #[link_name = "no_attrs"]
+    {}static mut rust_aliased_static: ::core::ffi::c_int;
+"#,
+                public
+            )
+        };
+        assert!(
+            src.contains(aliased_static_syntax("").trim())
+                || src.contains(aliased_static_syntax("pub ").trim())
+        )
     }
 }