Person:

Harrold, Mary Jean

Permanent Link

https://hdl.handle.net/1853/71329

Associated Organization(s)

Organizational Unit

School of Computer Science

School established in 2007

Full item page

Publication Search Results

Now showing 1 - 10 of 21

Automated Concolic Testing of Smartphone Apps

(Georgia Institute of Technology, 2012) Anand, Saswat ; Naik, Mayur ; Yang, Hongseok ; Harrold, Mary Jean

We present an algorithm and a system for generating input events to exercise smartphone apps. Our approach is based on concolic testing and generates sequences of events automatically and systematically. It alleviates the path-explosion problem by checking a condition on program executions that identifies subsumption between different event sequences. We also describe our implementation of the approach for Android, the most popular smartphone app platform, and the results of an evaluation that demonstrates its effectiveness on five Android apps.
Matching Test Cases for Effective Fault Localization

(Georgia Institute of Technology, 2011) Baah, George K. ; Podgurski, Andy ; Harrold, Mary Jean

Finding the cause of a program’s failure from a causal-analysis perspective requires, for each statement, tests that cover the statement and tests that do not cover the statement. However, in practice the composition of test suites can be detrimental to effective fault localization for two reasons: (1) lack-of-balance, which occurs if the coverage characteristics of tests that cover a statement differ from tests that do not cover the statement, and (2) lack-of-overlap, which occurs if test cases that reach the control-dependence predecessor of a statement cover or do not cover the statement. This paper addresses these two problems. First, the paper presents empirical results that show that, for effective fault localization, the composition of test suites should exhibit balance and overlap. Second, the paper presents new techniques to overcome these problems—matching to address lack-of-balance and causal-effect imputation to overcome lack-of-overlap—and presents empirical evidence that these techniques increase the effectiveness of fault localization.
Probabilistic Slicing for Predictive Impact Analysis

(Georgia Institute of Technology, 2010) Santelices, Raul ; Harrold, Mary Jean

Program slicing is a technique that determines which statements in a program affect or are affected by another statement in that program. Static forward slicing, in particular, can be used for impact analysis by identifying all potential effects of changes in software. This information helps developers design and test their changes. Unfortunately, static slicing is too imprecise—it often produces large sets of potentially affected statements, limiting its usefulness. To reduce the resulting set of statements, other forms of slicing have been proposed, such as dynamic slicing and thin slicing, but they can miss relevant statements. In this paper, we present a new technique, called Probabilistic Slicing (p-slicing), that augments a static forward slice with a relevance score for each statement by exploiting the observation that not all statements have the same probability of being affected by a change. P-slicing can be used, for example, to focus the attention of developers on the “most impacted” parts of the program first. It can also help testers, for example, by estimating the difficulty of “killing” a particular mutant in mutation testing and prioritizing test cases. We also present an empirical study that shows the effectiveness of p-slicing for predictive impact analysis and we discuss potential benefits for other tasks.
Applying Aggressive Propagation-based Strategies for Testing Changes

(Georgia Institute of Technology, 2010) Santelices, Raul ; Harrold, Mary Jean

Test-suite augmentation for evolving software— the process of augmenting a test suite to adequately test software changes—is necessary for any program that undergoes modifications as part of its development and maintenance cycles. Recently, we presented a new technique for test-suite augmentation based on leveraging the propagation conditions for the effects of changes. Although empirical studies show that this technique can be quite effective for testing changes, the experiments have been limited because of the complexity of the implementation. In this paper, we present a new and more efficient approach for propagation-based testing of changes that can reach much longer propagation-distances and can focus the testing more precisely on those behaviors of changes that can actually affect the output. Using an implementation of this new approach, we performed a study on a set of changes on Java programs for which we compared, to a much larger extent, our propagation-based strategy with other existing techniques for testing changes. The results of the study not only confirm the superior effectiveness of propagation-based strategies over these other techniques for testing changes, but also quantify that superiority and clarify the conditions under which our approach is most effective.
Visualization of Exception Handling Constructs to Support Program Understanding

(Georgia Institute of Technology, 2009) Shah, Hina ; Görg, Carsten ; Harrold, Mary Jean

This paper presents a new visualization technique for supporting the understanding of exception-handling constructs in Java programs. To understand the requirements for such a visualization, we surveyed a group of software developers, and used the results of that survey to guide the creation of the visualizations. The technique presents the exception-handling information using three views: the quantitative view, the flow view, and the contextual view. The quantitative view provides a high-level view that shows the throw-catch interactions in the program, along with relative numbers of these interactions, at the package level, the class level, and the method level. The flow view shows the type-throw-catch interactions, illustrating information such as which exception types reach particular throw statements, which catch statements handle particular throw statements, and which throw statements are not caught in the program. The contextual view shows, for particular type-throw-catch interactions, the packages, classes, and methods that contribute to that exception-handling construct. We implemented our technique in an Eclipse plugin called EnHanCe and conducted a usability and utility study with participants in industry.
SPA: Symbolic Program Approximation for Scalable Path-sensitive Analysis

