No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Paths-oriented Test Data Generation using Genetic Algorithm
... Table 7 summarizes all the metaheuristics and fitness functions related to code coverage testing using metaheuristics. The used meta-heuristics are the genetic algorithm (GA) (Fraser and Arcuri 2011;Charmchi and Cami 2021;Michael et al. 2001;Bottaci 2002;Sparks et al. 2007;Liu et al. 2008;Cao et al. 2009a, b;Rauf et al. 2010;Andrews et al. 2014;Shuai et al. 2013Shuai et al. , 2015aPałka et al. 2016;Paduraru et al. 2017;Arcuri 2017;Wei et al. 2018;Zhu et al. 2018;Wang et al. 2019b), evolutionary algorithm (EA) (Harman et al. 2002;Tlili et al. 2006;Baresel and Sthamer 2003;Afshan et al. 2013; LD(N(pa, AL(pa, i)), i)) Harman et al. (2002) Evolutionary algorithm Branch distance Bottaci (2002) Genetic algorithm Relational and logical predicate Baresel and Sthamer (2003) Evolutionary algorithm Node-node oriented fitness function Evolutionary algorithm The fitness of the sequence is determined based on the closest path to the test aim ...
The security of an application is critical for its success, as breaches cause loss for organizations and individuals. Search-based software security testing (SBSST) is the field that utilizes metaheuristics to generate test cases for the software testing for some pre-specified security test adequacy criteria This paper conducts a systematic literature review to compare metaheuristics and fitness functions used in software security testing, exploring their distinctive capabilities and impact on vulnerability detection and code coverage. The aim is to provide insights for fortifying software systems against emerging threats in the rapidly evolving technological landscape. This paper examines how search-based algorithms have been explored in the context of code coverage and software security testing. Moreover, the study highlights different metaheuristics and fitness functions for security testing and code coverage. This paper follows the standard guidelines from Kitchenham to conduct SLR and obtained 122 primary studies related to SBSST after a multi-stage selection process. The papers were from different sources journals, conference proceedings, workshops, summits, and researchers’ webpages published between 2001 and 2022. The outcomes demonstrate that the main tackled vulnerabilities using metaheuristics are XSS, SQLI, program crash, and XMLI. The findings have suggested several areas for future research directions, including detecting server-side request forgery and security testing of third-party components. Moreover, new metaheuristics must also need to be explored to detect security vulnerabilities that are still unexplored or explored significantly less. Furthermore, metaheuristics can be combined with machine learning and reinforcement learning techniques for better results. Some metaheuristics can be designed by looking at the complexity of security testing and exploiting more fitness functions related to detecting different vulnerabilities.
In software incremental development methodology, the product develops in several releases. In each release, one set of the requirements is suggested for development. The development team must select a subset of the proposed requirements for development in the next release such that by consideration the limitation of the problem provides the highest satisfaction to the customers and the lowest cost to the company. This problem is known as the next release problem. In complex projects where the number of requirements is high, development teams cannot choose an optimized subset of the requirements by traditional methods, so an intelligent algorithm is required to help in the decision-making process. The main contributions of this study are fivefold: (1) The customer satisfaction and the cost of every requirement are determined by use of fuzzy numbers because of the possible changing of the customers' priorities during the product development period; (2) An improved approximate approach is suggested for summing fuzzy numbers of different kinds, (3) A new metaheuristic algorithm namely the Binary Artificial Algae Algorithm is used for choosing an optimized subset of requirements, (4) Experiments performed on two fuzzy datasets confirm that the resulted subsets from the suggested algorithm are free of human mistake and can be a great guidance to development teams in making decisions.
Recommender systems are information filtering systems used in many online applications like music and video broadcasting and e-commerce platforms. They are also increasingly being applied to facilitate software engineering activities. Following this trend, we are witnessing a growing research interest on recommendation approaches that assist with modelling tasks and model-based development processes. In this paper, we report on a systematic mapping review (based on the analysis of 66 papers) that classifies the existing research work on recommender systems for model-driven engineering (MDE). This study aims to serve as a guide for tool builders and researchers in understanding the MDE tasks that might be subject to recommendations, the applicable recommendation techniques and evaluation methods, and the open challenges and opportunities in this field of research.
With modern requirements, there is an increasing tendency of considering multiple objectives/criteria simultaneously in many Software Engineering (SE) scenarios. Such a multi-objective optimization scenario comes with an important issue - how to evaluate the outcome of optimization algorithms, which typically is a set of incomparable solutions (i.e., being Pareto nondominated to each other). This issue can be challenging for the SE community, particularly for practitioners of Search-Based SE (SBSE). On one hand, multi-objective optimization could still be relatively new to SE/SBSE researchers, who may not be able to identify the right evaluation methods for their problems. On the other hand, simply following the evaluation methods for general multi-objective optimization problems may not be appropriate for specific SBSE problems, especially when the problem nature or decision maker's preferences are explicitly/implicitly known. This has been well echoed in the literature by various inappropriate/inadequate selection and inaccurate/misleading use of evaluation methods. In this paper, we first carry out a systematic and critical review of quality evaluation for multi-objective optimization in SBSE. We survey 717 papers published between 2009 and 2019 from 36 venues in seven repositories, and select 95 prominent studies, through which we identify five important but overlooked issues in the area. We then conduct an in-depth analysis of quality evaluation indicators/methods and general situations in SBSE, which, together with the identified issues, enables us to codify a methodological guidance for selecting and using evaluation methods in different SBSE scenarios.
Requirement Engineering is considered as the foremost part of Software development lifecycle. Hand-written requirements usually suffer from redundancy and inconsistency, which impact negatively on success of final software product. Artificial Intelligence techniques are used for avoiding erroneous requirements and human intervention, and also help in analyzing, classifying, and prioritization of requirements. This paper shows the state of the art of Artificial Intelligence techniques used in various Requirement Engineering approaches. It is surveyed that existing techniques Genetic Algorithm, Artificial Neural Network, and K-Nearest Neighbor show positive results in requirement prioritization. Many other techniques like Convolution Neural Network, Case-based reasoning are used for requirement classification, requirement traceability, and requirement analysis. This paper demonstrates some future research work, which is quite important and interesting, but needs further investigation in current research scenario and practice.
This chapter presents a holistic overview of software engineering research strategies. It identifies the two main modes of research within the software engineering research field, namely knowledge-seeking and solution-seeking research—the Design Science model corresponding well with the latter. We present the ABC framework for research strategies as a model to structure knowledge-seeking research. The ABC represents three desirable aspects of research—generalizability over actors (A), precise control of behavior (B), and realism of context (C). Unfortunately, as our framework illustrates, these three aspects cannot be simultaneously maximized. We describe the two dimensions that provide the foundation of the ABC framework—generalizability and control, explain the four different types of settings in which software engineering research is conducted, and position eight archetypal research strategies within the ABC framework. We illustrate each strategy with examples, identify appropriate metaphors, and present an example of how the ABC framework can be used to design a research program.
Many real-world test optimization problems (e.g., test case prioritization) are multi-objective intrinsically and can be tackled using various multi-objective search algorithms (e.g., Non-dominated Sorting Genetic Algorithm (NSGA-II)). However, existing multi-objective search algorithms have certain randomness when selecting parent solutions for producing offspring solutions. In a worse case, suboptimal parent solutions may result in offspring solutions with bad quality, and thus affect the overall quality of the solutions in the next generation. To address such a challenge, we propose CBGA-ES+, a novel cluster-based genetic algorithm with non-dominated elitist selection to reduce the randomness when selecting the parent solutions to support multi-objective test optimization. We empirically compared CBGA-ES+ with random search and greedy (as baselines), four commonly used multi-objective search algorithms (i.e., Multi-objective Cellular genetic algorithm (MOCell), NSGA-II, Pareto Archived Evolution Strategy (PAES), and Strength Pareto Evolutionary Algorithm (SPEA2)), and the predecessor of CBGA-ES+ (named CBGA-ES) using five multi-objective test optimization problems with eight subjects (two industrial, one real world, and five open source). The results showed that CBGA-ES+ managed to significantly outperform the selected search algorithms for a majority of the experiments. Moreover, for the solutions in the same search space, CBGA-ES+ managed to perform better than CBGA-ES, MOCell, NSGA-II, PAES, and SPEA2 for 2.2%, 13.6%, 14.5%, 17.4%, and 9.9%, respectively. Regarding the running time of the algorithm, CBGA-ES+ was faster than CBGA-ES for all the experiments.
To support agile software development projects, an array of tools and systems is available to plan, design, track, and manage the development process. In this paper, we explore a critical aspect of agile development i.e., effort prediction, that cuts across these tools and agile project teams. Accurate effort prediction can improve the planning of a sprint by enabling optimal assignments of both stories and developers. We develop a model for story-effort prediction using variables that are readily available when a story is created. We use seven predictive algorithms to predict a story’s effort. Interestingly, none of the predictive algorithms consistently outperforms others in predicting story effort across our test data of 423 stories. We develop an ensemble-based method based on our model for predicting story effort. We conduct computational experiments to show that our ensemble-based approach performs better in comparison to other ensemble-based benchmarking approaches. We then demonstrate the practical application of our predictive model and our ensemble-based approach by optimizing sprint planning for two projects from our dataset using an optimization model.
At early phases of a product development lifecycle of large scale Cyber-Physical Systems (CPSs), a large number of requirements need to be assigned to stakeholders from different organizations or departments of the same organization for review, clarification and checking their conformance to standards and regulations. These requirements have various characteristics such as extents of importance to the organization, complexity, and dependencies between each other, thereby requiring different effort (workload) to review and clarify. While working with our industrial partners in the domain of CPSs, we discovered an optimization problem, where an optimal solution is required for assigning requirements to various stakeholders by maximizing their familiarity to assigned requirements, meanwhile balancing the overall workload of each stakeholder. In this direction, we propose a fitness function that takes into account all the above-mentioned factors to guide a search algorithm to find an optimal solution. As a pilot experiment, we first investigated four commonly applied search algorithms (i.e., GA, (1 + 1) EA, AVM, RS) together with the proposed fitness function and results show that (1 + 1) EA performs significantly better than the other algorithms. Since our optimization problem is multi-objective, we further empirically evaluated the performance of the fitness function with six multi-objective search algorithms (CellDE, MOCell, NSGA-II, PAES, SMPSO, SPEA2) together with (1 + 1) EA (the best in the pilot study) and RS (as the baseline) in terms of finding an optimal solution using an real-world case study and 120 artificial problems of varying complexity. Results show that both for the real-world case study and the artificial problems (1 + 1) EA achieved the best performance for each single objective and NSGA-II achieved the best performance for the overall fitness. NSGA-II has the ability to solve a wide range of problems without having their performance degraded significantly and (1 + 1) EA is not fit for problems with less than 250 requirements Therefore we recommend that, if a project manager is interested in a particular objective then (1 + 1) EA should be used; otherwise, NSGA-II should be applied to obtain optimal solutions when putting the overall fitness as the first priority.
One of the major difficulties in software testing is the automatic generation of test data that satisfy a given adequacy criterion. This paper presents an automatic test data generation technique that uses a genetic algorithm (GA), which is guided by the data flow dependencies in the program, to search for test data to cover its def-use associations. The GA conducts its search by constructing new test data from previously generated test data that are evaluated as effective test data. The approach can be used in test data generation for programs with/without loops and procedures. The proposed GA accepts as input an instrumented version of the program to be tested, the list of def-use associations to be covered, the number of input variables, and the domain and precision of each input variable. The algorithm produces a set of test cases, the set of def-use associations covered by each test case, and a list of uncovered defuse associations, if any. In the parent selection process, the GA uses one of two methods: the roulette wheel method or a proposed method, called the random selection method, according to the user choice. Finally, the paper presents the results of the experiments that have been carried out to evaluate the effectiveness of the proposed GA compared to the random testing technique, and to compare the proposed random selection method to the roulette wheel method.
Path testing requires generating all paths through the program to be tested, and finding a set of program inputs that will execute every path. The number of possible paths in programs containing loops is infinite, and so it is very difficult, if not impossible, to test all of them. Path testing can be relaxed by selecting a subset of all executable paths that fulfill a certain path selection criterion and finding test data to cover it. The automatic generation of such test paths leads to more test coverage paths thus resulting in efficient and effective testing strategy. This paper presents a genetical swarm optimization (GSO) based technique, which effectively combines a genetic algorithm (GA) based technique and a particle swarm optimization (PSO) based technique, for automatic generation of a set of test paths that cover the all-uses criterion. Experiments have been carried out to evaluate the effectiveness of the proposed GSO approach in test paths generation compared to the GA and PSO approaches.
Identifying the most appropriate effort estimation methods is an important aspect for software project management. Within the scope of an software industry cluster project an expert system recommending estimation methods that best match the software development project’s characteristics and context has been developed. The knowledgebased recommender exploits an explicit knowledge base in order to infer matching items based on the software project’s context. The contribution of this article lies in presenting a constraint-based reasoning mechanism for computing recommendable items from a large set of choices and in its application to the domain of software project management. It discusses a recommendation model for effort estimation methods and presents specific extensions like explanation and repair mechanisms that proved exceptionally useful in this application domain. The application was conceptualized and developed in an iterative process and results from two rounds of evaluation are reported.
http://ojs.academypublisher.com/index.php/jetwi/article/view/0204282290
In the past five years there has been a dramatic increase in work on Search Based Software Engineering (SBSE), an approach to software engineering in which search based optimisation algorithms are used to address problems in Software Engineering. SBSE has been applied to problems throughout the Software Engineering lifecycle, from requirements and project planning to maintenance and re-engineering. The approach is attractive because it offers a suite of adaptive automated and semi-automated solutions in situations typified by large complex problem spaces with multiple competing and conflicting objectives. This paper 1 provides a review and classification of literature on SBSE. The paper identifies research trends and relationships between the techniques applied and the applications to which they have been applied and highlights gaps in the literature and avenues for further research.
Search-based software testing is the application of metaheuristic search techniques to generate software tests. The test adequacy criterion is transformed into a fitness function and a set of solutions in the search space are evaluated with respect to the fitness function using a metaheuristic search technique. The application of metaheuristic search techniques for testing is promising due to the fact that exhaustive testing is infeasible considering the size and complexity of software under test. Search-based software testing has been applied across the spectrum of test case design methods; this includes white-box (structural), black-box (functional) and grey-box (combination of structural and functional) testing. In addition, metaheuristic search techniques have also been applied to test non-functional properties. The overall objective of undertaking this systematic review is to examine existing work into non-functional search-based software testing (NFSBST). We are interested in types of non-functional testing targeted using metaheuristic search techniques, different fitness functions used in different types of search-based non-functional testing and challenges in the application of these techniques. The systematic review is based on a comprehensive set of 35 articles obtained after a multi-stage selection process and have been published in the time span 1996–2007. The results of the review show that metaheuristic search techniques have been applied for non-functional testing of execution time, quality of service, security, usability and safety. A variety of metaheuristic search techniques are found to be applicable for non-functional testing including simulated annealing, tabu search, genetic algorithms, ant colony methods, grammatical evolution, genetic programming (and its variants including linear genetic programming) and swarm intelligence methods. The review reports on different fitness functions used to guide the search for each of the categories of execution time, safety, usability, quality of service and security; along with a discussion of possible challenges in the application of metaheuristic search techniques.
The aim of Search Based Software Engineering (SBSE) research is to move software engineering problems from human-based search to machine-based search, using a variety of techniques from the metaheuristic search, operations research and evolutionary computation paradigms. The idea is to exploit humans' creativity and machines' tenacity and reliability, rather than requiring humans to perform the more tedious, error prone and thereby costly aspects of the engineering process. SBSE can also provide insights and decision support. This tutorial will present the reader with a step-by-step guide to the application of SBSE techniques to Software Engineering. It assumes neither previous knowledge nor experience with Search Based Optimisation. The intention is that the tutorial will cover sufficient material to allow the reader to become productive in successfully applying search based optimisation to a chosen Software Engineering problem of interest.
Background: Search-based Software Engineering (SBSE) uses a variety of techniques such as evolutionary algorithms or meta-heuristic searches but lacks a standard baseline method. Aims: The KEYS2 algorithm meets the criteria of a baseline. It is fast, stable, easy to understand, and presents results that are competitive with standard techniques. Method: KEYS2 operates on the theory that a small sub-set of variables control the majority of the search space. It uses a greedy search and a Bayesian ranking heuristic to fix the values of these variables, which rapidly forces the search towards stable high-scoring areas. Results: KEYS2 is faster than standard techniques, presents competitive results (assessed with a rank-sum test), and offers stable solutions. Conclusions: KEYS2 is a valid candidate to serve as a baseline technique for SBSE research.
This paper presents an automatic test-data generation technique that uses a genetic algorithm (GA) to generate test data that satisfy data-flow coverage criteria. The technique applies the concepts of dominance relations between nodes to define a new multi-objective fitness function to evaluate the generated test data. The paper also presents the results of a set of empirical studies conducted on a set of programs that evaluate the effectiveness of our technique compared to the random-testing technique. The studies show the effective of our technique in achieving coverage of the test requirements, and in reducing the size of test suites, the search time, and the number of iterations required to satisfy the data-flow criteria.
Search-based Software Engineering has been utilized for a number of software engineering activities.One area where Search-Based Software Engineering has seen much application is test data generation. Evolutionary testing designates the use of metaheuristic search methods for test case generation. The search space is the input domain of the test object, with each individual or potential solution, being an encoded set of inputs to that test object. The fitness function is tailored to find test data for the type of testthat is being undertaken. Evolutionary Testing (ET) uses optimizing search techniques such as evolutionary algorithms to generate test data. The effectiveness of GA-based testing system is compared with a Random testing system. For simple programs both testing systems work fine, but as the complexity of the program or the complexity of input domain grows, GA-based testing system significantly outperforms Random testing.
Artificial intelligences techniques such as knowledge based systems, neural networks, fuzzy logic and data mining have been advocated by many researchers and developers as the way to improve many of the software development activities. As with many other disciplines, software development quality improves with the experience, knowledge of the developers, past projects and expertise. Software also evolves as it operates in changing and volatile environments. Hence, there is significant potential for using AI for improving all phases of the software development life cycle. This chapter provides a survey on the use of AI for software engineering that covers the main software development phases and AI methods such as natural language processing techniques, neural networks, genetic algorithms, fuzzy logic, ant colony optimization, and planning methods
Web applications suffer from different security vulnerabilities that could be exploited by hackers to cause harm in a variety of ways. A number of approaches have been proposed to test for such vulnerabilities. However, some gaps are still to be addressed. In this paper, we address one of such gaps: the problem of automatically generating test data (i.e., possible attacks) to test for cross site scripting (XSS) type of vulnerability. The objective is to generate a set of test data to exercise candidate security-vulnerable paths in a given script. The desirable set of test data must be effective in the sense that it uncovers whether any path can indeed be exploited to launch an attack. We designed a genetic algorithm-based test data generator that uses a database of XSS attack patterns to generate possible attacks and assess whether the attack is successful. We considered different types of XSS vulnerability: stored, reflected and DOM based. We empirically validated our test data generator using case studies of Web applications developed using PHP and MySQL. Empirical results show that our test data generator is effective in generating, in one run, multiple test data to cover multiple target paths.
Software testing is a complex and expensive activity of the software development life cycle. Software testing includes test data generation according to a test adequacy criterion. The use of search-based techniques has been the focus of researchers to automate the process of software test data generation for structural control-flow criteria. Automating test data generation remains a challenging problem for more robust adequacy criterion such as satisfying data-flow dependencies of a program. This study proposes a search-based approach that generates test data for data-flow dependencies of a program using dominance concepts, branch distance, and elitism. Genetic algorithm is used for the proposed approach and Gray encoding is used to encode test data. A set of subject programs is taken from the research literature to evaluate efficiency and effectiveness of the proposed approach. For the proposed approach, the measures considered are the mean number of generations and mean percentage coverage achieved. The performance of the proposed approach is evaluated by comparing the results with those of random search and earlier studies on data-flow testing. Over several experiments, it is shown that the proposed approach performed significantly better than random search and earlier studies with respect to data-flow test data generation and optimization. There is an increasing performance gap for more complex subject programs.
Test case optimization is one of the techniques which efficiently manage the exponential growth in time and cost of testing. But in many times the researchers compromise with the code coverage while going for optimization. In this paper, the test suite is optimized using Intelligent Optimization Agent (IOA) while the keeping the percentage of code coverage unchanged. First the System Under Test (SUT) is modelled using UML Activity Diagram (AD) and converted into an Activity Graph (AG). Then the optimized path is found out in AD by using IOA and cost attributes. Then suitable algorithms are proposed to remove the redundant nodes in the optimized path. IOA is an agent based approach as compared to Hybrid Genetic Algorithm (HGA) in Intelligent Test Optimization Agent (ITOA).The proposed approach is found to be effective when compared with other optimization techniques like Genetic Algorithm (GA) and Intelligent Test Optimization Agent (ITOA).
Context
The generation of dynamic test sequences from a formal specification, complementing traditional testing methods in order to find errors in the source code.
Objective
In this paper we extend one specific combinatorial test approach, the Classification Tree Method (CTM), with transition information to generate test sequences. Although we use CTM, this extension is also possible for any combinatorial testing method.
Method
The generation of minimal test sequences that fulfill the demanded coverage criteria is an NP-hard problem. Therefore, search-based approaches are required to find such (near) optimal test sequences.
Results
The experimental analysis compares the search-based technique with a greedy algorithm on a set of 12 hierarchical concurrent models of programs extracted from the literature. Our proposed search-based approaches (GTSG and ACOts) are able to generate test sequences by finding the shortest valid path to achieve full class (state) and transition coverage.
Conclusion
The extended classification tree is useful for generating of test sequences. Moreover, the experimental analysis reveals that our search-based approaches are better than the greedy deterministic approach, especially in the most complex instances. All presented algorithms are actually integrated into a professional tool for functional testing.
The quality of Web applications is becoming more and more important. Web applications testing is a challenging work owing
to its dynamic behaviors and complex dependences. In this paper, we present an automatic test case generation algorithm by
exploiting DUCC expression and constructing transformed dependence diagram. We propose the two-phase approach to generate
test cases automatically and apply the approach into intra-and inter-page levels to decrease the complexity of test case generation.
To enlarge the generated test cases, we also exploit a predicate negating method to obtain more test cases. The experimental
result shows our approach is applicable for real world testing and can generate test cases effectively.
This paper proposes a dynamic test data generation framework based on genetic algorithms. The framework houses a Program Analyser and a Test Case Generator, which intercommunicate to automatically generate test cases. The Program Analyser extracts statements and variables, isolates code paths and creates control flow graphs. The Test Case Generator utilises two optimisation algorithms, the Batch-Optimistic (BO) and the Close-Up (CU), and produces a near to optimum set of test cases with respect to the edge/condition coverage criterion. The efficacy of the proposed approach is assessed on a number of programs and the empirical results indicate that its performance is significantly better compared to existing dynamic test data generation methods.
Developers have learned over time that software testing costs a considerable amount of a software project budget. Hence, software quality managers have been looking for solutions to reduce testing costs and time. Considering path coverage as the test adequacy criterion, we propose using genetic algorithms (GA) for automating the generation of test data for white-box testing. There are evidences that GA has been already successful in generating test data. However, existing GA-based test data generators suffer from some problems. This paper presents our approach to overcome one of these problems; that is the inefficiency in covering multiple target paths. We have designed a GA-based test data generator that is, in one run, able to synthesize multiple test data to cover multiple target paths. Moreover, we have implemented a set of variations of the generator. Experimental results show that our test data generator is more efficient and more effective than others.
This paper 1 provides a motivation for the application of search based optimization to Software Engineering, an area that has come to be known as Search Based Software Engineering (SBSE). SBSE techniques have already been applied to many problems throughout the Software Engineering lifecycle, with new application domains emerging on a regular basis. The approach is very generic and therefore finds wide application in Software Engineering. It facilitates automated and semi-automated solutions in situations typified by large complex prob- lem spaces with multiple competing and conflicting objectives. Previ- ous work has already discussed, in some detail, the advantages of the SBSE approach for Software Engineering. This paper summarises previ- ous work and goes further, by arguing that Software Engineering provides the ideal set of application problems for which optimization algorithms are supremely well suited.
The chapter presents a broad view of many important concepts needed for testing, either during design or under maintenance, together with an overview of a number of research results and approaches that will affect testing practice in the future. It classifies testing methods as black box testing or white box testing, and module, integration, system or acceptance testing. It describes mathematical theory of testing. In order to study concepts of program structure, digraphs are introduced as a potential model. A control flow graph is defined and utilized for a number of concepts needed in program testing, together with the technique of data flow analysis. The chapter discusses static data flow analysis and testing. It reviews mutation analysis and a variant of this approach is called weak mutation testing. The primary objective of mutation analysis is to evaluate the degree to which a test set exercises a program, rather than the initial generation of that test. The chapter further deals with path-oriented testing models.
Allocating resources to a software project and assigning tasks to teams constitute crucial activities that affect project cost and completion time. Finding a solution for such a problem is NP-hard; this requires managers to be supported by proper tools for performing such an allocation. This paper shows how search-based optimization techniques can be combined with a queuing simulation model to address these problems. The obtained staff and task allocations aim to minimize the completion time and reduce schedule fragmentation. The proposed approach allows project managers to run multiple simulations, compare results and consider trade-offs between increasing the staffing level and anticipating the project completion date and between reducing the fragmentation and accepting project delays. The paper presents results from the application of the proposed search-based project planning approach to data obtained from two large-scale commercial software maintenance projects. Copyright © 2011 John Wiley & Sons, Ltd.
The author sheds some light on why testing today's software
products is so challenging, and he identifies several solid approaches
that all testers should be able to thoughtfully apply. The effective
tester has a rich toolkit of fundamental testing techniques, understands
how the product will be used in its operating environment, and has a
nose for where subtle bugs might lurk in the product and a bag of tricks
for flushing them out. The methods described can help testers provide a
sensible answer to the question of what they really mean when they say
they have finished testing a software system
Recommender systems in model-driven engineering
- lissette
Genetic Algorithm Tutorial
- F Dreier