Search

Educational CubeSats still remain valuable hands-on practice activity in an academic environment and provide effective and innovative solutions from technical and management points of view. Fast delivery and low cost is the paradigm driving such projects. Contemporary, the simplicity of the solutions has to match with reliability to guarantee the success of the on orbit operations. The present paper shows the entire life cycle of a Sensing Suite System suitable as scientific data collector within a CubeSat, developed in less than four months from the conceptual design to the delivery and reaching the orbit in less than six months. Technical solutions for hardware and software development and test and management good practices are provided. Circuits details to withstand and/or tolerate the space environment and data handling to maximize the number of data and measurements gathered onboard are explained. The use of breadboards and flat-sat arrangements support both the design and verification of the protoflight comprising the schedule and increasing the confidence level on the goodness of the entire solution. The reliability of the design is proven through the entire assembly, integration and verification campaign and validated by the data sent by the satellite during the operative mission. • Fast delivery and low budget educational cubesat payload is presented. • Simple and reliable avionics system for small satellites is provided with details on software and hardware development. • Derails of schedule definition and management with the related lesson learned are shown. [ABSTRACT FROM AUTHOR]

Software reliability growth models (SRGMs) are used to estimate future failure rates and the number of residual defects in software. SRGM helps reliability software engineers make test termination decisions. Although more than 250 traditional SRGMs have been proposed for reliability assessment, research to develop more reliable models is still ongoing. Recently, new methods based on neural networks have been developed to improve the accuracy of software reliability assessment. The article develops a neural network algorithm for assessing software reliability. To do this, factors affecting software reliability and covering its life cycle were assessed. Based on them, sets for training a three-layer neural network were created. [ABSTRACT FROM AUTHOR]

The method of recognizing faults in a software system is acknowledged as software fault prediction. Software faults predicted in prior stages help in the management of resources and time required during software testing and maintenance. The identified software module can be fixed ahead of time, saving time and money near the end of the software development process. Over the years, various supervised machine learning-based techniques for fault prediction have been suggested. These models' accuracy is based on the training datasets. The models are created and trained using a labeled dataset consisting of multiple independent variables like lines of codes, the complexity of the software, the size of the software, etc., and a dependent binary variable, either true or false. But the fault dataset may have some concerns like a class overlapping problem, class imbalance problem, null values, etc. Recent research in software fault prediction focuses on data quality. An imbalanced dataset is one in which one of the class data is present in the majority and another class data is present in the minority. Models built using imbalanced datasets are biased which results in inaccurate predictions. Therefore, balancing the dataset is important. In this paper, the most recent software fault prediction algorithms, which focus on class imbalance issues are discussed. A comparative presentation is presented in this paper, which would benefit the scholar in selecting the best techniques of fault prediction based on different datasets and algorithms. According to the survey, SMOTE is the most commonly used data sampling technique for dealing with data quality issues. [ABSTRACT FROM AUTHOR]

Predicting faults in software aims to detect defects before the testing phase, allowing for better resource allocation and high-quality software development, which is a requisite for any organization. Machine learning techniques aid in the resolution of such issues and a variety of predictive models are being developed to categorize the software into defective modules and the one which is non-defective ones. Though applying these advanced machine learning techniques results in better utilization of time and other resources, there is still poor prediction as reported in many studies. This is because of several challenges that block defective software data, including redundancy, correlation, feature irrelevance, missing samples, and an imbalanced distribution between the faulty and non-faulty classes. Ensemble Machine learning has been adopted by practitioners and researchers globally to deal with such problems, and it is proven to demonstrate some improvement in defect prediction performance. In this review paper, all ensemble-based machine learning techniques developed for software defect prediction from 2018 to 2021 have been critically analyzed. The nucleus of this paper is to get a deep insight into why the various hybrid models still suffer from poor performance on the available datasets. A detailed review with a focus on multiple perspectives viz. faulty and non-defective datasets, performance evaluation criteria, and machine learning techniques have revealed certain gaps that can be addressed by developing more robust hyperparameter optimization algorithms, feature engineering, developing stacking and averaging models. [ABSTRACT FROM AUTHOR]

