University of Malta

Past Projects
UOM Main Page
Apply - Admissions 2016
Campus Map button


Improving the effectiveness of Incremental Mutation Testing

With software systems becoming more complex, the need to have good quality code is becoming increasingly important. Confidence in the code can only be gained if one has confidence in the test suite which checks that code. To do so, code coverage is widely used in the industry as a means of measuring how much lines of code are executed in the test suite. However, a high coverage does not guarantee absence of faults. 

Mutation testing is a fault-injection technique, which has been shown to be better than code coverage in measuring the quality of the test suite. If the test suite does not show errors when faults are injected, it may indicate possible shortcomings. Although this is a useful technique, it comes with a heavy computational expense, making it unattractive for software companies. The Agile development process is based upon developing software through numerous iterations. Incremental mutation testing exploits this iterative nature, by mutating only modified methods between iterations.  

While this has been shown to be faster, accuracy is lost because methods directly related to the changed methods, are not included in the mutation process. With the help of static analysis techniques,  these related methods will be included in mutation analysis, while also finding a suitable compromise between speed and accuracy.

The project has been successfully completed by Luke Bajada.  
 Luke Bajada
 Automated Regression Test Selection 

When it comes to software development, modifications in the code occur frequently for reasons such as bug fixes and software requirement changes.  Thus, regression testing is carried out so as to make sure that the program’s changed parts behave as anticipated and that the unmodified parts are not negatively affected by such changes.  This is done by rerunning the tests found in the program’s test suite.  This is an expensive task because running all the tests in the suite may take a very long time especially if the developer runs these tests several times a day.  For this reason, selective retest strategies are used so as to reduce the execution time taken by the tests while still uncovering any bugs which surface due to the modifications.  In this project the plan is to investigate different selective retest strategies through the use of static analysis of object-oriented code, specifically that written in Java.  This would allow one to evaluate each strategy as well as compare and contrast one strategy to another.  Such an evaluation would only be possible if such strategies are applied in the context of a real-life case study.

The project has been successfully completed by Graziella Galea.   

Graziella Galea 
 Investigating the Impact of Different Search Techniques on Object-Oriented Design Optimisation 

Good software design is of empirical importance in the industry as studies have outlined its critical role in producing quality software. When designing software, models are used to obtain a higher level of abstraction before coding since these give an insight into various properties of the program such as its coupling and cohesion. During this stage developers are faced with a non-exhaustive search space preventing them from manually exploring all options. The scope of this study is to determine the efficiency and effectiveness of various search techniques when, using a series of automated refactorings, a search is guided towards coupling and cohesion optimisation. 

The project has been successfully completed by Clyde Vassallo. 

 Clyde Vassallo 

Investigating the use of DSLs in Testing Graphically Intensive Games

Gaming is nowadays very popular, and in order to have a quality product it has to be tested adequately. However, current automation technologies suffer from understandability and maintainability issues. Domain specific languages (DSLs) have been used successfully to express notions in other domains. The aim of this project is to investigate the use of DSLs in testing graphically intensive games. 

Alan Grixti is currently working on the project.

 Alan Grixti
 A DSL for Automated Testing across Multiple Mobile Platforms

 The number of mobile applications has continued to grow over the last few years, many of which are expected to function across multiple mobile platforms (and versions thereof). This considerably increases the testing effort required, especially since users have high expectations and assume apps to be fully functional and bug free. If an app is found to be less reliable than others, users will easily switch to other similar apps and the reputation mechanisms further compound the problem.

Although there are multiple platforms, there is effectively one domain, that is to say mobile applications. Gestures, accelerometers and GPS locators are some examples of the main notions in this domain and remain consistent regardless of the specific platform.

This project is concerned with consolidating concepts in the mobile and testing domains into one domain-specific language, which then can be used to express and automate tests on numerous device platforms. Whilst language design is currently the main aim of this project, a prototype tool which implements a subset of this language is also being developed to evaluate the effectiveness of this technique.

The project has been successfully completed by Daryl Camilleri.
 Daryl Camilleri

Investigating the use of DSLs and Heuristics for Structure Agnostic Web Test Automation

Business-to-Consumer (B2C) e-commerce systems are common place and most companies launch their own online stores with the hope of reaching a wider spectrum of customers. The impact of such systems on a company’s income emphasises the need for ensuring a high level of technical quality. With an industry-wide shift to automated test execution justified by regular and ongoing changes to such systems, most companies invest considerably in setting up and maintaining test automation frameworks. In this work, we argue that whilst all systems will have their own particular implementations, they nevertheless share a common domain with identical notions such as shopping carts, product lists, and so on. We explore the design of Domain Specific Language (DSL) which can express tests over the B2C domain and implement a prototype tool which given a script in the DSL, will be able to execute tests on a B2C system without the need of intimate knowledge about its underlying implementation.

The project has been successfully completed by Neil Thomas Abela.

Niel Baldacchino  

Making Mutation Testing a Feasible Proposition for the Industry

Mutation testing is based on fault injection and is an effective technique for assessing the quality of test suites.  The modern software engineering industry is highly dependent on automated test suites in that they are used to detect regressions as software systems undergo continuous change.  In such situations, trust in the quality of the system can only follow from trust in the quality of the automated tests.  Despite this scenario, the industry seems to favour more primitive measures such as statement coverage analysis for analysing test suites.  Such techniques have been shown to give a false sense of security.  This project is concerned with identifying factors preventing the wider uptake of mutation testing in the industry and finding new ways to address them.  Although this has been attempted in the past, we take a novel approach in that we make leverage various aspects of Agile Development Processes in order to obtain faster results.  We are currently working on the concept of localised mutation as well as addressing the equivalent mutant problem using differential symbolic execution.

Mark Anthony Cachia has successfully completed the project. 
Mark Cachia 

Using Runtime Verification Formal Properties for Testing

While testing is still the prevailing approach to ensure software correctness, the use of runtime verification as a form of post-deployment testing is on the rise. Such continuous testing ensures that if bugs occur, they don't go unnoticed. Apart from being complementary, testing and runtime verification have a lot in common: Runtime verification of programs requires a formal specification of requirements against which the runs of the program can be verified. Similarly, in model-based testing, checks are written such that on each (model-triggered) execution step, the system state is checked for correctness. Due to this similarity, applying both testing and runtime verification techniques is frequently perceived as duplicating work. Attempts have already been made to integrate the runtime verification tool Larva with QuickCheck. We plan to take this forward by integrating the Larva tool with a Java model-based testing tool, ModelJUnit. The aim is to write one set of properties which can be used seamlessly for both testing and runtime verification. 

Renzo Schembri has successfully completed the project.

Renzo Schembri

Combining Model-Based Testing with Selenium

This project is concerned with combining tried-and-tested technologies and technies from two different worlds in order achieve new value in the world of web testing.  Selenium is an open source technology framework which allows developers to automate interaction with browsers.  It is widely used in the industry as the predominant technology for web test automation.  On the other hand, QuickCheck is a model-based test suite generation and execution framework which works in Erlang, a language which has been gaining steadily in popularity.  In this project we are implementing the Selenium API in Erlang, wrapping it in an API and subsequently connect it to QuickCheck such that web applications can be tested automatically through model-based testing.   

Mark Scerri has successfully completed the project.



Ongoing projects page updated
We are proud to present our team of graduates and postgraduates and the list of projects we are currently working on. Click <Ongoing Projects> to find out more...
LarvaLight tool launched
Visit the <LarvaLight tool page> for more information
Interested in collaborating?
Checkout our industry collaboration models <here>
Last Updated: 10 July 2014

Log In back to UoM Homepage