Search

The object of research in the article is the process of testing and operating software with cost minimization. In the Software Development Life Cycle, depending on the chosen option of the flexible methodology, special attention is focused on testing software versions both in the process of passing iterations and in the process of releasing alpha, beta and production versions. This article is devoted to the problem of developing a method for software testing cost optimization method that estimates the test cost function and the losses cost function from the occurrence of an error. Using the optimization method (for example, the first-order descent method) from the two functions of testing costs and estimating the losses caused during operation, it is possible to calculate the optimal cost of testing and operating the software product. The results obtained show that with the correct assessment of a cost function and a loss function such calculations allow to significantly save money and time for the production of the next version of the software product. These results are explained by the fact that the method of optimizing the cost function finds the optimum point and allows to pre-estimate the budget and risks during the development and operation of the software. The article provides several examples of the calculation and optimization of testing costs within the proposed concept for one iteration in a flexible software development cycle. The results of the study can be used in practice, provided that the functions of estimating costs for testing and compensation for losses caused during the operation of the software are set correctly. Experienced managers and project supervisors determine these functions quite accurately for a certain number of iterations, which makes it possible to apply the method of finding the minimum budget costs for testing and operating a software product. [ABSTRACT FROM AUTHOR]

Previous research in defect prediction has proposed approaches to determine which files require additional testing resources. However, practitioners typically create tests at a higher level of abstraction, which may span across many files. In this paper, we study software testing, especially test resource prioritization, from a different perspective. We use topic models to generate topics that provide a high-level view of a system, allowing developers to look at the test case coverage from a different angle. We propose measures of how well tested and defect prone a topic is, allowing us to discover which topics are well tested and which are defect prone. We conduct case studies on the histories of Mylyn, Eclipse, and NetBeans. We find that 34–78% of topics are shared between source code and test files, indicating that we can use topic models to study testing; well-tested topics are usually less defect prone, defect-prone topics are usually undertested; we can predict which topics are defect prone but not well tested with an average precision and recall of 75% and 77%, respectively; our approach complements traditional prediction-based approaches by saving testing and code inspection effort; and our approach is not particularly sensitive to the parameters that we use. [ABSTRACT FROM PUBLISHER]

Exploratory Testing technique is well applicable to software development projects, where test basis is not available (or at least not complete and consistent to the extent allowing the creation of efficient test cases). The key factor for the efficiency of this technique is a structured process for the recording of explored path in the system under test. This approach also allows the creation of the test cases during exploratory testing process. These test cases can be used in the following re-testing of the system. If performed manually, the efficiency of such process strongly depends on the team organization and systematic work of the individuals in the team. This process can be aided by an automated support. In the paper, a framework, which automatically records selected tester's actions in the system under test is presented. From these recordings, a model of the screen and action flows is reengineered and test cases are prepared. Tester is also able to define more meta-data in the test cases during this process. The recorded model and defined test cases are then available for the next rounds of testing. The performed case study shows that Exploratory Testing aided by this machine support is less resource demanding than Exploratory Testing performed manually only. Also, larger part of SUT was explored during the tests, when this systematic support was available to testers. [ABSTRACT FROM AUTHOR]

Testing is a key activity of software development and maintenance that determines the level of reliability. Traceability is the ability to describe and follow the life of software artifacts, and has been promoted as a means for supporting various activities, most importantly testing. Traceability information facilitates the testing and debugging of complex software by modeling the dependencies between code and tests. Actively supplementing traceability to testing enables rectifying defects more reliably and efficiently. Despite its importance, the development of test-to-code traceability has not been sufficiently addressed in the literature, and even worse there is currently no organized review of traceability studies in this field. In this work, we have investigated the main conferences, workshops, and journals of the requirements engineering, testing, and reliability, and identified those contributions that refer to traceability topics. From that starting point, we characterized and analyzed the chosen contributions against three research questions by utilizing a comparative framework including nine criteria. As a result, our study arrives to some interesting points, and outlines a number of potential research directions. This, in turn, can pave the way for facilitating and empowering traceability research in this domain to assist software engineers and testers in test management. [ABSTRACT FROM AUTHOR]