Software testing plays a critical role in the development and the assurance of the software quality. However, the quality of the code that is responsible for testing may, itself, be affected by poor design choices, known as test smells. In the literature, test smells may be interpreted differently by developers, which in turn can lead to different detection tools and results. In our work, we have selected the mostly commonly used detection tools and have investigated their overall agreement across different projects and different test smells. The found results were evaluated according to the average level of agreement, where we observed a definite disagreement between the tools. To overcome this gap of misinterpretation, we propose in this paper a multi-label classification approach to detect test smells based on a deep representation of the test code. We conducted our experiments using 4 problem-transformation techniques and 4 ensemble techniques. To evaluate our experimental results, we built a benchmark using a tool-based approach for labelling and made it publicly available. Binary Relevance and RAkEL are found to be the best multi-label techniques that achieve high performance results. [ABSTRACT FROM AUTHOR]

Project management has long been a challenge for Information Technology (IT) organizations to learn how to manage projects effectively and efficiently while balancing the iron triangle: cost, time and scope without sacrificing quality. Agile project management (APM) and traditional project management (TPM) are two different approaches related to software development, the core tenet of TPM is that projects are relatively simple, predictable, and linear with well-defined boundaries, whereas APM has emerged as a new methodology for managing high-risk, time-sensitive and scope flexible projects. While it is undeniable that the use of agile project management is increasing, the traditional opposite side continues to exist. The agile approach has an impact on all phases of software development, and they must adapt to this new way of thinking. Software testing is also impacted as a fundamental link in the software development life cycle that ensures quality. Software testing is a vital component of software Quality Assurance (QA) since it serves as the final review of the specification, design, and code. Has software testing evolved along with the evolution of project management? Is there a difference between a traditional and an agile software testing? This paper answers these questions by comparing software testing in the two approaches. [ABSTRACT FROM AUTHOR]

Software test is an important activity in life cycle of software development. If quality of generated test cases is high, number of detected errors before system dissemination would be significant and costs will be decreased. In recent years, different methods have been presented for test cases generation. One of the methods of test cases generation is using UML (unified modeling language) diagrams. Using UML diagrams for test cases generation and applying them in first stages of software development, leads to decrease in costs and efforts. In this paper, first some methods of test cases generation from Communication diagram, Sequence diagram, Activity diagram, State diagram, Class diagram and combination of some diagrams have been explained. Next, Communication diagram, Sequence diagram, Use Case diagram, Activity diagram, State diagram and Class diagram in test cases generation for different part of a system have been compared. Finally, UML diagrams have been applied for case study on depression on internet addiction estimation. • Software test is an important activity in life cycle of software development. • Different methods have been presented for test cases generation. • One of the methods of test cases generation is using UML diagrams. • Case study on depression on internet addiction estimation. [ABSTRACT FROM AUTHOR]

Abstract Models are extensively used in many areas of software engineering to represent the behaviour of software systems at different levels of abstraction. Because of the involvement of different stakeholders in constructing these models and their independent evolution, inconsistencies might occur between the models. It is thus crucial to detect these inconsistencies at early phases of the software development process, and especially as soon as refined models deviate from their abstract counterparts. In this article, we introduce a containment checking approach to verify whether a certain low-level behaviour model, typically created by refining and enhancing a high-level model, still is consistent with the specification provided in its high-level counterpart. We interpret the containment checking problem as a model checking problem, which has not received special treatment in the literature so far. Because the containment checking is based on model checking, it requires both formal consistency constraints and specifications of these models. Unfortunately, creating formal consistency constraints and specifications is currently done manually, and therefore, labour-intensive and error prone. To alleviate this issue, we define and develop a fully automated transformation of behaviour models into formal specifications and properties. The generated formal specifications and properties can directly be used by existing model checkers for detecting any discrepancy between the input models and yield corresponding counterexamples. Moreover, our approach can provide the developers more informative and comprehensive feedback regarding the inconsistency issues, and therefore, help them to efficiently identify and resolve the problems. The evaluation of various scenarios from industrial case studies demonstrates that the proposed approach efficiently translates the behaviour models into formal specifications and properties. Highlights • Containment checking of software behaviour models at different abstraction levels. • Automated transformation of models into LTL formulas and formal SMV descriptions. • Counterexample interpretation for resolving the inconsistencies between models. • Applicability and feasibility of the approach for realistically sized models. • Performance evaluation in a typical developer's working environment. [ABSTRACT FROM AUTHOR]

