Regression test selection (RTS) approaches reduce the number of regression tests. Current RTS approaches are typically monoglot, i.e., their implementations target a specific language. However, many subjects under test (SUT) are polyglot, i.e., they use multiple languages. Running multiple monoglot RTS approaches separately on a polyglot SUT is unsafe because tests that involve inter-language dependencies can be missed. Moreover, a new language may require completely reimplementing an RTS approach, especially if the original implementation relies on language and runtime features that are not available in the new language. We propose a new static approach called BabelRTS, which is multilingual (supports multiple languages out of the box), polyglot (analyzes SUTs written in multiple languages), and extensible (allows adding support for new languages). A key contribution is the idea of encapsulating the language-specific aspects of RTS by using patterns and actions. A pattern specifies programming language constructs used in each file that indicate dependencies to other files written in the same or a different language. An action specifies how to identify these files in the codebase. Patterns and actions can be customized to support new languages without modifying the test selection algorithm. BabelRTS is not tied to a specific language run-time system or paradigm. BabelRTS currently supports 12 languages and 5 language combinations. We evaluated BabelRTS on 142 open-source monoglot and polyglot SUTs, analyzing a total of more than two billion LOC. The performance of BabelRTS was similar to the state-of-the-art monoglot approaches on monoglot SUTs. On polyglot SUTs, BabelRTS was safer in polyglot mode and selected more tests for 60% of the commits than in monoglot mode, which missed inter-language dependencies.

Scientists use models to further their understanding of phenomena and inform decision-making. A confluence of factors has contributed to an exponential increase in spatial data volumes. In this study, we describe our methodology to identify spatial variation in the performance of classification models. Our methodology allows tracking a host of performance measures across different thresholds for the larger, encapsulating spatial area under consideration. Our methodology ensures frugal utilization of resources via a novel validation budgeting scheme that preferentially allocates observations for validations. We complement these efforts with a browser-based, GPU-accelerated visualization scheme that also incorporates support for streaming to assimilate validation results as they become available.

Students in entry level CS courses come from diverse backgrounds and are learning study and time management skills. Our belief for their success is that they must master a growth mindset and that the final grade should represent their final mastery of topics in the course. Traditional grading systems tend to be too restrictive and hinder a growth mindset. They require strict deadlines that fail to easily account for student accommodations and learning differences. Furthermore, they run into averaging and scaling issues with 59% of a score counting as failing, making it difficult for students to redeem grades even if they later demonstrate mastery of topics.

Scientists design models to understand phenomena, make predictions, and/or inform decision-making. This study targets models that encapsulate spatially evolving phenomena. Given a model, our objective is to identify the accuracy of the model across all geospatial extents. A scientist may expect these validations to occur at varying spatial resolutions (e.g., states, counties, towns, and census tracts). Assessing a model with all available ground-truth data is infeasible due to the data volumes involved. We propose a framework to assess the performance of models at scale over diverse spatial data collections. Our methodology ensures orchestration of validation workloads while reducing memory strain, alleviating contention, enabling concurrency, and ensuring high throughput. We introduce the notion of a validation budget that represents an upper-bound on the total number of observations that are used to assess the performance of models across spatial extents. The validation budget attempts to capture the distribution characteristics of observations and is informed by multiple sampling strategies. Our design allows us to decouple the validation from the underlying model-fitting libraries to interoperate with models constructed using different libraries and analytical engines; our advanced research prototype currently supports Scikit-learn, PyTorch, and TensorFlow.

Intervention in the form of changing one's teaching style is beneficial for boosting student grades and retention. However, in spite of the availability of multiple intervention approaches, a key hindrance is reliance on the belief that students know how to study.

Computer Science (CS 1) offerings in most universities tend to be notoriously difficult. Over the past 60 years about a third of the students either fail or drop out of the course. Past research has focused on improving teaching methods through small changes without changing the overall course structure.

