Search

Product Line Engineering (PLE) is a crucial practice in many software development environments where software systems are complex and developed for multiple customers with varying needs. At the same time, many development processes are use case-driven and this strongly influences their requirements engineering and system testing practices. In this paper, we propose, apply, and assess an automated system test case classification and prioritization approach specifically targeting system testing in the context of use case-driven development of product families. Our approach provides: (i) automated support to classify, for a new product in a product family, relevant and valid system test cases associated with previous products, and (ii) automated prioritization of system test cases using multiple risk factors such as fault-proneness of requirements and requirements volatility in a product family. Our evaluation was performed in the context of an industrial product family in the automotive domain. Results provide empirical evidence that we propose a practical and beneficial way to classify and prioritize system test cases for industrial product lines. [ABSTRACT FROM AUTHOR]

Background: Estimation of the mesio-distal width of permanent maxillary canines (PMCs) is a critical part of mixed dentition space analysis. The aim of this pilot study is to find a specific prediction equation for the estimation of the mesio-distal width of PMCs depending on the width of permanent maxillary and mandibular central incisors (PMMCIs) in a Kurdish population. Methods: A hundred study casts were collected. The mesio-distal widths of the PMMCIs and PMCs were measured by digital caliper. Linear regression tests were applied to find the prediction equation using the sum width of PMMCIs as predictors. Results: The mean age of the subjects was 17.2 ± 2.39 years old. Statistically significant differences in the mesio-distal widths of PMMCIs and PMCs were found between males and females (p = 0.0001). Furthermore, statistically significant correlations were identified between the widths of PMMCIs and PMCs in both males (r = 0.633, p = 0.0001) and females (r = 0.717, p = 0.0001). Likewise, the mesio-distal width of PMMCIs was found to be a significant predictor of the width of PMCs in both males (R2 = 0.403, p = 0.0001) and females (R2 = 5.14, p = 0.0001). Conclusion: For the first time, regression equations were developed for a Kurdish population and can be useful as a part of a mixed dentition space analysis in Kurdish children. [ABSTRACT FROM AUTHOR]