Highlights • A new atomic class-association rule mining is built for software defect prediction. • Redundant pruning is done using the relation between metrics in feature atomic rules. • The algorithm is used to 15 commonly-available datasets from the MDP and PROMISE repository. • The comparative experiments are performed in other well-known classifiers. Abstract To ensure the rational allocation of software testing resources and reduce costs, software defect prediction has drawn notable attention to many “white-box” and “black-box” classification algorithms. Although there have been lots of studies on using software product metrics to identify defect-prone modules, defect prediction algorithms are still worth exploring. For instance, it is not easy to directly implement the Apriori algorithm to classify defect-prone modules across a skewed dataset. Therefore, we propose a novel supervised approach for software defect prediction based on atomic class-association rule mining (ACAR). It holds the characteristics of only one feature of the antecedent and a unique class label of the consequent, which is a specific kind of association rules that explores the relationship between attributes and categories. It holds the characteristics of only one feature of the antecedent and a unique class label of the consequent, which is a specific kind of association rules that explores the relationship between attributes and categories. Such association patterns can provide meaningful knowledge that can be easily understood by software engineers. A new software defect prediction model infrastructure based on association rules is employed to improve the prediction of defect-prone modules, which is divided into data preprocessing, rule model building and performance evaluation. Moreover, ACAR can achieve a satisfactory classification performance compared with other seven benchmark learners (the extension of classification based on associations (CBA2), Support Vector Machine, Naive Bayesian, Decision Tree, OneR, K-nearest Neighbors and RIPPER) on NASA MDP and PROMISE datasets. In light of software defect associative prediction, a comparative experiment between ACAR and CBA2 is discussed in details. It is demonstrated that ACAR is better than CBA2 in terms of AUC, G-mean, Balance, and understandability. In addition, the average AUC of ACAR is increased by 2.9% compared with CBA2, which can reach 81.1%. [ABSTRACT FROM AUTHOR]

• Testability-driven development (TsDD) approach to developing software is introduced. • TsDD complements TDD with a cycle of predicting and refactoring for testability. • A hybrid machine learning model is proposed for efficient testability evaluation. • The impact of different refactorings on software testability is discussed. • The TsDD practice improves class testability by 77.81 % while reducing testing time. Test-first development (TFD) is a software development approach involving automated tests before writing the actual code. TFD offers many benefits, such as improving code quality, reducing debugging time, and enabling easier refactoring. However, TFD also poses challenges and limitations, requiring more effort and time to write and maintain test cases, especially for large and complex projects. Refactoring for testability is improving the internal structure of source code to make it easier to test. Refactoring for testability can reduce the cost and complexity of software testing and speed up the test-first life cycle. However, measuring testability is a vital step before refactoring for testability, as it provides a baseline for evaluating the current state of the software and identifying the areas that need improvement. This paper proposes a mathematical model for calculating class testability based on test effectiveness and effort and a machine-learning regression model that predicts testability using source code metrics. It also introduces a testability-driven development (TsDD) method that conducts the TFD process toward developing testable code. TsDD focuses on improving testability and reducing testing costs by measuring testability frequently and refactoring to increase testability without running the program. Our testability prediction model has a mean squared error of 0.0311 and an R2 score of 0.6285. We illustrate the usefulness of TsDD by applying it to 50 Java classes from three open-source projects. TsDD achieves an average of 77.81 % improvement in the testability of these classes. Experts' manual evaluation confirms the potential of TsDD in accelerating the TDD process. [ABSTRACT FROM AUTHOR]

