<html>
    <head>
        <title>TestNG - IDEA Plugin</title>
        <script type="text/javascript" src="banner.js"></script>
        <link rel="stylesheet" href="testng.css" type="text/css" />
      </head>
<body>

<script type="text/javascript">
    displayMenu("idea.html")
</script>

<h2 align="center">TestNG IDEA Plug-in</h2>



<p align="center">
<img src="http://testng.org/pictures/idea-output.png" />
</p>

<h3>IDEA 7</h3>

TestNG is bundled in IDEA 7 onwards, no extra plugins need to be installed.  The full documentation can be found <a href="http://www.jetbrains.com/idea/features/junit_testng.html#TestNG">here</a>.

<h3>IDEA 6 and older </h3>


TestNG has an IDEA plug-in that mirrors much of the behavior of the built-in JUnit support. You should be able to run tests within IDEA without defining any files externally, as well as quickly and easily migrate JUnit code. The plug-in also provides the same output test view as JUnit tests.

Installation

<ul>
	<li>From IDEA, go to Preferences -> Plugins.</li>
	<li>Click over to the Available Plugins tab.</li>
</ul>
<p>The latest version of the TestNG plugin will be listed there, ready to download and install.&nbsp;
Also, you can go to the <a href="http://svn.jetbrains.org/idea/Trunk/bundled/testng">
TestNG IDEA plug-in project page</a> and download its source from there.</p>
<p>Please note that this plug-in only works on IDEA 5.0 and 6.0.</p>

<p><b>Creating a TestNG Run/Debug configuration</b></p>
<p>Once you have installed the plug-in and restarted IDEA, and have some TestNG classes you would like to run, simply
open the Run/Debug window. You will see a TestNG tab, where you can add a configuration.

</p>
<p>There are a number of methods for determining the set of tests that will be run. These are:</p>
<ul>
	<li>Package: Specify a package to run. All tests in this package and below will be included.</li>
	<li>Group: Specify a TestNG group to run.</li>
	<li>Suite: Specify an external testng.xml file to run.</li>
	<li>Class: Run all tests in a single class.</li>
	<li>Method: Run a single test method.

</li>
</ul>
<p>Once you create the run configuration, you can run it. Upon running, the plug-in will launch an external process to run your tests. The test results will be display in a tree view, with passed and failed tests highlighted. You can narrow down on the console output for a specify test by clicking on it, while double clicking a test will navigate to its source code.
</p>

<p align="center">
<img src="http://testng.org/pictures/idea-rundialog.png" />
</p>


<script src="http://www.google-analytics.com/urchin.js" type="text/javascript">
</script>
<script type="text/javascript">
_uacct = "UA-238215-2";
urchinTracker();
</script>

</body>

</html>
