Merge pull request #2283 from natecook1000/formatting-tests

Author: ahoppen

Tests/SourceKitLSPTests/FormattingTests.swift

@@ -25,15 +25,13 @@ final class FormattingTests: XCTestCase {
     let testClient = try await TestSourceKitLSPClient()
     let uri = DocumentURI(for: .swift)
 
-    let positions = testClient.openDocument(
-      """
+    let source = """
       struct S {
-      1️⃣var foo: 2️⃣ 3️⃣Int
-      4️⃣var bar: Int
-      }5️⃣
-      """,
-      uri: uri
-    )
+      var foo:  Int
+      var bar: Int
+      }
+      """
+    testClient.openDocument(source, uri: uri)
 
     let response = try await testClient.send(
       DocumentFormattingRequest(
@@ -43,14 +41,18 @@ final class FormattingTests: XCTestCase {
     )
 
     let edits = try XCTUnwrap(response)
+    let formattedSource = apply(edits: edits, to: source)
+
+    XCTAssert(edits.allSatisfy { $0.newText.allSatisfy(\.isWhitespace) })
     XCTAssertEqual(
-      edits,
-      [
-        TextEdit(range: Range(positions["1️⃣"]), newText: "   "),
-        TextEdit(range: positions["2️⃣"]..<positions["3️⃣"], newText: ""),
-        TextEdit(range: Range(positions["4️⃣"]), newText: "   "),
-        TextEdit(range: Range(positions["5️⃣"]), newText: "\n"),
-      ]
+      formattedSource,
+      """
+      struct S {
+         var foo: Int
+         var bar: Int
+      }
+
+      """
     )
   }
 
@@ -217,15 +219,13 @@ final class FormattingTests: XCTestCase {
     let testClient = try await TestSourceKitLSPClient()
     let uri = DocumentURI(for: .swift)
 
-    let positions = testClient.openDocument(
-      """
-      1️⃣public 2️⃣extension Example {
-        3️⃣func function() {}
+    let source = """
+      public extension Example {
+        func function() {}
       }
 
-      """,
-      uri: uri
-    )
+      """
+    testClient.openDocument(source, uri: uri)
 
     let response = try await testClient.send(
       DocumentFormattingRequest(
@@ -235,42 +235,44 @@ final class FormattingTests: XCTestCase {
     )
 
     let edits = try XCTUnwrap(response)
+    let formattedSource = apply(edits: edits, to: source)
+
     XCTAssertEqual(
-      edits,
-      [
-        TextEdit(range: positions["1️⃣"]..<positions["2️⃣"], newText: ""),
-        TextEdit(range: Range(positions["3️⃣"]), newText: "public "),
-      ]
+      formattedSource,
+      """
+      extension Example {
+        public func function() {}
+      }
+
+      """
     )
   }
 
   func testMultiLineStringInsertion() async throws {
     let testClient = try await TestSourceKitLSPClient()
     let uri = DocumentURI(for: .swift)
 
-    let positions = testClient.openDocument(
-      #"""
+    let source = #"""
       _ = [
         Node(
           documentation: """
-          1️⃣A
-          2️⃣B
-          3️⃣C
-          4️⃣""",
+          A
+          B
+          C
+          """,
           children: [
             Child(
               documentation: """
-              5️⃣A
-      6️⃣        7️⃣\#("")
-      8️⃣  9️⃣      🔟"""
+              A
+              \#("")
+              """
             )
           ]
         )
       ]
 
-      """#,
-      uri: uri
-    )
+      """#
+    testClient.openDocument(source, uri: uri)
 
     let response = try await testClient.send(
       DocumentFormattingRequest(
@@ -280,18 +282,31 @@ final class FormattingTests: XCTestCase {
     )
 
     let edits = try XCTUnwrap(response)
+    let formattedSource = apply(edits: edits, to: source)
+
+    XCTAssert(edits.allSatisfy { $0.newText.allSatisfy(\.isWhitespace) })
     XCTAssertEqual(
-      edits,
-      [
-        TextEdit(range: Range(positions["1️⃣"]), newText: "  "),
-        TextEdit(range: Range(positions["2️⃣"]), newText: "  "),
-        TextEdit(range: Range(positions["3️⃣"]), newText: "  "),
-        TextEdit(range: Range(positions["4️⃣"]), newText: "  "),
-        TextEdit(range: Range(positions["5️⃣"]), newText: "  "),
-        TextEdit(range: Range(positions["6️⃣"]), newText: "\n"),
-        TextEdit(range: positions["7️⃣"]..<positions["8️⃣"], newText: ""),
-        TextEdit(range: positions["9️⃣"]..<positions["🔟"], newText: ""),
+      formattedSource,
+      #"""
+      _ = [
+        Node(
+          documentation: """
+            A
+            B
+            C
+            """,
+          children: [
+            Child(
+              documentation: """
+                A
+
+                """
+            )
+          ]
+        )
       ]
+
+      """#
     )
   }
 

Tests/SourceKitLSPTests/OnTypeFormattingTests.swift

@@ -54,33 +54,36 @@ final class OnTypeFormattingTests: XCTestCase {
     let testClient = try await TestSourceKitLSPClient()
     let uri = DocumentURI(for: .swift)
 
-    let positions = testClient.openDocument(
-      """
+    let source = """
       func foo() {
-      1️⃣if let SomeReallyLongVar = 2️⃣    3️⃣Some.More.Stuff(), let a = 4️⃣    5️⃣myfunc() 6️⃣{
+      if let SomeReallyLongVar =     Some.More.Stuff(), let a =     myfunc() 1️⃣{
       }
       }
-      """,
-      uri: uri
-    )
+      """
+    let positions = testClient.openDocument(source, uri: uri)
 
     let response = try await testClient.send(
       DocumentOnTypeFormattingRequest(
         textDocument: TextDocumentIdentifier(uri),
-        position: positions["6️⃣"],
+        position: positions["1️⃣"],
         ch: "{",
         options: FormattingOptions(tabSize: 4, insertSpaces: true)
       )
     )
 
     let edits = try XCTUnwrap(response)
+    let (_, unmarkedSource) = extractMarkers(source)
+    let formattedSource = apply(edits: edits, to: unmarkedSource)
+
+    XCTAssert(edits.allSatisfy { $0.newText.allSatisfy(\.isWhitespace) })
     XCTAssertEqual(
-      edits,
-      [
-        TextEdit(range: Range(positions["1️⃣"]), newText: "    "),
-        TextEdit(range: positions["2️⃣"]..<positions["3️⃣"], newText: ""),
-        TextEdit(range: positions["4️⃣"]..<positions["5️⃣"], newText: ""),
-      ]
+      formattedSource,
+      """
+      func foo() {
+          if let SomeReallyLongVar = Some.More.Stuff(), let a = myfunc() {
+      }
+      }
+      """
     )
   }
 

Tests/SourceKitLSPTests/RenameAssertions.swift

@@ -15,7 +15,7 @@ import SKTestSupport
 import SKUtilities
 import XCTest
 
-private func apply(edits: [TextEdit], to source: String) -> String {
+internal func apply(edits: [TextEdit], to source: String) -> String {
   var lineTable = LineTable(source)
   let edits = edits.sorted(by: { $0.range.lowerBound < $1.range.lowerBound })
   for edit in edits.reversed() {