MODEL PARTITIONS AND COMPACT TEST CASE SUITES

We present a generalized test case generation method, called the G method. Although inspired by the W method, the G method, in contrast, allows for test case suite generation even in the absence of characterization sets for the specification models. Instead, the G method relies on knowledge about the index of certain equivalences induced at the implementation models. We show that the W method can be derived from the G method as a particular case. Moreover, we discuss some naturally occurring infinite classes of FSM models over which the G method generates test suites that are exponentially more compact than those produced by the W method.

A Systematic Approach to Synthesis of Verification Test-suites for Modular SoC Designs

Verification is one of the important stages in designing an SoC (system on chips) that consumes upto 70% of the design time. In this work, we present a methodology to automatically generate verification test-cases to verify a class of SoCs and also enable re-use of verification resources created from one SoC to another. A prototype implementation for generating the test-cases is also presented.

a backtracking search tool for constructing combinatorial test suites

Combinatorial testing is an important testing method. It requires the test cases to cover various combinations of parameters of the system under test. The test generation problem for combinatorial testing can be modeled as constructing a matrix which has certain properties. This paper first discusses two combinatorial testing criteria: covering array and orthogonal array, and then proposes a backtracking search algorithm to construct matrices satisfying them. Several search heuristics and symmetry breaking techniques are used to reduce the search time. This paper also introduces some techniques to generate large covering array instances from smaller ones. All the techniques have been implemented in a tool called EXACT (EXhaustive seArch of Combinatorial Test suites). A new optimal covering array is found by this tool.

Instance generators and test suites for the multiobjective quadratic assignment problem

We describe, and make publicly available, two problem instance generators for a multiobjective version of the well-known quadratic assignment problem (QAP). The generators allow a number of instance parameters to be set, including those controlling epistasis and inter-objective correlations. Based on these generators, several initial test suites are provided and described. For each test instance we measure some global properties and, for the smallest ones, make some initial observations of the Pareto optimal sets/fronts. Our purpose in providing these tools is to facilitate the ongoing study of problem structure in multiobjective (combinatorial) optimization, and its effects on search landscape and algorithm performance.

Generating Effective Test Suites for Model Transformations Using Classifying Terms

Generating sample models for testing a model transformation is no easy task. This paper explores the use of classifying terms and stratified sampling for developing richer test cases for model transformations. Classifying terms are used to define the equivalence classes that characterize the relevant subgroups for the test cases. From each equivalence class of object models, several representative models are chosen depending on the required sample size. We compare our results with test suites developed using random sampling, and conclude that by using an ordered and stratified approach the coverage and effectiveness of the test suite can be significantly improved.

Fault Coverage-Driven Incremental Test Generation

In this paper, we consider a classical problem of complete test generation for deterministic finite-state machines (FSMs) in a more general setting. The first generalization is that the number of states in implementation FSMs can even be smaller than that of the specification FSM. Previous work deals only with the case when the implementation FSMs are allowed to have the same number of states as the specification FSM. This generalization provides more options to the test designer: when traditional methods trigger a test explosion for large specification machines, tests with a lower, but yet guaranteed, fault coverage can still be generated. The second generalization is that tests can be generated starting with a user-defined test suite, by incrementally extending it until the desired fault coverage is achieved. Solving the generalized test derivation problem, we formulate sufficient conditions for test suite completeness weaker than the existing ones and use them to elaborate an algorithm that can be used both for extending user-defined test suites to achieve the desired fault coverage and for test generation. We present the experimental results that indicate that the proposed algorithm allows obtaining a trade-off between the length and fault coverage of test suites.

Directed Test Suite Augmentation

As software evolves, engineers use regression testing to evaluate its fitness for release. Such testing typically begins with existing test cases, and many techniques have been proposed for reusing these cost-effectively. After reusing test cases, however, it is also important to consider code or behavior that has not been exercised by existing test cases and generate new test cases to validate these. This process is known as test suite augmentation. In this paper we present a directed test suite augmentation technique, that utilizes results from reuse of existing test cases together with an incremental concolic testing algorithm to augment test suites so that they are coverage-adequate for a modified program. We present results of an empirical study examining the effectiveness of our approach.

A Controlled Experiment Assessing Test Case Prioritization Techniques via Mutation Faults

