Adjust OmitReturnsTests to use the most recent APIs

Author: xedin

Tests/SwiftFormatTests/Rules/OmitReturnsTests.swift

@@ -1,105 +1,107 @@
+import _SwiftFormatTestSupport
+
 @_spi(Rules) import SwiftFormat
 
 final class OmitReturnsTests: LintOrFormatRuleTestCase {
   func testOmitReturnInFunction() {
-    XCTAssertFormatting(
+    assertFormatting(
       OmitReturns.self,
       input: """
         func test() -> Bool {
-          return false
+          1️⃣return false
         }
-        """,
+      """,
       expected: """
         func test() -> Bool {
           false
         }
-        """)
+      """,
+      findings: [
+        FindingSpec("1️⃣", message: "`return` can be omitted because body consists of a single expression")
+      ])
   }
 
   func testOmitReturnInClosure() {
-    XCTAssertFormatting(
+    assertFormatting(
       OmitReturns.self,
       input: """
         vals.filter {
-          return $0.count == 1
+          1️⃣return $0.count == 1
         }
-        """,
+      """,
       expected: """
         vals.filter {
           $0.count == 1
         }
-        """)
+      """,
+      findings: [
+        FindingSpec("1️⃣", message: "`return` can be omitted because body consists of a single expression")
+      ])
   }
 
   func testOmitReturnInSubscript() {
-      XCTAssertFormatting(
-        OmitReturns.self,
-        input: """
-          struct Test {
-            subscript(x: Int) -> Bool {
-              return false
-            }
-          }
-          """,
-        expected: """
-          struct Test {
-            subscript(x: Int) -> Bool {
-              false
-            }
+    assertFormatting(
+      OmitReturns.self,
+      input: """
+        struct Test {
+          subscript(x: Int) -> Bool {
+            1️⃣return false
           }
-          """)
+        }
 
-      XCTAssertFormatting(
-        OmitReturns.self,
-        input: """
-          struct Test {
-            subscript(x: Int) -> Bool {
-              get {
-                return false
-              }
-              set { }
+        struct Test {
+          subscript(x: Int) -> Bool {
+            get {
+              2️⃣return false
             }
+            set { }
+          }
+        }
+      """,
+      expected: """
+        struct Test {
+          subscript(x: Int) -> Bool {
+            false
           }
-          """,
-        expected: """
-          struct Test {
-            subscript(x: Int) -> Bool {
-              get {
-                false
-              }
-              set { }
+        }
+
+        struct Test {
+          subscript(x: Int) -> Bool {
+            get {
+              false
             }
+            set { }
           }
-          """)
+        }
+      """,
+      findings: [
+        FindingSpec("1️⃣", message: "`return` can be omitted because body consists of a single expression"),
+        FindingSpec("2️⃣", message: "`return` can be omitted because body consists of a single expression")
+      ])
   }
 
   func testOmitReturnInComputedVars() {
-    XCTAssertFormatting(
+    assertFormatting(
       OmitReturns.self,
       input: """
         var x: Int {
-          return 42
-        }
-        """,
-      expected: """
-        var x: Int {
-          42
+          1️⃣return 42
         }
-        """)
 
-    XCTAssertFormatting(
-      OmitReturns.self,
-      input: """
         struct Test {
           var x: Int {
             get {
-              return 42
+              2️⃣return 42
             }
             set { }
           }
         }
-        """,
+      """,
       expected: """
+        var x: Int {
+          42
+        }
+
         struct Test {
           var x: Int {
             get {
@@ -108,6 +110,10 @@ final class OmitReturnsTests: LintOrFormatRuleTestCase {
             set { }
           }
         }
-        """)
+      """,
+      findings: [
+        FindingSpec("1️⃣", message: "`return` can be omitted because body consists of a single expression"),
+        FindingSpec("2️⃣", message: "`return` can be omitted because body consists of a single expression")
+      ])
   }
 }