[Display omitted] • Quantum computers' noise and errors are exploitable resulting in security breaches. • Current stability and security approaches can provide a quantum security model. • The static analysis would be essential in ensuring security of quantum software. Quantum computing is no longer a promise of the future but a rapidly evolving reality. Advances in quantum hardware are making it possible to make tangible a computational reality that until now was only theoretical. The proof of this is that development languages and platforms are appearing that bring physical principles closer to developers, making it feasible to begin to propose, in different areas of society, solutions to problems that until now were unsolvable. However, security vulnerabilities are also emerging that could hinder the progress of quantum computing, as well as its transition and development in industry. For this reason, this article proposes a review of some of the first artefacts that are emerging in the field of quantum computing. From this analysis, we begin to identify possible security issues that could become potential vulnerabilities in the quantum software of tomorrow. Likewise, and following the experience in classical software development, the testing technique is analysed as a possible candidate for improving security in quantum software development. Following the principles of Quantum Software Engineering, we are aware of the lack of tools, techniques and knowledge necessary to guarantee the development of quantum software in the immediate future. Therefore, this article aims to offer some first clues on what would be a roadmap to guarantee secure quantum software development. [ABSTRACT FROM AUTHOR]

Because executable business processes are an important and critical software asset of organizations because they control and integrate critical information systems. Thus, testing them thoroughly is a very important task within the software development process. However, failures due to implementation defects still occur in production, which in turn means that the development team needs to analyze, fix and repair the failing processes. In order to support the activities of reproducing the problem outside of the production system and to create better test cases for verifying the fixed implementation, we propose to use process mining techniques on the production process event logs to aid the support & development teams. With our approach it is possible to automatically extract a working unit test case with all partner services being mocked that can run in a development environment. Within in this paper we present the extraction algorithm, our implementation, and possible ways to integrate the tool into the support & development process. [ABSTRACT FROM AUTHOR]

Software testing is an important and critical activity in software development that deals with software quality. However, the testing process is consuming activities that need to be automated to save a lot of resources. Towards automated testing, automating test cases generation as the first testing process is being highlighted. This research aims to generate test case automatically from UML diagram since model based testing that conducted on early phase of software development process show higher efficiency. UML diagrams used in this research are activity diagram, sequence diagram and SYTG as the combination graph. These three diagrams have been proved as the most compatible diagram to generate test case from previous research. Method proposed in this paper is Depth First Search algorithm that is modified to generate expected test cases. This paper proves that modified DFS algorithm applied to generate test case is provide accurate result, every node presented on the test case, include any condition (alt and opt). Comparison result from three different test cases generated shows that test cases from combined UML may not necessarily result in better test cases, due to the possibility of redundant test cases for some test cases. This paper also presenting an experiment result that proving sequence diagrams can produce better test cases. [ABSTRACT FROM AUTHOR]

The complexity of software systems have become a barrier for scientific model development and software modernization. In this study, we present a procedure to use compiler-based technologies to better understand complex scientific code. The approach requires no extra software installation and configuration and its software analysis can be transparent to developer and users. We designed a sample code to illustrate the data collection and analysis procedure from compiler technologies and showed a case study that used the information from interprocedure analysis to analyze a scientific function module extracted from an Earth System Model. We believe this study provides a new path to better understand legacy scientific code. [ABSTRACT FROM AUTHOR]

With the rise of agile development notion, software test automation is widely adopted by software organizations to reduce the testing time and costs during the software development process. However, it is essential to carefully implement the test automation to ensure the project's success. In the literature, several studies have indicated that decision-making is crucial for the adoption of test automation. For deciding about test automation adoption, several factors, including the skill level of testers, test tool, and development process, need to be considered since automated testing performance heavily depends on the mentioned factors and their interactions. Thus, it is of vital importance to ascertain the factors that influence test automation in the context of Agile-based Software Development (ASD). To accomplish this, we perform a systematic literature review and a questionnaire-based survey. In total, 21 factors are identified that significantly impact test automation in the ASD context. Additionally, the identified factors are categorized into five main classes. Following the identified factors' assessment, this work proposes a conceptual model that supports agile practitioners in deciding about the adoption of test automation in the context of ASD. Finally, this work validates the proposed model to assess its practical applicability. The validation of the proposed model is accomplished by using an expert-based validation approach. The attained results show that the proposed model supports agile practitioners in estimating the possibility of success when implementing test automation in the ASD context. [ABSTRACT FROM AUTHOR]

