Search

There currently exists a need for a platform that provides users with the ability to perform extensive, repeatable and meaningful simulation and testing for the hardware and software which compose vehicle/autonomous vehicle systems whilst being broadly accessible, widely supported and provides robust features and development tools. The contemporary implementations of similar systems are either financially exorbitant or highly contained. The system reflected in this paper aims to fill a gap in the industry of vehicle/autonomous vehicle development by extending on currently existing open-source software to provide a highly streamlined platform to support the production of general road vehicle and autonomous vehicle driving systems. The software tools and hardware components chosen for the system will be discussed, followed by the features constructed throughout the development process. The end result of the system is a platform that allows for quick, repeatable, accurate, and nearly endless testing of a digital twin of real life vehicles. This system will allow users to gain valuable simulation and testing data of hardware and software components in a manner which is not always feasible using the traditional methods of autonomous vehicle testing. [ABSTRACT FROM AUTHOR]

Though Deep Neural Networks (DNNs) have been widely deployed and achieved great success in many domains, they have severe safety and reliability concerns. To provide testing evidence for DNNs' reliable behaviors, various coverage testing techniques inspired by traditional software testing have been proposed. However, the coverage criteria in these techniques are either not fine enough to capture subtle behaviors of DNNs, or too time-consuming to be applied on large-scale DNNs. In this paper, we propose a coverage testing framework named HashC, which makes mainstream coverage criteria (e.g., NC and KMNC) much finer. Meanwhile, HashC reduces the time complexity of combinatorial coverage testing from polynomial time to linear time. We also develop the corresponding test sample selection method. Our experiments show that, (1) the existing mainstream coverage criteria are becoming finer after being equipped with HashC, (2) HashC greatly accelerates combinatorial coverage testing and can handle the testing of large-scale DNNs. [ABSTRACT FROM AUTHOR]

During the unit testing of model-driven tools, a large number of models and test classes needs to be managed and maintained. Typically, some of these artifacts are specified manually, some are generated automatically. Existing approaches to test management rely on the available visual and textual modeling notations. As these notations are not tailored to unit testing, distinct maintainability trade-offs arise. In this paper, we propose a notation that aims to combine the benefits of visual and text-based approaches. The notation is at the same time visual and text-based, as it uses ASCII characters to emulate the familiar graphical notations. In our evaluation based on real models, we identify problematic model shapes challenging the scalability our notation, while finding that it is well-suited to capture typical test models. [ABSTRACT FROM AUTHOR]

Software testing enables development teams to maintain the quality of a software system while it evolves. The database manipulation code requires special attention in this context. However, it is often neglected and suffers from software maintenance problems. In this paper, we study the current state-of-the-practice in testing database manipulation code. We first analysed the tests of 72 open-source projects to gain insight into the coverage of database access code. The database was poorly tested: 46% of the projects did not cover with tests half of their database access methods, and 33% did not cover the database code at all. This poor coverage motivated us to study developers' challenges and best practices. (i) First, we analysed 532 questions on Stack Exchange sites and deduced a taxonomy of issues. Developers mostly looked for general best practices to test database access code. Their technical questions were related to database management, mocking, parallelisation, or framework/tool usage. (ii) Next, we examined the answers to these questions. We manually labelled 598 answers to 255 questions. We distinguished 363 solutions and organised them in a taxonomy of best practices. Most of the suggestions considered the testing environment and recommended various tools or configurations. The second largest category was database management, where many addressed database initialisation and clean-up between tests. Other categories pertained to code structure or design, concepts, performance, processes, test characteristics, test code, and mocking. We illustrate the two taxonomies through intriguing examples. • A study on the coverage of database access code in the tests of open-source projects. • A qualitative assessment of developers' issues when testing database access code. • An investigation of developers' best practices when testing database access code. • Taxonomies of issues and best practices when testing database access code. • The full dataset of the studies is publicly available as an online appendix. [ABSTRACT FROM AUTHOR]