Abstract Regression test selection (RTS) approaches reduce the cost of regression testing of evolving software systems. Existing RTS approaches based on UML models use behavioral diagrams or a combination of structural and behavioral diagrams. However, in practice, behavioral diagrams are incomplete or not used. In previous work, we proposed a fuzzy logic based RTS approach called FLiRTS that uses UML sequence and activity diagrams. In this work, we introduce FLiRTS 2, which drops the need for behavioral diagrams and relies on system models that only use UML class diagrams, which are the most widely used UML diagrams in practice. FLiRTS 2 addresses the unavailability of behavioral diagrams by classifying test cases using fuzzy logic after analyzing the information commonly provided in class diagrams. We evaluated FLiRTS 2 on UML class diagrams extracted from 3331 revisions of 13 open-source software systems, and compared the results with those of code-based dynamic (Ekstazi) and static (STARTS) RTS approaches. The average test suite reduction using FLiRTS 2 was 82.06%. The average safety violations of FLiRTS 2 with respect to Ekstazi and STARTS were 18.88% and 16.53%, respectively. FLiRTS 2 selected on average about 82% of the test cases that were selected by Ekstazi and STARTS. The average precision violations of FLiRTS 2 with respect to Ekstazi and STARTS were 13.27% and 9.01%, respectively. The average mutation score of the full test suites was 18.90%; the standard deviation of the reduced test suites from the average deviation of the mutation score for each subject was 1.78% for FLiRTS 2, 1.11% for Ekstazi, and 1.43% for STARTS. Our experiment demonstrated that the performance of FLiRTS 2 is close to the state-of-art tools for code-based RTS but requires less information and performs the selection in less time.

Data quality significantly impacts the results of data analytics. Researchers have proposed machine learning based anomaly detection techniques to identify incorrect data. Existing approaches fail to (1) identify the underlying domain constraints violated by the anomalous data, and (2) generate explanations of these violations in a form comprehensible to domain experts. We propose IDEAL, which is an LSTM-Autoencoder based approach that detects anomalies in multivariate time-series data, generates domain constraints, and reports subsequences that violate the constraints as anomalies. We propose an automated autocorrelation-based windowing approach to adjust the network input size, thereby improving the correctness and performance of constraint discovery over manual and brute-force approaches. The anomalies are visualized in a manner comprehensible to domain experts in the form of decision trees extracted from a random forest classifier. Domain experts can then provide feedback to retrain the learning model and improve the accuracy of the process. We evaluate the effectiveness of IDEAL using datasets from Yahoo servers, NASA Shuttle, and Colorado State University Energy Institute. We demonstrate that IDEAL can detect previously known anomalies from these datasets. Using mutation analysis, we show that IDEAL can detect different types of injected faults. We also demonstrate that the accuracy improves after incorporating domain expert feedback.

This special issue contains extended versions of five papers from the 29th IEEE International Symposium on Software Reliability Engineering (ISSRE 2018). ISSRE is focused on innovative techniques and tools for assessing, predicting, and improving the reliability, safety, and security of software products. The symposium emphasizes scientific methods, industrial relevance, rigorous empirical validation, and shared value of practical tools and experiences. ISSRE boasts a large industry participation, with authors and participants from international corporations. Based on the reviews from the programme committee members and discussions with the editors-in-chief regarding the relevance of the papers to the journal's topics of interest, we invited the authors of seven papers to extend their work and submit to this special issue. The extended papers went through several rounds of revision during the rigorous peer-review process. The papers were reviewed by a panel of experts that included, but was not limited to, members of the ISSRE 2018 Program Committee. Five papers successfully completed the review process and are included in this special issue. The first paper, Using Mutants to Help Developers Distinguish and Debug (Compiler) Faults by Josie Holmes and Alex Groce, introduces a distance metric for failing test cases based on the intuition that failing tests that kill the same mutants are likely related to the same fault. This issue is especially relevant for very large test suites, as in the ‘compiler fuzzer taming’ problem. The paper evaluates the metric on two widely used real-world compilers by combining the metric with state-of-the-art methods for fault identification and localization. The second paper, Testing Microservice Architectures for Operational Reliability by Roberto Pietrantuono, Stefano Russo, and Antonio Guerriero, proposes a method for quantitatively assessing the probability of failures (‘operational reliability’) in the context of microservice applications, where the usage profile changes often for reasons such as frequent releases. The method achieves significant improvements in terms of accuracy and efficiency of reliability assessment on three open-source applications. The third paper, Model-based Hypothesis Testing of Uncertain Software Systems by Matteo Camilli, Angelo Gargantini, and Patrizia Scandurra, presents a methodology for combining model-based testing with Bayesian reasoning for testing systems with stochastic QoS properties using a model with uncertain parameters. The paper provides a detailed and reproducible case study for demonstrating the methodology. The fourth paper, Fully Automated HTML and Javascript Rewriting for Constructing a Self-healing Web Proxy by Thomas Durieux, Youssef Hamadi, and Martin Monperrus, applies the failure-oblivious computing principle to web applications. Errors are masked through HTML and Javascript code rewriting (e.g., to skip the faulty line) with an HTTP proxy and a browser extension, respectively. The approach is empirically evaluated on a large, publicly available data set of reproducible Javascript errors. A significant share of errors can be automatically self-healed with this simple strategy. The fifth paper, Facilitating Program Performance Profiling via Evolutionary Symbolic Execution by Andrea Aquino, Pietro Braione, Giovanni Denaro, and Pasquale Salza, pursues performance programme profiling by using symbolic execution and evolutionary algorithms to find worst-case execution paths. The paper shows that the combination of these two techniques significantly improves the effectiveness of the search. We express our thanks to the people who contributed to the success of ISSRE 2018 and to this special issue. We would like to express our gratitude to the authors for extending their papers and submitting their valuable work in the area of software reliability engineering and to the panel of experts for providing detailed and constructive reviews to the authors and assuring the quality of the papers. We are also grateful to the ISSRE steering committee, organizing committee, programme committee, and programme board. In particular, we thank the general chair, Bojan Cukic, whose support continued even after the conference and made this special issue possible. Finally, we would like to thank Robert Hierons and Jeff Offutt for their support, guidance, and enthusiasm for this special issue.