Due to the rapid spread of information technology, software quality is one of the most important tasks nowadays. In order for the software product to satisfy the final user, it must work flawlessly. That is why software products should be tested. However, testing should not be a chaotic process, based solely on intuition, but it should be integrated into all phases of software development. This paper examines such issues as integration of testing process into the entire software development lifecycle. The analysis was performed and the model proprosed for integrating testing into the software development process as a whole. All software development activities, such as requirements analysis, design, development, testing and project and quality management are essential to efficiently develop high quality software. One of the goals of software development is to provide the software without defects. The purpose of software testing is to ensure software satisfies the specification and to check whether it fulfills user's requirements. Before the start of system development it is necessary to examine the software testing management area (processes that take place in such projects). To accomplish this task the following tasks are done - the analysis of test management. The analysis of tasks performed during software testing are analysed. The deep analysis is done on requirements, test cases and defect management specifics. In accordance with best practices the data flow and the test management activity diagrams are done. To fulfill this task it is necessary to communicate with project management and testing professionals from various organizations and projects and use the information for designing data flows and activities. Testing - the part of project development process. In order to ensure the best possible quality of the project, the tester should be involved from the beginning of the project till the project handover to the client. Testing has shown that the software is fit for purpose. After the analysis of software testing processes and existing alike software solutions is done and when expert knowledge is gathered - the final requirements are gathered for the system. The aim - to analyze the software testing management systems and test management processes. [ABSTRACT FROM AUTHOR]

Testing of a software product is the key activity before deploying it in the real-time environment. Therefore testing should be introduced into the product development process as early as possible in order to decrease the costs of repairing the damage in later phases. In this paper we use Coloured Petri Nets (CPN) for the system specification and also as a system to be tested instead of its implementation. This specification also serves as the basis for the test suite generation. Test cases are provided in the language of Testing and Test Control Notation version 3 (TTCN-3) due to its general application area and platform independence. Stop-and-wait communication protocol has been used as a tutorial example of our approach. [ABSTRACT FROM AUTHOR]

Testing provides a primary means for assuring software in safety-critical systems. To demonstrate, particularly to a certification authority, that sufficient testing has been performed, it is necessary to achieve the test coverage levels recommended or mandated by safety standards and industry guidelines. Mutation testing provides an alternative or complementary method of measuring test sufficiency, but has not been widely adopted in the safety-critical industry. In this study, we provide an empirical evaluation of the application of mutation testing to airborne software systems which have already satisfied the coverage requirements for certification. Specifically, we apply mutation testing to safety-critical software developed using high-integrity subsets of C and Ada, identify the most effective mutant types, and analyze the root causes of failures in test cases. Our findings show how mutation testing could be effective where traditional structural coverage analysis and manual peer review have failed. They also show that several testing issues have origins beyond the test activity, and this suggests improvements to the requirements definition and coding process. Our study also examines the relationship between program characteristics and mutation survival and considers how program size can provide a means for targeting test areas most likely to have dormant faults. Industry feedback is also provided, particularly on how mutation testing can be integrated into a typical verification life cycle of airborne software. [ABSTRACT FROM PUBLISHER]

This paper provides a systematic meta-analysis of 27 studies that investigate the impact of Test-Driven Development (TDD) on external code quality and productivity. The results indicate that, in general, TDD has a small positive effect on quality but little to no discernible effect on productivity. However, subgroup analysis has found both the quality improvement and the productivity drop to be much larger in industrial studies in comparison with academic studies. A larger drop of productivity was found in studies where the difference in test effort between the TDD and the control group's process was significant. A larger improvement in quality was also found in the academic studies when the difference in test effort is substantial; however, no conclusion could be derived regarding the industrial studies due to the lack of data. Finally, the influence of developer experience and task size as moderator variables was investigated, and a statistically significant positive correlation was found between task size and the magnitude of the improvement in quality. [ABSTRACT FROM PUBLISHER]

