Search

The National Education Policy promotes moving from the conventional content-heavy and memorization learning practice towards holistic learning/integrated learning. It imparts a creative and multidisciplinary curriculum that focuses equally on curriculum and assessment. All educational establishments assess students using written examinations, quizzes, seminars, term paper writing, and course projects. A semester typically includes 4-5 courses, and students must earn credits for these courses by scoring a good Cumulative Grade Point Average (CGPA). As course projects offer depth knowledge/holistic learning/lifelong learning of a course for the student, many courses include course projects as one of the activities in the course. If all the courses are intended to include course projects as a mandatory pedagogy, it will be difficult for students to acquire in-depth knowledge and required skills while also dealing with stress. So we are proposing an integrated learning framework by applying the theory and practices of two core courses- Software Engineering and Web Technologies to develop a web application. This integrated learning focuses on developing software development and software testing skills in computer science for undergraduate students pursuing a bachelor of engineering degree. This framework alleviated the pressure on students during placement and created job opportunities in software development. The framework consists of three important phases- The first phase includes the identification of the problem as a need for customers, writing requirements and analyzing the same. Students apply modular design principles and break down the codebase into distinct modules. This technique enhances code organization, reusability, and maintainability. The second phase focused on developing the front end by harnessing the power of Angular, a leading web framework, to craft a sleek and interactive user interface. The backend is built using Node.js, which serves as the foundation, enabling the software system to cater to highperformance server environments. These modules communicated seamlessly through well-defined APIs, facilitating the integration of various components within the application, ultimately delivering a seamless and responsive user experience. An industry expert conducted a workshop on Angular This paper was submitted for review on Sept 10, 2023. It was accepted on Nov, 15, 2023. Corresponding author: Padmashree Desai, Department, K.L.E. Technological University, Karnataka India. Address: Hubblii-580031 (e-mail: padmashri@kletech.ac.in). Copyright © YYYY JEET. and React to get hands-on experience. The third phase focused on software testing using appropriate testing tools such as Selenium, Jmeter, TestComplete and Appium to test the web application. A software testing workshop was conducted for students by industry experts to expose the students to designing test cases, test plans, and testing strategies. The hands-on experience on testing tools was provided during the workshop. Faculty reviews are conducted on each phase, and rubrics-based assessment is done on each phase. Approximately sixty teams created web-based applications for real-world scenarios. Positive aspects of the framework in feedback indicated that more than 87% of the students agreed that they could apply Software engineering principles and practices such as requirements management. modular design and testing in web applications. Also, more than 85% of students acquire skills from code-to-web design mastery by developing web applications in Angular Node.js and backend implementation. This framework helped to improve teamwork, presentation and communication skills. Confidence in software development improved to a greater extent. The design and implementation of the framework met the stated outcome of the courses. The student's academic performance improved by 10% compared to the previous year when students were not involved in the integrated project development. [ABSTRACT FROM AUTHOR]

Purpose: The aim of the article is to provide an in-depth discussion of traditional and modern methods of software diagnostics and testing. The basic ways of implementing these processes will be discussed. We will also discuss the concept of automation of the testing process and its impact on modern software development with usage of Artificial Intelligence. Design/methodology/approach: The analysis of the article's topic is based on the analysis of sources discussing methods of software diagnostics and testing. Findings: The importance of analytical thinking and predictive skills. Originality/value: Presentation of various factors influencing the quality of software production with a particular focus on software test automation. [ABSTRACT FROM AUTHOR]

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]

Software testing is gaining much more importance in the software development life cycle. Many companies are investing in several testing methods and especially in test automation. Nevertheless, it is quite difficult to choose the best tool or framework to use. In this study, we will do an evaluation and comparison of Katalon Studio, Selenium and UFT in a web application. This is the preliminary work to achieve some solid outcomes in order to propose and create a new general framework for test and code optimisation. [ABSTRACT FROM AUTHOR]

Comparing behaviours of program models has become an important task in software maintenance and regression testing. Combinatorial testing focuses on recognizing faults that happen due to interaction of values of a small number of input parameters. In this paper presents the Black-Box Regression Maximization (BBM) Algorithm with Density-based Spatial Clustering Algorithm (DSC) using Greedy Search optimization algorithm focuses on combinatorial testing and proactively exposes behavioural deviations by checking inside block transitions. In this method presents new approach of BBM with Internal block transitions to measure the dissimilarity statements in large program data. To identify specific faults, an adaptive testing rule repeatedly constructs and tests configurations in order to determine, for each interaction of interest, whether it is faulty or not. [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]

