Com a necessidade cada vez maior de agilizar a entrega de novos desenvolvimentos ao cliente e de diminuir o tempo de desenvolvimento das aplicações, a priorização de casos de teste possibilita a detecção das falhas presentes na aplicação mais rapidamente por meio da ordenação dos casos de teste a serem executados. E, com isso, possibilita também que a correção destas falhas inicie o mais brevemente possível. Entretanto, quando os casos de teste a serem priorizados são testes automatizados de sistema, critérios tradicionais utilizados na literatura como cobertura de código ou modelos do sistema deixam de ser interessantes, dada a característica inerente deste tipo de teste na qual a organização e a modelagem adotadas são ignoradas por se tratarem de testes de caixa preta. Considerando a hipótese de que casos de teste automatizados grandes testam mais partes da aplicação e que casos de teste similares podem estar testando a mesma área da aplicação, parece válido crer que a execução dos casos de teste de sistema priorizando os testes mais complexos pode alcançar resultados positivos quando comparada à execução não ordenada dos casos de teste. É neste cenário que este trabalho propõe o uso dos grafos de chamadas dos próprios casos de teste como critério para priorização destes, priorizando assim a execução dos casos de teste com a maior quantidade de nós no seu grafo. A abordagem proposta neste trabalho mostrou, por meio de dois estudos de caso, ser capaz de melhorar a taxa de detecção de falhas em relação à execução não ordenada dos casos de teste. Além disso, a abordagem proposta obteve resultados semelhantes as abordagens tradicionais de priorização utilizando cobertura de código da aplicação. / With the increasing need to streamline the delivery of new developments to the customer and reduce application development time, test case prioritization allows a quicker detection of faults present in the application through the ordering of test cases to be executed. Besides that, a quicker detection enables also the correction of these faults to start as soon as possible. However, when the test cases to be prioritized are automated system tests, traditional criteria used in the literature like code coverage or system models become uninteresting, given that this type of test case, classified as black box test, ignores how the application was coded or modeled. Considering the hypothesis that bigger automated test cases verify more parts of the application and that similar test cases may be testing the same application areas, it seems valid to believe that giving a higher priority to more complex test cases to be executed first can accomplish positive results when compared to the unordered execution of test cases. It is on this scenario that this project studies the usage of call graphs from test cases as the criterion to prioritize them, increasing the priority of the execution of test cases with the higher number of nodes on the graph. The approach proposed in this document showed through two case studies that it is capable of improving fault detection rate compared to unordered test cases. Furthermore, the proposed approach achieved similar results when compared to a traditional prioritization approach using code coverage of the application.

Indiana University-Purdue University Indianapolis (IUPUI) / Evolutionary testing (ET) techniques (e.g., mutation, crossover, and natural selection) have been applied successfully to many areas of software engineering, such as error/fault identification, data mining, and software cost estimation. Previous research has also applied ET techniques to performance testing. Its application to performance testing, however, only goes as far as finding the best and worst case, execution times. Although such performance testing is beneficial, it provides little insight into performance characteristics of complex functions with multiple branches. This thesis therefore provides two contributions towards performance testing of software systems. First, this thesis demonstrates how ET and genetic algorithms (GAs), which are search heuristic mechanisms for solving optimization problems using mutation, crossover, and natural selection, can be combined with a constraint solver to target specific paths in the software. Secondly, this thesis demonstrates how such an approach can identify local minima and maxima execution times, which can provide a more detailed characterization of software performance. The results from applying our approach to example software applications show that it is able to characterize different execution paths in relatively short amounts of time. This thesis also examines a modified exhaustive approach which can be plugged in when the constraint solver cannot properly provide the information needed to target specific paths.

Indiana University-Purdue University Indianapolis (IUPUI) / Current mainstream computing systems have become increasingly complex. Most of which have Central Processing Units (CPUs) that invoke multiple threads for their computing tasks. The growing issue with these systems is resource contention and with resource contention comes the risk of encountering a deadlock status in the system. Various software and hardware approaches exist that implement deadlock detection/avoidance techniques; however, they lack either the speed or problem size capability needed for real-time systems. The research conducted for this thesis aims to resolve issues present in past approaches by converging the two platforms (software and hardware) by means of the Graphics Processing Unit (GPU). Presented in this thesis are two GPU-based deadlock detection algorithms and one GPU-based deadlock avoidance algorithm. These GPU-based algorithms are: (i) GPU-OSDDA: A GPU-based Single Unit Resource Deadlock Detection Algorithm, (ii) GPU-LMDDA: A GPU-based Multi-Unit Resource Deadlock Detection Algorithm, and (iii) GPU-PBA: A GPU-based Deadlock Avoidance Algorithm. Both GPU-OSDDA and GPU-LMDDA utilize the Resource Allocation Graph (RAG) to represent resource allocation status in the system. However, the RAG is represented using integer-length bit-vectors. The advantages brought forth by this approach are plenty: (i) less memory required for algorithm matrices, (ii) 32 computations performed per instruction (in most cases), and (iii) allows our algorithms to handle large numbers of processes and resources. The deadlock detection algorithms also require minimal interaction with the CPU by implementing matrix storage and algorithm computations on the GPU, thus providing an interactive service type of behavior. As a result of this approach, both algorithms were able to achieve speedups over two orders of magnitude higher than their serial CPU implementations (3.17-317.42x for GPU-OSDDA and 37.17-812.50x for GPU-LMDDA). Lastly, GPU-PBA is the first parallel deadlock avoidance algorithm implemented on the GPU. While it does not achieve two orders of magnitude speedup over its CPU implementation, it does provide a platform for future deadlock avoidance research for the GPU.