This paper describes the authors' experience of teaching agile software development to students of computer science, software engineering, and other related disciplines, and comments on the implications of this and the lessons learned. It is based on the authors' eight years of experience in teaching agile software methodologies to various groups of students at different universities, in different cultural settings, and in a number of courses and seminars. It specifically discusses three different courses on agile software development, given in different teaching settings and at different levels, and briefly surveys variations to these courses given elsewhere. Based on the experience acquired, analyses and evaluations conducted, and current pedagogical trends at relevant university departments, the authors provide recommendations on how to overcome potential problems in teaching agile software development and make their adoption more effective. [ABSTRACT FROM AUTHOR]

Abstract: Models are abstractions of reality that have predetermined limits (often not consciously thought through) on what problem domains the models can be used to explore. These limits are determined by the range of observed data used to construct and validate the model. However, it is important to remember that operating the model beyond these limits, one of the reasons for building the model in the first place, potentially brings unwanted behaviour and thus reduces the usefulness of the model. Our experience with the Agricultural Production Systems Simulator (APSIM), a farming systems model, has led us to adapt techniques from the disciplines of modelling and software development to create a model development process. This process is simple, easy to follow, and brings a much higher level of stability to the development effort, which then delivers a much more useful model. A major part of the process relies on having a range of detailed model tests (unit, simulation, sensibility, validation) that exercise a model at various levels (sub-model, model and simulation). To underline the usefulness of testing, we examine several case studies where simulated output can be compared with simple relationships. For example, output is compared with crop water use efficiency relationships gleaned from the literature to check that the model reproduces the expected function. Similarly, another case study attempts to reproduce generalised hydrological relationships found in the literature. This paper then describes a simple model development process (using version control, automated testing and differencing tools), that will enhance the reliability and usefulness of a model. [ABSTRACT FROM AUTHOR]

The article presents information on an computer processor, Bugnet which helps the software developers to deterministically replay and debug an application while executing an computer program. The article author says that the difficult part of debugging is reproducing the bugs at a customer's site because it relys on core dumps which contain the final state of the system before the crash. The article authors' say that they propose the BugNet architecture to assist program developers to continuously record a program's execution as it runs. The Deterministic Replay Debugging technique helps to replay the exact same sequence of instructions that led up to the crash. The processor Bugnet continuously records a program's execution without interfering with the execution of the monitored program. The BugNet writes the logs to a fixed-sized buffer allocated in main memory so that software developers can then use these logs at the time of crash to deterministically replay the last part of execution as many times as required to fix the bug.

Modern virtualization technology allows us to run operating systems in a virtual machine that can be hosted on facilities ranging from our laptop to a datacenter in the cloud. It's thus possible to create a virtualized development environment that contains all the tools, applications, and libraries that a programmer requires. This speeds up developer setup time, brings economies of scale, introduces parity between development and production environments, allows the use of platform-specific tools, and simplifies embedded-system development. Using VMs, testers can ensure a pristine environment and access to diverse (virtual) platforms. Deployment is also simplified by packaging all the system's components and setup into a VM appliance. Finally, on the operations side, VMs make it easier for a system to support application provisioning, maintenance windows, high availability, and disaster recovery. [ABSTRACT FROM PUBLISHER]

This study is a quasi experiment comparing the software defect rates and implementation costs of two methods of software defect reduction: code inspection and test-driven development. We divided participants, consisting of junior and senior computer science students at a large Southwestern university, into four groups using a two-by-two, between-subjects, factorial design and asked them to complete the same programming assignment using either test-driven development, code inspection, both, or neither. We compared resulting defect counts and implementation costs across groups. We found that code inspection is more effective than test-driven development at reducing defects, but that code inspection is also more expensive. We also found that test-driven development was no more effective at reducing defects than traditional programming methods. [ABSTRACT FROM PUBLISHER]