Data quality tests validate heterogeneous data to detect violations of syntactic and semantic constraints. The specification of these constraints can be incomplete because domain experts typically specify them in an ad hoc manner. Existing automated test approaches can generate false alarms and do not explain the constraint violations while reporting faulty data records. In previous work, we proposed ADQuaTe, which is an automated data quality test approach that uses an unsupervised deep learning techni que (1) to discover constraints from big datasets that may have been missed by experts, and (2) to label as suspicious those records that violate the constraints. These records are grouped and explanations for constraint violations are presented to domain experts who determine whether or not the groups are actually faulty. This paper presents ADQuaTe2, which extends ADQuaTe to use an interactive learning technique that incorporates expert feedback to retrain the learning model and improve the accuracy of constraint discovery and fault detection. We evaluate the effectiveness of the approach on real-world datasets from a health data warehouse and a plant diagnosis database. We also use datasets with known faults from the UCI repository to evaluate the improvement in the accuracy of the approach after incorporating ground truth knowledge.

ProQuest powers research in academic, corporate, government, public and school libraries around the world with unique content. Explore millions of resources from scholarly journals, books, newspapers, videos and more.

Regression testing is performed to verify that previously developed functionality of a software system is not broken when changes are made to the system. Since executing all the existing test cases can be expensive, regression test selection (RTS) approaches are used to select a subset of them, thereby improving the efficiency of regression testing. Model-based RTS approaches select test cases on the basis of changes made to the models of a software system. While these approaches are useful in projects that already use model-driven development methodologies, a key obstacle is that the models are generally created at a high level of abstraction. They lack the information needed to build traceability links between the models and the coverage-related execution traces from the code-level test cases. In this paper, we propose a fuzzy logic based approach named FLiRTS, for UML model-based RTS. FLiRTS automatically refines abstract UML models to generate multiple detailed UML models that permit the identification of the traceability links. The process introduces a degree of uncertainty, which is addressed by applying fuzzy logic based on the refinements to allow the classification of the test cases as retestable according to the probabilistic correctness associated with the used refinement. The potential of using FLiRTS is demonstrated on a simple case study. The results are promising and comparable to those obtained from a model-based approach (MaRTS) that requires detailed design models, and a code-based approach (DejaVu).

An increasing number of modern software systems need to be adapted at runtime without stopping their execution. Runtime adaptations can introduce faults in existing functionality, and thus, regression testing must be conducted after an adaptation is performed but before the adaptation is deployed to the running system. Regression testing must be completed subject to time and resource constraints. Thus, test selection techniques are needed to reduce the cost of regression testing. The FiGA framework provides a complete loop from code to models and back that allows fine-grained model-based adaptation and validation of running Java systems without stopping their execution. In this paper we present a model-based test selection approach for regression testing during the validation activity to be used with the FiGA framework. The evaluation results show that our approach was able to reduce the number of selected test cases, and that the model-level fault detection ability of the selected test cases was never lower than that of the original test cases.

Subtle Higher Order Mutants (HOMs) are those HOMs that cannot be killed by existing test suites that kill all First Order Mutants (FOMs) for the program under test. Subtle HOMs simulate complex, real faults, whose behavior cannot be simulated using FOMs. However, due to the coupling effect, subtle HOMs are rare in the exponentially large space of candidate HOMs and they can be costly to find even for small programs.

