Product Overview
Panorama C/C++ is a full integrated software engineering environment that supports both the development of a new system and the improvement of an existing system. It is particularly useful in software testing, quality assurance, maintenance, and re-engineering.
Problems addressed
Twenty years ago, 15% of the total cost of a typical computing and information management system was spent on software while 85% was spent on hardware. Today, however, the situation is reversed: 85% of the system cost is spent on software. There are many problems with today's software engineering:
- Compared with the progress of hardware development technologies, the progress of software development technologies is much slower. Many software engineering tasks still have to be fulfilled manually.
- Software systems have become larger and more complex.
- Software written in multiple files in textual format (un-diagrammed) is very hard to read and understand.
- There is no a general and practical way to prove whether a program is correct (bug-free), so software developers must try to find errors within a program through extensive testing. This is why about 50% of a software development cost is spent on testing.
- About 50% of the code is still untested in a program "fully tested" using functional test methods alone. Structural testing, however, is very difficult to perform without automatic tools.
- Software systems often needs to be changed to meet new requirements or to add new features. Making changes to a system, however, is risky it may often introduce inconsistencies in other modules of the system.
- Software is hard to maintain because the design documents are often not readily accessible or are out of date with respect to the source code.
Panorama C/C++ is designed to solve these problems with today's software systems. It brings automation to the software development life cycle to make a software system easy to understand, test, modify, and maintain.
Advanced Techniques Applied
Many advanced techniques have been adopted in Panorama C/C++:
Development
Analysis
Diagramming
- Fully Automatic Diagram Generation, Linking, and Conversion Technique
for generating more than fourteen different types of diagrams, linking together different high-level diagrams and low-level diagrams, and for automatically converting one kind of diagram to another.
- Dynamic Graphic Representation and Cross Reference Technique
for making a software system much easier to understand, inspect, test, and maintain, and for code inspection by enabling the diagram display to jump between related code segments.
Testing
- Makefile-Driven Multi-level Code Instrumentation Technique
for efficiently recording block/branch/segment/condition-segment test coverage data.
- Test Case Minimization Technique
for selecting a minimal subset of test cases from users' entire test case suite and ensuring the same test coverage result.
Quality Assurance
- Object-Oriented Software Quality Measurement Technique
for measuring an Object-Oriented software quality using various new metrics, such as the depth of class inheritance, the level of coupling among classes, and the ratio of code reused.
Documentation
General features
Here are the major features of Panorama C/C++:
- Integrated
Panorama C/C++ is integrated from five products and more than twenty tools. Those products and tools communicate with each other directly or indirectly through an internal repository of information.
- Automated
Panorama offers full automation of static and dynamic analyses from input to output (see figure below). To specify a program, the user only needs to input a makefile name. The output charts, diagrams, tables are all automatically generated by Panorama.
- Comprehensive
Panorama supports many phases of the software development process, including physical design, less-bug coding, incremental unit and system testing, Object-Oriented-metrics based quality assurance, less-change-effect maintenance, and re-engineering. It provides comprehensive system, class, function, data, complexity, performance, and test coverage analyses and on-line accessible documents.
- User friendly
Panorama is a visual working environment under the Motif/Openlook interface. It is easy to learn and use: the average learning curve is one day.
- Efficient
Panorama runs efficiently with respect to both space and time. It completes all the static and dynamic analyses in only one pass.
- Methodology-independent
Panorama supports all existing software engineering methodologies.
Panorama C/C++ consists of five products (Panorama/OO-Browser, Panorama/OO-Diagrammer, Panorama/OO-Analyzer, Panorama/OO-SQA, and Panorama/OO-Test.) and more than twenty tools, as shown below:
These products can be used either stand-alone or integrated together. Users can also select some of them to form a sub-system to meet their particular needs. The major functionalities of each product are described in the pages following.
Panorama/OO-Browser
Panorama/OO-Browser is a stand-alone software design and re-engineering tool that has also been integrated into Panorama C/C++ software engineering environment.
Features
- System class/function browsing using active J-Charts
- Function Call Graph
- Class Inheritance Tree
- Class-Function Coupling Graph
- Unlimited and dynamic sub-tree generating
- Select from parents only, children only, or both
- Nest subtrees
- Store path of traversal
- Incremental module coding and testing order
- General bottom-up or top-down ordering
- Selective ordering for critical module paths
- Direct source editing
- Click on module-box to directly edit code
- Select from multiple editors
- Direct module diagram viewing
- Logic diagram
- Control flow diagram
- Dynamic highlighting of related modules
- Parents only, children only, or both
- Directly or indirectly related
- Graphic information representation (using bar graph overlaid on each module-box) in user-defined scope
- complexity and module size
- running time and execution frequency (with OO-Test)
- various test coverage (with OO-Test)
- Postscript formatted printing
- User-friendly interface
- Mouse-driven operations
- Customization
- View Finder for locating area in J-Chart
Benefits
- Gives you the overview of the function and class organization of an entire system.
- Provides you a multi-level understanding of your system from top level to sub-system level, allows you to dynamically navigate through it to understand its detailed structure.
- Reduces costly coding and testing errors. When you code following the bottom-up coding order, critical modules can be coded and tested first. Then when you write a module call, the called module should already have been coded and can be viewed; when you perform unit/system testing, you do not need to design stub modules to replace uncoded/untested modules.
- Enables you to easily modify a module without having to memorize what file under what directory contains the module.
- Shows you the detailed module diagrams of your system. Diagrammed code facilitates reading and understanding.
- Pinpoints the related modules quickly and dynamically to make your system easy to understand, inspect, test, and maintain. When you modify a module, you can easily determine what other modules may be affected.
- Allows you to quickly identify problems such as the runtime bottle-neck, unmaintainable code, and the less tested modules by offering you a visual overview of the related information;
- Helps you to document your system development progress; provides you with a framework for discussing the system with your team members.
- Facilitates your software development tasks. You can activate most functions by a simple mouse click; easily customize the format of J-Chart; and efficiently zoom in on the parts you are interested in using View Finder.
Panorama/OO-Diagrammer
Panorama/OO-Diagrammer is developed using ISA's Dynamic Graphic Representation Technique. It generates three kinds of active diagrams, J-Diagram, J-Flow, and Action Plus Diagrams directly from users' source code.
Features
- J-Diagram, a dynamic procedural logic diagram
- Uses different logic notations
- Shows code execution frequency and test coverage, and highlights unexecuted elements (with OO-Test)
- J-Flow, a dynamic control flow diagram
- Uses different logic notations
- Shows source code location and decision conditions.
- shows code execution frequency and test coverage, and highlights unexecuted elements or paths (with OO-Test)
- ActionPlus Diagram
- Automatic high-level and low-level diagram linking
- program tree to detailed logic diagrams
- program tree to detailed control flow diagrams
- Path analysis (with OO-Test)
- Generates paths through any untested element
- Selects one with most number of untested elements
- Class structure diagramming
- On-line marking and direct source editing
- Mark interested locations for quick jumping
- Edit the source code directly from diagrams
- Dynamic cross referencing
- between a caller and a called module
- between object definition/deletion and class constructor/destructor
- between base class and derived class
- between "goto" and the label
- On-line multiple diagram conversion and printing
- Converts among J-Diagram, J-Flow, and ActionPlus diagram
- Prints diagrams in ASCII or Postscript format.
Benefits
- Assists you in understanding your program logic -- a dynamic picture is worth thousands of words in representing a large system. With Panorama/OO-Test, test coverage results can be shown in the J-Diagram generated. In particular, unexecuted elements can be highlighted to help you find them quickly and design the corresponding test case easily.
- Gives you a detailed view of your program control flow to help you identify complex code, perform logic debugging, and plan and review testing.
- Offers you an enhanced version of the Action Diagram for code understanding.
- Enables you to obtain quickly a full understanding of your program from system-level directly to the module-level. No need to search for the correct logic diagram or match up a high-level diagram with the right low-level diagram by hand.
- Simplifies test case designing for executing the unexecuted paths.
- Provides you with a deep understanding of the class structure for code reusability and maintainability.
- Enables you to comment on the diagrammed code with on-line markers for later referencing, and to efficiently edit the code while viewing the diagram.
- Facilitates code inspection and walk-through. For example, you can click on the active number associated with a function call statement to directly view the called function. It is easy to walk-through a even complex program.
- Helps you to document your source code. Convert easily from one type of diagram to another. Use hard copies of diagrams to document your development progress.
Panorama/OO-Analyzer
Panorama/OO-Analyzer is a stand-alone tool that has also been integrated into Panorama. It provides most comprehensive analysis capability including system/class/function/data/complexity/performance/test coverage (with OO-Test) analysis with more than 100 reports.
Features
- Multi-level compactness analysis
- Project/file level
- Class/function level
- General class analysis
- Base class and derived class
- Data member and function member
- Constructor and destructor
- Class nesting and friend
- Analysis of conventional functions
- Cross reference and fan-in fan-out
- Unused function
- Analysis of special functions
- Static function
- Overloaded and virtual function
- Global and static variable analysis
- global variables defined/used/changed
- static variables defined/used, changed
- Label cross referencing
- Label and "goto" reference
- Unused labe
- Multi-metrics based complexity analysis
- Cyclomatic complexity
- Test complexity
- Dynamic performance analysis
- Function execution frequency
- Function execution time
- Multi-level test coverage analysis (with Panorama/OO-Test)
- Project/File/Class/Function scope
- Block/branch/segment/condition-decision/condition-segment test coverage
- Accumulated and last-run only test coverage
- On-line accessible report layout and printing
- Presented in customized tables and charts
- Printed in a book format using ASCII graphics or Postscript format
Benefits
- Enables you to document productivity, program readability and required re-engineering effort for a software system.
- Brings you a deeper understanding of classes in your object-oriented software systems.
- Helps you to understand the relationships between conventional functions: estimate the degree of function coupling and cohesion, identify other functions that may need modification when one function is modified, and pinpoint potential problems identified by unused functions in the system.
- Makes special functions as easy to understand as conventional functions. In particular, confusions with overloading functions can be avoided.
- Explores the behavior of global and static variables, helps you find potential problems and reduce the re-engineering effort required in data modification.
- Gives you an evaluation of the structure of your program, helps you find potential problems identified by unused labels.
- Offers you a way to measure and improve program maintainability and testability, helps you perform better test planning.
- Pinpoints the performance bottlenecks for you to help you improve the overall performance of your software systems
- Assists you in measuring the reliability of your software systems and the efficiency of your structural testing, gives you great flexibility to meet your software testing needs from low cost to high quality.
- Automates your systems documentation both on- and off-line, frees you from searching for the required information by hand and makes your systems easy to maintain.
Panorama/OO-Test
Panorama/OO-Test is the strongest test coverage analysis and test case minimization tool currently available. It addressees the two "50%" problems: 50% of the software cost is spent in testing; only 50% of the code is tested in a program "fully tested" using functional test methods.
Features
- Object-Oriented test planning support
- Path/control flow analysis
- Class/function cyclomatic complexity analysis
- Class/function test complexity analysis
- Advanced code instrumentation
- User-defined scope
- Multiple test coverage metrics based
- Both accumulated and last-run-only test coverage data recording
- Object-Oriented multi-level coverage analysis
- Class/function test coverage
- Block test coverage
- Branch test coverage
- Segment test coverage
- Condition-decision test coverage
- J-Coverage (for Condition-segment coverage)
- Frequency analysis
- Function execution frequency
- Segment execution frequency
- Unexpected program termination locating
- Test case and code correspondence analysis
- Test case to class/function/code segment
- Class/function/code segment to test case
- Test case minimization by multi-level test coverage contribution, and automatic software re-testing using the playback script files generated based on the results of Test case minimization
- Graphic Representation of data and program logic
- Charts, tables, and bar graph
- J-Flows with execution frequency,
with J-Coverage,
with unexecuted elements highlighted,
with source code cross-reference
- User friendly, easy to learn and use
- Makefile-driven instrumentation
- GUI with active on-line help
- Command line operation
Benefits
- Simplifies your test planning and test case design. Understanding the control flow of a function allows you to create the right test cases for more thorough testing. Complexity analysis helps you to plan the testing process by identifying complicated code that may take more testing effort.
- Gives you more testing flexibility.
- Provides the most comprehensive coverage analysis capability to meet your different testing needs -- from high quality to low cost.
- Helps you to trace program execution and find potential logic problems.
- Pinpoints the source locations of fatal run-time errors.
- Reduces your time in unit re-testing. OO-Test identifies clearly what code can be tested by each test case, and what test cases can be used to test each class/function/segment. So after a module-level modification, you only need to re-run the corresponding test cases.
- Brings you great savings in system-level re-testing. Panorama/OO-Test automatically selects a minimal subset of test cases from your entire test case set and guarantees the same level of test coverage result. It helps you to greatly reduce the time and cost of system-level software re-testing.
- Allows you to view all the relevant test results easily and locate problems quickly. The test coverage data are shown in a variety of easy-to-see formats for quick overview or detailed untested segment locating. Panorama/OO-Test also provides more than 40 different reports to document your systems.
- Makes your testing tasks easier. Panorama/OO-Test allows you to specify a project with only a makefile. You can select either the graphic user interface or the command line.
Panorama/OO-SQA
It is impossible to precisely measure the quality of an object-oriented system using traditional procedure-based quality measurement methods. Panorama/OO-SQA is the most powerful object-oriented quality assurance tool available today, which uses the most comprehensive set of object-oriented metrics.
Features
- User-defined quality standard setting
- metric selection
- acceptable standards setting
- Multi-level compactness measurement
- Project/file compactness
- Function compactness
- Multi-level complexity measurement
- Project/file/function cyclomatic complexity
- Project/file/function test complexity
- Multi-metrics based test coverage measurement (available when working with Panorama/OO-Test)
- Project/File/Function scope
- Block/branch/segment/condition-decision/condition-segment test coverage analysis
- Object-Oriented software quality measurement
- Lines Of Code per class (LOC)
- Number Of Methods per class (NOM)
- Number of Method Users per class (NMU)
- Weighted Methods per Class (WMC) in multiple complexity metrics
- Depth of Inheritance Tree (DIT)
- Number Of Children per class (NOC)
- Coupling Between Objects (CBO)
- Response For a Class (RFC)
- Lines of Code Reused per class (LCR)
- Ratio of Code Reused per class (RCR)
- Test Coverage per Class (TCC) in multiple test coverage metrics
- Powerful dynamic graphic representation and printing of the measurement results
- Weighted bar-chart
- Kiviat diagram
- multiple diagram
- Histogram
- Report
Benefits
- Assists you in establishing practical and measurable software quality standards for your company or project team.
- Helps you to precisely measure productivity and systematically estimate the code readability and the required re-engineering effort for a software system.
- Offers you a way to precisely measure and improve the program maintainability and testability, facilitates your test planning.
- Provides you multiple ways of measuring the reliability of you software systems and the efficiency of your structural testing, gives you great flexibility to meet your software testing needs from low cost to high quality using various test coverage metrics.
- Allows you to precisely measure and review the quality and reliability of your software system developed using object-oriented techniques: helps you to find potential problems in your systems through class response analysis, to increase system maintainability through inheritance analysis and coupling analysis, to promote system testability through weighted methods complexity analysis, to increase your program reliability through multimetrics-based test coverage analysis, and to elevate your program reusability through code reusability analysis.
- Automates your system quality documentation: frees you from manually searching for the quality information needed, makes the quality measurements easy to read and understand, helps you to better manage the quality of your Object-Oriented software systems.
The complexity and the test coverage metrics used in Panorama C/C++ conform to the IEEE standards (refer to IEEE std 982.1-1988).
Cyclomatic Complexity
This measure may be used to determine the structural complexity of a coded module. The use of this measure is designed to limit the complexity of a module, thereby promoting understandability of the module.
Primitives:
N = Number of nodes (sequential groups of program statements).
E = Number of edges (program flows between nodes).
SN = Number of splitting nodes (nodes with more than one edge emanating from it).
RG = Number of regions (areas bounded by edges with no edges crossing).
Using regions, or nodes and edges, a strongly connected graph of the module is required. A strongly connected graph is one in which a node is reachable from any other node. This is accomplished by adding an edge between the exit node ad the entry node. Once the graph is constructed, the measure is computed as follows:
C=E-N+1
The cyclomatic complexity is also equivalent to the number of regions (RG) or the number of splitting nodes plus one (SN+1). If a program contains an N-way predicate, such as a CASE statement with N cases, the N-way predicate contributes N-1 to the count of SN.
Example: Following figure illustrates a strongly connected graph. The nodes are labeled A (the entry node) through J (the exit node). Each node represents a block of code where control flow can only go from one statement to the next. There are 14 edges, 5 numbered regions, and 10 nodes. The complexity can be computed using either of the three methods:

C = complexity = number of regions = 5
The five regions are bounded by paths:
A-B-C-E-G-J-A and J-A
A-B-C-E-F-I-J-A and A-B-C-E-G-J-A
A-B-C-E-F-H-J and A-B-C-E-F-I-J
A-B-C-D-J and A-B-C-E-F-H-J
D-D (this could be a DO statement)
Nodes and Edges: complexity = E-N+1 = 14-10+1 = 5
Splitting nodes: complexity = SN+1 = 4+1 = 5
The four splitting nodes are: C,D,E and F.
Test Coverage
Test coverage is a measure of the completeness of the testing process from both a developer and a user perspective. The measure relates directly to the development, integration and operational test stages of product development, in particular, unit functional, system and acceptance tests. Developers, using the program class of primitives, can apply the measure in unit test to obtain a measure of thoroughness of structure tests. System testers can apply the measure in two ways. First, by focusing on requirements primitives, the system testers can gain a user view of the thoroughness of functional tests. Second, by focusing on the program class of primitives, the system tester can determine the amount of implementation in the operational environment.
Primitives:
The primitives for test coverage are in two classes, program and requirements. For program, there are two types: functional and data. The program functional primitives are either modules, segments, statements, branches(nodes), or paths. Program data primitives are equivalence classes of data. Requirements primitives are either test cases or functional capabilities.
Test coverage (TC) is the percentage of requirements primitives implemented times the percentage of primitives executed during a set of tests. A simple interpretation of test coverage can be expressed by the following formula:
TC(%) = (implemented capabilities) / (required capabilities) * (program primitives tested) / (total program primitives)*100
The following table is an example of Test Coverage Measurements.