Ana Maria Ambrosio

ConData: a tool for automating specification-based test case generation for communication systems

This paper describes a tool called ConData used as test generation for communication protocols specified as extended finite state machines. The strategy for test generation combines different specification-based test methods: (i) transition testing for the control part of a protocol and (ii) syntax and equivalence partitioning for the data part. The tool uses a representation of the protocol in PSL (Protocol Specification Language), which is transformed into a format readable by a Prolog program. This implements the test strategies mentioned above. The text also presents some results obtained in the test generation for the protocol of the Tele-command Communication System of the SACI-1 satellite.

A Conformance Testing Process for Space Applications Software Services

Comprehensive tests for space applications software are costly but extremely necessary. These software must be reliable and produced within schedule and budget. In a tentative of make the space mission software development for space agencies and industries more costeffective, the European Committee for Space Standardization (ECSS) has been compiling a set of standards that specify the common core of some space application systems. Once the set of services is standardized, the conformance problem is raised. In this paper we present a testing process for standardized services, which is based on the IS-9646 standard for ISO protocol conformance testing. The process includes an approach to derive test and fault cases by combining conformance testing concepts with the software-implemented fault injection (SWIFI) technique. One advantage of this process is the generation of a re-usable

Designing fault injection experiments using state-based model to test a space software

Software for space applications requires significant testing. This paper presents an evaluation of the CoFI testing methodology as applied to actual space software, where deterministic fault cases derived from state-based models were executed using the software-implemented fault injection technique. Different models were used to represent the behavior of embedded software in a real satellite computer under the presence of both normal inputs and external faults in communication, processor, and memory. CoFI methodology was used for model construction, the Condado tool for test derivation, and the QSEE-TAS tool for test execution. In total, 8,620% of 471 fault cases detected errors in the software; this is a very large number, and more so considering that the software had already been tested by the company which developed it before being subject the CoFI methodology.

Brazilian Satellite Simulators: Previous Solutions Trade-off and New Perspectives for the CBERS Program

This paper presents the new architecture of the satellite simulator software for the third China-Brazil Earth Resources Satellite (CBERS-3). This architecture is flexible and scalable to comply with the new challenge imposed of making software reusable to reduce cost. The article discusses previous solutions adopted at INPE since the 90’s. Advantages and disadvantages of past simulator solutions are summarized, from simple satellites, like the Brazilian data collection SCD’s, up to the more complex earth resources observation satellites (CBERSs). The experience of purchasing a COTS (Commercial Off-The-Shelf) product to accelerate the simulator development for scientific satellites is also reported. The new simulator architecture, for CBERS3, is intended to serve as a framework also for the development of the scientific satellite simulators. Furthermore, the simulator development is to comply with INPE’s policy of improving and giving priority to the national space software industry. To achieve this, the architecture includes a common, reusable, real time command monitoring core software, which is based on software engineering concepts of objectoriented modeling and design patterns.

Contributions of model checking and CoFI methodology to the development of space embedded software

The role of embedded software in the last space accidents highlights the importance of verification and validation techniques for the development of space embedded software. In this context, this work analyses the contribution of two verification techniques applied to the onboard data handling software of space products. The first technique is model checking. The system is modeled by a set of timed automata and the verification of safety and liveness properties is performed using UPPAAL model checker. The verified model is then used to generate the embedded software. The second technique analyzed in this work is model based approach for the generation of test cases. The Conformance and Fault Injection (CoFI) testing methodology is used to guide the development of a set of Finite State Machine (FSM) models from the software specification. The test suite is automatically generated from the FSM models. The contributions of the two methodologies are analyzed based on the results provided by an experiment. Two software products are used as case study, each one implementing two services of the Packet Utilization Standard (PUS). These services represent the functionalities offered by a satellite onboard data handling computer. One of the products is developed with the aid of model checking, while the other is developed according to the practices currently used at the Instituto Nacional de Pesquisas Espaciais (INPE). Both software products are tested by the CoFI methodology. The experiment highlights the advantages and vulnerable points of model checking. It also demonstrates that the main contribution of CoFI testing methodology is to highlight problems related to situations that have not been considered in the software specification, such as the occurrence of inopportune events. This analysis helps to understand how different techniques can be integrated in the design of critical embedded software.

Errors on Space Software Requirements: A Field Study and Application Scenarios

This paper presents a field study on real errors found in space software requirements documents. The goal is to understand and characterize the most frequent types of requirement problems in this critical application domain. To classify the software requirement errors analyzed we initially used a well-known existing taxonomy that was later extended in order to allow a more thorough analysis. The results of the study show a high rate of requirement errors (9.5 errors per each 100 requirements), which is surprising if we consider that the focus of the work is critical embedded software. Besides the characterization of the most frequent types of errors, the paper also proposes a set of operators that define how to inject realistic errors in requirement documents. This may be used in several scenarios, including: evaluating and training reviewers, estimating the number of requirement errors in real specifications, defining checklists for quick requirement verification, and defining benchmarks for requirements specifications.

An Independent Software Verification and Validation Process for Space Applications

This paper presents an Independent Software Verification and Validation process that applies reviews for verification and a systematic testing methodology to guide validation. This process was applied to a pilot project named Quality Software Embedded in Space Missions (QSEE) at INPE and pointed very good results. The main feature of the process is that it uses a particular testing methodology named CoFI and an automatic test cases generation tool based in state-models. These features allowed systematizing validation activities which were carried on by a team not involved with the software development. The main activities of the process, the results in terms of the errors found not only through the reviews but also through the tests are presented. Lessons learned including drawbacks and benefits are discussed as well.

Applying Data Mining for Detecting Anomalies in Satellites

Telemetry data is the only source for identifying/predicting anomalies in artificial satellites. Human specialists analyze these data in real time, but its large volume, makes this analysis extremely difficult. In this experience paper we study the hypothesis of using clustering algorithms to help operators and analysts to perform telemetry analysis. Two real cases of satellite anomalies in Brazilian space missions are considered, allowing assessing and comparing the effectiveness of two clustering algorithms (K-means and Expectation Maximization), which showed to be effective in the case study where several telemetry channels tended to deliver outlier values and, in these cases, could support the satellite operators by allowing the anticipation of anomalies. However for silent problems, where there was just a small variation in a single telemetry, the algorithms were not as efficient.

Benchmarking software requirements documentation for space application

Poorly written requirements are a common source of software defects. In application areas like space systems, the cost of malfunctioning software can be very high. This way, assessing the quality of software requirements before coding is of utmost importance. This work proposes a systematic procedure for assessing software requirements for space systems that adopt the European Cooperation for Space Standardization (ECSS) standards. The main goal is to provide a low-cost, easy-to-use benchmarking procedure that can be applied during the software requirements review to guarantee that the requirements specifications comply with the ECSS standards. The benchmark includes two checklists that are composed by a set of questions to be applied to the requirements specification. It was applied to the software requirements specification for one of the services described in the ECSS Packet Utilization Standard (PUS). Results show that the proposed benchmark allows finding more with a low effort.

A Comparative Analysis of two Verification Techniques for DEDS: Model Checking versus Model-based Testing

Abstract This paper presents a comparative analysis of two verification techniques: (1) formal verification of the system specification and (2) execution of FSM-derived test cases on the delivered product. It uses as a testbench a didactic example of a coffee machine and a work team composed of post-graduation students. The purpose is to analyze the advantages and drawbacks of each technique, define the kind of errors detect by each one and highlight the contributions to the development process.