One goal of higher order mutation testing is to produce higher order mutants (HOMs) that represent subtle faults. We define subtle HOMs as those that are not killed by an existing test set that kills all the first order mutants of a given program. The fault detection effectiveness of the test set can be improved by adding test cases that kill subtle HOMs. However, finding subtle HOMs can be costly even for small programs because of the large space of candidate HOMs. Moreover, a large majority of HOMs are killed by test sets that kill all first order mutants, making the subtle ones relatively rare. We introduce three search-based algorithms (Genetic Algo-rithm, Local Search, and Random Search) for finding subtle HOMs in Java and AspectJ programs. All three algorithms found subtle HOMs for all studied programs but Local Search was more successful in finding subtle HOMs than Genetic Algorithm and Random Search.

This special issue contains extended versions of three papers from the Third IEEE International Conference on Software Testing, Verification and Validation (ICST 2010). These papers were selected on the basis of the reviews from members of the programme committee and subsequently subjected to additional rounds of review and revision. We issued nine invitations to this special issue. Two were not selected after submission, one chose not to revise the paper after being reviewed, three never submitted a major revision, and three papers were eventually accepted. The first paper is ‘Covering and Uncovering Equivalent Mutants’ by Schuler and Zeller. The conference version won the best paper award at ICST 2010. This paper addresses the problem of identifying equivalent mutants. A study is performed on seven real-life programs to assess the percentage of equivalent mutants, which are found to range from 25% to 70%. An approach that uses changes in test coverage to detect nonequivalent mutants is proposed and demonstrated to be superior to state-of-the-art techniques. The approach is implemented as part of the open-source JAVALANCHE framework. The second paper is ‘Efficient Mutation Testing of Multithreaded Code’ by Gligoric, Jagannath, Luo and Marinov. This paper presents a framework for efficiently exploring thread schedules during mutation testing of multithreaded programs. Five techniques are presented and implemented in a tool called MuTMuT. Evaluation studies performed on 12 multithreaded programs show that the techniques can substantially reduce the time required for mutation testing of multithreaded code. The third paper is ‘Formal Specification and Analysis of Functional Properties of Graph Rewriting-based Model Transformation’ by Asztalos, Lengyel and Levendovszky. This paper proposes a language for formally specifying the functional properties of a model transformation. The model transformations are described in a declarative way. Automated algorithms are proposed to analyse the transformations. We express our thanks to the people who contributed to the success of ICST 2010 and this special issue. The steering committee members provided valuable advice, and we were assisted by industry chairs Paul Baker, Wolfgang Grieskamp, Dominique Potier and Andreas Ulrich; workshop chairs Paul Ammann, Benoit Baudry and Ina Schieferdecker; PhD Symposium chairs Atif Memon, Manuel Nunez and Fatiha Zaidi; and the general chair Marie-Claude Gaudel. Thanks go to all the reviewers who provided detailed and timely reviews for the ICST submissions as well as the manuscripts submitted to the special issue. We are also indebted to the ICST 2010 publicity chairs Khaled El-Fakih, Vahid Garousi, Yves Le Traon and Elaine Martins and the Web chair Stephane Maag. We thank the authors for sharing their ideas and results with us. Finally, thanks go to editors-in-chief Jeff Offutt and Robert Hierons for their support and enthusiasm. ANA CAVALLI SUDIPTO GHOSH Co-chairs, Technical Program Committee ICST 2010 10 May 2013

Coincidentally correct test cases are those that execute faulty statements but do not cause failures. Such test cases reduce the effectiveness of spectrum-based fault localization techniques, such as Ochiai, because the correlation of failure with the execution of a faulty statement is lowered. Thus, coincidentally correct test cases need to be predicted and removed from the test suite used for fault localization. Techniques for predicting coincidentally correct test cases can produce false positives, such as when one predicts a fixed percentage that is higher than the actual percentage of coincidentally correct test cases. False positives may cause non-faulty statements to be assigned higher suspiciousness scores than the faulty statements. We propose an approach that iteratively predicts and removes coincidentally correct test cases. In each iteration, we present the tester the set of statements that share the highest Ochiai suspiciousness score. If the tester reports that these statements are not faulty, we use that feedback to determine a number that is guaranteed to be less than or equal to the actual number of coincidentally correct test cases. We predict and remove that number of coincidentally correct test cases, recalculate the suspiciousness scores of the remaining statements, and repeat the process. We evaluated our approach with the Siemens benchmark suite and the Unix utilities, grep and gzip. Our approach outperformed an existing approach that predicts a fixed percentage of test cases as coincidentally correct. The results with Ochiai were mixed. In some cases, our approach outperformed Ochiai by up to 67%. In others, Ochiai was more effective.

