Miscellaneous adjustments to make tests pass on Windows

This is mostly test infrastructure that needed adjusting.

Author: ahoppen

Sources/BuildSystemIntegration/CompilationDatabase.swift

@@ -34,6 +34,10 @@ import struct TSCBasic.RelativePath
 import var TSCBasic.localFileSystem
 #endif
 
+#if os(Windows)
+import WinSDK
+#endif
+
 /// A single compilation database command.
 ///
 /// See https://clang.llvm.org/docs/JSONCompilationDatabase.html
@@ -97,7 +101,7 @@ package struct CompilationDatabaseCompileCommand: Equatable, Codable {
   /// it falls back to `filename`, which is more likely to be the identifier
   /// that a caller will be looking for.
   package var uri: DocumentURI {
-    if filename.hasPrefix("/") || !directory.hasPrefix("/") {
+    if filename.isAbsolutePath || !directory.isAbsolutePath {
       return DocumentURI(filePath: filename, isDirectory: false)
     } else {
       return DocumentURI(URL(fileURLWithPath: directory).appendingPathComponent(filename, isDirectory: false))
@@ -288,3 +292,15 @@ enum CompilationDatabaseDecodingError: Error {
   case missingCommandOrArguments
   case fixedDatabaseDecodingError
 }
+
+fileprivate extension String {
+  var isAbsolutePath: Bool {
+    #if os(Windows)
+    Array(self.utf16).withUnsafeBufferPointer { buffer in
+      return !PathIsRelativeW(buffer.baseAddress)
+    }
+    #else
+    return self.hasPrefix("/")
+    #endif
+  }
+}

Sources/SKSupport/DocumentURI+symlinkTarget.swift

@@ -27,10 +27,10 @@ extension DocumentURI {
     guard let fileUrl = fileURL else {
       return nil
     }
-    let realpath = fileUrl.realpath
-    if realpath == fileURL {
+    let realpath = DocumentURI(fileUrl.realpath)
+    if realpath == self {
       return nil
     }
-    return DocumentURI(realpath)
+    return realpath
   }
 }

Sources/SKTestSupport/BuildServerTestProject.swift

@@ -17,7 +17,7 @@ import XCTest
 fileprivate let sdkArgs =
   if let defaultSDKPath {
     """
-    "-sdk", "\(defaultSDKPath)",
+    "-sdk", "\(defaultSDKPath.replacing(#"\"#, with: #"\\"#))",
     """
   } else {
     ""

Sources/SKTestSupport/FindTool.swift

@@ -48,8 +48,14 @@ package func findTool(name: String) async -> URL? {
     return nil
   }
   #if os(Windows)
-  path = String((path.split { $0.isNewline })[0])
+  // where.exe returns all files that match the name. We only care about the first one.
+  if let newlineIndex = path.firstIndex(where: \.isNewline) {
+    path = String(path[..<newlineIndex])
+  }
   #endif
   path = path.trimmingCharacters(in: .whitespacesAndNewlines)
+  if path.isEmpty {
+    return nil
+  }
   return URL(fileURLWithPath: path, isDirectory: false)
 }

Sources/SKTestSupport/IndexedSingleSwiftFileTestProject.swift

@@ -87,6 +87,19 @@ package struct IndexedSingleSwiftFileTestProject {
 
       // The following are needed so we can import XCTest
       let sdkUrl = URL(fileURLWithPath: sdk)
+      #if os(Windows)
+      let xctestModuleDir =
+        sdkUrl
+        .deletingLastPathComponent()
+        .deletingLastPathComponent()
+        .appendingPathComponent("Library")
+        .appendingPathComponent("XCTest-development")
+        .appendingPathComponent("usr")
+        .appendingPathComponent("lib")
+        .appendingPathComponent("swift")
+        .appendingPathComponent("windows")
+      compilerArguments += ["-I", xctestModuleDir.path]
+      #else
       let usrLibDir =
         sdkUrl
         .deletingLastPathComponent()
@@ -103,6 +116,7 @@ package struct IndexedSingleSwiftFileTestProject {
         "-I", usrLibDir.path,
         "-F", frameworksDir.path,
       ]
+      #endif
     }
 
     let compilationDatabase = JSONCompilationDatabase(

Sources/SKTestSupport/MultiFileTestProject.swift

@@ -102,7 +102,10 @@ package class MultiFileTestProject {
 
     var fileData: [String: FileData] = [:]
     for (fileLocation, markedText) in files {
-      let markedText = markedText.replacingOccurrences(of: "$TEST_DIR", with: scratchDirectory.path)
+      let markedText =
+        markedText
+        .replacingOccurrences(of: "$TEST_DIR_URL", with: scratchDirectory.absoluteString)
+        .replacingOccurrences(of: "$TEST_DIR", with: scratchDirectory.path)
       let fileURL = fileLocation.url(relativeTo: scratchDirectory)
       try FileManager.default.createDirectory(
         at: fileURL.deletingLastPathComponent(),

Sources/SKTestSupport/Utils.swift

@@ -68,10 +68,17 @@ package func testScratchDir(testName: String = #function) throws -> URL {
   if let firstDash = uuid.firstIndex(of: "-") {
     uuid = uuid[..<firstDash]
   }
-  let url = FileManager.default.temporaryDirectory
-    .realpath
+  // Including the test name in the directory frequently makes path lengths of test files exceed the maximum path length
+  // on Windows. Choose shorter directory names on that platform to avoid that issue.
+  #if os(Windows)
+  let url = FileManager.default.temporaryDirectory.realpath
+    .appendingPathComponent("lsp-test")
+    .appendingPathComponent("\(uuid)")
+  #else
+  let url = FileManager.default.temporaryDirectory.realpath
     .appendingPathComponent("sourcekit-lsp-test-scratch")
     .appendingPathComponent("\(testBaseName)-\(uuid)")
+  #endif
   try? FileManager.default.removeItem(at: url)
   try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
   return url

Sources/SourceKitLSP/Clang/ClangLanguageService.swift

@@ -326,7 +326,7 @@ actor ClangLanguageService: LanguageService, MessageHandler {
       // safer, can also indefinitely hang as `CreateRemoteThread` may not be serviced depending on the state of
       // the process. This just attempts to terminate the process, risking a deadlock and resource leaks, which is fine
       // since we only use `crash` from tests.
-      _ = TerminateProcess(self.hClangd, 0)
+      _ = TerminateProcess(self.hClangd, 255)
     }
     #else
     if let pid = self.clangdPid {

Tests/BuildSystemIntegrationTests/BuildServerBuildSystemTests.swift

@@ -53,7 +53,7 @@ final class BuildServerBuildSystemTests: XCTestCase {
                 {
                   "target": {"uri": "bsp://dummy"},
                   "sources": [
-                    {"uri": "file://$TEST_DIR/Test.swift", "kind": 1, "generated": False}
+                    {"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False}
                   ],
                 }
               ]
@@ -123,7 +123,7 @@ final class BuildServerBuildSystemTests: XCTestCase {
                 {
                   "target": {"uri": "bsp://dummy"},
                   "sources": [
-                    {"uri": "file://$TEST_DIR/Test.swift", "kind": 1, "generated": False}
+                    {"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False}
                   ],
                 }
               ]
@@ -197,7 +197,7 @@ final class BuildServerBuildSystemTests: XCTestCase {
                 {
                   "target": {"uri": "bsp://dummy"},
                   "sources": [
-                    {"uri": "file://$TEST_DIR/Test.swift", "kind": 1, "generated": False}
+                    {"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False}
                   ],
                 }
               ]
@@ -273,8 +273,8 @@ final class BuildServerBuildSystemTests: XCTestCase {
                 {
                   "target": {"uri": "bsp://dummy"},
                   "sources": [
-                    {"uri": "file://$TEST_DIR/Crash.swift", "kind": 1, "generated": False},
-                    {"uri": "file://$TEST_DIR/Test.swift", "kind": 1, "generated": False},
+                    {"uri": "$TEST_DIR_URL/Crash.swift", "kind": 1, "generated": False},
+                    {"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False},
                   ],
                 }
               ]

Tests/BuildSystemIntegrationTests/CompilationDatabaseTests.swift

@@ -152,16 +152,27 @@ final class CompilationDatabaseTests: XCTestCase {
     )
   }
 
-  func testJSONCompilationDatabaseLookup() {
+  func testJSONCompilationDatabaseLookup() throws {
+    #if os(Windows)
+    let fileSystemRoot = "c:/"
+    #else
+    let fileSystemRoot = "/"
+    #endif
+
     let cmd1 = CompilationDatabase.Command(directory: "a", filename: "b", commandLine: [], output: nil)
-    let cmd2 = CompilationDatabase.Command(directory: "/c", filename: "b", commandLine: [], output: nil)
-    let cmd3 = CompilationDatabase.Command(directory: "/c", filename: "/b", commandLine: [], output: nil)
+    let cmd2 = CompilationDatabase.Command(directory: "\(fileSystemRoot)c", filename: "b", commandLine: [], output: nil)
+    let cmd3 = CompilationDatabase.Command(
+      directory: "\(fileSystemRoot)c",
+      filename: "\(fileSystemRoot)b",
+      commandLine: [],
+      output: nil
+    )
 
     let db = JSONCompilationDatabase([cmd1, cmd2, cmd3])
 
     XCTAssertEqual(db[DocumentURI(filePath: "b", isDirectory: false)], [cmd1])
-    XCTAssertEqual(db[DocumentURI(filePath: "/c/b", isDirectory: false)], [cmd2])
-    XCTAssertEqual(db[DocumentURI(filePath: "/b", isDirectory: false)], [cmd3])
+    XCTAssertEqual(db[DocumentURI(filePath: "\(fileSystemRoot)c/b", isDirectory: false)], [cmd2])
+    XCTAssertEqual(db[DocumentURI(filePath: "\(fileSystemRoot)b", isDirectory: false)], [cmd3])
   }
 
   func testJSONCompilationDatabaseFromDirectory() throws {
@@ -250,19 +261,16 @@ final class CompilationDatabaseTests: XCTestCase {
         """
     )
 
-    let db = try tryLoadCompilationDatabase(
-      directory: AbsolutePath(validating: "/a"),
-      fs
-    )
-    XCTAssertNotNil(db)
+    let db = try XCTUnwrap(tryLoadCompilationDatabase(directory: AbsolutePath(validating: "/a"), fs))
 
+    // Note: Use `AbsolutePath(validating:).pathString` to normalize forward slashes to backslashes on Windows
     XCTAssertEqual(
-      db![DocumentURI(filePath: "/a/b", isDirectory: false)],
+      db[DocumentURI(filePath: "/a/b", isDirectory: false)],
       [
         CompilationDatabase.Command(
           directory: try AbsolutePath(validating: "/a").pathString,
-          filename: "/a/b",
-          commandLine: ["clang", "-xc++", "-I", "libwidget/include/", "/a/b"],
+          filename: try AbsolutePath(validating: "/a/b").pathString,
+          commandLine: ["clang", "-xc++", "-I", "libwidget/include/", try AbsolutePath(validating: "/a/b").pathString],
           output: nil
         )
       ]