TCAT C/C++ Complete Coverage Analyzer and Structure Analysis/Display System for C/C++
BENEFITS	Measure Effectiveness of Tests, Test Suites. Identify untested code and reveal more defects. Improve test efficiency.
KEY FEATURES	Combined branch and call-pair coverage for C/C++. (Separate branch and call-pair instrumenters for Ada, F77). Annotatable calltree displays with access to source. Annotatable digraph displays with access to source.
APPLICATIONS	Branch coverage: unit testing, integration testing. Call-pair coverage: integration testing, system testing, test suite validation. Graphical annotation: all levels of code test completion browsing, analysis.
TestWorks INDEX VALUE	+80 Points if C1 > 85%. +90 Points if S1 > 95%.
Take a tour of TestWorks for UNIX: TestWorking MotifBurger Download an evaluation copy of TCAT C/C++ for Unix

SUMMARY

TCAT works by instrumenting a C/C++ application to permit collecting dynamic coverage information. TCAT C/C++ reports the coverage as a percentage of possible branches exercised (C1) and as a percentage of possible call-pairs exercised (S1). (A call-pair is a caller-to-callee connection). The TCAT C/C++ package includes the instrumenter engine, the runtime unit, and graphics oriented analyzers for call-pair and branch coverage, for detailed analysis of the calling-structure of your C/C++ application and complete directed graph (digraph) analysis of each function present in the C/C++ source code.

In addition, TCAT C/C++ permits browsing through your C/C++ source code from the call-tree, from the digraph, and from the coverage analyzer sections.

Technical Features (BACK TO TOP)

• Full processing for all standard dialects of C/C++.
• Standard floating license manager (flexlm).
• Easy to use point-and-click coverage reporting with full reflection of coverage data to original source texts, plus point-and-click display of call-tree, class-hierarchy, and individual function digraph with immediate back-reference to source code.
• Separable C1 (very high detail, at the segment level) and S1 (lower detail, at the call-pair level) coverage measurement.
• Complete support for all C/C++ constructs, including templates, in-line functions, exception handlers.
• Easy interfaces to handle large, multiple complex projects, without capacity limitations.
• Fully-indexed user documentation available both in hard copy and on-line versions.
• The GUI that permits easy collection of detailed coverage data using your own application as a testbed.
• Improvements in instrumentation efficiency, runtime data-collection efficiency, and source-viewing capability.

Benefits (BACK TO TOP)

• Highly reliable, low overhead calculation of test suite completeness, suitable for use by developers as well as testers.
• Rapid identification of untested logical segments and/or call-pairs help you pinpoint untested functions, segments, classes, objects and units.
• Early detection of latent defects due to untested or poorly tested software.
• Better program understanding from detailed system level (call tree) and object level structure (digraph) displays.

Summary of Graphical Features of TCAT C/C++. (BACK TO TOP)

• Understand visually of what was, wasn't covered
• Coverage completion steps (adding tests to complete the testing)
• Appreciation of complexity of application (make a better choice)
• Demonstration of results for the record
• Comparison of tests

• Instrumentation
  • Full instrumentation of segments (default)
  • Optional instrumentation of call-pairs/MIPs
  • Pass-through of all local compiler options
  • Professional level diagnostics during processing
  • In-line de-instrumentation option (/* TCAT OFF */ /* TCAT ON */)

• CallTree/MIP Display
  • Display Options
    • Zoom-in/Zoom Out with adjustable scaling
    • Direct connect to each object's digraph
    • Hi/Mid/Low color options
    • Print the Display on N x M sheets (default N = M = 1)
  • Tree Statistics
    • Depth of Tree
    • Number of call-pairs/MIPs
    • Number of objects
  • Geometry Selections
    • Size and shape of boxes and links
    • Vertical, horizontal spacing
  • Annotation of Display
    • Color the tree in three threshold colors based on:
      • S0 (object called) coverage values
      • Number of times invoked
      • S1 value for object
      • C1 value for object
      • Cyclomatic complexity (E - N + 2) for object
      • Number of segments in the object
      • Number of call-pairs in the object
      • Number of source lines in the object
      • number of paths in object (per apg values)
      • User-supplied function to partition into three colors
      • Caller/callee connections

• Digraph/Flowchart Display
  • Display Options
    • Zoom-in/Zoom Out with adjustable scaling
    • Hi/Mid/Low color options
    • Print the Display on N x M sheets (default N = M = 1)
  • Geometry Selections
    • Size and shape of nodes and edges
    • Vertical, horizontal spacing
  • Annotation of Display
    • Color the Digraph in three threshold colors based on:
      • Number of times the edge was hit
      • Percent of total hits on this edge relative to total
      • Number of associated source lines
      • User-supplied function to partition into three colors
      • Nth path according to apg calculations

• Coverage Display
  • Display shows C1 & S1 (or S0) for current test and all prior tests
  • View coverage values by file, function
  • Source viewing from any segment or callpair (see source viewing option)

• APG Features

  SR Patented "All Paths Generator" (APG) algorithm is used for computing the total number of paths through an object, modulo the loop count value (we use the 1-trip loop count assumption). The APG output shows for any object you have in the Digraph Display, the total number of paths, distribution of paths by loop complexity, other statistics that characterize the object's overall internal structural complexity.

  The total path count metric for a object has been shown to be highly correlated with likely life-cycle implementation defect count.

Applications of TCAT C/C++ (BACK TO TOP)

• Industrial strength applications which are very large and highly complex and which stress C/C++ applications to their limits.
• Test suite completeness checking (to determine how to expand/extend incomplete suites).
• Unit/object level and system level (integration) testing support.
• Modification analysis and re-testing in maintenance/upgrade modes.