JavaToolbox Category : Code coverage

UnitCover

Fri, 01 Sep 2006 11:11:51 GMT

Code coverage viewer plugin for NetBeans 5.

UnitCover displays the code coverage of unit tests in the NetBeans editor. As unit tests are run, the module will update the code coverage data and markup the editors lines accordingly. The lines which are fully covered by unit tests are annotated with a green color and the ones covered partially are annotated in yellow.
The functionality provided by the plugin helps to visually identify the portions of code with low coverage and helps in targeted tests development.
Java Application, Java Library, Java Project with Existing Sources and NetBeans module projects are supported.

more about UnitCover

Optimizeit Enterprise Suite

Sun, 02 Jan 2005 04:28:47 GMT

Equips developers with a toolkit for optimizing performance and managing application quality throughout development.
Optimizeit Enterprise Suite allows developers to track performance bottlenecks at the JDBC, JMS, JNDI, JSP, and EJB level. It integrates with popular application servers and IDEs, and it supports multiple operating systems.
Optimizeit Enterprise Suite includes:
- Optimizeit Profiler: isolate memory and CPU performance issues.
- Optimizeit Thread Debugger: solve thread issues. View the status of all threads and monitors in real time, avoid thread starvation and contentions that lead to crashes, and predict deadlocks before they occur.
- Optimizeit Code Coverage: view in real time how frequently each class, method, and line of code is executed. Code Coverage can be included in automated batch testing sessions, and it allows for report generation.
- Optimizeit Request Analyzer: analyze the performance behavior of code across J2EE application tiers.

more about Optimizeit Enterprise Suite

IntelliJ IDEA

Tue, 21 Dec 2004 00:49:00 GMT

Java IDE focused on developer productivity.

Features include:
- Multiple projects support
- Refactoring
- Java EE (J2EE), Java SE (J2SE), Java ME (J2ME) support
- Supported languages: Java, JavaScript/ Flex, HTML/XHTML/CSS, XML/XSL, Ruby/JRuby, Groovy
- Technologies and frameworks supported: JSP, JSF, EJB, AJAX, GWT, Struts, Spring, Seam, Hibernate/ JPA, Web Services, Rails, Grails, Java ME MIDP/CLDC, OSGi, Google App Engine, Tapestry, Android
- Support for SQL-92 and MySQL
- Support for FreeMarker and Velocity
- Integration with Ant, JUnit, TestNG and Maven
- Integration with CVS, Subversion, StarTeam, Perforce, ClearCase UCM and Visual SourceSafe version control systems
- Supports ER diagrams with EJB3
- Swing GUI designer
- IDE customization
- Code generation
- Code analysis
- PHP support
- Free and open-source IDE for Java SE, Groovy and Android

more about IntelliJ IDEA

Cobertura

Mon, 21 Mar 2005 15:02:50 GMT

Free Java tool that calculates the percentage of code accessed by tests.
Cobertura can be used to identify which parts of your Java program are lacking test coverage. It is based on jcoverage.

Features include:
- Can be executed from Ant or from the command line.
- Instruments Java bytecode after it has been compiled.
- Can generate reports in HTML or XML.
- Shows percent of lines coveraged and branches coveraged for each class, package, and for the overall project.
- Shows the McCabe cyclomatic code complexity of each class, and the average cyclomatic code complexity for each package, and for the overall product.
- Can sort HTML results by class name, percent of lines covered, percent of branches covered, etc. It can also sort in ascending or descending order.

more about Cobertura

EMMA

Mon, 24 Jan 2005 18:03:57 GMT

Open-source toolkit for measuring and reporting Java code coverage.
EMMA is based on bytecode instrumentation.
Features include:
- Can instrument classes for coverage either offline (before they are loaded) or on the fly (using an instrumenting application classloader).
- Supported coverage types: class, method, line, basic block. EMMA can detect when a single source code line is covered only partially.
- Coverage stats are aggregated at method, class, package, and "all classes" levels.
- Output report types: plain text, HTML, XML. All report types support drill-down, to a user-controlled detail depth. The HTML report supports source code linking.
- Output reports can highlight items with coverage levels below user-provided thresholds.
- Coverage data obtained in different instrumentation or test runs can be merged together.
- Does not require access to the source code and degrades gracefully with decreasing amount of debug information available in the input classes.
- Can instrument individual .class files or entire .jars (in place, if desired). Coverage subset filtering is possible, too.
- Makefile and ANT build integration are supported on equal footing.

more about EMMA

Hansel

Mon, 19 Sep 2005 19:12:06 GMT