(Georgia Institute of Technology, 2009) Harrold, Mary Jean ; Santelices, Raul

Symbolic execution is a static-analysis technique that has been used for applications such as test-input generation and change analysis. Symbolic execution’s path sensitivity makes scaling it difficult. Despite recent advances that reduce the number of paths to explore, the scalability problem remains. Moreover, there are applications that require the analysis of all paths in a program fragment, which exacerbate the scalability problem. In this paper, we present a new technique, called Symbolic Program Approximation (SPA), that performs an approximation of the symbolic execution of all paths between two program points by abstracting away certain symbolic subterms to make the symbolic analysis practical, at the cost of some precision. We discuss several applications of SPA, including testing of software changes and static invariant discovery. We also present a tool that implements SPA and an empirical evaluation on change analysis and testing that shows the applicability, effectiveness, and potential of our technique.
HDCCSR: software self-awareness using dynamic analysis and Markov models

(Georgia Institute of Technology, 2008-12-20) Harrold, Mary Jean ; Rugaber, Spencer ; Rehg, James M.
Improving the Classification of Software Behaviors using Ensembles

(Georgia Institute of Technology, 2005) Bowring, James Frederick ; Harrold, Mary Jean ; Rehg, James M.

One approach to the automatic classification of program behaviors is to view these behaviors as the collection of all the program's executions. Many features of these executions, such as branch profiles, can be measured, and if these features accurately predict behavior, we can build automatic behavior classifiers from them using statistical machine-learning techniques. Two key problems in the development of useful classifiers are (1) the costs of collecting and modeling data and (2) the adaptation of classifiers to new or unknown behaviors. We address the first problem by concentrating on the properties and costs of individual features and the second problem by using the active-learning paradigm. In this paper, we present our technique for modeling a data-flow feature as a stochastic process exhibiting the Markov property. We introduce the novel concept of databins to summarize, as Markov models, the transitions of values for selected variables. We show by empirical studies that databin-based classifiers are effective. We also describe ensembles of classifiers and how they can leverage their components to improve classification rates. We show by empirical studies that ensembles of control-flow and data-flow based classifiers can be more effective than either component classifier.
Software Behavior: Automatic Classification and its Applications

(Georgia Institute of Technology, 2003) Bowring, James Frederick ; Rehg, James M. ; Harrold, Mary Jean

A program's behavior is ultimately the collection of all its executions. This collection is diverse, unpredictable, and generally unbounded. Thus it is especially suited to statistical analysis and machine learning techniques. We explore the thesis that 1st- and 2nd-order Markov models of event-transitions are effective predictors of program behavior. We present a technique that models program executions as Markov models, and a clustering method for Markov models that aggregates multiple program executions, yielding a statistical description of program behaviors. With this approach, we can train classifiers to recognize specific behaviors emitted by an execution without knowledge of inputs or outcomes. We evaluate an application of active learning to the efficient refinement of our classifiers by conducting three empirical studies that explore a scenario illustrating automated test plan augmentation. We present a set of potential research questions and applications that our work suggests.
Understanding Data Dependences in the Presence of Pointers

(Georgia Institute of Technology, 2003) Orso, Alessandro ; Sinha, Saurabh ; Harrold, Mary Jean

Understanding data dependences in programs is important for many software-engineering activities, such as program understanding, impact analysis, reverse engineering, and debugging. The presence of pointers, arrays, and structures can cause subtle and complex data dependences that can be difficult to understand. For example, in languages such as C, an assignment made through a pointer dereference can assign a value to one of several variables, none of which may appear syntactically in that statement. In the first part of this paper, we describe two techniques for classifying data dependences in the presence of pointer dereferences. The first technique classifies data dependences based on definition type, use type, and path type. The second technique classifies data dependences based on span. We present empirical results to illustrate the distribution of data-dependence types and spans for a set of real C programs. In the second part of the paper, we discuss two applications of the classification techniques. First, we investigate different ways in which the classification can be used to facilitate data-flow testing and verification. We outline an approach that uses types and spans of data dependences to determine the appropriate verification technique for different data dependences; we present empirical results to illustrate the approach. Second, we present a new slicing paradigm that computes slices based on types of data dependences. Based on the new paradigm, we define an incremental slicing technique that computes a slice in multiple steps. We present empirical results to illustrate the sizes of incremental slices and the potential usefulness of incremental slicing for debugging.