EXAM Test Automation Platform
Rich Client Architecture for HIL Device Configuration and Automotive ECU Testing
1) Context
MicroNova develops software solutions for test automation. In the automotive domain, the EXAM platform was used to develop, configure and execute automated tests for electronic control units (ECUs) and HIL test environments.
The application was based on the Eclipse Rich Client Platform and provided engineers with multiple specialized perspectives for system configuration, test composition, parameter administration and variable mapping.
The core challenge was not only to build editors and views, but to keep a complex graphical engineering environment synchronized with an underlying logical data model and database persistence layer.
2) Business and Engineering Challenge
HIL test systems contain many configurable devices, parameters, dependencies and uniquely identifiable objects. Engineers need to edit these configurations safely and consistently before they are used in real test environments.
- Configuration of HIL devices and test components
- Management of parameters and their dependencies
- Full identification of engineering objects
- Synchronization between graphical editors, tree views, property views and database models
- Reusable infrastructure for future test automation features
3) Centralized RCP Application Controller
I designed and implemented a central application controller responsible for coordinating the main Eclipse RCP and JFace components.
Controlled UI Components
- Tree Views
- Property Views
- Table Views
- Editor Views
- Dependency Views
Architectural Purpose
- Centralized control of user actions
- Reduced coupling between views
- Consistent update behavior
- Reusable JFace integration layer
Instead of implementing direct communication between individual views and editors, all components were coordinated through a central control mechanism. This made the application easier to extend and helped avoid duplicated synchronization logic.
4) Synchronized GUI and Data Model Architecture
A key part of my work was the implementation of a synchronized data model architecture between the graphical user interface and the underlying logical model.
GUI Model
↓
Logical Data Model
↓
Hibernate Model
↓
Database
User changes inside editors were first reflected in the graphical/logical model. Through an Observer/Provider architecture, dependent views were notified and updated automatically. On explicit save operations, the corresponding Hibernate models were updated and persisted to the database.
The architecture ensured that graphical representation, logical configuration data and database state remained consistent without forcing every view to know every other view.
5) Observer / Provider Architecture
I implemented an event-driven Observer/Provider mechanism to distribute changes between editors, views and data models.
- Change notifications from editors to dependent views
- Activity and state handling for JFace components
- Centralized update propagation
- Consistent refresh behavior for tree, property, table and dependency views
6) Dependency View and Engineering Object Relationships
I designed and implemented a Dependency View to visualize relationships between HIL configuration objects, parameters and test components.
This view was not an isolated feature. It was integrated into the central synchronization framework and reacted automatically to changes in the underlying model.
- Visualization of dependencies between test objects
- Support for uniquely identifiable configuration elements
- Integration with tree and property views
- Improved transparency for complex HIL configurations
7) Database Persistence with Hibernate
Hibernate was used as the persistence framework. I connected the application data models to the Hibernate layer so that edited engineering objects could be stored consistently.
The save workflow was deliberately explicit: user modifications were collected and synchronized inside the application model first. Only after a save action were the responsible Hibernate models updated and persisted.
8) Implemented Engineering Features
- Graphical User Interfaces for multiple user perspectives
- Specialized editors with tables and tree structures
- Views with tree structures for detailed display
- Reusable data models for editors and views
- Event handlers for component notification and state changes
- Model-View-Controller based GUI/data model architecture
- Create, copy, edit and delete operations for test components
- Generalization of GUI and data model components
- Graphical Drag & Drop support for test nodes and parameters
- Find & Replace support in editors
- Asynchronous storage of user changes in the database
- Global error handling with warnings and error output
- Export wizard for test sequences using Apache POI / Excel
- Import wizard for XML-based test parameter data
9) Technologies
- Java
- Eclipse Rich Client Platform (RCP)
- SWT / JFace
- Hibernate
- Apache POI
- XML
- Observer / Provider Pattern
- Model-View-Controller
- Central Application Controller
- Rich Client Architecture
10) Architectural Result
- Reusable framework for synchronized Eclipse RCP views and editors
- Clear separation of GUI model, logical model and persistence layer
- Centralized control of tree, property, table, editor and dependency views
- Consistent HIL device configuration with parameter dependencies and object identification
- Improved maintainability through event-driven synchronization
- Scalable foundation for future EXAM test automation features
The project demonstrates the design of a scalable Rich Client Platform architecture: not just GUI implementation, but a synchronized engineering environment with centralized control, reusable data models and database persistence.