With the growing demand for application software, there is a race among industries to develop software as quickly as possible. However, maintaining pace and ensuring bug-free software has become increasingly challenging in a work-from-home arrangement as software developers are not under constant supervision. It increases the possibility of buggy products, and traditional testing techniques fail to provide optimal performance. We propose an Artificial Intelligence (AI) and blockchain-based novel decentralized software testing system. The proposed system aims to detect and prevent vulnerable code by synergizing deep learning capabilities and smart-contract-powered blockchain. The vulnerability detection is performed automatically without relying on manually written rules. We propose a non-vulnerability score range map to classify the source code. Furthermore, we integrate an InterPlanetary File System (IPFS) to ensure efficient storage over the blockchain. We conduct a testbed-based experiment to demonstrate the effectiveness of AI and blockchain integration for secure code development and testing. [Display omitted] • Software testing is one of the vital phases in the software development life cycle. • AI can automate the code testing process for vulnerability detection. • A blockchain-based system ensures transparency and trust in software development. • Integrating AI and Blockchain can enhance the software testing lifecycle. [ABSTRACT FROM AUTHOR]

Testing is a crucial activity in software development. However exhaustive testing of a given software is impossible in practice because projects have serious time and budget limitations. Therefore, software testing teams need guidance about which modules they should focus on. Defect prediction techniques are useful for this situation because they let testers to identify and focus on defect prone parts of software. These techniques are essential for software teams, because they help teams to efficiently allocate their precious resources in testing phase. Software defect prediction has been an active research area in recent years. Researchers in this field have been using different types of metrics in their prediction models. However, value of extracting static code metrics for style sheet languages has been ignored until now. User experience is a very important part of web applications and its mostly provided using Cascading Style Sheets (CSS). In this research, our aim is to improve defect prediction performance for web applications by utilizing metrics generated from CSS code. We generated datasets from four open source web applications to conduct our experiments. Defect prediction is then performed using three different well-known machine learning algorithms. The results revealed that static code metrics based defect prediction techniques can be performed effectively to improve quality of CSS code in web applications. Therefore we recommend utilizing domain-specific characteristics of applications in defect prediction as they result in significantly high prediction performance with low costs. [ABSTRACT FROM AUTHOR]

Defect prediction is commonly used to reduce the effort from the testing phase of software development. A promising strategy is to use machine learning techniques to predict which software components may be defective. Features are key factors to the prediction's success, and thus extracting significant features can improve the model's accuracy. In particular, code smells are a category of those features that have been shown to improve the prediction performance significantly. However, Design code smells, a state-of-the-art collection of code smells based on the violations of the object-oriented programming principles, have not been studied in the context of defect prediction. In this paper, we study the performance of defect prediction models by training multiple classifiers for 97 real projects. We compare using Design code smells as features and using other Traditional smells from the literature and both. Moreover, we cluster and analyze the models' performance based on the categories of Design code smells. We conclude that the models trained with both the Design code smells and the smells from the literature performed the best, with an improvement of 4.1% for the AUC score, compared to models trained with only Traditional smells. Consequently, Design smells are a good addition to the smells commonly studied in the literature for defect prediction. [ABSTRACT FROM AUTHOR]

The software testing practices generate test cases manually, that affects both the effectiveness and efficiency. In aerospace and safety critical domains, software quality assurance is strict to rules and regulations such as DO-178B standard. To resolve these issues, concolic testing generates test suite that can attain high coverage using an automated technique based on Branch Coverage. In this paper, we propose a framework to compute branch coverage percentage for test case generation. To achieve an increase in branch coverage, we transform the input Java program, P , into its transformed version, P t , using JPCT. Then we use JCUTE to generate test cases and find branch coverage percentage. Our experimental studies on branch coverage percentage consists of two steps: the first observation is made without using Java program code transformer, the second observation is made by using Java program code transformer. The Java program code transformer adds additional conditional statements for each decision that causes variation in branch coverage. We quantify this variation in the form of branch coverage percentage. This approach resolves some of the bottleneck issues associated with traditional concolic testers. The experimental studies show that our approach achieves 20.146% of average increase in branch coverage. This increase in branch coverage percentage is achieved in an average computation time of 33837.6 milli seconds. [ABSTRACT FROM AUTHOR]