Regression testing is an important part of software maintenance, but it can also be very expensive. To reduce this expense, software testers may prioritize their test cases so that those that are more important are run earlier in the regression testing process. Previous work has shown that prioritization can improve a test suite’s rate of fault detection, but the assessment of prioritization techniques has been limited to hand-seeded faults, primarily due to the belief that such faults are more realistic than automatically generated (mutation) faults. A recent empirical study, however, suggests that mutation faults can be representative of real faults. We have therefore designed and performed a controlled experiment to assess the ability of prioritization techniques to improve the rate of fault detection techniques, measured relative to mutation faults. Our results show that prioritization can be effective relative to the faults considered, and they expose ways in which that effectiveness can vary with characteristics of faults and test suites. We also compare our results to those collected earlier with respect to the relationship between hand-seeded faults and mutation faults, and the implications this has for researchers performing empirical studies of prioritization.

A Binary Classifier for Test Case Feasibility Applied to Automatically Generated Tests of Event-Driven Software

Modern software application testing, such as the testing of software driven by graphical user interfaces (GUIs) or leveraging event-driven architectures in general, requires paying careful attention to context. Model-based testing (MBT) approaches first acquire a model of an application, then use the model to construct test cases covering relevant contexts. A major shortcoming of state-of-the-art automated model-based testing is that many test cases proposed by the model are not actually executable. These \textit{infeasible} test cases threaten the integrity of the entire model-based suite, and any coverage of contexts the suite aims to provide. In this research, I develop and evaluate a novel approach for classifying the feasibility of test cases. I identify a set of pertinent features for the classifier, and develop novel methods for extracting these features from the outputs of MBT tools. I use a supervised logistic regression approach to obtain a model of test case feasibility from a randomly selected training suite of test cases. I evaluate this approach with a set of experiments. The outcomes of this investigation are as follows: I confirm that infeasibility is prevalent in MBT, even for test suites designed to cover a relatively small number of unique contexts. I confirm that the frequency of infeasibility varies widely across applications. I develop and train a binary classifier for feasibility with average overall error, false positive, and false negative rates under 5\%. I find that unique event IDs are key features of the feasibility classifier, while model-specific event types are not. I construct three types of features from the event IDs associated with test cases, and evaluate the relative effectiveness of each within the classifier. To support this study, I also develop a number of tools and infrastructure components for scalable execution of automated jobs, which use state-of-the-art container and continuous integration technologies to enable parallel test execution and the persistence of all experimental artifacts.

Synthesizing Racy Tests

Subtle concurrency errors in multithreaded libraries that arise because of incorrect or inadequate synchronization are often difficult to pinpoint precisely using only static techniques. On the other hand, the effectiveness of dynamic race detectors is critically dependent on multithreaded test suites whose execution can be used to identify and trigger races. Usually, such multithreaded tests need to invoke a specific combination of methods with objects involved in the invocations being shared appropriately to expose a race. Without a priori knowledge of the race, construction of such tests can be challenging. In this paper, we present a lightweight and scalable technique for synthesizing precisely these kinds of tests. Given a multithreaded library and a sequential test suite, we describe a fully automated analysis that examines sequential execution traces, and produces as its output a concurrent client program that drives shared objects via library method calls to states conducive for triggering a race. Experimental results on a variety of well-tested Java libraries yield 101 synthesized multithreaded tests in less than four minutes. Analyzing the execution of these tests using an off-the-shelf race detector reveals 187 harmful races, including several previously unreported ones.

Generating Circuit Tests by Exploiting Designed Behavior

This thesis describes two programs for generating tests for digital circuits that exploit several kinds of expert knowledge not used by previous approaches. First, many test generation problems can be solved efficiently using operation relations, a novel representation of circuit behavior that connects internal component operations with directly executable circuit operations. Operation relations can be computed efficiently by searching traces of simulated circuit behavior. Second, experts write test programs rather than test vectors because programs are more readable and compact. Test programs can be constructed automatically by merging program fragments using expert-supplied goal-refinement rules and domain-independent planning techniques.

Checking Completeness of Tests for Finite State Machines

In testing from a Finite State Machine (FSM), the generation of test suites which guarantee full fault detection, known as complete test suites, has been a long-standing research topic. In this paper, we present conditions that are sufficient for a test suite to be complete. We demonstrate that the existing conditions are special cases of the proposed ones. An algorithm that checks whether a given test suite is complete is given. The experimental results show that the algorithm can be used for relatively large FSMs and test suites.

Alterações de propriedades físicas e químicas e das frações húmicas de um nitossolo vermelho na sucessão milheto-soja em semeadura direta

Coordenação de Aperfeiçoamento de Pessoal de Nível Superior (CAPES)

Stable isotope and Mg/Ca record of Globigerinoides ruger morphotypes