Property-based testing has gained popularity in recent years in many areas of software development. The specification of assertions/properties helps to understand the semantics of pieces of code, and in modern programming environments, it can serve to test the program behavior. In this paper an XQuery property-based testing tool is presented, which enables to automatically test XQuery programs. The tool is able to systematically generate XML instances (i.e., test cases) from a given XML schema, and to filter XML instances with input properties specified by the programmer. Additionally, the tool automatically checks output (respectively, input-output) properties in each output instance (respectively, each pair of input-output instances). The tool is able to report whether the XQuery program passes the test, that is, if all the test cases satisfy the (input-)output property, as well as the number of test cases used for testing. In addition, if the XQuery program fails the test, the tool shows counterexamples found in the test cases. Properties are specified with XQuery Boolean functions, and the testing tool has been implemented in XQuery. Additionally, an XQuery path validation tool is presented. This tool is able to detect wrong paths in XQuery expressions. The path validation tool takes as input an XML schema, and it reports those paths on the XQuery program that do not match the XML schema. The path validation tool is a complement to the testing tool rejecting XQuery programs that do not conform to the XML schema. The path validation tool has been also implemented in XQuery. Finally, a web tool has been developed enabling to test and validate XQuery programs. [ABSTRACT FROM AUTHOR]

As blockchain technology is gaining popularity in industry and society, solutions for Verification and Validation (V&V) of blockchain-based software applications (BC-Apps) have started gaining equal attention. To ensure that BC-Apps are properly developed before deployment, it is paramount to apply systematic V&V to verify their functional and non-functional requirements. While existing research aims at addressing the challenges of engineering BC-Apps by providing testing techniques and tools, blockchain-based software development is still an emerging research discipline, and therefore, best practices and tools for the V&V of BC-Apps are not yet sufficiently developed. In this paper, we provide a comprehensive survey on V&V solutions for BC-Apps. Specifically, using a layered approach, we synthesize V&V tools and techniques addressing different components at various layers of the BC-App stack, as well as across the whole stack. Next, we provide a discussion on the challenges associated with BC-App V&V, and summarize a set of future research directions based on the challenges and gaps identified in existing research work. Our study aims to highlight the importance of BC-App V&V and pave the way for a disciplined, testable, and verifiable BC development. [ABSTRACT FROM AUTHOR]

Software testing is a very delicate aspect of software development, since designing good test sets is a non-trivial task. In this article, we describe a testing technique for testing business rules using property-based testing and the property-based automatic testing tool QuickCheck. Systematic, effective, and efficient testing of business rules increases the confidence on the validation of business concepts and domain rules which are specifically critical to data consistency. The approach is presented on the basis of small but representative examples in order to facilitate the readers' understanding, but it has been successfully evaluated in a number of different industrial examples, demonstrating that it generalises to much larger systems and is, thus, broadly applicable. [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]

Abstract: The goal of this paper is to review the literature in order to understand the implications of accessibility testing processes with the objective to detect potential improvements and developments in the field. Thus, a brief review is presented of the fundamental test processes proposed by the International Software Testing Qualification Board (ISTQB) and the currently available literature about testing processes for evaluating the accessibility of web applications. The result of the review reflects an array of proposals to incorporate accessibility requirements and evaluation tools, but they do not describe a comprehensive testing process at each phase of the development lifecycle of accessible web applications. [Copyright &y& Elsevier]

An important research area of Spectrum-Based Fault Localization (SBFL) is the effectiveness of risk evaluation formulas. Most previous studies have adopted an empirical approach, which can hardly be considered as sufficiently comprehensive because of the huge number of combinations of various factors in SBFL. Though some studies aimed at overcoming the limitations of the empirical approach, none of them has provided a completely satisfactory solution. Therefore, we provide a theoretical investigation on the effectiveness of risk evaluation formulas. We define two types of relations between formulas, namely, equivalent and better. To identify the relations between formulas, we develop an innovative framework for the theoretical investigation. Our framework is based on the concept that the determinant for the effectiveness of a formula is the number of statements with risk values higher than the risk value of the faulty statement. We group all program statements into three disjoint sets with risk values higher than, equal to, and lower than the risk value of the faulty statement, respectively. For different formulas, the sizes of their sets are compared using the notion of subset. We use this framework to identify the maximal formulas which should be the only formulas to be used in SBFL. [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]

SUMMARY Automation of testing is an essential requirement to render it viable for software development. Although there are several testing techniques and criteria in many different domains, developing methods to test programs with complex outputs remains an unsolved challenge. This setting includes programs with graphical output, which produce images or interface windows. One possible approach towards automating the testing activity is the use of automatic oracles in which a reference image, taken as correct, can be used to establish a correctness measure in the tested program execution. A method that uses concepts of content-based image retrieval to facilitate oracle automation in the domain of programs with graphics output is presented. Two case studies, one using a computer-aided diagnostic system and one using a Web application, are presented, including some reflections and discussions that demonstrate the feasibility of the proposed approach. Copyright © 2011 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

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]