Higher order mutation testing is a relatively new area of research. Researchers have claimed that higher order mutants have the potential to increase test effectiveness and reduce test effort. However, these claims have not been evaluated in the context of the aspect-oriented programming paradigm, which introduces new and unique concepts and constructs, and consequently new testing challenges. We present an exploratory study of higher order mutation testing in the context of AspectJ, which is the most widely used aspect-oriented programming language. Based on published fault-models, we propose four approaches to constructing higher order mutants in AspectJ programs. We evaluate the approaches in terms of their ability to create higher order mutants that result in higher test effectiveness and lower test effort compared to first order mutants. The approaches (1) insert two faults in a single base class or two faults in a single aspect, (2) insert two faults in two different base classes, (3) insert two faults in two different aspects, and (4)~insert one fault in a base class and one in an aspect. We developed a prototype tool that automates the process of generating, compiling, and executing higher order mutants. The first approach produced a larger percentage of higher order mutants that were harder to kill than the constituent first order mutants as compared to the last three approaches. The first approach lowered the total number of mutants to be compiled and executed to a greater extent than the last three approaches. The last three approaches produced a lower density of equivalent mutants but the absolute number of equivalent mutants is greater for higher order mutants than for first order mutants.

The primary claimed benefits of aspect-oriented programming (AOP) are that it improves the understandability and maintainability of software applications by modularizing crosscutting concerns. Before there is widespread adoption of AOP, developers need further evidence of the actual benefits as well as costs. Applying AOP techniques to refactor legacy applications is one way to evaluate costs and benefits. We replace crosscutting concerns with aspects in three industrial applications to examine the effects on qualities that affect the maintainability of the applications. We study several revisions of each application, identifying crosscutting concerns in the initial revision and also crosscutting concerns that are added in later revisions. Aspect-oriented refactoring reduced code size and improved both change locality and concern diffusion. Costs include the effort required for application refactoring and aspect creation, as well as a decrease in performance.

Spectrum based fault localization techniques such as Tarantula and Ochiai calculate the suspiciousness score of a program statement using the number of failing and passing test cases that execute the statement. These techniques implicitly assume that all test cases are equally important. However, research on test case generation and selection techniques has shown that using certain test cases can lead to more effective fault localization than others. In this paper, we present an approach to improve the effectiveness of spectrum based fault localization by incorporating the relative importance of different test cases in the calculation of suspiciousness scores.

Abstract Aspect‐oriented programming (AOP) promises better software quality through enhanced modularity. Crosscutting concerns are encapsulated in separate units called aspects and are introduced at specific points in the base program at compile time or runtime. However, aspect‐oriented mechanisms also introduce new risks for reliability that must be tackled by specific testing techniques in order to fully benefit from the use of AOP. This paper focuses on the pointcut descriptor (PCD) that declares the set of points in the base program's execution where the crosscutting concern must be woven. A fault in the PCD can have a ripple effect and result in many different faults. New behavior may be added in unexpected places, or places where new behavior should be added may be missed. When implementing aspect‐oriented programs with AspectJ, JUnit is most commonly used to test the program. However, JUnit does not offer any mechanism to look for faults specifically located in the PCD. As a consequence, these faults can be detected only through complex test scenarios and side effects that are difficult to trigger and observe. This paper proposes to monitor the execution of advices in an aspect‐oriented program and use this information to build test cases that target faults in PCDs. The AdviceTracer tool has been developed to automatically monitor and store all information related to advice executions. It also offers a set of operations that can be used to check the presence or absence of advices at specific points in the execution. These operations improve the definition of an oracle for PCD test cases. An empirical study is performed to compare JUnit and AdviceTracer for testing PCDs in terms of the complexity of test cases and their ability to detect faults. The study is performed on a Healthwatcher system that has 93 classes and 19 PCDs. It reveals that test cases that use AdviceTracer to test PCDs are easier to write (shorter test cases and written in less time than with JUnit) and detect more faults. Copyright © 2011 John Wiley & Sons, Ltd.

There is a need for rigorous analysis techniques that developers can use to uncover security policy violations in their UML designs. There are a few UML analysis tools that can be used for this purpose, but they either rely on theorem-proving mechanisms that require sophisticated mathematical skill to use effectively, or they are based on model-checking techniques that require a ldquoclosed-worldrdquo view of the system (i.e., a system in which there are no inputs from external sources). In this paper we show how alight weight, scenario-based UML design analysis approach we developed can be used to rigorously analyze a UML design to uncover security policy violations. In the method, a UML design class model, in which security policies and operation specifications are expressed in the Object Constraint Language (OCL), is analyzed against a set of scenarios describing behaviors that adhere to and that violate security policies. The method includes a technique for generating scenarios. We illustrate how the method can be applied through an example involving role-based access control policies.

