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.
Develop > Preferences > Analyzer > Edit Analyzer Scripts
Execute > Tools > Analyzer
Execution Analyzer Features
Benefits of the Execution Analyzer
The Execution Analyzer provides an integrated development and testing environment for multiple platforms, including Microsoft .NET, Java, Native C++, Mono 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.
- Visualize program execution
- 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
- Establish the sequence of events that occur immediately prior to system failure
- Simulate the execution of behavior models including StateMachines, Activities and Interactions
Simulate UML behavior models to verify their logical and design correctness, for:
Record executing programs and represent the behavior as a UML Sequence diagram; recording is supported for:
Quickly view / report on behaviors of running applications. Profiling is supported for these platforms:
Test Use Cases with Testpoints system
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:
Create and work with objects created within the Enterprise Architect modeling environment using a dynamic Object Workbench.
Run xUnit tests
Run nUnit and jUnit tests for Java and Microsoft .NET
Record and document results.
Import code from analysis
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.
- Build and Debug (for the Enterprise Architect MDDE and Debugger)