Visual Execution Analysis

The Visual Execution Analyzer (VEA) is made up of an advanced and powerful suite of tools that allow you to build, debug, record, profile, simulate and otherwise construct and verify your software development while keeping the code tightly integrated with your model. Enterprise Architect has rich support for a wide range of popular compilers and platforms, in particular the Java, .Net and Microsoft Windows C++ environments. Software development becomes a highly streamlined visual experience, quite unlike working in traditional environments.

Enterprise Architect is itself modeled, built, compiled, debugged, tested, managed, profiled and otherwise constructed totally within the Visual Execution Analyzer built into Enterprise Architect. While the VEA can be used to complement other tool suites, it also shines when used as the primary development IDE in close coupling with the model and project management capabilities provided by Enterprise Architect.

Visual Execution Analysis

This collection of images shows the variety of controls at your disposal

Access

Ribbon

Code > Analyzer > Analyzer Scripts

Execute > Analyze > Analyzer Scripts

Context Menu

Right-click on Package | Execution Analyzer

Keyboard Shortcuts

Shift+F12

Execution Analyzer Features

Feature

Description

Build & Debug

Using Analyzer Scripts linked to Model Packages, it is possible to tightly integrate the code/build/debug cycle into Enterprise Architect. For Java, .Net and Microsoft C++ in particular, it is simple to link to project code bases and take over the building and debugging within Enterprise Architect's Model Driven Development Environment. In addition to standard debugging features, the strong coupling with the model and the use of advanced debugging features such as Action Points makes Enterprise Architect the ideal platform from which to both design and construct your software application.

Simulation

Bring your behavioral models to life with instant, real-time behavioral model execution. Coupled with tools to manage triggers, events, guards, effects, breakpoints and simulation variables, plus the ability to visually track execution at run-time, the Simulator is a powerful means of 'watching the wheels turn' and verifying the correctness of your behavioral models.

Profiling

Easily see what an application is doing by taking snapshots of the runtime behavior of a program; whether its Microsoft .NET, native C++ or Java. Save reports, rate and compare performance. Profiles can also be used to build visual Sequence Diagrams highlighting actual behavior in a recorded session as a means of both documenting and verifying your applications low level behavior.

Recording Execution

Record the execution of code without the need for instrumentation. Control the amount of detail through filters and stack depth. Generate beautiful Sequence diagrams and diagrams that illustrate Class collaboration. Use recording to create Test domain diagrams which can be used with the VEATestpoints feature.

Workbench class behavior on the fly, by instantiating them in the Object Workbench and then invoking their operations. You can even pass objects on the workbench as parameters to other workbench objects.

Visual Execution Analyzer Samples

Try our sample patterns to set up and explore some of the powerful features of the Visual Execution Analyzer.

Benefits of the Execution Analyzer

The Execution Analyzer provides an integrated development and testing environment for multiple platforms, including Microsoft .NET, Java, Native code and Android. It includes a feature-rich debugger, execution recording and profiling, and Testpoint management.

It helps you to generate Sequence, Test Domain Class and Collaborative Class diagrams from a single recording. This is a great way to understand and document your application.

Optimize existing system resources and understand resource allocation

Verify that the system is following the rules as designed

Produce high quality documentation that more accurately reflects system behavior

Understand how and why systems work

Train new employees in the structure and function of a system

Provide a comprehensive understanding of how existing code works

Identify costly or unnecessary function calls

Illustrate interactions, data structures and important relationships within a system

Trace problems to a specific line of code, system interaction or event

Visualize why a sequence of events is important

Establish the sequence of events that occur immediately prior to system failure

Simulate the execution of behavior models including StateMachines, Activities and Interactions

Testpoints Management provides a facility to define the constraints on a class model as contracts. The contracts provide the assets on which to create Test domains. A single Testpoint domain can then be used to test and report the behavior of multiple applications. You can also use the Execution Analyzer to record a Use Case and generate a Test Domain diagram with very little effort. Any existing Testpoints are automatically linked to the generated domain or the Test Domain diagram can be used as the context for new contract compositions. How an application behaves for a given Test domain can be seen immediately in real time! Results are displayed in the Testpoint report window every time a contract is passed or failed. The decoupling of test measurement from the code-base has a number of benefits, one of which is aiding the reconciliation of multiple systems with a common Test domain, rather than one another.

The Testpoint system supports these contracts:

Class invariants

Method pre-conditions

Method post-conditions

Line conditions

Create and work with objects created within the Enterprise Architect modeling environment using a dynamic Object Workbench.

Create objects from class model

Invoke methods and view results

Workbench class collaboration

Pass objects as parameters to other objects

Full debugging features including recording

Run nUnit and jUnit tests for Java and Microsoft .NET

Record and document results.

Execution Recording and Profiling both acquire a collection of relevant code files, which you can reverse-engineer to the current model in a single operation.