Run, debug, and test Scala projects

1. Create or import a Scala project as you would normally create or import any other project in IntelliJ IDEA.

2. Open your application in the editor.

3. Press ShiftF10 to execute the application. Alternatively, in the editor gutter, click the icon and select Run 'name'.

   

You can run your application using the sbt shell that is a part of any sbt project.

1. Open your sbt project.

2. If you want to delegate your builds and imports to sbt, in the sbt tool window, click the icon and select sbt Settings.

   On the sbt settings page, under the sbt shell select the build option (required sbt 0.13.5+) and click OK to save the changes.

   

   This option is also available when you create or import an sbt project.

   If you don't want to delegate your builds and imports to sbt, you can still work in the sbt shell (click sbt shell on the status bar) and run sbt commands directly from it including running your application.

3. In the sbt projects tool window, click the sbt Tasks node.

4. In the list that opens, select the run task that will run a main method.

   

   The result of execution is displayed in sbt shell tool window.

   

1. Open your Scala application in the editor.

2. In the gutter, set your breakpoints for the lines of code you want to debug. For more information about breakpoints, refer to Breakpoints.

3. If needed, you can access the Run/Debug configurations dialog (Run | Edit Configurations) and adjust the settings, but usually the default settings are enough to successfully run your debugging session.

4. Press ShiftF9.

   Alternatively, on the project widget, click icon to start debugging.

5. Evaluate the results in the Debug tool window.

   For more information about using options in the Debug tool window, refer to the Debug code section.

1. Press CtrlAlt0S to open settings and then select Build, Execution, Deployment | Debugger.

2. From the options on the right, you can edit the general debugger settings, or scroll down to the Scala section and adjust the Scala-specific debugger settings.

   

   If you need to disable Smart step into for the Scala code, select Debugger | Stepping and disable the Always do smart step into option in the Scala section.

   

1. Open your sbt project.

2. Open your application in the editor.

3. In the editor gutter, set your breakpoints for the lines of code you want to debug.

   

   You cannot debug code defined in actual .sbt files, but you can debug code in Scala files that can be invoked from build.sbt.

   note

   If forking is enabled for the run or test tasks, debugging the tasks via the sbt shell will not work.

4. In the Settings dialog (CtrlAlt0S) , select Build, Execution, Deployment | Build Tools | sbt.

5. On the sbt page, select the Enable debugging and click OK to save the changes.

6. In the sbt shell tool window, click the icon to connect to the debugger server and start a debugging session.`

   IntelliJ IDEA also creates a run/debug configuration for the debugging session.

   

   You can edit the run/debug configuration settings, but the default settings should be enough to successfully debug your code.

7. In the sbt shell enter the run command to run the program.

   

   Evaluate your results in the Debug tool window.

   

1. Open your project and configure dependencies:

   • If you have an sbt project, open the build.sbt file and specify the following dependencies for ScalaTest:

     libraryDependencies += "org.scalactic" %% "scalactic" % "3.2.17"

     libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.17" % "test"

     Click icon in the sbt projects tool window to refresh your project or use the Sync project after changes in the build scripts option specified in the Build Tools settings to automatically refresh your project each time you make changes to build.sbt.

   • If you have a regular Scala project, use the Project Structure dialog, to configure test libraries.

2. Open a class for which you want to create a test and place the caret within the line containing the class declaration.

3. Press CtrlShift0T and select Create New Test.

   Alternatively, to create a test suite, right-click the class and from the context menu select Go to | Test.

4. In the dialog that opens, specify your test settings and click OK.

5. Open the test in the editor, press CtrlShiftF10 or right-click the test class and from the context menu select Run 'test name'.

   IntelliJ IDEA creates a run/debug configuration for the test automatically, but if you want to edit settings in your configuration, click Run | Edit Configurations from the main menu.

6. In the Run/Debug Configurations dialog, on the right side, specify settings for the test suite and click OK. The configuration has standard options, and you can find further details in the Run tests section.

   You can also specify the following Scala-related options:

   • You can select the Use sbt shell checkbox to run your test via sbt shell and the Use UI with sbt to display the test results in the same format as for platform test runner.

   • You can select the Test kind option to specify what kind of test you want to run. For example, you can select Regular expression and set class and test patterns.

7. On the main toolbar, click the icon to run the test.

8. Evaluate the results in the Run tool window.

The procedure for testing a Scala application using Specs2 is the same as the procedure described in the Test a Scala application using ScalaTest section except for the following options:

• Specify the following dependency for your sbt project:

  libraryDependencies ++= Seq("org.specs2" %% "specs2-core" % "3.9.5" % "test")

  For regular Scala projects, use the Project Structure dialog, to configure the test library.

• The Use UI with sbt option that displays the test results in the same format as for platform test runner is not available.

IntelliJ IDEA lets you test scopes using ScalaTest or Specs2.

You can run tests inside a scope or test the whole scope in your Scala projects.

1. Create your test scope. For example:

   import org.scalatest.GivenWhenThen
   import org.scalatest.featurespec.AnyFeatureSpec
   
   class StackFeatureSpec extends AnyFeatureSpec with GivenWhenThen {
   
       Feature("Feature 1") {
           Scenario("Scenario A") {
           }
           Scenario("Scenario B") {
           }
   
       }
       Feature("Feature 2") {
           Scenario("Scenario C") {
           }
       }
       Feature("empty") {
       }
   }

2. In the editor, depending on your test scope, you can perform the following:

   • If you open the context menu for one of the tests inside the scope, you can create a run configuration for the specified test inside that scope.

     

   • If you open a context menu for the whole scope, you can create a run configuration for all tests inside the scope.

     

3. Run your tests and view the output in the Run tool window.

   

   You can also use the sbt shell to run scope tests.

IntelliJ IDEA lets you run your test suite with code coverage.

1. If you haven't done it already, you need to first install the 'Code Coverage for Java' plugin. Go to Settings | Plugins and search for it in the Marketplace



2. Open your project.

3. Open the test you want to run in the editor.

4. In the gutter, click and select the Run 'name' with Coverage option.

   Alternatively, you go to Run | Run with Coverage in the main menu, to run your code with coverage.

   IntelliJ IDEA runs the test and displays the Coverage tool window with code coverage information. You can open the Coverage tool window by clicking on its icon on the right side of the editor.

   

You can also adjust default code coverage settings or code coverage behavior if you need.

If you have already run you test suite, IntelliJ IDEA creates the run/debug configuration automatically. You can open the created run configuration and adjust the settings. If you want to create a new run configuration for the test suite, do the following:

1. In the main menu, go to Run | Edit Configurations.

2. In the Run/Debug Configurations dialog, click the icon from the options on the left.

3. From the list that opens, select the configuration you need.

4. From the options on right, click the Code Coverage tab.

5. Adjust the default settings and click OK. For more information, refer to Code coverage

You can also adjust code coverage behavior.

1. Press CtrlAlt0S to open settings and then select >Build, Execution, Deployment | Coverage.

2. From the options on right, adjust the settings and click OK.