Hansel is an extension to JUnit that adds code coverage testing to the testing framework.

more about Hansel

Clover

Tue, 21 Dec 2004 00:21:24 GMT

Configurable code coverage analysis tool.
Clover highlights sections of code that are not being adequately exercised by your unit tests.
Main features:
- plug-ins for IntelliJ IDEA, Eclipse, NetBeans, JBuilder and JDeveloper.NET 2003
- integration with projects using Ant
- integration into legacy build systems with command line interface and API
- configurable coverage reporting of Method, Statement, and Branch coverage
- reporting in HTML, XML, PDF, and plain text
- standalone Swing Viewer providing interactive browsing of source-level coverage results
- control over the instrumentation and coverage recording process, using source level directives, regexp-based filters and runtime system properties

more about Clover

JProbe Suite

Tue, 06 Jun 2006 09:51:47 GMT

Java profiler providing diagnostics on memory usage, performance and test coverage.

JProbe Suite includes:
- JProbe Memory: for proactively discovering, diagnosing and resolving memory allocation issues such as memory leaks (loitering objects) and excessive garbage collection activity (object cycling) that can lead to out-of-memory system crashes and slower overall system performance.
- JProbe Performance: for proactively discovering, diagnosing and resolving code bottlenecks such as expensive methods, deadlocks and stalled threads that can lead to slow application performance and limit scalability.
- JProbe Coverage: for proactively assessing the completeness and accuracy of test runs in development and QA – enhances development and QA collaboration in creating more complete test suites.

JProbe also offers an Eclipse plug-in that provides code performance analysis and problem resolution directly within the Eclipse Java IDE.

more about JProbe Suite

McCabe IQ

Mon, 15 Sep 2008 13:24:07 GMT

Interactive, visual environment for managing software quality through static analysis and test/code coverage.
McCabeIQ comes in three editions: Developers, Test Team, Enterprise.

Features include:
- Software metrics: McCabe Cyclomatic Complexity; McCabe Essential Complexity; Module Design Complexity; Integration Complexity; Lines of Code; Halstead.
- Color-coded structure Battlemaps, scatter plot diagrams, and flow graphs
- Metric Trend Reports: track a system's metric values over time to document the progress made in improving the overall stability and quality of the project
- Customized reporting
- Plan software testing resources in advance, identifying test paths and the number of tests required
- Code coverage
- McCabe Compare: helps you locate redundant code so you can either delete or reengineer it
- McCabe Data: track data use within your programs and anticipate complexity
- McCabe Change: identify the modules in your program that have changed since the first time you parsed your code
- McCabe Slice: uncover your program’s internal architecture
- Supports Ada, ASM86/95, C, C#, C++.NET, C++, Cobol, Fortran, Java, JSP, Perl, PL1, VB, VB.NET
- Enterprise Edition provides all the functionality of the Developers and Test Team Editions. In addition, it provides enterprise reporting, reengineering capabilities, change analysis, and secure web-enabled test data collection.

more about McCabe IQ

jcoverage

Mon, 21 Mar 2005 14:58:36 GMT

jcoverage identifies how many times each line of code in your application has been executed and you can see which parts of your software remain untested. After instrumenting your code and running your tests, a report is generated allowing you to view information coverage figures from a project level right down to the individual line of code.
jcoverage works by modifying your Java classes at the bytecode level. It also works against code that you do not have the source code for, as well as code that has itself been modified at byte-code level, for example, JDO data classes and aspect-derived code. When these modified classes are executed, during a test-run for instance, data is collected that identifies how many times each line of code has been executed.

Features include:
- measure the percentage of code that has been tested.
- run your tests, create your reports, get all information about problems in your system (with data shown on a per-test basis).
- set-up your test in isolation using mock-object technologies to reduce reliance on extensive end-to-end per system tests.

Three versions are available: jcoverage/gpl (free version released under the GPL); jcoverage commercial edition (fully supported); jcoverage+ (introduces more rigour and finer granularity to your testing).
A commercial jcoverage plugin is available for Eclipse 3.

more about jcoverage

EclEmma

Sat, 21 Oct 2006 12:03:48 GMT

Code coverage tool for Eclipse.
Internally, EclEmma is based on the EMMA Java code coverage tool, trying to adopt EMMA's philosophy for the Eclipse workbench:
- Fast develop/test cycle: Launches from within the workbench like JUnit test runs can directly be analyzed for code coverage.
- Coverage results are immediately summarized and highlighted in the Java source code editors.
- Non-invasive: does not require modifying your projects or performing any other setup.

