prototype cmake generation

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/actions/SyncWrappersAndStubsAction.kt

@@ -0,0 +1,14 @@
+package org.utbot.cpp.clion.plugin.actions
+
+import com.intellij.openapi.actionSystem.AnActionEvent
+import org.utbot.cpp.clion.plugin.utils.client
+
+class SyncWrappersAndStubsAction: UTBotBaseAction() {
+ override fun actionPerformed(e: AnActionEvent) {
+ e.client.syncWrappersAnsStubs()
+ }
+
+ override fun updateIfEnabled(e: AnActionEvent) {
+ e.presentation.isEnabledAndVisible = e.project != null
+ }
+}

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/client/Client.kt

@@ -22,6 +22,8 @@ import org.utbot.cpp.clion.plugin.actions.ShowSettingsAction
 import org.utbot.cpp.clion.plugin.client.channels.LogChannel
 import org.utbot.cpp.clion.plugin.grpc.IllegalPathException
 import org.utbot.cpp.clion.plugin.client.logger.ClientLogger
+import org.utbot.cpp.clion.plugin.client.requests.SyncProjectStubsAndWrappers
+import org.utbot.cpp.clion.plugin.grpc.GrpcRequestBuilderFactory
 import org.utbot.cpp.clion.plugin.listeners.ConnectionStatus
 import org.utbot.cpp.clion.plugin.listeners.UTBotEventsListener
 import org.utbot.cpp.clion.plugin.settings.projectIndependentSettings
@@ -83,46 +85,46 @@ class Client(
  )
  return
  }
- executeRequestImpl(request)
+ requestsCS.launch(CoroutineName(request.toString())) {
+ executeRequestImpl(request, coroutineContext[Job])
+ }
  }
 