Background: Psychiatric disorders are associated with poor pregnancy outcomes both for mother and child. This study aimed to determine the prevalence and related demographic risk factors of psychiatric symptoms among the pregnant women in Babol City. Methods: This cross-sectional study was conducted in five private and public obstetrics clinics of Babol city. During routine appointments of prenatal care, 176 pregnant women filled in three questionnaires including; sociodemographic questionnaire, Edinburg Prenatal Depression Scale (EPDS), and Symptom Checklist-25 (SCL-25). Wilcoxon test, Spearman correlation, and multivariate logistic regression tests were used to interpret the data. Results: The prevalence of depressive disorders was 15.4%% for Edinburg scores ≥13. The overall rate of maternal psychiatric symptoms (global severity index or GSI scores ≥ 1.75) was 48.5%. The prevalence of psychiatric symptoms was high; for 25% somatization, 258% anxiety, obsession-compulsion disorders or OCD 6.4%, 8.8% interpersonal sensitivity, 5.3% phobia, 7.6% paranoid ideation, and 1.2% psychoticism. Multivariate logistic regression revealed that pregnant women with history of abortion in previous pregnancy were at risk of depressive symptoms more (β=3.18, CI 1.28-7.93, p=0.01) than those without history of abortion. Also, the only demographic factor related to psychiatric symptoms was the age of pregnant women; younger age was associated with higher symptom levels for GSI ((r=-0.17). Conclusion: The high prevalence of psychiatric symptoms, especially depressive symptoms, in pregnant women highlights the need for continued research on screening, identifying the risk factors, and developing effective treatments for mental disorders in pregnant women. [ABSTRACT FROM AUTHOR]

Copyright of Turkish Journal of Obstetrics & Gynecology is the property of Galenos Yayinevi Tic. LTD. STI and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Regression testing is the activity performed by developers to check whether new modifications have not introduced bugs. A crucial requirement to make regression testing effective is that test cases are deterministic. Unfortunately, this is not always the case as some tests might suffer from so-called flakiness, i.e., tests that exhibit both a passing and a failing outcome with the same code. Flaky tests are widely recognized as a serious issue, since they hide real bugs and increase software inspection costs. While previous research has focused on understanding the root causes of test flakiness and devising techniques that automatically fix them, in this paper we explore an orthogonal perspective: the relation between flaky tests and test smells, i.e., suboptimal development choices applied when developing tests. Relying on (1) an analysis of the state-of-the-art and (2) interviews with industrial developers, we first identify five flakiness-inducing test smell types, namely Resource Optimism, Indirect Testing, Test Run War, Fire and Forget, and Conditional Test Logic, and automate their detection. Then, we perform a large-scale empirical study on 19,532 JUnit test methods of 18 software systems, discovering that the five considered test smells causally co-occur with flaky tests in 75% of the cases. Furthermore, we evaluate the effect of refactoring, showing that it is not only able to remove design flaws, but also fixes all 75% flaky tests causally co-occurring with test smells. [ABSTRACT FROM AUTHOR]

Regression testing is a means to assure that a change in the software, or its execution environment, does not introduce new defects. It involves the expensive undertaking of rerunning test cases. Several techniques have been proposed to reduce the number of test cases to execute in regression testing, however, there is no research on how to assess industrial relevance and applicability of such techniques. We conducted a systematic literature review with the following two goals: firstly, to enable researchers to design and present regression testing research with a focus on industrial relevance and applicability and secondly, to facilitate the industrial adoption of such research by addressing the attributes of concern from the practitioners' perspective. Using a reference-based search approach, we identified 1068 papers on regression testing. We then reduced the scope to only include papers with explicit discussions about relevance and applicability (i.e. mainly studies involving industrial stakeholders). Uniquely in this literature review, practitioners were consulted at several steps to increase the likelihood of achieving our aim of identifying factors important for relevance and applicability. We have summarised the results of these consultations and an analysis of the literature in three taxonomies, which capture aspects of industrial-relevance regarding the regression testing techniques. Based on these taxonomies, we mapped 38 papers reporting the evaluation of 26 regression testing techniques in industrial settings. [ABSTRACT FROM AUTHOR]

The rapid advancement of mobile computing technology and the rising usage of mobile apps made our daily life more productive. The mobile app should operate all the time bug-free in order to improve user satisfaction and offers great business value to the end user. At the same time, smartphones are full of special features that make testing of apps more challenging. Actually, the quality is a must for successful applications and it cannot be achieved without testing and verification. In this paper, we present the behavior driven development methodology and Cucumber framework to automate regression testing for Android apps. Particularly, the proposed methods use the visual programming language for smartphones (Catrobat) as a reference. The Catrobat program scripts communicate via a broadcast mechanism. The objective is to test the broadcast mechanism from different angles and track regression errors as well as specify and diagnose bugs with the help of executable specifications. The results show that the methods are able to effectively reveal deficiencies in the broadcast mechanism, and ensure that the app meets end users' expectations and needs. [ABSTRACT FROM AUTHOR]

Summary: Although the importance of models continuously grows in software development, common development approaches are less able to integrate the automatic management of model integrity into the development process. These critically important constraints may ensure the coherence of models in the evolution process to prevent manipulations that could violate defined constraints on a model. This paper proposes an integrity framework in the context of model‐driven architecture to achieve sufficient structural code coverage at a higher program representation level than machine code. Our framework offers to propagate the modifications from a platform‐independent specification to the corresponding test template model while keeping the consistency and integrity constraints after system evolution. To examine the efficiency of the proposed framework, a quantitative analysis plan is evaluated based on two experimental case studies. In addition, we propose coverage criteria for integrity regression testing (IRT), derived from logic coverage criteria that apply different conceptual levels of testing for the formulation of integrity requirements. The defined criteria for IRT reduce the inherent complexity and cost of verifying complex design changes in regression testing while keeping the fault detection capability with respect to the changes. The framework aims to keep pace with IRT in a formal way. The framework can solve a number of restricted outlooks in model integrity and some limiting factors of incremental maintenance and retesting. The framework satisfies several valuable quality attributes in software testing, such as safety percentage, precision, abstract fault detection performance measurable coverage level, and generality. [ABSTRACT FROM AUTHOR]

Summary: Continuous integration, at its core, includes a set of practices that aim to prevent and reduce the cost of software integration issues by merging working software copies often. Regression testing is considered a good practice in software development with continuous integration, which ensures that code changes are not negatively affecting software functionality. As, nowadays, software development is carried out iteratively, with small code increments continuously developed and regression tested, it is of critical importance that continuous regression testing is time efficient. However, in practice, regression testing is often long lasting and faces scalability problems as software grows larger or as software changes are made more frequently. One contributing factor to these issues is test redundancy, which causes the same software functionality being tested multiple times across a test suite. In large‐scale software, especially highly configurable software, redundancy in continuous regression testing can significantly grow the size of test suites and negatively affect the cost effectiveness of continuous integration. This paper presents a practical learning algorithm for optimizing continuous integration testing by reducing ineffective test redundancy in regression suites. The novelty of the algorithm lies in learning and predicting the fault‐detection effectiveness of continuous integration tests using historical test records and combining this information with coverage‐based redundancy metrics. The goal is to identify ineffective redundancy, which is maximally reduced in the resulting regression test suite, thus reducing test time and improving the performance of continuous integration. We apply and evaluate the algorithm in two industrial projects of continuous integration. The results show that the proposed algorithm can improve the efficiency of continuous integration practice in terms of decreasing test execution time by 38% on average compared to the industry practice of our case study and by 40% on average compared to the retest‐all approach. The results further demonstrate no significant reduction in fault‐detection effectiveness of continuous regression testing. This suggests that the proposed algorithm contributes to the state of the practice in the continuous integration development and testing of highly configurable systems. [ABSTRACT FROM AUTHOR]

Considering that some intelligent software in mobile devices is related to location of sensors and devices, regression testing for it faces a major challenge. Test case prioritization (TCP), as a kind of regression test optimization technique, is beneficial to improve test efficiency. However, traditional TCP techniques may have limitations on testing intelligent software embedded in mobile devices because they do not take into account characteristics of mobile devices. This paper uses a smart mall as a scenario to design a novel location-based TCP technique for software embedded in mobile devices using the law of gravitation. First, test gravitation is proposed by applying the idea of universal gravitation. Second, a specific calculation model of test gravitation is designed for a smart mall scenario. Third, how to create a faulted test case set is designed by the pseudocode. Fourth, a location-based TCP using the law of gravitation algorithm is proposed, which utilizes test case information, fault information, and location information to prioritize test cases. Finally, an empirical evaluation is presented by using one industrial project. The observation, underlying the experimental results, is that our proposed TCP approach performs better than traditional TCP techniques. In addition, besides location information, the level of devices is also an important factor which affects the prioritization efficiency. [ABSTRACT FROM AUTHOR]

Software regression testing is one of the most critical phases of software development life cycle, used by developers with the intent of detecting new faults to validate modified software prior to delivery to the customer. To validate updated features, new test cases are generated by the testers which increment the test suite size automatically. The resulting test suite may contain obsolete, redundant, and ambiguous test cases. Therefore, there is a strong requirement of an intelligent testing approach to reduce the test suite size by removing those unessential test cases economically. This paper proposed an interesting approach, which involves the combination of regression testing techniques: minimization, and prioritization both. The main focus is on multiple regression activities with multiple criteria rather than using only single activity to produce an optimal solution. In this paper clustering approach is also considered, which could simplify and enhance the minimization and prioritization task. To evaluate the effectiveness of the strategy, we performed an experimental investigation together with an eminent heuristic Harrold Gupta and Soffa (HGS), considering the testing measures of the minimized test suite size and fault coverage. The results show that, similarity-based greedy approach with multiple coverage criteria can be quite effective in terms of fault detection loss of reduced test suite without much affecting the percentage of suite size reduction. [ABSTRACT FROM AUTHOR]

In order to improve the interpretation of principal components, many sparse principal component analysis (PCA) methods have been proposed by in the form of self-contained regression-type. In this paper, we generalize the steps needed to move from PCA-like methods to its self-contained regression-type, and propose a joint sparse pixel weighted PCA method. More specifically, we generalize a self-contained regression-type framework of graph embedding. Unlike the regression-type of graph embedding relying on the regular low-dimensional data, the self-contained regression-type framework does not rely on the regular low-dimensional data of graph embedding. The learned low-dimensional data in the form of self-contained regression theoretically approximates to the regular low-dimensional data. Under this self-contained regression-type, sparse regularization term can be arbitrarily added, and hence, the learned sparse regression coefficients can interpret the low-dimensional data. By using the joint sparse $\ell _{2,1}$ -norm regularizer, a sparse self-contained regression-type of pixel weighted PCA can be produced. Experiments on six data sets demonstrate that the proposed method is both feasible and effective. [ABSTRACT FROM AUTHOR]

To address the Multi-Objective Test Case Prioritization (MOTCP) problem, an Epistatic Particle Swarm Optimization (EPSO) algorithm is presented. The epistasis in biology is introduced into the new algorithm, and the particles are updated based on the crossover of Epistatic Test Case Segment (ETS) in the test case sequence. The average coverage percentage of program entity and effective execution time of the test case sequence are set as two objective fitness functions in EPSO. The experiment selects four typical open12 source projects as benchmark programs. We adopted Average Percentage of Branch Coverage (APBC) and Effective Execution Time (EET) as objective fitness. The four classical Java testing projects results show that the EPSO is more effective and more diverse than single-point PSO and order PSO. The EPSO algorithm efficiently solves the MOTCP problem by promoting early detection of software defects and reducing software testing costs in regression testing. [ABSTRACT FROM AUTHOR]

Much work has been done on automating regression testing for applications. But most of them focus on test execution. Little work has been done on automatically determining if a test case passes or fails. This decision is often made by comparing the results of executing test cases on a base version of the application and post-modification version of the application. If the two results match, the test case passes, otherwise fails. However, to the best of our knowledge, there is no regression testing method for automatically deciding pass/fail of dynamic Web applications which use JavaScript or CSS. We propose a method that automatically decides if a dynamic Web application passes a regression test case. The basic idea is to obtain a screenshot each time the GUI of the Web application (i.e. Web page) changes its state, and then compare each corresponding screenshot to see if they match. The evaluation results showed that the accuracy rate of our approach is high and our approach can be considered as fast enough for practical use. [ABSTRACT FROM AUTHOR]

Regression test case selection techniques attempt to increase the testing effectiveness based on the measurement capabilities, such as cost, coverage, and fault detection. This systematic literature review presents state-of-the-art research in effective regression test case selection techniques. We examined 47 empirical studies published between 2007 and 2015. The selected studies are categorized according to the selection procedure, empirical study design, and adequacy criteria with respect to their effectiveness measurement capability and methods used to measure the validity of these results. The results showed that mining and learning-based regression test case selection was reported in 39% of the studies, unit level testing was reported in 18% of the studies, and object-oriented environment (Java) was used in 26% of the studies. Structural faults, the most common target, was used in 55% of the studies. Overall, only 39% of the studies conducted followed experimental guidelines and are reproducible. There are 7 different cost measures, 13 different coverage types, and 5 fault-detection metrics reported in these studies. It is also observed that 70% of the studies being analyzed used cost as the effectiveness measure compared to 31% that used fault-detection capability and 16% that used coverage. [ABSTRACT FROM AUTHOR]

There is an urgent need to create awareness about the potential benefits of using agents in software test case generation and to identify the need to develop agent-based regression testing techniques and approaches. It may help in reducing time and cost required for testing. This study reports systematic literature review of existing test case generation approaches for regression testing and agent-based software testing systems. The emphasis is articulated on agent-based regression test case generation. Further research directions are recommended. In the systematic literature review, we framed three sets of research questions. Based on our inclusion and exclusion criteria, we identified 115 potential research papers on test case generation in regression testing and agent-based software testing. We explored journals, international conferences, workshops and identified 59 studies in test case generation for regression testing and 56 studies in agent-based software testing. The data extracted from our study are classified into seven broader areas of agent-based software testing. Based on our systematic literature survey, we recognized available techniques, approaches, platforms as well as methodologies for regression test case generation and developing agent-based software testing systems. This study will benefit the researchers to carry forward their work in the domain of regression test case generation and agent-based software testing. To cut down on schedule and cost, mobile agent-based software testing can be a promising alternative. [ABSTRACT FROM AUTHOR]

By ordering test cases, early fault detection is focused on test case prioritization. In this field, it is widely known that algorithm and coverage criteria focused works are common. Previous works, which are related to test case prioritization, showed that practitioners need a novel method that optimizes test cases according to the cost of each test case instead of regarding the total cost of a test suite. In this work, by utilizing local and global search properties of a bat algorithm, a new bat-inspired test cases prioritization algorithm (BITCP) is proposed. In order to develop BITCP, test case execution time and the number of faults were adapted to the distance from the prey and loudness, respectively. The proposed method is then compared with four methods which are commonly used in this field. According to the results of the experiment, BITCP is superior to the conventional methods. In addition, as the complexity of the code of test cases increases, the decline in average percentage of fault detection is less in BITCP than the other four comparison algorithms produced. [ABSTRACT FROM AUTHOR]

The prevailing scenario of ever increasing dependency of human beings on software applications has built pressure on software organizations to produce quality software. The quality of software is determined by many factors. One of the vital factors in deciding the software quality is optimized usage of testing tools and techniques employed during regression testing. Extremely high complexity of regression testing makes it necessary to utilize optimized way of running a selected and minimized test suite. Still, various challenges like redundancy, repetition ratio, Recurrence ratio or missing functionalities during regression testing are common. This paper discusses about the problems and challenges encountered during regression testing. [ABSTRACT FROM AUTHOR]

Regression testing is one among the strongest testing criteria which ensure the quality of the software under test. However, regression testing is too expensive due to execution of too many test cases. Test case prioritization is one of the traditional techniques which improve the regression testing by proposing a test case order that increases the rate of fault detection. In this paper, we propose a cost - cognizant history based test case prioritization approach that utilizes the historical information of the test cases like cost, fault identified by the test case and the severity of the identified fault for prioritization. Also an artificial immune system based, Clonal selection algorithm is proposed to find an effective test case order from existing test suite. To evaluate the proposed approach, controlled experiment were performed and the evaluation results indicates the test case order produced by proposed approach shows improvement in terms of average percentage of fault detected per cost. [ABSTRACT FROM AUTHOR]

Test suite reduction is an important approach that decreases the cost of regression testing. A test suite reduction technique operates based on the relationship between the test cases in the regression test suite and the test requirements in the program under test. Thus, its effectiveness should be closely related to the complexity of a regression test suite – the product of the number of test cases and the number of test requirements. Our previous work has shown that cost-aware techniques (i.e., the test suite reduction techniques that aim to decrease the regression test suite's execution cost) generally outperform the others in terms of decreasing the cost of running the regression test suite. However, the previous empirical studies that evaluated cost-aware techniques did not take into account test suite complexity. That is, prior experiments do not reveal if the cost-aware techniques scale and work effectively on test suites with more test cases and more test requirements. This means that prior experiments do not appropriately shed light on how well test suite reduction methods work with large programs or test suites. Therefore, this paper focuses on the Greedy-based techniques and empirically evaluates the additional Greedy and two cost-aware Greedy techniques – at different levels of test suite complexity – from various standpoints including the cost taken to run the regression test suite, the time taken to reduce the test suites, the total regression testing costs, the fault detection capability, the fault detection efficiency, and the common rates of the representative sets. To the best of our knowledge, none of the previous empirical studies classify a considerable number of test suites according to their complexity. Nor do any prior experiments evaluate the test suite reduction techniques, in terms of the aforementioned criteria, at different levels of test suite complexity. This paper represents the first such attempt to carry out this important task. Based on the empirical results, we confirm the strengths and weaknesses of the cost-aware techniques and develop insights into how the cost-aware techniques' effectiveness varies as the test suite complexity increases. [ABSTRACT FROM AUTHOR]

Software testing is an important activity in the software development life cycle. Several previous studies reported the results of surveys on software testing practices among practitioners from different countries. In this paper, we analyze these surveys aiming to get their main questions, and replicate a survey with practitioners from Brazil and Uruguay, two emerging South American software development scenarios. This survey was previously conducted in Manaus/Brazil in 2006 and Buenos Aires/Argentina in 2013. The replication's scope includes three regions (Northern Brazil, Southern Brazil, and Uruguay). A total of 150 software testing practitioners responded to the survey. Its results are compared with the previous executions and other software testing surveys identified in the technical literature, strengthening previous findings. The Brazilian and Uruguayan participants indicate that: (1) documentation of test artifacts (plan, cases, procedures, results) are useful and important for software testing practitioners; (2) system and regression testing are the two test types deemed most useful and important; (3) tools for monitoring and management of test process tasks and bug reports are considered useful and important; (4) it is usual for software companies to have a definition of a testing process and to have a dedicated testing team; (5) there is a lack of measurement of test tasks and coverage in the industry; and (6) tools to support automation of test case generation and execution or code coverage are still poorly used in their organizations. [ABSTRACT FROM AUTHOR]

Unintended changes in the utilization of resources like CPU and memory can lead to severe problems for the operation of robotics and intelligent systems. Nevertheless, systematic testing for such performance regressions has largely been ignored in this domain. We present a method to specify and execute performance tests for individual components of component-based robotics systems based on their middleware interfaces. The method includes an automatic analysis of each component revision against previous ones that reports potential changes to the resource utilization characteristics. This informs developers about the impact of their changes. We describe the design of the framework and present evaluation results for the automatic detection of performance changes based on tests for a variety of robotics components. Additionally, we demonstrate how performance tests can be used as a basis for learning resource utilization models of components. These models can be used to detect faults at system run-time, which provides an additional level of safety for the systems besides the offline testing. Presents a testing framework for automatic performance regression detection. Individual components are tested based on their middleware interfaces. Test recordings can be used to train resource prediction models. [ABSTRACT FROM PUBLISHER]

Software testers always face the dilemma of whether to retest the software with all the test cases or select a few of them on the basis of their fault detection ability. This paper introduces a novel approach to minimizing the test suite as an integer linear programming problem with optimal results. The minimization method uses the cohesion values of the program parts affected by the changes made to the program. The hypothesis is that the program parts with low cohesion values are more prone to errors. This assumption is validated on the mutation fault detection ability of the test cases. The experimental study carried out on 30 programs evaluates the effectiveness and usefulness of the proposed framework. The experimental results show that the minimized test suite can efficiently reveal the errors and ensure acceptable software quality. [ABSTRACT FROM AUTHOR]

Topology learning neural networks such as Growing Neural Gas (GNG) and Self-Organizing Incremental Neural Network (SOINN) are online clustering methods. With GNG and SOINN implemented as basic learners, this software completes two machine learning tasks, namely density estimation and regression. A kernel density estimation framework is implemented to transform the topology learning neural networks into density estimation methods. Besides, a kernel smoother to implement supervised and semi-supervised regression is devised. Moreover, the implemented frameworks can be used to transform other clustering methods into density estimation, supervised regression and semi-supervised regression. [ABSTRACT FROM AUTHOR]

The purpose of regression testing is to ensure that changes made to software, such as adding new features or modifying existing features, have not adversely affected features of the software that should not change. Regression testing is usually performed by running some, or all, of the test cases created to test modifications in previous versions of the software. Many techniques have been reported on how to select regression tests so that the number of test cases does not grow too large as the software evolves As the software systems evolve with time, regression testing is an important and very expensive activity to ensure that this evolution will not disrupt the existing functionalities of the system. An important issue, in this context, is optimal selection of subset of test cases from the initial test suite to minimize the testing time, cost and effort. Researchers have proposed various types of regression test selection techniques that are code-based, and modelbased. Code-based regression test selection techniques can be effectively applied for unit-testing. It uses relationship between code parts and test cases that traverse them to locate test cases for retest when code is modified. This paper is the analysis of both code-based and model-based regression testing technique according to some comparison and evaluation criterion. [ABSTRACT FROM AUTHOR]

Testing software products is very expensive and time consuming, especially for large software systems with extensive regression testing. During regression testing, a modified system is often re-tested using an existing test suite. Since test suites can be very large, testers are interested in detecting faults in the modified system as early as possible. Test prioritization tries to order test cases for execution in a way that increases the chances of the early detection of faults. Most of the existing test prioritization methods are based on the code of the system under test, but model-based test prioritization has been lately proposed. Most of the existing model-based test prioritization methods can be used only when models are modified during system maintenance. In this paper, we present model-based prioritization for a class of modifications for which models are not modified (only the source code is modified). After identifying the elements of the model related to the modified source code, information collected during the execution of the model is used to prioritize tests for execution. Here, we present and compare existing and new model-based test prioritization methods focused on this class of modifications. The major motivation for presenting these methods is to provide system developers with simple and yet effective test prioritization techniques for early fault detection. Statistical analysis of the empirical study, which compares the effectiveness of the presented methods in terms of early fault detection, show that compared to random ordering of test cases, model-based test prioritization significantly improve the effectiveness of test prioritization with respect to early fault detection. [ABSTRACT FROM AUTHOR]

The purpose of regression testing is to ensure that bug fixes and new functionality introduced in a new version of a software do not adversely affect the correct functionality inherited from the previous version. I have proposed a new slicing method to decompose a Java program into affected packages, classes, methods and statements identified with respect to the modification made in the program.Because java program has hierarchical characteristics(Package/Class/Method), this decomposition is based on this characteristic. I also have proposed an intermediate representation for Java programs that shows Package Level, Class Level and Method Level Dependency. I have named this intermediate representation as Program Dependency Tree(PDT). This PDT is used to identify the program parts that are possibly affected by the change made to the program. With the help of PDT, we can obtain program slices. The packages, classes, methods and statements thus affected are identified by traversing the Program Dependency Tree. The proposed approach maps the decomposed slice (comprising of the affected program parts) with the coverage information of the existing test suite to select the appropriate test cases for regression testing. [ABSTRACT FROM AUTHOR]

Regression testing repeatedly executes test cases of previous builds to validate that the original features are not affected with any new changes. In recent years, regression testing has seen a remarkable progress with the increasing popularity of agile methods, which stress the central role of regression testing in maintaining software quality. The optimum case for regression testing in agile context is to run regression set at the end of each sprint and release, which requires a lot of cost and time. In this paper, we present an automated agile regression testing approach on both the sprints and release levels. The proposed approach addresses both weighted sprint test cases prioritization technique, which prioritizes test cases based on several parameters having real practical weight for testers, and Cluster-based Release Test cases Selection technique that clusters user stories based on the similarity of covered modules to solve the scalability issue. Test cases are then selected based on issues logged for failed test cases using text mining techniques. The proposed approach achieves enhancement for both the prioritization and selection of test cases for agile regression testing. Copyright © 2016 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

The software industry continues to move toward delivering software applications on the cloud. Reports show that revenues from cloud-based software were close to $48 billion in 2014, and growth is predicted to continue to increase to $493 billion by 2026. Software as a service (SaaS), one of the fastest growing software segments, allows customers to pay and manage their service needs dynamically via the web. The flexible nature of SaaS requires SaaS applications to follow more stringent quality needs than the traditional applications that are delivered on premise. The challenges facing the software engineering industry shift increasingly toward improving efficiency and effectiveness in the development cycle. The author's prior research focused on improving test effectiveness on SaaS applications. In her prior research she modeled service-level use cases from field failures as abstract events and then generated sequences of these for testing to provide a broad coverage of the possible use cases. This paper extends the author's prior study to a much broader set of services that are part of an offering. It presents an approach of prioritizing scenarios that was generated for the entire set of services in an offering and demonstrates an improved rate of fault detection. This research will allow practitioners delivering enterprise cloud applications to effectively prioritize testing, which allows teams to minimize field failures by detecting faults in the test phase and improve customer perceived quality. [ABSTRACT FROM AUTHOR]

How important is the ability to freely control eye movements for reading comprehension? And how does the parser make use of this freedom? We investigated these questions using coregistration of eye movements and event-related brain potentials (ERPs) while participants read either freely or in a computer-controlled word-by-word format (also known as RSVP). Word-by-word presentation and natural reading both elicited qualitatively similar ERP effects in response to syntactic and semantic violations (N400 and P600 effects). Comprehension was better in free reading but only in trials in which the eyes regressed to previous material upon encountering the anomaly. A more fine-grained ERP analysis revealed that these regressions were strongly associated with the well-known P600 effect. In trials without regressions, we instead found sustained centro-parietal negativities starting at around 320 ms post-onset; however, these negativities were only found when the violation occurred in sentence-final position. Taken together, these results suggest that the sentence processing system engages in strategic choices: In response to words that don't match built-up expectations, it can either explore alternative interpretations (reflected by regressions, P600 effects, and good comprehension) or pursue a 'good-enough' processing strategy that tolerates a deficient interpretation (reflected by progressive saccades, sustained negativities, and relatively poor comprehension). [ABSTRACT FROM AUTHOR]

Regression test case prioritization is used to improve certain performance goals. Limited resources force to choose an effective prioritization technique, which makes an ordering of the test cases so that the most suitable test case will be executed first. Executing regression test cases for a fixed time is all about time aware test case prioritization. Regression test case prioritization using chemical reaction optimization (CRO) for object-oriented programs is proposed in this paper. The effectiveness of the test case ordering was measured using average percentage of faults detected (APFD). Experiments on three objectoriented subject programs involving three different techniques were performed to judge the proposed approach. The empirical results indicate that the algorithm implemented using CRO gives a higher APFD value than the other two techniques. [ABSTRACT FROM AUTHOR]

Among the fault localization methods of the coverage-based regression test cases, the ranking of suspiciousness degree is seriously impacted due to the existence of similar test cases, the existence of isolated treatment of each program entity and the coincidental correctness test cases as well as the poor quality of regression test cases, which reduces the efficiency of fault localization. This paper proposes a method that combines the control dependence and data dependence, test cases covering table and test result with vector angular cosine weight to solve the aforesaid problems. Experimental results show that the efficiency of the proposed fault localization of regression test cases is better than that of Tarantula, Jaccard, Ochiai, PPDG and CP methods. [ABSTRACT FROM AUTHOR]

Software tests, specifically software represented through regression testing, it accompanies the entire lifestyles cycle of industrial software machine. In this report a regression testing technique for enterprise-orientated programs to solve troubles such as time. Regression Testing is a form of software program testing that verifies that software previously evolved and tested nevertheless performs efficiently even after it turned into modified or interfaced with different software program. Changes may consist of software program enhancements, patches, configuration modifications, and many others. At some stage in regression trying out, new software program insects or regressions may be uncovered. Sometimes a software trade effect analysis is done to decide what regions could be suffering from the proposed modifications. Those areas may encompass purposeful and non-functional regions of the gadget. In this proposed work, pruning of regression testinghas been performed by designing a mathematical model.For that, five different parametersand two test-case scenarios have been chosen and the effect of individual change or combinational changes in parameters have been analyzed. The automated pruning on the basis of changes in these parameters has been performed.The parameters have been chosen in which changes are made and then scenarios of change have been selected to generate various tests cases. The results showed that the objectives have been fully achieved after pruning the results and has improved both quantitatively and qualitatively in terms of their cost, risk and time factors. The time taken for testing has been minimized up to 50% whereas cost and risk factors has also been improved very effectively when compared with the results obtained from existing technique. [ABSTRACT FROM AUTHOR]

Communicating or autonomous systems rely on high-quality software-based components. that must be thoroughly verified before they are released and deployed in operational settings. Regression testing is a crucial verification process that compares any new release of a software-based component against its previous versions, by executing available test cases. However, limited testing time makes selection of test cases in regression testing challenging, and some selection criteria must be respected. Validation engineers usually address this problem, coined as test suite reduction (TSR), through manual analysis or by using approximation techniques. In this paper, we address the TSR problem with sound artificial intelligence techniques such as constraint programming (CP) and global constraints. By using distinct cost-value-aggregating criteria, we propose several constraint-optimization models to find a subset of test cases that cover all the test requirements and optimize the overall cost of selected test cases. Our contribution includes reuse of existing preprocessing rules to simplify the problem before solving it and the design of structure-aware heuristics that take into account the notion of the costs associated with test cases. The work presented in this paper has been motivated by an industrial application in the communication domain. Our overall goal is to develop a constraint-based approach of test suite reduction that can be deployed to test a complete product line of conferencing systems in continuous delivery mode. By implementing this approach in a software prototype tool and experimentally evaluating it on both randomly generated and industrial instances, we hope to foster a quick adoption of the technology. [ABSTRACT FROM AUTHOR]

Automated program repair (APR) tools apply fault localization (FL) techniques to identify the locations of likely faults to be repaired. The effectiveness, performance, and repair correctness of APR depends in part on the FL method used. If FL does not identify the location of a fault, the application of an APR tool will not be effective-it will fail to repair the fault. If FL assigns the actual faulty statement a low priority for repair, APR performance will be reduced by increasing the time required to find a potential repair. In addition, the correctness of a generated repair will be decreased since APR will modify fault-free statements that are assigned a higher priority for repair than an actual faulty statement. We conducted a controlled experiment to evaluate the impact of ten FL techniques on APR effectiveness, performance, and repair correctness using a brute force APR tool applied to faulty versions of the Siemens Suite and two other large programs: space and sed. All FL techniques were effective in identifying all faults; however, Wong3 and Ample1 were the least effective FL techniques since they assigned the lowest priority for repair in more than 26 % of the trials. We obtained the worst APR performance significantly when Ample1 was used since it generated a large number of variants in 29.11 % of the trials, and took the longest time to produce potential repairs. Jaccard FL improved repair correctness by generating more validated repairs-potential repairs that pass a set of regression tests, and generating potential repairs that failed fewer regression tests. Also Jaccard's performance is noteworthy in that it never generated a large number of variants during the repair process compared to the alternatives. [ABSTRACT FROM AUTHOR]

Regression testing is a kind of software testing that authenticates that software previously developed and established still accomplishes correctly after it was altered or interfaced with other software. The aim of the investigation is to progress the software competence via cloud based regression testing. The projected technique has three chief stages such as, 1) test case generation, 2) clustering and 3) test case prioritization. Primarily the input implementation is send to the cloud for test case generation. For producing the test cases the projected method utilizes coverage metrics. Following the test case generation, the existing test cases are gathered with the help of kernel fuzzy c means clustering algorithm. Subsequently each group is fed to test case prioritization; in that grey wolf optimization algorithm is utilized for test case prioritization. Thus we will get operative prioritized test cases. Our method will be implemented on JAVA with Cloud Sim platform. The presentation will be assessed using execution time and memory use. From the solution the applied method precedes minimum implementation time associated with the available technique. [ABSTRACT FROM AUTHOR]