Test Case Prioritization in Continuous Integration environments: A systematic mapping study Abstract   Context: Continuous Integration (CI) environments allow frequent integration of software changes, making software evolution more rapid and costeffective. In such environments, the regression test plays an important role, as well as the use of Test Case Prioritization (TCP) techniques. Such techniques attempt to identify the test case order that maximizes certain goals, such as early fault detection. This research subject has been raising interest because some new challenges are faced in the CI context, as TCP techniques need to consider time constraints of the CI environments.  Objective: This work presents the results of a systematic mapping study on Test Case Prioritization in Continuous Integration environments (TCPCI) that reports the main characteristics of TCPCI approaches and their evaluation aspects.  Method: The mapping was conducted following a plan that includes the definition of research questions, selection criteria and search string, and the selection of search engines. The search returned 35 primary studies classified based on the goal and kind of used TCP technique, addressed CI particularities and testing problems, and adopted evaluation measures.  Results: The results show a growing interest in this research subject. Most studies have been published in the last four years. 80% of the approaches are historybased, that is, are based on the failure and test execution history. The great majority of studies report evaluation results by comparing prioritization techniques. The preferred measures are Time and numberpercentage of Faults Detected. Few studies address CI testing problems and characteristics, such as parallel execution and test case volatility.  Conclusions: We observed a growing number of studies in the field. Future work should explore other information sources such as models and requirements, as well as CI particularities and testing problems, such as test case volatility, time constraint, and flaky tests, to solve existing challenges and offer costeffective approaches to the software industry.

Incorporating faultproneness estimations into coveragebased test case prioritization methods Abstract   Context: During the development process of a software program, regression testing is used to ensure that the correct behavior of the software is retained after updates to the source code. This regression testing becomes costly over time as the number of test cases increases and it makes sense to prioritize test cases in order to execute faultdetecting test cases as soon as possible. There are many coveragebased test case prioritization (TCP) methods that only use the code coverage data to prioritize test cases. By incorporating the faultproneness estimations of code units into the coveragebased TCP methods, we can improve such techniques.  Objective: In this paper, we aim to propose an approach which improves coveragebased TCP methods by considering the faultproneness distribution over code units. Further, we present the results of an empirical study that shows using our proposed approach significantly improves the additional strategy, which is a widely used coveragebased TCP method.  Method: The approach presented in this study uses the bug history of the software in order to introduce a defect prediction method to learn a neural network model. This model is then used to estimate faultproneness of each area of the source code and then the estimations are incorporated into coveragebased TCP methods. Our proposed approach is a general idea that can be applied to many coveragebased methods, such as the additional and total TCP methods.  Results: The proposed methods are evaluated on datasets collected from the development history of five realworld projects including 357 versions in total. The experiments show that using an appropriate bug history can improve coveragebased TCP methods.  Conclusion: The proposed approach can be applied to various coveragebased TCP methods and the experiments show that it can improve these methods by incorporating estimations of code units faultproneness.