diff --git a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/UtTestsDialogProcessor.kt b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/UtTestsDialogProcessor.kt
index cacfbe7f45..4405702541 100644
--- a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/UtTestsDialogProcessor.kt
+++ b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/UtTestsDialogProcessor.kt
@@ -1,9 +1,6 @@
 package org.utbot.intellij.plugin.generator
 
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.application.PathManager
-import com.intellij.openapi.application.ReadAction
-import com.intellij.openapi.application.invokeLater
+import com.intellij.openapi.application.*
 import com.intellij.openapi.compiler.CompilerPaths
 import com.intellij.openapi.components.service
 import com.intellij.openapi.module.Module
@@ -166,7 +163,12 @@ object UtTestsDialogProcessor {
                         val psi2KClass = mutableMapOf<PsiClass, ClassId>()
                         var processedClasses = 0
                         val totalClasses = model.srcClasses.size
-                        val process = EngineProcess.createBlocking(project)
+                        val classNameToPath = runReadAction {
+                            model.srcClasses.map { psiClass ->
+                                psiClass.canonicalName to psiClass.containingFile.virtualFile.canonicalPath
+                            }.toMap()
+                        }
+                        val process = EngineProcess.createBlocking(project, classNameToPath)
 
                         process.terminateOnException { _ ->
                             process.setupUtContext(buildDirs + classpathList)
@@ -191,12 +193,14 @@ object UtTestsDialogProcessor {
                                     }
                                 }
 
-                                val (methods, className) = process.executeWithTimeoutSuspended {
+                                val (methods, classNameForLog) = process.executeWithTimeoutSuspended {
                                     var canonicalName = ""
                                     var srcMethods: List<MemberInfo> = emptyList()
+                                    var srcNameForLog: String? = null
                                     DumbService.getInstance(project)
                                         .runReadActionInSmartMode(Computable {
                                             canonicalName = srcClass.canonicalName
+                                            srcNameForLog = srcClass.name
                                             srcMethods = if (model.extractMembersFromSrcClasses) {
                                                 val chosenMethods =
                                                     model.selectedMembers.filter { it.member is PsiMethod }
@@ -214,11 +218,11 @@ object UtTestsDialogProcessor {
                                     process.findMethodsInClassMatchingSelected(
                                         classId,
                                         srcMethods
-                                    ) to srcClass.name
+                                    ) to srcNameForLog
                                 }
 
                                 if (methods.isEmpty()) {
-                                    logger.error { "No methods matching selected found in class $className." }
+                                    logger.error { "No methods matching selected found in class $classNameForLog." }
                                     continue
                                 }
 
@@ -227,7 +231,7 @@ object UtTestsDialogProcessor {
                                 updateIndicator(
                                     indicator,
                                     ProgressRange.SOLVING,
-                                    "Generate test cases for class $className",
+                                    "Generate test cases for class $classNameForLog",
                                     processedClasses.toDouble() / totalClasses
                                 )
 
@@ -250,7 +254,7 @@ object UtTestsDialogProcessor {
                                             updateIndicator(
                                                 indicator,
                                                 ProgressRange.SOLVING,
-                                                "Generate test cases for class $className",
+                                                "Generate test cases for class $classNameForLog",
                                                 (processedClasses.toDouble() + innerTimeoutRatio) / totalClasses
                                             )
                                         }, 0, 500, TimeUnit.MILLISECONDS)
@@ -273,16 +277,16 @@ object UtTestsDialogProcessor {
                                         if (rdGenerateResult.notEmptyCases == 0) {
                                             if (!indicator.isCanceled) {
                                                 if (model.srcClasses.size > 1) {
-                                                    logger.error { "Failed to generate any tests cases for class $className" }
+                                                    logger.error { "Failed to generate any tests cases for class $classNameForLog" }
                                                 } else {
                                                     showErrorDialogLater(
                                                         model.project,
-                                                        errorMessage(className, secondsTimeout),
-                                                        title = "Failed to generate unit tests for class $className"
+                                                        errorMessage(classNameForLog, secondsTimeout),
+                                                        title = "Failed to generate unit tests for class $classNameForLog"
                                                     )
                                                 }
                                             } else {
-                                                logger.warn { "Generation was cancelled for class $className" }
+                                                logger.warn { "Generation was cancelled for class $classNameForLog" }
                                             }
                                         } else {
                                             testSetsByClass[srcClass] = rdGenerateResult
diff --git a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/process/EngineProcess.kt b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/process/EngineProcess.kt
index 99a4117b04..eef1a9608b 100644
--- a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/process/EngineProcess.kt
+++ b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/process/EngineProcess.kt
@@ -61,7 +61,7 @@ data class RdTestGenerationResult(val notEmptyCases: Int, val testSetsId: Long)
 class EngineProcessInstantDeathException :
     InstantProcessDeathException(UtSettings.engineProcessDebugPort, UtSettings.runEngineProcessWithDebug)
 
-class EngineProcess private constructor(val project: Project, rdProcess: ProcessWithRdServer) :
+class EngineProcess private constructor(val project: Project, private val classNameToPath: Map<String, String?>, rdProcess: ProcessWithRdServer) :
     ProcessWithRdServer by rdProcess {
     companion object {
         private val log4j2ConfigFile: File
@@ -125,9 +125,9 @@ class EngineProcess private constructor(val project: Project, rdProcess: Process
             add(rdPortArgument(port))
         }
 
-        fun createBlocking(project: Project): EngineProcess = runBlocking { EngineProcess(project) }
+        fun createBlocking(project: Project, classNameToPath: Map<String, String?>): EngineProcess = runBlocking { EngineProcess(project, classNameToPath) }
 
-        suspend operator fun invoke(project: Project): EngineProcess =
+        suspend operator fun invoke(project: Project, classNameToPath: Map<String, String?>): EngineProcess =
             LifetimeDefinition().terminateOnException { lifetime ->
                 val rdProcess = startUtProcessWithRdServer(lifetime) { port ->
                     val cmd = obtainEngineProcessCommandLine(port)
@@ -152,7 +152,7 @@ class EngineProcess private constructor(val project: Project, rdProcess: Process
                 }
                 rdProcess.awaitProcessReady()
 
-                return EngineProcess(project, rdProcess)
+                return EngineProcess(project, classNameToPath, rdProcess)
             }
     }
 
@@ -177,7 +177,7 @@ class EngineProcess private constructor(val project: Project, rdProcess: Process
             val sourceFile = psiClass?.navigationElement?.containingFile?.virtualFile?.canonicalPath
 
             logger.debug { "computeSourceFileByClass result: $sourceFile" }
-            sourceFile
+            sourceFile ?: classNameToPath[params.canonicalClassName]
         }
 
     fun createTestGenerator(