Features include:
- Launching: EclEmma adds a so called launch mode to the Eclipse workbench. It is called Coverage mode and works exactly like the existing Run and Debug modes.
- Analysis: After your application or unit test has terminated code coverage information is automatically available in the Eclipse workbench (Coverage overview, Source highlighting). Additional features support analysis for your test coverage (Different counters, Multiple coverage sessions, Merge Sessions)
- Import/Export: Coverage data import, Coverage report export as a .ec file or in XML or HTML format

more about EclEmma

TeamCity

Fri, 21 Jul 2006 01:20:52 GMT

IDE-independent integrated team environment.
TeamCity automates and coordinates key collaborative processes to eliminate manual systems and delays, providing integration with multiple build and test tools, real-time unit test frequency, server-side inspections and code coverage analysis.

Features include:
- continuous integration and testing
- server-side code analysis
- build management
- automated team communication
- code coverage analysis and reporting
- web-based interface and project dashboard
- extensibility
- IntelliJ IDEA, Eclipse and Visual Studio integration
- pre-tested (delayed) commit
- remote run for personal builds

Supported environments:
- Ant, Maven, NAnt, MSBuild
- Having an IntelliJ IDEA project or a Visual Studio solution, you can build your application with TeamCity, even without providing a build script
- Supports JUnit and NUnit
- Integrates with Perforce, CVS, Subversion, Visual SourceSafe, StarTeam

more about TeamCity

Codign CoView

Thu, 22 Jun 2006 01:03:53 GMT

Eclipse plug-ins and Ant task that provide unit tests and coverage data for Java applications.
CoView consists of:
- CoViewDeveloper: helps developers improve the testability of their code, design and generate JUnit tests, highlight paths and measure path coverage.
- CoViewManager: helps managers define quality standards and check coverage before code is released into production.
- Comet: available for Ant, lets you measure your metrics during the build process.

Features include:
- CoView JUnit Runner for running tests
- In addition to JUnit support, CoViewDeveloper also has wizards for HTTPUnit and DbUnit, as well as support for abstract classes and private methods
- Immediate metric analysis
- User-defined testability metrics, thresholds and severity levels
- Path coverage
- JUnit wizards
- Auto-generated proxy code to test private methods
- Support for DbUnit and HTTPUnit
- Prevent compilation if code exceeds metric thresholds
- Metric violation notification
- Generate HTML or XML reports
- Supports JDK 1.4, 5 and 6

more about Codign CoView

Convergence

Tue, 15 Mar 2005 03:09:34 GMT

Quality management dashboard that enables tracking of application quality early in the software development life-cycle.

With Convergence, teams can:
- Determine if new code is being unit tested
- Track and understand code growth with respect to test coverage
- Identify areas to focus on to detect defects
- Identify the cause of test failures
- Uncover practices that impair maintainability and increase risk

Unlike static build reports, which convey limited information, Convergence tracks and relates multiple data points, enabling teams to understand and report on application quality through a unified focus on:
- NUnit/JUnit test statuses, code coverage and outputs
- Source code and code changes in CM systems like CVS and Subversion
- Assembly/package and class dependencies
- Code size, code audits, complexity and coupling
- NUnit/JUnit test & defect report relationships in defect tracking systems like JIRA and Bugzilla

more about Convergence

Rational PurifyPlus

Thu, 31 Mar 2005 00:02:12 GMT

Set of automated runtime analysis tools for improving Linux-, UNIX- and Windows-based application reliability and performance.
Designed for Java, C, C++, and .NET applications.

Features include:
- Runtime and memory management error detection: memory corruption and leak detection.
- Application performance profiling: highlights application performance bottlenecks.
- Code coverage analysis: identifies untested code.
- Instruments code at the byte or object level.
- Server-side Java support: install PurifyPlus on your Web server to analyze Java Server Pages (JSP) and servlets.
- For software developers working with Java, Visual C++ and all VS.NET managed languages (including C# and VB.NET).
- Runs directly inside WebSphere Studio, Eclipse or Visual Studio, as well as stand-alone.
- Selective instrumentation: allows you to select which modules of an application to analyze.

more about Rational PurifyPlus

JCover

Mon, 29 Aug 2005 19:16:19 GMT

Code coverage analyser for Java programs.

Features include:
* User interface
* Statement and branch coverage
* Source as well as class files
* Client and server-side testing
* Coverage comparison
* Coverage differencing
* Reports and charts
* Coverage API for better control
* Batch mode for automated build

more about JCover