Hasan Sözer

A Survey of Software Testing in the Cloud

Cloud computing has emerged as a new computing paradigm that impacts several different research fields, including software testing. Testing cloud applications has its own peculiarities that demand for novel testing methods and tools. On the other hand, cloud computing also facilitates and provides opportunities for the development of more effective and scalable software testing techniques. This paper reports on a systematic survey of published results attained by the synergy of these two research fields. We provide an overview regarding main contributions, trends, gaps, opportunities, challenges and possible research directions. We provide a review of software testing over the cloud literature and categorize the body of work in the field.

Software architecture reliability analysis using failure scenarios

We propose a Software Architecture Reliability Analysis (SARA) approach that benefits from both reliability engineering and scenario-based software architecture analysis to provide an early reliability analysis of the software architecture. SARA makes use of failure scenarios that are prioritized with respect to the user-perception in order to provide a severity analysis for the software architecture and the individual components.

A peer-to-peer file search and download protocol for wireless ad-hoc networks

Deployment of traditional peer-to-peer file sharing systems on a wireless ad-hoc network introduces several challenges. Information and workload distribution as well as routing are major problems for members of a wireless ad-hoc network, which are only aware of their immediate neighborhood. In this paper, we propose a file sharing system that is able to answer location queries, and also discover and maintain the routing information that is used to transfer files from a source peer to another peer. We present a cross-layer design, where the lookup and routing functionality are unified. The system works according to peer-to-peer principles, distributes the location information of the shared files among the members of the network. The paper includes a sample scenario to make the operations of the system clearer. The performance of the system is evaluated using simulation results and analysis is provided for comparing our approach with a flooding-based, unstructured approach.

Software Architecture Reliability Analysis Using Failure Scenarios

We propose a Software Architecture Reliability Analysis (SARA) approach that benefits from both reliability engineering and scenario-based software architecture analysis to provide an early reliability analysis of the software architecture. SARA makes use of failure scenarios that are prioritized with respect to the user-perception in order to provide a severity analysis for the software architecture and the individual components.

Introducing Recovery Style for Modeling and Analyzing System Recovery

An analysis of the current practice for representing architectural views reveals that they focus mainly on functional concerns and are limited when considering quality concerns. We introduce the recovery style for modeling the structure of the system related to the recovery concern. The recovery style is a specialization of the module viewtype in the Views&Beyond approach. It is used to communicate and analyze architectural design decisions and to support detailed design with respect to recovery. We illustrate the style for modeling the recovery views for the open-source software, MPlayer.

Optimizing decomposition of software architecture for local recovery

The increasing size and complexity of software systems has led to an amplified number of potential failures and as such makes it harder to ensure software reliability. Since it is usually hard to prevent all the failures, fault tolerance techniques have become more important. An essential element of fault tolerance is the recovery from failures. Local recovery is an effective approach whereby only the erroneous parts of the system are recovered while the other parts remain available. For achieving local recovery, the architecture needs to be decomposed into separate units that can be recovered in isolation. Usually, there are many different alternative ways to decompose the system into recoverable units. It appears that each of these decomposition alternatives performs differently with respect to availability and performance metrics. We propose a systematic approach dedicated to optimizing the decomposition of software architecture for local recovery. The approach provides systematic guidelines to depict the design space of the possible decomposition alternatives, to reduce the design space with respect to domain and stakeholder constraints and to balance the feasible alternatives with respect to availability and performance. The approach is supported by an integrated set of tools and illustrated for the open-source MPlayer software.

FLORA: a framework for decomposing software architecture to introduce local recovery

The decomposition of software architecture into modular units is usually driven by the required quality concerns. In this paper we focus on the impact of local recovery concern on the decomposition of the software system. For achieving local recovery, the system needs to be decomposed into separate units that can be recovered in isolation. However, it appears that this required decomposition for recovery is usually not aligned with the decomposition based on functional concerns. Moreover, introducing local recovery to a software system, while preserving the existing decomposition, is not trivial and requires substantial development and maintenance effort. To reduce this effort we propose a framework that supports the decomposition and implementation of software architecture for local recovery. The framework provides reusable abstractions for defining recoverable units and the necessary coordination and communication protocols for recovery. We discuss our experiences in the application and evaluation of the framework for introducing local recovery to the open-source media player called MPlayer. Copyright

Combining model-based and risk-based testing for effective test case generation

Model-based testing employs models of the system under test to automatically generate test cases. In this paper, we propose an iterative approach, in which these models are refined based on the principles of risk-based testing. We use Markov Chains as system models, in which transitions among system states are annotated with probabilities. Initially, these probability values are equal and as such, states have equal chances for being visited by the generated test cases. Memory leaks are monitored during the execution of these test cases. Then, transition probabilities are updated based on the risk that a failure can occur due to the observed memory leaks. We applied our approach in the context of an industrial case study for model-based testing of a Smart TV system. We observed promising results, in which several crash failures were detected after an iteration of model refinement. We aim at automating the whole process based on an adaptation model using the history of recorded memory leaks during previous test executions.

Defining architectural viewpoints for quality concerns

A common practice in software architecture design is to apply architectural views to model the design decisions for the various stakeholder concerns. When dealing with quality concerns, however, it is more difficult to address these explicitly in the architectural views. This is because quality concerns do not easily match the architectural elements that seem to be primarily functional in nature. As a result, the communication and analysis of these quality concerns becomes more problematic in practice. We introduce a general and practical approach for supporting architects to model quality concerns by extending the architectural viewpoints of the so-called V&B approach. We illustrate the approach for defining recoverability and adaptability viewpoints for an open source software architecture.

Improving Models for Model-Based Testing Based on Exploratory Testing

Model-based testing facilitates automatic generation of test cases by means of models of the system under test. Correctness and completeness of these models determine the effectiveness of the generated test cases. Critical faults can be missed due to omissions in the models, which are primarily created manually. In practice, these faults are usually detected with exploratory testing performed manually by experienced test engineers. In this paper, we propose an approach for refining system models based on the experience and domain knowledge of these test engineers. Our toolset analyzes the execution traces that are recorded during exploratory testing activities and identifies the omissions in system models. The identified omissions guide the refinement of models to be able to generate more effective test cases. We applied our approach in the context of an industrial case study to improve the models for model-based testing of a Digital TV system. After applying our approach, three critical faults were detected. These faults were not detected by the initial set of test cases and they were also missed during the exploratory testing activities.