Model-Based Testing of GUI-Driven Applications

While thorough testing of reactive systems is essential to ensure device safety, few testing methods center on GUI-driven applications. In this paper we present one approach for the model-based testing of such systems. Using the AHLTA-Mobile case study to demonstrate our approach, we first introduce a high-level method of modeling the expected behavior of GUI-driven applications. We show how to use the NModel tool to generate test cases from this model and present a way to execute these tests within the application, highlighting the challenges of using an API-geared tool in a GUI-based setting. Finally we present the results of our case study

Finite State Testing of Graphical User Interface using Genetic Algorithm

Graphical user interfaces are the key components of any software. Nowadays, the popularity of the software depends upon how easily the user can interact with the system. However, as the system becomes complex, this interaction is also complicated with many states. The testing of graphical user interfaces is an important phase of modern software. The testing of GUI is possible only by interacting with the system, which may be a time-consuming process and is generally automated based on the test suite. The test suite generation proposed in this paper is based on the genetic algorithm in which various test cases are generated heuristically. For performance validation of the proposed approach, the same has been compared with a variant of PSO, and it found that GA is slightly better in comparison to the PSO

A Visual Language for Composable Simulation Scenarios

Modeling and Simulation plays an important role in how the Air Force trains and fights, Scenarios are used in simulation to give users the ability to specify entities and behaviors that should be simulated by a model: however, building and understanding scenarios can be a difficult and time-consuming process, furthermore, as composable simulations become more prominent, the need for a common descriptor for simulation scenarios has become evident. In order to reduce the complexity of creating and understanding simulation scenarios, a visual language was created, The research on visual languages presented in this thesis examines methods of visually specifying the high-level behavior of entities in scenarios and how to represent the hierarchy of the entities in scenarios. Through a study of current behavior specification techniques and the properties of mission-level simulation scenarios, Simulation Behavior Specification Diagrams (SBSD) were developed to represent the behavior of entities in scenarios, Additionally, the information visualization technique of treemaps was adapted to represent the hierarchy of entities in scenarios, After completing case studies on scenarios for the OneSAF simulation model, SBSDs and the application of treemaps to scenarios was considered successful, SBSD diagrams accurately represented the behavior of entities in the simulation scenarios and through software can be converted into code for use by simulation models, The treemap displayed the hierarchy of the entities along with information about the relative size of the entities when applied to simulation scenarios

Modular supervisory controller for complex systems

Automation for the oil and gas industry is driven by the need to improve efficiency, productivity, consistency, and personnel safety, while reducing cost. Fully automated systems alleviate the physical toll on human operators and allow them to focus on monitoring unsafe well events and machinery maintenance. Complex systems like drilling rigs and snubbing units require supervisory controllers that can safely coordinate equipment and processes, overcome interoperability challenges and allow for functional scalability without sacrificing safety, security, and consistency of operations. The primary objective of this report is to explore the feasibility of developing a modular supervisory controller architecture which addresses these concerns by modifying and extending existing architectures. Such modifications include the use of non-homogeneous models in sub-system modules, including discrete event models for control and physics-based models for collision avoidance, addition of a system compilation module (Meta Module) to identify simple design errors, and implementation of an algorithm for synthesis of modules and filters to replace missing sub-systems. This report discusses the implementation results of the modular supervisory control architecture (modMFSM) on a simplified two-machine drilling system for assessment of design practices. Simulations for three test cases were executed to assess the ability of the controller to correctly perform error-free operations, detect and react to possible collisions, and adapt to missing equipment. The report then discusses the possibilities of extending the modMFSM architecture to control large complex systems such as drilling rigs, using snubbing operations as an example.Mechanical Engineerin

Symbolic Model-Checking using ITS-tools

International audienceWe present the symbolic model-checking toolset ITS-tools. The model-checking back-end engine is based on hierarchical set decision diagrams (SDD) and supports reachability, CTL and LTL model-checking, using both classical and original algorithms. As front-end input language, we promote a Guarded Action Language (GAL), a simple yet expressive language for concurrency. Transformations from popular formalisms into GAL are provided enabling fully symbolic model-checking of third party (Uppaal, Spin, Divine...) specifications. The tool design allows to easily build your own transformation, leveraging tools from the meta-modeling community. The ITS-tools additionally come with a user friendly GUI embedded in Eclipse

Neighborhood Detection in Mobile Ad-Hoc Network Using Colored Petri Net

Colored Petri Nets (CPNs) [2] is a language for the modeling and validation of systems in which concurrency, communication [6], and synchronization play a major role. Colored Petri Nets is a discrete-event modeling language combining Petri nets with the functional programming language Standard ML. Petri nets provide the foundation of the graphical notation and the basic primitives for modeling concurrency, communication, and synchronization. Standard ML provides the primitives for the definition of data types, describing data manipulation, and for creating compact and parameterizable models. A CPN model of a system is an executable model representing the states of the system and the events (transitions) that can cause the system to change state [4]. The CPN language makes it possible to organize a model as a set of modules, and it includes a time concept for representing the time taken to execute events in the modeled system. In a mobile ad-hoc network(MANET) mobile nodes directly send messages to each other via wireless transmission. A node can send a message to another node beyond its transmission range by using other nodes as relay points, and thus a node can function as a router [1]. Typical applications of MANETS include defense systems such as battlefield survivability and disaster recovery. The research on MANETs originates from part of the Advanced Research Projects Agency(ARPA) project in the 1970s [1]. With the explosive growth of the Internet and mobile communication networks, challenging requirements have been introduced into MANETs and designing routing protocols has become more complex. One approach for ensuring correctness of an existing routing protocol is to create a formal model for the protocol and analyze the model to determine if indeed the protocol provides the defined service correctly. Colored Petri Nets are a suitable modeling language for this purpose as it can conveniently express non-determinism, concurrency and different levels of abstraction that are inherent in routing protocols. However, it is not easy to build a CPN model of a MANET because a node can move in and out of its transmission range and thus the MANET‟s topology dynamically changes. In this paper we propose an algorithm for addressing such mobility problem of a MANET [1]. Using this algorithm a node can find its neighbors ,which are dynamically changing, at any instant of time