Software testing is the most significant analytic quality assurance for software products, but it is very expensive and time consuming process. This limitation is overcome by automatic testing to reduce high cost and to increase reliability & efficiency as compared to manual testing. Basis path testing is a coverage criterion of software testing that can detect almost sixty five percent of errors in program under test. In this paper a new fitness function has been proposed named as Extended Level Branch (ExLB) Fitness function for basis path testing using simple genetic algorithm (SGA) and hybrid genetic algorithm (hill climbing with selection operator). Using a triangle classifier as program under test, performance of SGA with Simply Combined Fitness Function, SGA with ExLB Fitness Function and HGA with ExLB Fitness Function have been compared using MATLAB. Experimental results showed that SGA with ExLB Fitness Function (proposed approach) performs better than the SGA with Simply Combined Fitness Function and HGA using ExLB Fitness Function is better than all these approaches in terms of test data generation under basis path coverage criteria. [ABSTRACT FROM AUTHOR]

• Detecting code changes responsible for performance regression is time-consuming. • Dynamic analysis is a credible source in detection performance regression but expensive. • Detecting performance regression problem formulated as optimization problem. • Detection rules generated by using a multi-objective evolutionary algorithm. In contemporary software development, developers commonly conduct regression testing to ensure that code changes do not affect software quality. Conducting performance regression testing after every code change is known to be expensive which emigres the need to direct the performance regression testing efforts on code changes that are most likely introducing performance regression. In this paper, we exploit code change metrics to identify the group introducing the regression based on a pre-trained detection rule. We present PRICE approach as a new formulation of detecting code changes introducing performance regression as an optimization problem using multi-objective evolutionary algorithms. PRICE evaluated using a set of 8000 commits, extracted from the Git project. Results show the effectiveness of our approach in accurately detecting performance regression introducing code changes. The average regression detection PRICE provides is 77% which is 22% more than the state-of-the-art deterministic approach. This improvement didn't compromise the detection of the contradicted code changes that are not introducing a regression. PRICE provides detection of code changes not introducing a regression averaged 63%, which is also an improvement of 14% than the comparative approach. Using PRICE, we were able to explore new search spaces and provide competing results. [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]

The detection and prevention of hazard is the focus of software safety. It helps safety personnel to eliminate hazard and find unknown hazard through the research on the classification of software hazard. The current situation of software hazard and concepts are first introduced in this paper. And then software hazard classification is presented from three aspects which based on the structure, system and process. This paper provides a new good way to solve software safety testing and testing requirements analysis from the angle of reuse and efficiency. [ABSTRACT FROM AUTHOR]

Abstract: Finite State Machines (FSMs) are widely used for verification and testing of many reactive systems and many methods are proposed for generating tests from FSMs with the guaranteed fault coverage. However, some systems can only be properly described when time constraints are considered, advocating the adoption of models with the notion of time. In this paper, a method for deriving conformance tests with the guaranteed fault coverage from a Timed FSM (TFSM) with a single clock is presented. Test derivation is based on a given fault domain that allows the derivation of test suites with reasonable length. More precisely, the fault domain includes every possible faulty TFSM implementation with the known largest time constraints boundaries and minimal duration of time guards. Given a deterministic possibly partial TFSM specification, a complete test suite that guarantees the detection of all faulty implementations with respect to the above fault domain is derived. Experiments with randomly generated timed FSMs are conducted to determine length of obtained test suites and assess the impact of varying the TFSM specification parameters on length of obtained test suites. Further, experiments with both untimed and timed machines are conducted and these experiments show that similar patterns for timed and untimed machines are obtained with respect to varying the number of states, inputs, and outputs of machines. [Copyright &y& Elsevier]

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]

DevOps is an emerging paradigm that refer to a collaborative culture of development and operation teams aiming to develop the high quality software product. Software organizations are adopting DevOps culture for software development and easy maintenance instead of using traditional SDLC mechanism. To enter the production stage, in DevOps process, the software product have to pass through quality gates were the software are tested during development phase to meet the established targeted criteria. This indicates that the mechanism of testing in DevOps process is not straightforward, and to establish strong DevOps testing platform there is a need to explore more automated testing practices. Thus, using multivocal literature review approach, we have selected 39 studies and identify the 20 testing capabilities. Finally, the interpretive structure modeling (ISM) and fuzzy technique for order preference by similarity to ideal solution (fuzzy TOPSIS) were applied. The results shows that (C2, CCi=0.808; C6, CCi=0.720; and C3, CCi=0.705) are top ranked testing capabilities. Using analysis results, we develop a holistic structure of testing capabilities to show their inter-relationship with each other and their priorities to select the best testing capabilities for DevOps process. • Identification of DevOps testing capabilities. • Application of ISM approach to analyze the interaction among the testing capabilities. • Determination of relative importance for each identified testing capability. [ABSTRACT FROM AUTHOR]