We propose a novel testing approach that combines information from UML sequence models and state machine models. Current approaches that rely solely on sequence models do not consider the effects of the message path under test on the states of the participating objects. Dinh-Trong et al. proposed an approach to test input generation using information from class and sequence models.We extend their variable assignment graph (VAG) based approach to include information from state machine models. The extended VAG (EVAG) produces multiple execution paths representing the effects of the messages on the states of their target objects.We performed mutation analysis on the implementation of a video store system to demonstrate that our test inputs are more effective than those that cover only sequence diagram paths.

Aspect-oriented programming (AOP) languages introduce new constructs that can lead to new types of faults, which must be targeted by testing techniques. In particular, AOP languages such as AspectJ use a pointcut descriptor (PCD) that provides a convenient way to declaratively specify a set of joinpoints in the program where the aspect should be woven. However, a major difficulty when testing that the PCD matches the intended set of joinpoints is the lack of precise specification for this set other than the PCD itself. In this paper, we propose a test-driven approach for the development and validation of the PCD. We developed a tool, AdviceTracer, which enriches the JUnit API with new types of assertions that can be used to specify the expected joinpoints. In order to validate our approach, we also developed a mutation tool that systematically injects faults into PCDs. Using these two tools, we perform experiments to validate that our approach can be applied for specifying expected joinpoints and for detecting faults in the PCD.

We present a novel testing approach that combines information from UML sequence models and state machine models. We use sequence models to extract message paths that play a role in critical usage scenarios of a system. We use state machines to generate multiple execution paths from a message path by analyzing the effect of the messages on state transitions of the system. By covering these execution paths, we generate more effective test cases than the approaches that only cover message paths. The approach also reduces the number of state transitions to be tested by selecting only those that are fired in critical scenarios.

Testing aspect-oriented programs is challenging in part because of the interactions between the aspects and the base classes with which the aspects are woven. Coverage metrics, such as joinpoint coverage, address faults resulting from the changes in base class control flow that may be introduced by the woven advices. Definitions of joinpoint coverage in the literature typically require counting the execution of aspects at each joinpoint. We present a tool for measuring joinpoint coverage from two perspectives: per advice, which measures the execution of the advice at each joinpoint it is woven into, and per class, which measures the execution of all the advices in each joinpoint in the class. This gives a more detailed measurement of joinpoint coverage and helps in identifying what more needs to be tested in both the base class and the aspect. The tool is based on AspectJ and Java bytecode, and thus, does not require any source code. We demonstrate the use of our tool to measure the joinpoint coverage of test inputs generated by Xie and Zhao's Aspectra framework.

In aspect-oriented modeling (AOM), a design is described using a set of design views. It is sometimes necessary to compose the views to obtain an integrated view that can be analyzed by tools. Analysis can uncover conflicts and interactions that give rise to undesirable emergent behavior. Design models tend to have complex structures and thus manual model composition can be arduous and error- prone. Tools that automate significant parts of model composition are needed if AOM is to gain industrial acceptance. One way of providing automated support for composing models written in a particular language is to define model composition behavior in the metamodel defining the language. In this paper we show how this can be done by extending the UML metamodel with behavior describing symmetric, signature-based composition of UML model elements. We also describe an implementation of the metamodel that supports systematic composition of UML class models.

Practical model validation techniques are needed for model driven development (MDD) techniques to succeed. This paper presents an approach to generating inputs to test UML design models that are produced in the detailed design phase of an MDD project. A symbolic execution based approach is used to derive test input constraints from the paths of a variable assignment graph, which integrates information from UML class and sequence diagrams. The constraints are solved using Alloy, a configuration constraint solver, to obtain the test inputs. The results of a pilot study carried out to explore the fault detection capability of the test inputs are reported

Moving program code that implements cross-cutting concerns into aspects can improve the maintainability of legacy systems. This kind of refactoring, called aspectualization, can also introduce faults into a system. A test driven approach can identify these faults during the refactoring process so that they can be removed. We perform systematic testing as we aspectualize commercial VLSI CAD applications. The process of refactoring these applications revealed the kinds of faults that can arise during aspectualization, and helped us to develop techniques to reduce their occurrences

