Software need testing and manual testing is likely to ineffective and inefficient. Automated testing is the way forward. However, automated testing techniques tend to consume a lot of computing power and time. They typically have a large state space, which they search systematically to come up with the states of interest. They usually do not take into account the cases in which the partial problem has already been solved by a previous execution. Therefore, they tend to do redundant work and thus consume computing power and time that could have been avoided.

In this dissertation, we propose to use incremental techniques to solve this problem in which we save some information during an execution and reuse it in the next incremental execution. Doing so we avoid redundant work. We apply these techniques in two systematic techniques: bounded exhaustive test case generation and symbolic execution.

For the former, we use state-of-the-art tool Korat to generate structures according the given specification. We extend it to work in incremental fashion. Our implementation enables iterative deepening and translates to breadth-first exploration of the search space.

For the latter, we extend KLEE for symbolic execution to work incrementally for test suite maintenance. We use as much test cases as possible from the previous execution and for the newer version generate test cases only for the newly introduced paths. We also take care of infeasible paths, which may travel through different code versions and be attempted for solution uselessly. We show that it performs better than the naive invocation of KLEE on the newer version of code.