Abstract: With a rapid increase in size and complexity of software today, the scope of software testing is also expanding. The efficiency of software testing needs to be improved in order to ensure the appropriate delivery deadline and cost of software development. For improving efficiency of software testing, the test needs to be designed in a way that the number of test cases is sufficient and appropriate in quantity. Test analysis is the activity to refine Application Under Test (AUT) into proper size that test design techniques can be applied to. It is for designing the test properly. However, the classification for proper size depends on individual's own judgments. This paper proposes a test analysis method for the black box testing using a test category that is the classification based on fault and AUT knowledge. [Copyright &y& Elsevier]

Abstract: Software testing is an important but complex part of software development life cycle. The optimization of the software testing process is a major challenge, and the generation of the independent test paths remains unsatisfactory. In this paper, we present an approach based on metaheuristic firefly algorithm to generate optimal test paths. In order to optimize the test case paths, we use a modified firefly algorithm by defining appropriate objective function and introducing guidance matrix in traversing the graph. Our simulations and comparison show that the test paths generated are critical and optimal paths. [Copyright &y& Elsevier]

Abstract: Just as business-IT alignment has received significant focus as a strategic concern in the IS literature, it is also important to consider internal alignment between the diverse subunits within the IT organization. This study investigates alignment between developers and testers in software development to understand alignment within the IT unit. Prior evidence of tension between these sub-groups (and others as well) suggests that all is not necessarily well within the IT organization. Misalignment within the IT unit can certainly make it difficult for the IT unit to add strategic value to the organization. This study is an important initial step in investigating IT subunit alignment which can inform future research focusing on the alignment of other IT subunits such as architecture, operations, and customer-support. Using theoretical concepts from strategic business-IT alignment, we test a research model through a survey of professional software developers and testers. Results suggest that relational but not structural dimensions influence IT subunit alignment. [Copyright &y& Elsevier]

Abstract: While Computational Logic plays an important role in several areas of Computer Science (CS), most educational software developed for teaching logic is not suitable to be used directly in large portions of the CS education domain where the application of logical notions is usually required. In this paper we describe an innovative methodology based on a logic teaching tool on semantic tableaux that has been developed to help students to use logic as a formal proof technique in other advanced topics of CS, such as the verification of algorithms, the algorithmic debugging of programs, and the derivation of algorithms from logical specifications, which are foundations of good development of software. We present the results of the evaluation of this tool by means of several educational experiences during the academic year 2009/2010. From these results we conclude that the use of the tool in current CS teaching can help our students to understand more advanced CS concepts and clarify the formal process involved in the design and analysis of correct and efficient imperative programs. [Copyright &y& Elsevier]

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]

Abstract: Over the past three decades, many software reliability growth models (SRGMs) have been proposed, and they can be used to predict and estimate software reliability. One common assumption of these conventional SRGMs is to assume that detected faults will be removed immediately. In reality, this assumption may not be reasonable and may not always occur. During debugging, developers need time to reproduce the failure, identify the root causes of faults, fix them, and then re-run the software. From some experiments or observations, the fault correction rate may not be a constant and could be changed at certain points as time proceeds. Consequently, in this paper, we will investigate and study how to apply queueing models to describe the fault detection and correction processes during software development. We propose an extended infinite server queueing model with multiple change-points to predict and assess software reliability. Experimental results based on real failure data show that the proposed model can depict the change of fault correction rates and predict the behavior of software development more accurately than traditional SRGMs. [Copyright &y& Elsevier]