Tests of the planktonic foraminifer Globigerinoides ruber (white; d'Orbigny) have become a standard tool for reconstructing past oceanic environments. Paleoceanographers often utilize the Mg/Ca ratios of the foraminiferal tests for reconstructing low-latitude ocean glacial-interglacial changes in sea surface temperatures (SST). We report herein a comparison of Mg/Ca measurements on sample pairs (n = 20) of two G. ruber (white) morphotypes (G. ruber sensu stricto (s.s.) and G. ruber sensu lato (s.l.)) from surface and downcore samples of the western Pacific and Indian Oceans. G. ruber s.s. refers to specimens with spherical chambers sitting symmetrically over previous sutures with a wide, high arched aperture, whereas G. ruber s.l. refers to a more compact test with a diminutive final chamber and small aperture. The G. ruber s.s. specimens generally show significantly higher Mg/Ca ratios compared to G. ruber s.l. Our results from the Mg/Ca ratio analysis suggest that G. ruber s.l. specimens precipitated their shells in slightly colder surface waters than G. ruber s.s. specimens. This conclusion is supported by the differences in delta18O and delta13C values between the two morphotypes. Although it is still unclear if these two morphotypes represent phenotypic variants or sibling species, our findings seem to support the hypothesis of depth and/or seasonal allopatry within a single morphospecies.

Implantación de técnicas de QA en un proyecto de desarrollo software

Hoy en día existe una preocupación creciente por la calidad del software entregado en los proyectos que se realizan a lo largo del mundo. El trabajo de fin de grado que va a ser desarrollado en estas páginas pretende demostrar la importancia de la realización de tests funcionales durante el proceso de desarrollo de software para que el proyecto alcance la calidad requerida tan demandada en estos días. Para ello, después de una pequeña introducción a la historia del software, se presentarán y compararán diversos tipos de metodologías de desarrollo de software, tanto pesadas (cascada, espiral, etc.) como ágiles (Extreme Programming y Scrum), se enfatizará en dichas metodologías ágiles y cómo el proceso de testing y control de calidad encaja perfectamente con la filosofía de las citadas metodologías ágiles. Se desarrollará una explicación del papel de QA en el desarrollo de software, asi como una explicación de los tipos de test existentes, y las herramientas, tecnologías y patrones que existen a disposición de aquellos que quieran desempeñar el papel de QA. Para complementar el punto de vista teórico de este trabajo se presentará un caso práctico real realizado en la empresa bq bajo una metodología Scrum. Dicho caso práctico muestra el uso de ciertas herramientas y su aporte para el control de calidad del proyecto bajo desarrollo, demostrando su importancia. Se realizará énfasis en el proceso de automatización de ciertas baterías de test (llamadas test suites), mostrando desde el planteamiento inicial de las diferentes historias de usuario y la batería de test, pasando por la elección de las tecnologías más adecuadas para la elaboración de los test hasta llegar al lanzamiento de dicha batería de pruebas y la comprobación de éstas. El punto de vista práctico quedará complementado por una explicación del framework nightwatch.js, framework utilizado en el desarrollo del proyecto en bq para la automatización de test funcionales. Esta explicación comprenderá tanto la configuración y uso del framework como el uso de patrones y la estructura de las pruebas. ABSTRACT Nowadays there is a growing concern about the Quality of the software delivered in the projects that are made all around the world. This final project will try to prove the importance of performing functional tests during the Software Development Process in order to be able to reach the demanded Quality. To fulfill this objective, different types of Software Development methodologies will be presented and compared. Heavy methodologies (waterfall, spiral methodologies, etc.) as well as agile methodologies (Extreme Programming and Scrum). There will be an emphasis in the second kind (agile methodologies) and how the testing and quality assurance process fits perfectly in their philosophy. A deep explanation of the role that Quality Assurance holds on software development will be presented, as well as an explanation on the current types of testing and an explanation of the different tools; technologies and patrons that exist to help anyone who wants to perform the role of QA. To complement the theoretical perspective of this work a real case study, performed at the company bq under a Scrum methodology, will be presented. The mentioned study covers the use of certain tools and their input for the quality assurance of the project under development, proving its relevance. Emphasis will be made in the process of conducting a set of tests (called test suite), showing from the initial approach of the different users stories and the set of tests, going through the choosing of the most suitable technologies for the tests development, and ending with the performance of this battery of tests and their checkout. The practical point of view will be complemented by a deep explanation of the creation process using the nightwatch.js automated test framework, used in the project in bq. This explanation will cover both the configuration and use of the framework as the use of patterns and structure of the tests.