Software testing is an important step in the life cycle of agile development; it represents an efficient way to ensure the good functioning of the product. But as the complexity of a system increases, the effort and expertise to test it also increases. To significantly reduce these efforts, and reduce the cost and time; several studies have been carried out and various tools and test automation techniques have been proposed. In this paper, we present an approach to automatic generation of test cases from UML 2 Models at the Scrum agile process. This approach automates two important steps: the transformation of design models into test models and generating test cases, based on an open source MDA framework. [ABSTRACT FROM AUTHOR]

We show how to write concise and readable specifications of linked data structures that are applicable for both formal deductive verification and testing. A singly linked list and a binary search tree are provided as examples. The main characteristic of the specifications is the use of observer methods, in particular to express reachability of elements in a data structure. The specifications are written in the Java Modeling Language (JML) and do not require extensions of that language. This paper addresses a mixed audience of users and developers in the fields of formal verification, testing, and specification language design. We provide an in-depth description of the proposed specifications and analyze the implications both for verification and testing. Based on this analysis we have developed verification techniques that are implemented in the deductive verification tool KeY and enable fully automatic verification of the linked list example. This techniques are also described in this paper. [ABSTRACT FROM AUTHOR]

Test case prioritization is the process of ordering the test cases to be conducted eventually. Prioritizing test cases aids to meet two important constraints namely time and budget in software testing in order to enhance the fault detection rate as early as possible. This results us finding the problem earlier due to improved fault detection rate at early stage and deliver the system at short period of time .Interactions and relationships between a systems or sub system of an user is called as dependency. Few techniques that have been used in the past are namely Random order, greedy technique as well as fine grained and coarse grained. But all these techniques have considered the test cases in a test suite as an independent way. Few techniques have been derived dependency structures among test cases manually. Hence, this paper focuses to provide a set of algorithms to derive dependency structures among functions in a system and find exact number of dependents of each function in a system to prioritize the test cases in automated manner. High priority is assigned to test cases that are more dependent in using graph coverage values. By executing high priority (more complex) test cases earlier, the rate of fault detection will be improved at earlier stage and help to fix the fault earlier. For this experimentation purposes, Siemens test suite has been taken to establish the truth of verifying the given proposed technique. [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]

Abstract: Extenics is a new discipline for modeling contradiction problems with formalized methods and transformation. This paper for the first time combines software testing with Extenices and proposes an automatic approach to generating test cases from UML activity diagrams based on Extension Theory (Extenics). In order to find more defects in software system by minimized test cases, we design algorithm to construct the Euler circuit and generates test sequences automatically by Euler circuit algorithm. Our preliminary result shows that test cases generated not only satisfy the specified test coverage criteria but also the number of test cases is decreased. [Copyright &y& Elsevier]

Abstract: When computational methods are developed, the efficiency of the novel methods should be compared to the existing ones. This can be done using, e.g., analytical methods and benchmark test patterns. In addition, the comparison of the best and the worst case performance is commonly of interest. In this paper, methodologies of genetic algorithm based software testing are adopted to the comparative computational testing of three varieties of dynamic two-dimensional nearest point algorithms. The extreme performances of the algorithms are searched for by optimizing the shape of two-dimensional Gaussian distributions, from which the test patterns are drawn. In particular, an approach to pairwise comparisons of computational complexities of algorithms is proposed. The test case algorithms can be sorted with respect to their computational complexity by the proposed method. [Copyright &y& Elsevier]

Abstract: The paper shows experiences with using Extreme Programming (XP) for specific projects. XP practices Test-Driven Development, pair programming, short interaction, a team code ownership and acceptance tests. Author writes about possibilities of information technologies when improving communicative skills of children with specific disorders, such as autistic spectrum disorders, Down syndrome, mental retardation, etc. The development of an application stemming from the communication system PECS (The Picture Exchange Communication System) and its Czech variant VOKS is the base of this paper to show specificity of the development and verification of software for the given group of handicapped users. The paper shows suitability of using agile methods of software development for a concrete application which is designed for users with specific disorders. It tries to show advantages and disadvantages of new methodologies, particularly Extreme Programming. This agile method prefers fast reaction to a change before the plan completion, which proved to be important in the case of the developed software. There were plenty of changes and new requirements during the development, and their solution was more important for the output quality than following the time schedule of the development. [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]