- private fun executeRequestImpl(request: Request) {
- requestsCS.launch(CoroutineName(request.toString())) {
- try {
- request.execute(stub, coroutineContext[Job])
- } catch (e: io.grpc.StatusException) {
- val id = request.id
- when (e.status.code) {
- Status.UNAVAILABLE.code -> notifyNotConnected(project, port, serverName)
- Status.UNKNOWN.code -> notifyError(
- UTBot.message("notify.title.unknown.server.error"), // unknown server error
- UTBot.message("notify.unknown.server.error"),
- project
- )
- Status.CANCELLED.code -> notifyError(
- UTBot.message("notify.title.cancelled"),
- UTBot.message("notify.cancelled", id, e.message ?: ""),
- project
- )
- Status.FAILED_PRECONDITION.code, Status.INTERNAL.code, Status.UNIMPLEMENTED.code, Status.INVALID_ARGUMENT.code -> notifyError(
- UTBot.message("notify.title.error"),
- UTBot.message("notify.request.failed", e.message ?: "", id),
- project
- )
- else -> notifyError(
- UTBot.message("notify.title.error"),
- e.message ?: "Corresponding exception's message is missing",
- project
- )
- }
- } catch (e: IllegalPathException) {
- notifyError(
- UTBot.message("notify.bad.settings.title"),
- UTBot.message("notify.bad.path", e.message ?: ""),
- project,
- ShowSettingsAction()
+ private suspend fun executeRequestImpl(request: Request, job: Job?) {
+ try {
+ request.execute(stub, job)
+ } catch (e: io.grpc.StatusException) {
+ val id = request.id
+ when (e.status.code) {
+ Status.UNAVAILABLE.code -> notifyNotConnected(project, port, serverName)
+ Status.UNKNOWN.code -> notifyError(
+ UTBot.message("notify.title.unknown.server.error"), // unknown server error
+ UTBot.message("notify.unknown.server.error"),
+ project
+ )
+ Status.CANCELLED.code -> notifyError(
+ UTBot.message("notify.title.cancelled"),
+ UTBot.message("notify.cancelled", id, e.message ?: ""),
+ project
+ )
+ Status.FAILED_PRECONDITION.code, Status.INTERNAL.code, Status.UNIMPLEMENTED.code, Status.INVALID_ARGUMENT.code -> notifyError(
+ UTBot.message("notify.title.error"),
+ UTBot.message("notify.request.failed", e.message ?: "", id),
+ project
+ )
+ else -> notifyError(
+ UTBot.message("notify.title.error"),
+ e.message ?: "Corresponding exception's message is missing",
+ project
  )
  }
+ } catch (e: IllegalPathException) {
+ notifyError(
+ UTBot.message("notify.bad.settings.title"),
+ UTBot.message("notify.bad.path", e.message ?: ""),
+ project,
+ ShowSettingsAction()
+ )
  }
  }
 
@@ -134,17 +136,27 @@ class Client(
  }
  }
 
- private fun registerClient() {
- requestsCS.launch {
- try {
- logger.info { "Sending REGISTER CLIENT request, clientID == $clientId" }
- stub.registerClient(Testgen.RegisterClientRequest.newBuilder().setClientId(clientId).build())
- } catch (e: io.grpc.StatusException) {
- logger.error { "${e.status}: ${e.message}" }
- }
+ private suspend fun registerClient() {
+ try {
+ logger.info { "Sending REGISTER CLIENT request, clientID == $clientId" }
+ stub.registerClient(Testgen.RegisterClientRequest.newBuilder().setClientId(clientId).build())
+ } catch (e: io.grpc.StatusException) {
+ logger.error { "Exception on registering client: ${e.status}: ${e.message}" }
  }
  }
 
+ fun syncWrappersAndStubs() {
+ createRequestForSync().also {
+ executeRequestIfNotDisposed(it)
+ }
+ }
+
+ private fun createRequestForSync(): SyncProjectStubsAndWrappers =
+ SyncProjectStubsAndWrappers(
+ GrpcRequestBuilderFactory(project).createProjectRequestBuilder(),
+ project
+ )
+
  private fun startPeriodicHeartBeat() {
  logger.info { "The heartbeat started with interval: $HEARTBEAT_INTERVAL ms" }
  servicesCS.launch(CoroutineName("periodicHeartBeat")) {
@@ -167,6 +179,7 @@ class Client(
  notifyInfo(UTBot.message("notify.connected.title"), UTBot.message("notify.connected", port, serverName))
  logger.info { "Successfully connected to server!" }
  registerClient()
+ executeRequestIfNotDisposed(createRequestForSync())
  }
 
  if (newClient || !response.linked) {

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/client/ManagedClient.kt

@@ -103,6 +103,10 @@ class ManagedClient(val project: Project) : Disposable {
  return "${(System.getenv("USER") ?: "user")}-${createRandomSequence()}"
  }
 
+ fun syncWrappersAnsStubs() {
+ client?.syncWrappersAndStubs()
+ }
+
  @TestOnly
  fun waitForServerRequestsToFinish(
  timeout: Long = SERVER_TIMEOUT,

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/client/handlers/testsStreamHandler/CMakePrinter.kt

@@ -0,0 +1,52 @@
+package org.utbot.cpp.clion.plugin.client.handlers.testsStreamHandler
+
+class CMakePrinter(private val currentCMakeListsContent: String) {
+ private val ss = StringBuilder()
+ var isEmpty = true
+ private set
+
+ init {
+ ss.append("\n")
+ startUTBotSection()
+ }
+
+ private fun add(string: String) {
+ ss.append(string)
+ ss.append("\n")
+ }
+
+ fun startUTBotSection() {
+ add("#utbot_section_start")
+ }
+
+ fun addDownloadGTestSection() {
+ isEmpty = false
+ add(
+ """
+ include(FetchContent)
+ FetchContent_Declare(
+ googletest
+ GIT_REPOSITORY https://github.com/google/googletest.git
+ GIT_TAG release-1.12.1
+ )
+ # For Windows: Prevent overriding the parent project's compiler/linker settings
+ set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+ FetchContent_MakeAvailable(googletest)
+ enable_testing()
+ include(GoogleTest)
+ """.trimIndent()
+ )
+ }
+
+ fun addSubdirectory(dirRelativePath: String) {
+ isEmpty = false
+ val addDirectoryInstruction = "add_subdirectory($dirRelativePath)"
+ if (!currentCMakeListsContent.contains(addDirectoryInstruction))
+ add(addDirectoryInstruction)
+ }
+
+ fun get(): String {
+ return ss.toString() + "#utbot_section_end\n"
+ }
+}
+

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/client/handlers/testsStreamHandler/ShouldInstallGTestDialog.kt

@@ -0,0 +1,20 @@
+package org.utbot.cpp.clion.plugin.client.handlers.testsStreamHandler
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.ui.DialogWrapper
+import com.intellij.ui.dsl.builder.panel
+import javax.swing.JComponent
+import org.utbot.cpp.clion.plugin.UTBot
+
+class ShouldInstallGTestDialog(project: Project) : DialogWrapper(project) {
+ init {
+ init()
+ title = "UTBot: GTest Install"
+ }
+
+ override fun createCenterPanel(): JComponent {
+ return panel {
+ row(UTBot.message("dialog.should.install.gtest")) {}
+ }
+ }
+}

clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/client/handlers/TestsStreamHandler.kt → clion-plugin/src/main/kotlin/org/utbot/cpp/clion/plugin/client/handlers/testsStreamHandler/TestsStreamHandler.kt

@@ -1,22 +1,32 @@
-package org.utbot.cpp.clion.plugin.client.handlers
+package org.utbot.cpp.clion.plugin.client.handlers.testsStreamHandler
 
 import com.intellij.openapi.components.service
+import com.intellij.openapi.progress.ProgressIndicator
+import com.intellij.openapi.progress.ProgressManager
+import com.intellij.openapi.progress.Task
 import com.intellij.openapi.project.Project
 import com.intellij.util.io.exists
+import com.intellij.util.io.readText
+import kotlin.io.path.appendText
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.Flow
+import org.utbot.cpp.clion.plugin.UTBot
+import org.utbot.cpp.clion.plugin.client.handlers.SourceCode
+import org.utbot.cpp.clion.plugin.client.handlers.StreamHandlerWithProgress
 import org.utbot.cpp.clion.plugin.settings.settings
 import org.utbot.cpp.clion.plugin.ui.services.TestsResultsStorage
-import org.utbot.cpp.clion.plugin.utils.convertFromRemotePathIfNeeded
 import org.utbot.cpp.clion.plugin.utils.createFileWithText
 import org.utbot.cpp.clion.plugin.utils.invokeOnEdt
+import org.utbot.cpp.clion.plugin.utils.isCMakeListsFile
 import org.utbot.cpp.clion.plugin.utils.isSarifReport
 import org.utbot.cpp.clion.plugin.utils.logger
 import org.utbot.cpp.clion.plugin.utils.markDirtyAndRefresh
 import org.utbot.cpp.clion.plugin.utils.nioPath
+import org.utbot.cpp.clion.plugin.utils.notifyError
 import testsgen.Testgen
 import testsgen.Util
+import java.io.IOException
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
@@ -31,34 +41,91 @@ class TestsStreamHandler(
 ) : StreamHandlerWithProgress<Testgen.TestsResponse>(project, grpcStream, progressName, cancellationJob) {
 
  private val myGeneratedTestFilesLocalFS: MutableList<Path> = mutableListOf()
+ private var isCMakePresent = false
+ private var isSarifPresent = false
 
  override fun onData(data: Testgen.TestsResponse) {
  super.onData(data)
 
- val testSourceCodes = data.testSourcesList
- .map { SourceCode(it, project) }
- .filter { !it.localPath.isSarifReport() }
+ // currently testSourcesList contains not only test sourse codes but
+ // also some extra files like sarif report, cmake generated file
+ // this was done for compatibility
+ val sourceCodes = data.testSourcesList.mapNotNull { it.toSourceCodeOrNull() }
+ val testSourceCodes = sourceCodes
+ .filter { !it.localPath.isSarifReport() && !it.localPath.isCMakeListsFile() }
  handleTestSources(testSourceCodes)
 
- val stubSourceCodes = data.stubs.stubSourcesList.map { SourceCode(it, project) }
+ // for stubs we know that stubSourcesList contains only stub sources
+ val stubSourceCodes = data.stubs.stubSourcesList.mapNotNull { it.toSourceCodeOrNull() }
  handleStubSources(stubSourceCodes)
 
- val sarifReport =
- data.testSourcesList.find { it.filePath.convertFromRemotePathIfNeeded(project).isSarifReport() }?.let {
- SourceCode(it, project)
- }
- sarifReport?.let { handleSarifReport(it) }
+ val sarifReport = sourceCodes.find { it.localPath.isSarifReport() }
+ if (sarifReport != null)
+ handleSarifReport(sarifReport)
+
+ val cmakeFile = sourceCodes.find { it.localPath.endsWith("CMakeLists.txt") }
+ if (cmakeFile != null)
+ handleCMakeFile(cmakeFile)
 
  // for new generated tests remove previous testResults
  project.service<TestsResultsStorage>().clearTestResults(testSourceCodes)
  }
 
  override fun onFinish() {
  super.onFinish()
+ if (!isCMakePresent)
+ project.logger.warn("CMake file is missing in the tests response")
+ if (!isSarifPresent)
+ project.logger.warn("Sarif report is missing in the tests response")
  // tell ide to refresh vfs and refresh project tree
  markDirtyAndRefresh(project.nioPath)
  }
 
+ private fun handleCMakeFile(cmakeSourceCode: SourceCode) {
+ isCMakePresent = true
+ createFileWithText(cmakeSourceCode.localPath, cmakeSourceCode.content)
+ val rootCMakeFile = project.nioPath.resolve("CMakeLists.txt")
+ if (!rootCMakeFile.exists()) {
+ project.logger.warn("Root CMakeLists.txt file does not exist. Skipping CMake patches.")
+ return
+ }
+
+ val currentCMakeFileContent = rootCMakeFile.readText()
+ val cMakePrinter = CMakePrinter(currentCMakeFileContent)
+ invokeOnEdt { // we can show dialog only from edt
+
+ if (!project.settings.storedSettings.isGTestInstalled) {
+ val shouldInstallGTestDialog = ShouldInstallGTestDialog(project)
+
+ if (shouldInstallGTestDialog.showAndGet()) {
+ cMakePrinter.addDownloadGTestSection()
+ }
+
+ // whether user confirmed that gtest is installed or we added the gtest section, from now on
+ // we will assume that gtest is installed
+ project.settings.storedSettings.isGTestInstalled = true
+ }
+
+ cMakePrinter.addSubdirectory(project.settings.storedSettings.testDirRelativePath)
+
+ // currently we are on EDT, but writing to file better to be done on background thread
+ ProgressManager.getInstance().run(object : Task.Backgroundable(project, "Modifying CMakeLists.txt file", false) {
+ override fun run(progressIndicator: ProgressIndicator) {
+ try {
+ if (!cMakePrinter.isEmpty)
+ project.nioPath.resolve("CMakeLists.txt").appendText(cMakePrinter.get())
+ } catch (e: IOException) {
+ notifyError(
+ UTBot.message("notify.title.error"),
+ UTBot.message("notify.error.write.to.file", e.message ?: "unknown reason"),
+ project
+ )
+ }
+ }
+ })
+ }
+ }
+
  override fun onCompletion(exception: Throwable?) {
  invokeOnEdt {
  indicator.stopShowingProgressInUI()
@@ -71,6 +138,7 @@ class TestsStreamHandler(
  }
 
  private fun handleSarifReport(sarif: SourceCode) {
+ isSarifPresent = true
  backupPreviousClientSarifReport(sarif.localPath)
  createSourceCodeFiles(listOf(sarif), "sarif report")
  project.logger.info { "Generated SARIF report file ${sarif.localPath}" }
@@ -97,6 +165,15 @@ class TestsStreamHandler(
  }
  }
 
+ private fun Util.SourceCode.toSourceCodeOrNull(): SourceCode? {
+ return try {
+ SourceCode(this, project)
+ } catch (e: IllegalArgumentException) {
+ project.logger.error("Could not convert remote path to local version: bad path: ${this.filePath}")
+ null
+ }
+ }
+
  private fun handleStubSources(sources: List<SourceCode>) {
  if (project.settings.isRemoteScenario) {
  createSourceCodeFiles(sources, "stub")