Python Code Running Assistance

Save run/debug configuration

Click More Actions to see additional running options, including Run with Coverage, Profile, Start the concurrency visualization session. Below, there are available actions for the current configuration.

Select Save Configuration - now this configuration becomes permanent and gets the normal icon.

Edit run/debug configuration

Now click near solver and select Edit configurations. The Run/Debug Configurations dialog opens:

Here you can see the solver configuration and its default settings.

The default configuration options are derived from the predefined Python template. Click the Edit configuration templates link, to preview and modify the patterns.

For example, here you change the default Java interpreter. Then it will ibe preselected in any newly created run/debug configuration of the Python type.

Let's go back to the Run/Debug Configurations dialog.

Under the Python node on the left, you see the only run/debug configuration solver. It is denoted with the icon of the normal opacity – which corresponds to the permanent run/debug configuration (remember, it became permanent because you've saved it – however, any specially created run/debug configuration also becomes permanent).

If you change anything in one of the existing run/debug configurations, then only this particular run/debug configuration will be affected.

Redirect standard input from a text file

You can use the Run/Debug Configuration dialog to automatically submit input values from a text file instead of typing them in the Run tool window.

1. Create the in.txt file in the project root with the following values of a, b, and c:

   1
   11
   1

2. Click the Run widget and select Edit Configurations. If you have several run configurations, select solver on the left.

3. Click Modify options and select the Redirect input from. The corresponding field appears in the dialog.

   Specify the path to the in.txt file in it.

   

Click Run at the bottom of the dialog to save the configuration and run it.

Creating a test

To run a test, you have to create it first. IntelliJ IDEA suggests a smart way to stub a test out: click the class name and then press , or go to Navigate | Test in the main menu. If a test exists, you can jump directly to it; if it doesn't, IntelliJ IDEA will create it:

Click the suggested action, and IntelliJ IDEA will show the following dialog:

Click OK, and see the test class is opened in the editor:

IntelliJ IDEA has produced a test class for us. However, this is just a stub which lacks the actual testing functionality. So, we will import the class to be tested, and add a test method. The resulting code might be as follows:

import unittest

from Solver import Solver


class MyTestCase(unittest.TestCase):

    def test_negative_discr(self):

        s = Solver()

        self.assertRaises(Exception)

    def test_something(self):

        self.assertEqual(True, False)


if __name__ == '__main__':

    unittest.main()

tip

If you have a different project structure, you will need to reflect that in your import statement (from solver import Solver).

Running a test

When ready with the testing code, right-click the test class name and select Run Python tests.

Launch it and observe results in the Test Runner tab of the Run tool window. To see successful test along with the failed ones, click Show Passed on the toolbar.

Breakpoint - what is it?

A breakpoint is a line of the source code, where IntelliJ IDEA will suspend, when this line is reached. IntelliJ IDEA discerns several types of breakpoints, each one denoted with its own icon.

Setting breakpoints

This is definitely the easiest part of the process. Just click the gutter on the lines you want to explore – and the breakpoints are there:

Note that each breakpoint is denoted also with a red stripe over the entire line. This color corresponds to a breakpoint that has not yet been reached. Later we will see how the line at breakpoint changes its color.

By the way, removing breakpoints is same easy – click the gutter.

Hover over a breakpoint. IntelliJ IDEA shows a tooltip with the most essential breakpoint information – line number and script address. However, if you want to change breakpoint settings, you have to right-click a breakpoint. Try changing breakpoint settings for your own, and see how the breakpoint icon changes.

Debugging session

So, we are now ready for debugging. Let's start.

First of all, select the solver run/debug configuration in the Run widget and click .

What happens next?

• IntelliJ IDEA starts, and then suspends execution at the first breakpoint.

• The line at breakpoint becomes blue. It means that IntelliJ IDEA has reached the line with the breakpoint, but has not yet executed it.

• Next to the executed lines in the editor, the values of the variables appear.

• The Debug tool window appears. This tool window shows all the important information related to debugging, and allows managing the debugging process.

For more information, refer to the product documentation.

Working in the Console tab

Why do we need it at all? For example, you'd like to see the error messages, or perform some calculations not related to the current application... With IntelliJ IDEA this is not a problem.

Click the Console tab to bring it forward.

Try to execute Java commands in this interactive console:

Note that interactive console provides code completion and history (Up/Down arrow keys).

You can always invoke the debug console by using the command Tools | Open Debug Command Line from the main menu.