fix(intellij): make comparing testitem uri's platform independend

Author: d-biehl

Diff for: intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/RobotIcons.kt

@@ -1,16 +1,18 @@
 package dev.robotcode.robotcode4ij
 
-import com.intellij.openapi.util.IconLoader
 import com.intellij.ui.IconManager
 
 class RobotIcons {
     companion object {
         @JvmField
         val Resource = IconManager.getInstance().getIcon("/images/resource.svg", Companion::class.java.classLoader)
+        
         @JvmField
         val Suite = IconManager.getInstance().getIcon("/images/suite.svg", Companion::class.java.classLoader)
+        
         @JvmField
         val RobotCode = IconManager.getInstance().getIcon("/images/robotcode.svg", Companion::class.java.classLoader)
+        
         @JvmField
         val Robot = IconManager.getInstance().getIcon("/images/suite.robot", Companion::class.java.classLoader)
     }

Diff for: intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/lsp/RobotCodeServerApi.kt

@@ -5,6 +5,6 @@ import org.eclipse.lsp4j.services.LanguageServer
 import java.util.concurrent.CompletableFuture
 
 
-interface RobotCodeServerApi: LanguageServer {
+interface RobotCodeServerApi : LanguageServer {
     @JsonRequest("robot/cache/clear") fun clearCache(): CompletableFuture<Void>?
 }

Diff for: intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/testing/DataItems.kt

@@ -1,7 +1,23 @@
 package dev.robotcode.robotcode4ij.testing
 
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient
 import kotlinx.serialization.json.JsonElement
+import java.net.URI
+
+private object UriCache {
+    const val MAX_SIZE = 512
+    
+    private val cache = object : LinkedHashMap<String, URI>(MAX_SIZE, 0.75f, true) {
+        override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, URI>?): Boolean {
+            return size >= MAX_SIZE
+        }
+    }
+    
+    fun get(uri: String): URI {
+        return cache.getOrPut(uri) { URI.create(uri) }
+    }
+}
 
 @Serializable
 data class Position(val line: UInt, val character: UInt)
@@ -68,6 +84,18 @@ data class Position(val line: UInt, val character: UInt)
         result = 31 * result + (tags?.contentHashCode() ?: 0)
         return result
     }
+    
+    @Transient
+    val realUri: URI? = if (uri != null) UriCache.get(uri) else null
+    
+    fun isSameUri(uri: String?): Boolean {
+        if (realUri == null || uri == null)
+            return false
+        
+        val otherUri = UriCache.get(uri)
+        
+        return otherUri.scheme == realUri.scheme && otherUri.path == realUri.path
+    }
 }
 
 @Serializable data class RobotCodeDiscoverResult(

Diff for: intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/testing/RobotCodeTestManager.kt

@@ -25,7 +25,6 @@ import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.elementType
 import com.intellij.psi.util.startOffset
-import com.intellij.util.io.URLUtil
 import dev.robotcode.robotcode4ij.RobotSuiteFileType
 import dev.robotcode.robotcode4ij.buildRobotCodeCommandLine
 import dev.robotcode.robotcode4ij.psi.IRobotFrameworkElementType
@@ -38,10 +37,9 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
-import java.net.URI
+import java.nio.file.Paths
 import java.util.*
 
-
 @Service(Service.Level.PROJECT) class RobotCodeTestManager(private val project: Project) : Disposable, DocumentListener,
                                                                                            AsyncFileListener,
                                                                                            FileEditorManagerListener {
@@ -229,7 +227,7 @@ import java.util.*
                     arrayOf(*defaultPaths, "discover", "--read-from-stdin", "all"), format = "json"
                 ).withCharset(Charsets.UTF_8).withWorkDirectory(project.basePath)
 
-                var openFiles = mutableMapOf<String, String>()
+                val openFiles = mutableMapOf<String, String>()
 
                 ApplicationManager.getApplication().runReadAction {
                     FileEditorManagerEx.getInstanceEx(project).openFiles.forEach { file ->
@@ -239,7 +237,7 @@ import java.util.*
                     }
                 }
 
-                var openFilesAsString = Json.encodeToString(openFiles)
+                val openFilesAsString = Json.encodeToString(openFiles)
 
                 val result = CapturingProcessHandler(cmdLine).apply {
                     process.outputStream.bufferedWriter().apply {
@@ -276,11 +274,11 @@ import java.util.*
     ): RobotCodeTestItem? {
 
         if (line == null) {
-            if (root.uri == uri) {
+            if (root.isSameUri(uri)) {
                 return root
             }
         } else {
-            if (root.uri == uri && root.range != null && root.range.start.line == line) {
+            if (root.isSameUri(uri) && root.range != null && root.range.start.line == line) {
                 return root
             }
         }
@@ -334,9 +332,23 @@ import java.util.*
     }
 }
 
+private fun getRfcCompliantUri(virtualFile: VirtualFile): String {
+    val filePath = virtualFile.path
+    
+    val normalizedPath = if (isWindows()) {
+        filePath.replace("\\", "/")
+    } else {
+        filePath
+    }
+    
+    return Paths.get(normalizedPath).toUri().toString()
+}
+
+private fun isWindows(): Boolean = System.getProperty("os.name").lowercase().contains("win")
+
 val VirtualFile.uri: String
     get() {
-        return URI.create(fileSystem.protocol + URLUtil.SCHEME_SEPARATOR + "/" + path.replace(":", "%3A")).toString()
+        return getRfcCompliantUri(this)
     }
 
 val Project.testManger: RobotCodeTestManager