Navegación

Búsqueda

Búsqueda avanzada

Spectrum-based fault localization in software product lines

Artículo relevante publicado en 2018 en el ISTContext: Software Product Line (SPL) testing is challenging mainly due to the potentially huge number ofproducts under test. Most of the research on this field focuses on making testing affordable by selecting arepresentative subset of products to be tested. However, once the tests are executed and some failures revealed,debugging is a cumbersome and time consuming task due to difficulty to localize and isolate the faulty featuresin the SPL.Objective: This paper presents a debugging approach for the localization of bugs in SPLs.Method: The proposed approach works in two steps. First, the features of the SPL are ranked according to theirsuspiciousness (i.e., likelihood of being faulty) using spectrum-based localization techniques. Then, a novel faultisolation approach is used to generate valid products of minimum size containing the most suspicious features,helping to isolate the cause of failures.Results: For the evaluation of our approach, we compared ten suspiciousness techniques on nine SPLs of differentsizes. The results reveal that three of the techniques (Tarantula, Kulcynski2 and Ample2) stand out over the rest,showing a stable performance with different types of faults and product suite sizes. By using these metrics, faultswere localized by examining between 0.1% and 14.4% of the feature sets.Conclusion: Our results show that the proposed approach is effective at locating bugs in SPLs, serving as a helpfulcomplement for the numerous approaches for testing SPLs.

Spectrum-Based Fault Localization in Model Transformations

Model transformations play a cornerstone role in Model-Driven Engineering as they provide the essential mechanisms for manipulating and transforming models. The correctness of software built using MDE techniques greatly relies on the correctness of model transformations. However, it is challenging and error prone to debug them, and the situation gets more critical as the size and complexity of model transformations grow, where manual debugging is no longer possible.Spectrum-Based Fault Localization (SBFL) uses the results of test cases and their corresponding code coverage information to estimate the likelihood of each program component (e.g., statements) of being faulty. In this paper we present an approach to apply SBFL for locating the faulty rules in model transformations. We evaluate the feasibility and accuracy of the approach by comparing the effectiveness of 18 different state-of-the-art SBFL techniques at locating faults in model transformations. Evaluation results revealed that the best techniques, namely Kulcynski2, Mountford, Ochiai and Zoltar, lead the debugger to inspect a maximum of three rules in order to locate the bug in around 74% of the cases. Furthermore, we compare our approach with a static approach for fault localization in model transformations, observing a clear superiority of the proposed SBFL-based method.

Causal-Consistent Replay Debugging for Message Passing Programs

Debugging of concurrent systems is a tedious and error-prone activity. A main issue is that there is no guarantee that a bug that appears in the original computation is replayed inside the debugger. This problem is usually tackled by so-called replay debugging, which allows the user to record a program execution and replay it inside the debugger. In this paper, we present a novel technique for replay debugging, that we call controlled causal-consistent replay. Controlled causal-consistent replay allows the user to record a program execution and, in contrast to traditional replay debuggers, to reproduce a visible misbehavior inside the debugger including all and only its causes. In this way, the user is not distracted by the actions of other, unrelated processes.(*) This paper has been accepted for presentation at the 39th International Conference on Formal Techniques for Distributed Objects, Components, and Systems, FORTE 2019

Ontology and Constraint Reasoning Based Analysis of SPARQL Queries

The discovery and diagnosis of wrong queries in database query languages have gained more attention in recent years. While for imperative languages well-known and mature debugging tools exist, the case of database query languages has traditionally attracted less attention. SPARQL is a database query language proposed for the retrieval of information in Semantic Web resources. RDF and OWL are standardized formats for representing Semantic Web information, and SPARQL acts on RDF/OWL resources allowing to retrieve answers of user’s queries. In spite of the SPARQL apparent simplicity, the number of mistakes a user can make in queries can be high and their detection, localization, and correction can be difficult to carry out. Wrong queries have as consequence most of the times empty answers, but also wrong and missing (expected but not found) answers. In this paper we present two ontology and constraint reasoning based methods for the discovery and diagnosis of wrong queries in SPARQL. The first method is used for detecting wrongly typed and inconsistent queries. The second method is used for detecting mismatching between user intention and queries, reporting incomplete, faulty queries as well as counterexamples. We formally define the above concepts and a batch of examples to illustrate the methods is shown.

An Approach for Debugging Model Transformations Applying Spectrum-Based Fault Localization

Model transformations play a cornerstone role in Model-Driven Engineering as they provide the essential mechanisms for manipulating and transforming models. The use of assertions for checking their correctness has been proposed in several works. However, it is still challenging and error prone to locate the faulty rules, and the situation gets more critical as the size and complexity of model transformations grow, where manual debugging is no longer possible. Spectrum-Based Fault Localization (SBFL) is a technique for software debugging that uses the results of test cases and their corresponding code coverage information to estimate the likelihood of each program component (e.g., statements) of being faulty. This paper describes a proposal for applying SBFL for locating the faulty rules in ATL model transformations. The approach aims at automatically detecting the transformation rule that makes an assertion fail.

Debugging Fuzzy XPath Queries

n this paper we report a preliminary work about XPath debugging. We will describe how we can manipulate an XPath expression in order to obtain a set of alternative XPath expressions that match to a given XML document. For each alternative XPath expression we will give a chance degree that represents the degree in which the expression deviates from the initial expression. Thus, our work is focused on providing the programmer a repertoire of paths that (s)he can use to retrieve answers. The approach has been implemented and tested.