To manage the development of cooperative information systems that support the dynamics and mobility of modern businesses, separation of concern mechanisms and abstractions are needed. Model driven development (MDD) approaches utilize abstraction and transformation to handle complexity. In MDD, specifying transformations between models at various levels of abstraction can be a complex task. Specifying transformations for pervasive system services that are tangled with other system services is particularly difficult because the elements to be transformed are distributed across a model. This paper presents an aspect oriented model driven framework (AOMDF) that facilitates separation of pervasive services and supports their transformation across different levels of abstraction. The framework facilitates composition of pervasive services with enterprise services at various levels of abstraction. The framework is illustrated using an example in which a platform independent model of a banking service is transformed to a platform specific model.

Model driven development (MDD) tackles software complexity through the use of models. However, managing relationships and specifying transformations between models at various levels of abstraction are complex tasks. System models tangled with concerns such as security and middleware make it difficult to develop complex systems and specify model transformations. This paper presents an MDD framework that uses aspect oriented techniques to facilitate separation of concerns. We argue that using the framework will simplify both the model development task and the task of specifying transformations. The conceptual model of the framework is presented and illustrated using distributed transactions at the PIM and PSM levels.

In model driven development (MDD), specifying transformations between models at various levels of abstraction can be a complex task. Specifying transformations for pervasive system features that are tangled with other system features is particularly difficult because the elements to be transformed are distributed across a model. This paper presents an aspect oriented model driven framework (AOMDF) that facilitates separation of pervasive features and supports their transformation across different levels of abstraction. The framework is illustrated using an example in which a platform independent model of a banking application is transformed to a platform specific model.

For model driven development approaches to succeed, there is a need for model validation techniques. This paper presents an approach to testing designs described by UML class diagrams, interaction diagrams, and activity diagrams. A UML design model under test is transformed into an executable form. Test infrastructure is added to the executable form to carry out tests. During testing, object configurations are created, modified and observed. In this paper, we identify the structural and behavioral characteristics that need to be observed during testing. We describe a prototype tool that (1) transforms UML design models into executable forms with test infrastructure, (2) executes tests, and (3) reports failures.

An innovative middleware-transparent approach to developing distributed applications is presented. The approach uses an aspect-oriented software development technique to separate an application's middleware-independent functionality from its middleware-specific functionality. Application elements that are specific to the middleware are localized in aspects that can be seamlessly integrated into middleware-independent application designs. The middleware-transparent approach is used to decouple business functionality from middleware-specific functionality. The decoupling allows developers to change middleware application elements without significantly modifying business functionality. Middleware technologies such as Java Remote Method Invocation (RMI), Jini, Simple Object Access Protocol (SOAP) remote procedure call (RPC) and .Net are used as examples to illustrate the approach. Copyright © 2005 John Wiley & Sons, Ltd.

Middleware technologies such as CORBA provide dependability features in the form of security and fault tolerance services. A major challenge to software development organizations is the complexity of creating and evolving distributed systems resulting from the tangling of middleware-specific functionality with core business functionality in system designs. We present an MDA-compliant middleware transparent software development approach in which application designs are developed independently of the middleware platform. Middleware features corresponding to dependability are encapsulated as aspects and woven with artifacts that realize core functionality. Our approach enables easy replacement of one dependability mechanism by another, and easy migration from one middleware platform to another. The approach also promotes reuse of aspects in multiple applications. This paper illustrates our approach with CORBA security services.

Informally described design patterns are useful for communicating proven solutions for recurring design problems to developers, but they cannot be used as compliance points against which solutions that claim to conform to the patterns are checked. Pattern specification languages that utilize mathematical notation provide the needed formality, but often at the expense of usability. We present a rigorous and practical technique for specifying pattern solutions expressed in the unified modeling language (UML). The specification technique paves the way for the development of tools that support rigorous application of design patterns to UML design models. The technique has been used to create specifications of solutions for several popular design patterns. We illustrate the use of the technique by specifying observer and visitor pattern solutions.

Design patterns describe solutions to recurring design problems in the development of software designs. To encourage the use of design patterns, we are investigating tool support for incorporating patterns into UML models. The development of such tools requires patterns to be specified at the metamodel level. Patterns may be specified using roles, where a role is played by model elements. However, the notion of role in the object-oriented community is strictly based on objects, and does not allow the use of the word "role" in any other place where the context is not object-based. In this paper, we propose a notion of role that can be used to specify design patterns at the metamodel level. We survey the characteristics of object-based roles and generalize them. Based on the generalized notion of a role define a new notion of a model role which is played by a model element. We illustrate the use of model roles with a specification of a variant of the Observer design pattern.

