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
• Optimization
• 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 including:

• 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 range.

What add-on modules are available, and what do they do?

• Inuse: 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: 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 executed.
  

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 click here, call us at (888)305-0041, or email us at info@parasoft.com, and we'll be happy to send you a copy.