Insure++ Quick Fact Sheet
Insure++ is a powerful runtime error detection tool
that automatically detects a wide range of errors in C/C++ applications.
Using Insure++ you can produce robust, well-optimized, high-quality software, while
slashing development time and reducing maintenance and support costs.
Insure++ includes two add-ons that work together to help improve development.
- Inuse visualizes in real-time the memory manipulation of your program,
helping developers spot bugs and inefficiencies in memory handling.
- TCA performs coverage analysis of programs, providing necessary feedback
to programmers about which parts of the code were actually tested.
Insure++ operates at four distinct levels in the software development and
maintenance life cycle:
- Memory Reference Verification
- Programming Verification
- Coverage Analysis
Insure++ improves software reliability by verifying memory references
and program implementation. Insure++ exposes the bugs during development
rather than the customer's site. Insure++ pinpoints the bugs and provides
the information necessary to repair the bug immediately. In addition, the
add-on modules provide further information that is valuable to the
developer. TCA gives feedback about which parts of the code were tested
and where bugs might still be hiding. Once the software is functioning,
Inuse helps to optimize software performance.
What types of errors does Insure++ find?
Insure++ finds a wide variety of programming and memory access errors
- Memory corruption due to reading or writing beyond the valid areas
of global, local, shared, and dynamically allocated objects.
- Operations on uninitialized, NULL, or "wild" pointers.
- Memory leaks.
- Errors allocating and freeing dynamic memory.
- String manipulation errors.
- Operations on pointers to unrelated data blocks.
- Invalid pointer operations.
- Incompatible variable declarations.
- Mismatched variable types in printf and scanf argument lists.
Insure++ finds memory reference errors. It does not use a "statistical"
approach to trap memory reference errors. Instead, Insure++ checks each memory reference
for validity when that reference is executed, including those to static (global)
and stack, as well as dynamically allocated memory. When Insure++ finds
a problem, it reports the name of related variables, the line of source code containing
the error, a description of the error, and a stack trace.
Just as it does with memory reference errors, Insure++ finds library interface errors.
- Mismatched argument types or function declarations.
- Out of range, or otherwise invalid arguments in library calls.
- Errors returned by library calls.
Insure++ understands standard UNIX system calls, the X Window System,
Motif, and many other popular libraries. On each library call, Insure++
checks that every variable is of the correct type and is within its valid
What add-on modules are available, and what do they do?
Programs linked with Insure++ can connect at runtime to Inuse, a dynamic
memory visualization tool. Inuse is available as an add-on module to Insure++.
Inuse displays valuable statistics regarding the amount of dynamic memory
in use, memory fragmentation, sizes of allocated blocks, and the number
of calls to memory management routines.
TCA is a coverage analysis module. While looking
for bugs in the program, Insure++ keeps track of which parts of the program
are being tested. Once the program finishes, Insure++ saves coverage information
for TCA to use. TCA shows which parts of the code were tested,
how much code was tested, and how many times different code blocks were
What kind of applications can I test with Insure++?
Insure++ has been used on programs with hundreds of thousands of lines
of code. Multi-process applications and programs distributed over hundreds
of workstations have been validated with Insure++. Some of these applications
ran for many weeks in production settings with Insure++ reporting bugs
whenever they arose, with no disruption of normal system operations.
Does Insure++ require modification of the source code?
Insure++ does not require modification of the source code. You use Insure++
by processing your program with Insure++ in place of your normal compiler.
Then you run the resulting program in the normal fashion.
What compilers does Insure++ work with?
Insure++ works with all popular compilers (cc, gcc, acc, etc). Insure++
can check interfaces to modules written in languages other than C, such
as Fortran, Ada, Pascal, etc.
Can Insure++ check third-party libraries and functions?
Insure++ can check third-party libraries and functions thoroughly,
at the interface level. It verifies parameter types and ranges and also
checks return error codes. Insure++ includes built-in interface tests
for hundreds of libraries. You can construct additional interface checks
easily, with the interface definition features of Insure++.
What platforms is Insure++ available on?
Insure++ is available for Windows NT/2000 and a wide variety
of UNIX platforms, including: DEC (Alpha 4.x & TruUnix64 5), HP (HPUX 10.x & 11),
IBM (AIX 4.x), Linux (glibc 2.2.4 or higher), SGI (Irix 6.x & 6.x 64-bit), and Solaris 2.x.
The Windows version of Insure++ supports Visual C++ 6.0.
For a copy of the Insure++ white paper, you can either
call us at (888)305-0041, or email us at
firstname.lastname@example.org, and we'll be happy to send you a copy.