Leesa Murray

Teaching programming to beginners - choosing the language is just the first step

Over the years there has been an ongoing debate about which computer language to adopt for a first programming subject. Although some may not agree, the current consensus is that the object-oriented languages are winning the argument, and Java has increasingly become the language of choice for teaching beginners. But choosing the language is only the first step in designing a first programming subject. The adoption of an object-oriented language such as Java offers an opportunity to completely rethink our approach to teaching first-year programming, an opportunity that should not be missed. In this paper we identify what we see as the non language-specific core issues, and discuss how we approached these issues when designing and teaching a programming subject for beginners.

From Object-Z specifications to ClassBench test suites

This paper describes a method for specification‐based class testing that incorporates test case generation, execution, and evaluation based on formal specifications. This work builds on previous achievements in the areas of specification‐based testing and class testing by integrating the two within a single framework. The initial step of the method is to generate test templates for individual operations from a specification written in the Object‐Z specification language. These test templates are combined to produce a finite state machine for the class that is used as the basis for test case execution using the ClassBench test execution framework. An oracle derived from the Object‐Z specification is used to evaluate the outputs. The method is explained using a simple example and its application to a more substantial case study is also discussed. Copyright

Extending test templates with inheritance

We are extending a framework for specification-based testing, the Test Template Framework, to include object-oriented features such as those provided in Object-Z. We report on our work extending the framework to include inheritance. In testing a subclass, the testing information for the parent class is inherited and thus reused. We have identified conditions under which testing information can be inherited without change, when it is inherited with modifications and when it must be derived from scratch. We illustrate the technique with an example based on the Eiffel Queue classes.

Translating Object-Z specifications to object-oriented test oracles

This paper describes the translation of Object-Z specifications of container classes to C++ test oracle classes. It presents a three-stage translation process and describes how the derived test oracles are integrated into the ClassBench testing framework. The method caters for object-oriented features such as inheritance and aggregation. Translation issues and the limitations of the method are discussed. Our approach is illustrated with an example based on an integer set class.

Specification-based class testing: a case study

The paper contains a case study demonstrating a complete process for specification based class testing. The process starts with an abstract specification written in Object-Z and concludes by exercising an implementation with test cases and evaluating the results. The test cases are derived using the Test Template Framework for each individual operation. They are analysed to generate a finite state machine that can execute test sequences within the ClassBench framework. An oracle is also derived from the Object-Z specification. The case study demonstrates how a formal specification contributes to the development of practical tests that can be executed by a testing tool. It also shows how a test oracle can be derived from a specification and used by the same testing tool to evaluate test results.

TinMan-a test derivation and management tool for specification-based class testing

Even with increasing use of formal methods for software development, software testing continues to be a dominant technique for verification and validation. With specification-based testing, the precision of formal specifications can make the testing more systematic. This paper describes a tool to assist the derivation of test cases from Object-Z specifications. The tool supports the Test Template Framework and manages the testing information for the user. Management of the generated testing information is regarded as a high priority and is one of the tools features. The tool is demonstrated on a simple example to indicate its core functionality.

Formal Derivation of Finite State Machines for Class Testing

Previous work on generating state machines for the purpose of class testing has not been formally based. There has also been work on deriving state machines from formal specifications for testing non-object-oriented software. We build on this work by presenting a method for deriving a state machine for testing purposes from a formal specification of the class under test. We also show how the resulting state machine can be used as the basis for a test suite developed and executed using an existing framework for class testing. To derive the state machine, we identify the states and possible interactions of the operations of the class under test. The Test Template Framework is used to formally derive the states from the Object-Z specification of the class under test. The transitions of the finite state machine are calculated from the derived states and the classs operations. The formally derived finite state machine is transformed to a ClassBench testgraph, which is used as input to the ClassBench framework to test a C++ implementation of the class. The method is illustrated using a simple bounded queue example.

Specification-based class testing with ClassBench

In this paper, we present an approach that combines specification-based testing and class testing. In particular, we provide a method for generating Finite State Machines (FSMs) from formal, object-oriented specifications, and use the ClassBench testing framework to build a test suite from those formally generated FSMs. We briefly outline our approach and focus on one step in the approach; the transformation of the formally derived FSM into a ClassBench testgraph, which is used by ClassBench to drive the test execution. We illustrate the method with a simple bounded queue class, and discuss the application of the method to a larger example, which is a simplified model of a process scheduling system.

OptoNet - a case study in using rigorous analysis techniques to justify a revised product assurance strategy

When upgrading software in mission-critical or safety-related industrial control systems, it is imperative to ensure that system integrity properties are preserved. Comprehensive system testing is one way to gain this assurance. This has limitations, however, in that the hardware may be too expensive to assemble a large test rig, or where a product upgrade is to be deployed in diversely configured systems. This paper describes a method that uses rigorous system analysis to justify the replacement of system testing with both static analysis of the system configuration and dynamic testing of the upgraded system components. The paper reports on industrial experience in applying this method to the OptoNet product, which is an embedded software product used in industrial control systems. System analysis techniques are used to develop a detailed understanding of how OptoNet components (RTUs) interact to realise OptoNet system behaviour. Based on this detailed understanding, recommendations for a revised assurance strategy are made. The lessons learnt in the trial application of this method to the OptoNet product are discussed, and possible extensions to the method are proposed.

Module testing embedded software-an industrial pilot project

This paper reports on an industrial pilot project that introduces systematic, automated module testing for embedded software in distributed, real-time, control systems. The systems are used in safety-related applications, are complex in nature, and hence have strong requirements for test coverage, auditability and repeatability. This paper explores issues of isolating modules from the run-time environment, improving integration of testing into the development environment, automating testing, and improving test planning and documentation. Metrics were gathered throughout the project that allow a coarse cost-benefit evaluation. Code coverage metrics for statement and branch coverage were also gathered using a commercial code coverage analysis tool. The testing exposed a number of latent faults within the software, and the overall results of the project show that module testing is feasible for this complex, embedded software.