Parasoft delivers a complete framework to create, manage,
and extract greater value from unit tests. We help you exercise
and test an incomplete system-enabling you to identify problems
when they are least difficult, costly, and time-consuming
to fix, which in turn reduces the length and cost of downstream
processes such as debugging. Our patented technologies automatically
generate tests that not only verify code correctness and reliability
at multiple levels, but also capture the code's code behavior
to establish a baseline for regression testing. Once this
baseline test suite is in place, you can incrementally improve
its intelligence and value by:
- Extending the automatically-generated xUnit test cases.
- Integrating your legacy xUnit test cases (or writing new
- Exercising the use case scenarios for the functionality
you want to "freeze." Parasoft Tracer will observe
the code behavior and automatically design unit test cases
with real data that represents the paths taken through the
Collectively, these test cases establish a safety net that
alerts the team when modifications impact application behavior.
Since all tests are written at the unit level, the test suite
can be run independent of the complete system to isolate code
behavior changes, reduce setup complexities, and make it practical
to execute on a daily basis.
If your team has a large code base with minimal tests or
no tests, the fastest route to regression testing is to automatically
generate a regression test suite that captures the code's
current behavior– and then run it daily to determine if code
modifications break existing functionality. To help you achieve
this, we scan the project code base, then automatically generate
a baseline set of unit test cases that capture the code's
current behavior. Then, we establish a continuous regression
testing process that ensures code modification impacts are
identified and addressed daily, and the test suite stays in
synch with the evolving application. This provides a safety
net that helps developers rapidly change code with confidence,
which is especially critical for teams working on complex
and constantly-evolving applications.
Parasoft provides a variety of technologies to help you extend
the automatically-generated test cases to verify specific
functionality requirements and/or increase coverage. We provide
a number of ways to help you increase the value of the automatically-generated
test suite with minimal effort; for example:
- Manually extending the generated xUnit (JUnit, CppUnit,
NUnit, Cactus, HttpUnit, etc.) test classes.
- Using an object repository and flexible stubs framework
to make tests more realistic.
- Leveraging test data stored in a data source to extend
the coverage of existing tests.
Parasoft solutions can execute your existing xUnit (JUnit,
CppUnit, NUnit, Cactus, HttpUnit, etc.) test cases, allowing
you to centralize your test execution, reporting, and coverage
analysis. Our reporting and authorship calculation capabilities
help the team track which test cases failed, since when, and
who is responsible for fixing each failure. The team can run
all of their tests in command-line mode each night. In the
morning, each developer can import the regression failures
caused by their modifications; this provides instant feedback
on whether their code changes broke the existing functionality.
Since each regression failures are directed to the developer
responsible for them, the overall process of fixing them is
much more streamlined than it would be if all developers had
to review the same long list of test failures.
Parasoft's Tracer technology provides a fast and easy way
to create the realistic test cases required for functional
testing. Simply use the application's UI or Parasoft's SOA/Web
solution to execute the use cases you want to verify. Tracer
automatically designs unit test cases with real data that
represents the paths taken through the application. No coding
or scripting is required. If the functionality associated
with your "traced" use cases later breaks, you will
be alerted by the failure of the related test cases.
The generated unit tests directly correlate tests to source
code, which improves error identification and diagnosis, and
allows developers to run these test cases without having to
depend on access to the production environment or set up a
complex staging environment. This facilitates collaboration
between QA and Development: QA can provide developers traced
test sessions with code-level test results, and these tests
help developers identify, understand, and resolve the problematic