Product Overview

What is Panorama C/C++?

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:

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

Testing

Quality Assurance

Documentation

General features

Here are the major features of Panorama C/C++:

Product Family and Functionalities

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: family.GIF - 13.21 K

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

  1. System class/function browsing using active J-Charts
  2. Unlimited and dynamic sub-tree generating
  3. Incremental module coding and testing order
  4. Direct source editing
  5. Direct module diagram viewing
  6. Dynamic highlighting of related modules
  7. Graphic information representation (using bar graph overlaid on each module-box) in user-defined scope
  8. Postscript formatted printing
  9. User-friendly interface

Benefits

  1. Gives you the overview of the function and class organization of an entire system.
  2. 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.
  3. 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.
  4. Enables you to easily modify a module without having to memorize what file under what directory contains the module.
  5. Shows you the detailed module diagrams of your system. Diagrammed code facilitates reading and understanding.
  6. 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.
  7. 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;
  8. Helps you to document your system development progress; provides you with a framework for discussing the system with your team members.
  9. 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

  1. J-Diagram, a dynamic procedural logic diagram
  2. J-Flow, a dynamic control flow diagram
  3. ActionPlus Diagram
  4. Automatic high-level and low-level diagram linking
  5. Path analysis (with OO-Test)
  6. Class structure diagramming
  7. On-line marking and direct source editing
  8. Dynamic cross referencing
  9. On-line multiple diagram conversion and printing

Benefits

  1. 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.
  2. Gives you a detailed view of your program control flow to help you identify complex code, perform logic debugging, and plan and review testing.
  3. Offers you an enhanced version of the Action Diagram for code understanding.
  4. 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.
  5. Simplifies test case designing for executing the unexecuted paths.
  6. Provides you with a deep understanding of the class structure for code reusability and maintainability.
  7. 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.
  8. 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.
  9. 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

  1. Multi-level compactness analysis
  2. General class analysis
  3. Analysis of conventional functions
  4. Analysis of special functions
  5. Global and static variable analysis
  6. Label cross referencing
  7. Multi-metrics based complexity analysis
  8. Dynamic performance analysis
  9. Multi-level test coverage analysis (with Panorama/OO-Test)
  10. On-line accessible report layout and printing

Benefits

  1. Enables you to document productivity, program readability and required re-engineering effort for a software system.
  2. Brings you a deeper understanding of classes in your object-oriented software systems.
  3. 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.
  4. Makes special functions as easy to understand as conventional functions. In particular, confusions with overloading functions can be avoided.
  5. Explores the behavior of global and static variables, helps you find potential problems and reduce the re-engineering effort required in data modification.
  6. Gives you an evaluation of the structure of your program, helps you find potential problems identified by unused labels.
  7. Offers you a way to measure and improve program maintainability and testability, helps you perform better test planning.
  8. Pinpoints the performance bottlenecks for you to help you improve the overall performance of your software systems
  9. 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.
  10. 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

  1. Object-Oriented test planning support
  2. Advanced code instrumentation
  3. Object-Oriented multi-level coverage analysis
  4. Frequency analysis
  5. Unexpected program termination locating
  6. Test case and code correspondence analysis
  7. 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
  8. Graphic Representation of data and program logic
  9. User friendly, easy to learn and use

Benefits

  1. 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.
  2. Gives you more testing flexibility.
  3. Provides the most comprehensive coverage analysis capability to meet your different testing needs -- from high quality to low cost.
  4. Helps you to trace program execution and find potential logic problems.
  5. Pinpoints the source locations of fatal run-time errors.
  6. 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.
  7. 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.
  8. 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.
  9. 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

  1. User-defined quality standard setting
  2. Multi-level compactness measurement
  3. Multi-level complexity measurement
  4. Multi-metrics based test coverage measurement (available when working with Panorama/OO-Test)
  5. Object-Oriented software quality measurement
  6. Powerful dynamic graphic representation and printing of the measurement results

Benefits

  1. Assists you in establishing practical and measurable software quality standards for your company or project team.
  2. Helps you to precisely measure productivity and systematically estimate the code readability and the required re-engineering effort for a software system.
  3. Offers you a way to precisely measure and improve the program maintainability and testability, facilitates your test planning.
  4. 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.
  5. 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.
  6. 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.

Supporting The IEEE Standards

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:

ieee.GIF - 3.72 K

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.

table.GIF - 9.66 K

back to Table of Contents