155 research outputs found
Model-based regression test selection for validating runtime adaptation of software systems
No full textAn 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
Using models to dynamically refactor runtime code
No full textModern software systems that play critical roles in society's infrastructures are often required to change at runtime so that they can continuously provide essential services in the dynamic environments they operate in. Updating open, distributed software systems at runtime is very challenging. Using runtime models as an interface for updating software at runtime can help developers manage the complexity of updating software while it is executing. To support this idea, we developed the FiGA framework that permits developers to update running software through changes made to UML models of the running software. In this paper, we address the following question: can the UML models be used to express any type of code change a developer desires? Specifically, we report our experience on applying Fowler's code refactoring catalog through model refactoring in the FiGA framework. The goal of this work is to show that the set of FiGA change operators is complete by showing that the refactorings at the source code level can be expressed as model changes in the FiGA approach
A model for the internal evaluation of the quality of care after lung resection in the elderly
No full textSupporting inheritance hierarchy changes in model-based regression test selection
No full textModels can be used to ease and manage the development, evolution, and runtime adaptation of a software system. When models are adapted, the resulting models must be rigorously tested. Apart from adding new test cases, it is also important to perform regression testing to ensure that the evolution or adaptation did not break existing functionality. Since regression testing is performed with limited resources and under time constraints, regression test selection (RTS) techniques are needed to reduce the cost of regression testing. Applying model-level RTS for model-based evolution and adaptation is more convenient than using code-level RTS because the test selection process happens at the same level of abstraction as that of evolution and adaptation.
In earlier work, we proposed a model-based RTS approach called MaRTS to be used with a fine-grained model-based adaptation framework that targets applications implemented in Java. MaRTS uses UML models consisting of class and activity diagrams. It classifies test cases as obsolete, reusable, or retestable based on changes made to UML class and activity diagrams of the system being adapted. However, MaRTS did not take into account the changes made to the inheritance hierarchy in the class diagram and the impact of these changes on the selection of test cases. This paper extends MaRTS to support such changes, and demonstrates that the extended approach performs as well as or better than code-based RTS approaches in safely selecting regression test cases. While MaRTS can generally be used during any model-driven development or model-based evolution activity, we have developed it in the context of runtime adaptation. We evaluated the extended MaRTS on a set of applications, and compared the results with code-based RTS approaches that also support changes to the inheritance hierarchy. The results showed that the extended MaRTS selected all the test cases relevant to the inheritance hierarchy changes, and that the fault detection ability of the selected test cases was never lower than that of the baseline test cases. The extended MaRTS achieved comparable results to a graph-walk code-based RTS approach (DejaVu), and showed a higher reduction in the number of selected test cases when compared with a static analysis code-based RTS approach (ChEOPSJ)
Supporting opportunities for female entrepreneurs in Jordan
No full textFemale entrepreneurship in developing countries is a growing body of research that tries
to address the main challenges faced in such a context. The aim of this paper is to shed some
light on the real opportunities for female entrepreneurs in terms of support for their start-ups.
A lack of studies with this specific focus may detach the pertinent literature from real
business practice and the true conditions faced by women during the start-up process. We
grounded our analysis in Jordan, a country that has received little attention, despite the fact
that it has one of the liveliest entrepreneurial contexts in the Middle East. A sample of 28
institutions operating in Jordan that offer support for entrepreneurial activities were
examined. This is followed by a discussion of the main implications of the initiatives
dedicated to female entrepreneurs
Using models to validate unanticipated, fine-grained adaptations at tuntime
No full textAn increasing number of modern software systems need to be adapted at runtime while they are still executing. It becomes crucial to validate each adaptation before it is deployed to the running system. Models are used to ease software maintenance and can, therefore, be used to manage dynamic software adaptations. For example, models are used to manage coarse-grained anticipated adaptations for self-adaptive systems. However, the need for both fine-grained and unanticipated adaptations is becoming increasingly common, and their validation is also becoming more crucial. This paper proposes an approach to validate unanticipated, fine-grained adaptations performed on models before the adaptations are deployed into the running system. The proposed approach exploits model execution where model representations of the test suites of a software system are executed. The proposed approach is demonstrated and evaluated within the Fine Grained Adaptation (FiGA) framework
A fuzzy Logic Based Approach for Model-based Regression Test Selection
No full textRegression 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)
Internal comparative audit in a thoracic surgery unit using the physiological and operative severity score for the enumeration of mortality and morbidity (POSSUM).
No full textNew Rimocidin/CE-108 Derivatives Obtained by a Crotonyl-CoA Carboxylase/Reductase Gene Disruption in Streptomyces diastaticus var. 108: Substrates for the Polyene Carboxamide Synthase PcsA.
No full textThe rimJ gene, which codes for a crotonyl-CoA carboxylase/reductase, lies within the biosynthetic gene cluster for two polyketides belonging to the polyene macrolide group (CE-108 and rimocidin) produced by Streptomyces diastaticus var. 108. Disruption of rimJ by insertional inactivation gave rise to a recombinant strain overproducing new polyene derivatives besides the parental CE-108 (2a) and rimocidin (4a). The structure elucidation of one of them, CE-108D (3a), confirmed the incorporation of an alternative extender unit for elongation step 13. Other compounds were also overproduced in the fermentation broth of rimJ disruptant. The new compounds are in vivo substrates for the previously described polyene carboxamide synthase PcsA. The rimJ disruptant strain, constitutively expressing the pcsA gene, allowed the overproduction of CE-108E (3b), the corresponding carboxamide derivative of CE-108D (3a), with improved pharmacological properties
Fine-grained software evolution using UML activity and class models
No full textModern software systems that play critical roles in society's infrastructures are often required to change at runtime so that they can continuously provide essential services in the dynamic environments they operate in. Updating open, distributed software systems at runtime is very challenging. Using runtime models as an interface for updating software at runtime can help developers manage the complexity of updating software while it is executing. In this work we describe an approach to updating Java software at runtime through the use of runtime models consisting of UML class and activity diagrams. Changes to models are turned into changes on Java source code, which is then propagated to the runtime system using the JavAdaptor technology. In particular, the presented approach permits in-the-small software changes, i.e., changes at the code statement level, as opposed to in-the-large changes, i.e., changes at the component level. We present a case study that demonstrates the major aspects of the approach and its use
- …
