96,145 research outputs found
Test Case Generation Using Visual Contracts
Visual contracts provide a diagrammatic notation for pre- and postconditionsas alternative to the Object-Constraint Language (OCL) or code-levelcontract languages. Using visual contracts for testing, we benefit from their executabilityand formal background in graph transformation to provide model-basedtest oracles and coverage criteria. Based on a static analysis of their dependenciesand conflicts, in this paper we use visual contracts to generate test cases accordingto these coverage criteria.Together with previous work, this adds up to a comprehensive approach aiming toautomate the three major challenges of testing through the use of models
Automated verification of model transformations based on visual contracts
The final publication is available at Springer via http://dx.doi.org/10.1007/s10515-012-0102-yModel-Driven Engineering promotes the use of models to conduct the different phases of the software development. In this way, models are transformed between different languages and notations until code is generated for the final application. Hence, the construction of correct Model-to-Model (M2M) transformations becomes a crucial aspect in this approach.
Even though many languages and tools have been proposed to build and execute M2M transformations, there is scarce support to specify correctness requirements for such transformations in an implementation-independent way, i.e., irrespective of the actual transformation language used.
In this paper we fill this gap by proposing a declarative language for the specification of visual contracts, enabling the verification of transformations defined with any transformation language. The verification is performed by compiling the contracts into QVT to detect disconformities of transformation results with respect to the contracts. As a proof of concept, we also report on a graphical modeling environment for the specification of contracts, and on its use for the verification of transformations in several case studies.This work has been funded by the Austrian Science Fund (FWF) under grant P21374-N13,
the Spanish Ministry of Science under grants TIN2008-02081 and TIN2011-24139, and the
R&D programme of the Madrid Region under project S2009/TIC-1650
Automatic Test Generation for Space
The European Space Agency (ESA) uses an engine to perform tests in the Ground
Segment infrastructure, specially the Operational Simulator. This engine uses
many different tools to ensure the development of regression testing
infrastructure and these tests perform black-box testing to the C++ simulator
implementation. VST (VisionSpace Technologies) is one of the companies that
provides these services to ESA and they need a tool to infer automatically
tests from the existing C++ code, instead of writing manually scripts to
perform tests. With this motivation in mind, this paper explores automatic
testing approaches and tools in order to propose a system that satisfies VST
needs
Spectrum-Based Fault Localization in Model Transformations
Model transformations play a cornerstone role in Model-Driven Engineering (MDE), 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 article 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 stateof-
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 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.ComisiĂłn Interministerial de Ciencia y TecnologĂa TIN2015-70560-RJunta de AndalucĂa P12-TIC-186
A heuristic-based approach to code-smell detection
Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together â data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache
Service Platform for Converged Interactive Broadband Broadcast and Cellular Wireless
A converged broadcast and telecommunication
service platform is presented that is able to create, deliver, and
manage interactive, multimedia content and services for consumption
on three different terminal types. The motivations of
service providers for designing converged interactive multimedia
services, which are crafted for their individual requirements, are
investigated. The overall design of the system is presented with
particular emphasis placed on the operational features of each
of the sub-systems, the flows of media and metadata through the
sub-systems and the formats and protocols required for inter-communication
between them. The key features of tools required for
creating converged interactive multimedia content for a range of
different end-user terminal types are examined. Finally possible
enhancements to this system are discussed. This study is of particular
interest to those organizations currently conducting trials
and commercial launches of DVB-H services because it provides
them with an insight of the various additional functions required
in the service provisioning platforms to provide fully interactive
services to a range of different mobile terminal types
Automated Fixing of Programs with Contracts
This paper describes AutoFix, an automatic debugging technique that can fix
faults in general-purpose software. To provide high-quality fix suggestions and
to enable automation of the whole debugging process, AutoFix relies on the
presence of simple specification elements in the form of contracts (such as
pre- and postconditions). Using contracts enhances the precision of dynamic
analysis techniques for fault detection and localization, and for validating
fixes. The only required user input to the AutoFix supporting tool is then a
faulty program annotated with contracts; the tool produces a collection of
validated fixes for the fault ranked according to an estimate of their
suitability.
In an extensive experimental evaluation, we applied AutoFix to over 200
faults in four code bases of different maturity and quality (of implementation
and of contracts). AutoFix successfully fixed 42% of the faults, producing, in
the majority of cases, corrections of quality comparable to those competent
programmers would write; the used computational resources were modest, with an
average time per fix below 20 minutes on commodity hardware. These figures
compare favorably to the state of the art in automated program fixing, and
demonstrate that the AutoFix approach is successfully applicable to reduce the
debugging burden in real-world scenarios.Comment: Minor changes after proofreadin
The Search for the Laws of Automatic Random Testing
Can one estimate the number of remaining faults in a software system? A
credible estimation technique would be immensely useful to project managers as
well as customers. It would also be of theoretical interest, as a general law
of software engineering. We investigate possible answers in the context of
automated random testing, a method that is increasingly accepted as an
effective way to discover faults. Our experimental results, derived from
best-fit analysis of a variety of mathematical functions, based on a large
number of automated tests of library code equipped with automated oracles in
the form of contracts, suggest a poly-logarithmic law. Although further
confirmation remains necessary on different code bases and testing techniques,
we argue that understanding the laws of testing may bring significant benefits
for estimating the number of detectable faults and comparing different projects
and practices.Comment: 20 page
Contracting the Facebook API
In recent years, there has been an explosive growth in the popularity of
online social networks such as Facebook. In a new twist, third party developers
are now able to create their own web applications which plug into Facebook and
work with Facebook's "social" data, enabling the entire Facebook user base of
more than 400 million active users to use such applications. These client
applications can contain subtle errors that can be hard to debug if they misuse
the Facebook API. In this paper we present an experience report on applying
Microsoft's new code contract system for the .NET framework to the Facebook
API.We wrote contracts for several classes in the Facebook API wrapper which
allows Microsoft .NET developers to implement Facebook applications. We
evaluated the usefulness of these contracts during implementation of a new
Facebook application. Our experience indicates that having code contracts
provides a better and quicker software development experience.Comment: In Proceedings TAV-WEB 2010, arXiv:1009.330
Employing Classifying Terms for Testing Model Transformations
This contribution proposes a new technique for developing test cases for UML and OCL models. The technique is based on an approach that automatically constructs object
models for class models enriched by OCL constraints. By guiding the construction process through so-called classifying terms, the built test cases in form of object models are classified into equivalence classes. A classifying term can be an arbitrary OCL term on the class model that calculates for an object model a characteristic value. From each equivalence class of object models with identical characteristic values one representative is chosen. The constructed test cases behave significantly different with regard to the selected classifying term. By building few diverse object models, properties of the UML and OCL model can be explored effectively. The technique is applied for automatically constructing relevant source model test cases for model transformations between a source and target metamodel.Universidad de MĂĄlaga. Campus de Excelencia Internacional AndalucĂa Tech
- âŠ