Systematic design testing, in which executable models of behaviors are tested using inputs that exercise scenarios, can help reveal flaws in designs before they are implemented in code. We present a testing method in which executable forms of the Unified Modeling Language (UML) models are tested. The method incorporates the use of test adequacy criteria based on UML model elements in class diagrams and interaction diagrams. Class diagram criteria are used to determine the object configurations on which tests are run while interaction diagram criteria are used to determine the sequences of messages that should be tested. The criteria can be used to define test objectives for UML designs. In this paper, we describe and illustrate the use of the proposed test method and adequacy criteria.

Abstract Systematic design testing, in which executable models of behaviours are tested using inputs that exercise scenarios, can help reveal flaws in designs before they are implemented in code. In this paper a technique for testing executable forms of UML (Unified Modelling Language) models is described and test adequacy criteria based on UML model elements are proposed. The criteria can be used to define test objectives for UML designs. The UML design test criteria are based on the same premise underlying code test criteria: coverage of relevant building blocks of models is highly likely to uncover faults. The test adequacy criteria proposed in this paper are based on building blocks for UML class and interaction diagrams. Class diagram criteria are used to determine the object configurations on which tests are run, while interaction diagram criteria are used to determine the sequences of messages that should be tested. Copyright © 2003 John Wiley & Sons, Ltd.

Distributed Java applications represent a large growth area in software. Validating such applications using information from runtime interactions is a challenge. We propose techniques for visualizing interactions, specifying and verifying assertions, and checking conformance of the implementation with its design. Our work helps in making the debugging and testing activities more systematic.

Cost-effective development of large, integrated computer-based systems can be realized through systematic reuse of development experiences throughout the development process. We describe a technique for representing reusable modeling experiences. The technique allows developers to express domain-specific design patterns as a sub-language of the modeling language, the UML. Use of the sub-language to build application-specific UML models results in the reuse of the embedded design experiences. We use a notation called the (meta)Role-Based Modeling Language (RBML) to define UML sub-languages. A (meta-)Role Model is a specialization of the UML (Unified Modeling Language) meta-model, that is, it determines a sub-language of the UML. We show how RBML can be used to define domain-specific design patterns.

Understanding the behavior of components is an important task in the component-based software development process. Component users build mental models to understand a component when they use it for the first time. The models are also useful during the evolution of the component and the application that incorporates it. The process of component understanding employed by the component user influences the kind of models that can be developed. lit this paper we examine several comprehension models used in practice, and analyze existing component understanding approaches with respect to the comprehension models. We illustrate the development of comprehension models with the example of a spreadsheet component used in an application.

Fault insertion based techniques have been used for measuring test adequacy and testability of programs. Mutation analysis inserts faults into a program with the goal of creating mutation-adequate test sets that distinguish the mutant from the original program. Software testability is measured by calculating the probability that a program will fail on the next test input coming from a predefined input distribution, given that the software includes a fault. Inserted faults must represent plausible errors. It is relatively easy to apply standard transformations to mutate scalar values such as integers, floats, and character data, because their semantics are well understood. Mutating objects that are instances of user defined types is more difficult. There is no obvious way to modify such objects in a manner consistent with realistic faults, without writing custom mutation methods for each object class. We propose a new object mutation approach along with a set of mutation operators and support tools for inserting faults into objects that instantiate items from common Java libraries heavily used in commercial software as well as user defined classes. Preliminary evaluation of our technique shows that it should be effective for evaluating real-world software testing suites.

Mutation analysis inserts faults into a program to create test sets that distinguish the mutant from the original program. Inserted faults must represent plausible errors. Standard transformations can mutate scalar values such as integers, floats, and character data. Mutating objects is an open problem, because object semantics are defined by the programmer and can vary widely. We develop mutation operators and support tools that can mutate Java library items that are heavily used in commercial software. Our mutation engine can support reusable libraries of mutation components to inject faults into objects that instantiate items from these common Java libraries. Our technique should be effective for evaluating real-world software testing suites.

Abstract Applications that utilize a broker‐based architecture are often composed of components that need to be tested individually and in combination. Furthermore, adequacy assessment of tests of components is useful in that it assists testers in identifying weaknesses in the tests generated so far and in offering hints on what the new tests must be. Traditional test adequacy criteria have limitations for commercial use, especially when tests for large components are to be assessed for their adequacy. This paper describes a test adequacy criterion based on interface mutation and a method, based on the criterion, to test components. This method requires the mutation of elements only from within a component's interface and not from within the code that implements the interface. The adequacy criterion based on interface mutation was evaluated empirically and compared with coverage criteria based on control flow for its relative effectiveness in revealing errors and in the cost incurred in developing test sets that satisfy the criterion. Copyright © 2001 John Wiley & Sons, Ltd.