Abstract: Component-based development allows one to build software from existing components and promises to improve software reuse and reduce costs. For critical applications, the user of a component must ensure that it fits the requirements of the application. To achieve this, testing is a well-suited means when the source code of the components is not available. Robustness testing is a testing methodology to detect the vulnerabilities of a component under unexpected inputs or in a stressful environment. As components may fail differently in different states, we use a state machine based approach to robustness testing. First, a set of paths is generated to cover transitions of the state machine, and it is used by the test cases to bring the component into a specific control state. Second, method calls with invalid inputs are fed to the component in different states to test the robustness. By traversing the paths, the test cases cover more states and transitions compared to stateless API testing. We apply our approach to several components, including open source software, and compare our results with existing approaches. [Copyright &y& Elsevier]

Diagnostic testing is an oft-recommended use of sensitivity analysis to assess correctness or plausibility of model behavior. In this paper we demonstrate the use of sensitivity analysis as a complementary first-pass software test for the validation of model behavior. Typical testing processes rely on comparing model outputs to results known to be correct. Such approaches are limited to specific model configurations and require that correct results be known in advance. Property-based Sensitivity Analysis (PbSA) examines model properties in terms of the behavior of parameter sensitivities to provide a line of evidence that the expected conceptual relationships between model factors and their effects are present. Unanticipated results can indicate issues to be corrected. The PbSA approach is also scalable as it can complement existing testing practices and be applied in conjunction with global sensitivity methods that can reuse existing model evaluations or are otherwise independent of the sampling scheme. • Property-based testing is a common approach for diagnostic assessment and validation in software development. • Sensitivity analysis is used for similar purposes in model development. • Realities of integrated model development may complicate the use of global sensitivity analyses for diagnostic purposes. • Parameter sensitivities can be treated as a property to test to aid in identifying issues during the model development cycle. • Sensitivity analyses should be leveraged to complement other model testing and validation processes. [ABSTRACT FROM AUTHOR]

Software testing is highly significant during the software development lifecycle for the earlier detection of errors and bugs. Test suite optimization is a selection of the smallest subset of the test cases. This enables quick recovery of the faults in the software product within a minimum time. Selection and prioritization of the test cases are the main approaches to solve the issues in the test case optimization. Various selection and prioritization techniques are developed in the recent days. However, the existing techniques require more cost and time consumption. Also, the increase in the number of objectives reduces the performance of the existing techniques. This paper proposes a multi-objective based test case selection and prioritization for distributed cloud environment. The Resemblance-Based Cluster Head (RBCH) algorithm is proposed to select the Cluster Head (CH) based on the overall similarity between the test cases. The Distance-Based Transposition (DBT) is proposed to prioritize the optimal test case clusters in the distributed environment. This proposed approach efficiently minimizes the time consumption for the testing process by reducing the number of iterations in the test case searching process. From the experimental result, it is observed that the proposed approach achieves higher fault detection rate, prioritization accuracy and lower execution time than the existing prioritization techniques. [ABSTRACT FROM AUTHOR]

With the introduction of the ISO26262 standard in the automotive field, numerous solutions for the in-field and on-line testing have been proposed. Among the several test solutions available, the Built-In Self-Test (BIST) approach is the most used for manufacturing test of chips, while the Software-Based Self-Test (SBST) approach is the most commonly used for on-line test the modern processors. This paper faces a very concrete problem concerning SBST development. In order to address more market demands, semiconductor industries are usually developing families of microcontroller, usually based on similar processors, instead of a single instance. This variety of architectures makes the development of SBST programs a repetitive, time and human consuming activity. The main aim of this work is to propose a methodology according with the SBST paradigm that permits to develop test programs able to achieve high coverage on different microcontrollers of the same family. The developed test programs are not showing any significant drop in coverage performance when they are used on different processors included in product of the same microcontroller family. The approach is based on the analysis of the processor hierarchy to identify the common units between the processors of the same family, first of all looking at those that show design differences. The module classification permits than to plan the most effective SBST development. A segment of industrial microcontrollers developed by STMicroelectronics for the automotive field, adapting many processors belonging to the same processor family, is used as a case of study. The experimental results demonstrate the effectiveness of the proposed approach, i.e., to reach the same fault coverage figures over many processors while dramatically reducing the development time. • Numerous solutions for the in-field and on-line testing have been proposed. • The effects of possible faults may lead to significant damages. • In safety-critical applications a set of very good test practices have been introduced. • A methodology for developing software-based test solutions is proposed. [ABSTRACT FROM AUTHOR]