@article {15470,
	title = {Developing a Single Model and Test Prioritization Strategies for Event-Driven Software},
	journal = {Software Engineering, IEEE Transactions on},
	volume = {37},
	year = {2011},
	month = {2011///},
	pages = {48 - 64},
	abstract = {Event-Driven Software (EDS) can change state based on incoming events; common examples are GUI and Web applications. These EDSs pose a challenge to testing because there are a large number of possible event sequences that users can invoke through a user interface. While valuable contributions have been made for testing these two subclasses of EDS, such efforts have been disjoint. This work provides the first single model that is generic enough to study GUI and Web applications together. In this paper, we use the model to define generic prioritization criteria that are applicable to both GUI and Web applications. Our ultimate goal is to evolve the model and use it to develop a unified theory of how all EDS should be tested. An empirical study reveals that the GUI and Web-based applications, when recast using the new model, show similar behavior. For example, a criterion that gives priority to all pairs of event interactions did well for GUI and Web applications; another criterion that gives priority to the smallest number of parameter value settings did poorly for both. These results reinforce our belief that these two subclasses of applications should be modeled and studied together.},
	keywords = {EDS, event-driven software, graphical user interface, Graphical user interfaces, GUI testing, Internet, program testing, service-oriented architecture, test prioritization strategy, Web application testing},
	isbn = {0098-5589},
	doi = {10.1109/TSE.2010.12},
	author = {Bryce,R.C. and Sampath,S. and Memon, Atif M.}
}
@article {15477,
	title = {GUI Interaction Testing: Incorporating Event Context},
	journal = {Software Engineering, IEEE Transactions on},
	volume = {37},
	year = {2011},
	month = {2011/08//july},
	pages = {559 - 574},
	abstract = {Graphical user interfaces (GUIs), due to their event-driven nature, present an enormous and potentially unbounded way for users to interact with software. During testing, it is important to $\#$x201C;adequately cover $\#$x201D; this interaction space. In this paper, we develop a new family of coverage criteria for GUI testing grounded in combinatorial interaction testing. The key motivation of using combinatorial techniques is that they enable us to incorporate $\#$x201C;context $\#$x201D; into the criteria in terms of event combinations, sequence length, and by including all possible positions for each event. Our new criteria range in both efficiency (measured by the size of the test suite) and effectiveness (the ability of the test suites to detect faults). In a case study on eight applications, we automatically generate test cases and systematically explore the impact of context, as captured by our new criteria. Our study shows that by increasing the event combinations tested and by controlling the relative positions of events defined by the new criteria, we can detect a large number of faults that were undetectable by earlier techniques.},
	keywords = {automatic test case generation, automatic test pattern generation, combinatorial interaction testing, event driven nature, graphical user interface, Graphical user interfaces, GUI interaction testing, program testing},
	isbn = {0098-5589},
	doi = {10.1109/TSE.2010.50},
	author = {Xun Yuan and Cohen,M. B and Memon, Atif M.}
}
@conference {16055,
	title = {ManyNets: an interface for multiple network analysis and visualization},
	booktitle = {Proceedings of the 28th international conference on Human factors in computing systems},
	series = {CHI {\textquoteright}10},
	year = {2010},
	month = {2010///},
	pages = {213 - 222},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Traditional network analysis tools support analysts in studying a single network. ManyNets offers these analysts a powerful new approach that enables them to work on multiple networks simultaneously. Several thousand networks can be presented as rows in a tabular visualization, and then inspected, sorted and filtered according to their attributes. The networks to be displayed can be obtained by subdivision of larger networks. Examples of meaningful subdivisions used by analysts include ego networks, community extraction, and time-based slices. Cell visualizations and interactive column overviews allow analysts to assess the distribution of attributes within particular sets of networks. Details, such as traditional node-link diagrams, are available on demand. We describe a case study analyzing a social network geared towards film recommendations by means of decomposition. A small usability study provides feedback on the use of the interface on a set of tasks issued from the case study.},
	keywords = {exploratory analysis, graphical user interface, Information Visualization, interaction, network analysis, table interface},
	isbn = {978-1-60558-929-9},
	doi = {10.1145/1753326.1753358},
	url = {http://doi.acm.org/10.1145/1753326.1753358},
	author = {Freire,Manuel and Plaisant, Catherine and Shneiderman, Ben and Golbeck,Jen}
}
@conference {15493,
	title = {Repairing GUI Test Suites Using a Genetic Algorithm},
	booktitle = {Software Testing, Verification and Validation (ICST), 2010 Third International Conference on},
	year = {2010},
	month = {2010/04//},
	pages = {245 - 254},
	abstract = {Recent advances in automated functional testing of Graphical User Interfaces (GUIs) rely on deriving graph models that approximate all possible sequences of events that may be executed on the GUI, and then use the graphs to generate test cases (event sequences) that achieve a specified coverage goal. However, because these models are only approximations of the actual event flows, the generated test cases may suffer from problems of infeasibility, i.e., some events may not be available for execution causing the test case to terminate prematurely. In this paper we develop a method to automatically repair GUI test suites, generating new test cases that are feasible. We use a genetic algorithm to evolve new test cases that increase our test suite{\textquoteright}s coverage while avoiding infeasible sequences. We experiment with this algorithm on a set of synthetic programs containing different types of constraints and for test sequences of varying lengths. Our results suggest that we can generate new test cases to cover most of the feasible coverage and that the genetic algorithm outperforms a random algorithm trying to achieve the same goal in almost all cases.},
	keywords = {automated functional testing, genetic algorithm, Genetic algorithms, graph model, graphical user interface, Graphical user interfaces, GUI test suite, program testing, random algorithm, synthetic program, test case},
	doi = {10.1109/ICST.2010.39},
	author = {Huang,Si and Cohen,M. B and Memon, Atif M.}
}
@conference {19285,
	title = {Scalable representation of dataflow graph structures using topological patterns},
	booktitle = {2010 IEEE Workshop on Signal Processing Systems (SIPS)},
	year = {2010},
	month = {2010},
	pages = {13 - 18},
	abstract = {Tools for designing signal processing systems with their semantic foundation in dataflow modeling often use high-level graphical user interface (GUI) or text based languages that allow specifying applications as directed graphs. Such graphical representations serve as an initial reference point for further analysis and optimizations that lead to platform-specific implementations. For large-scale applications, the underlying graphs often consist of smaller substructures that repeat multiple times. To enable more concise representation and direct analysis of such substructures in the context of high level DSP specification languages and design tools, we develop the modeling concept of topological patterns, and propose ways for supporting this concept in a high-level language. We augment the DIF language - a language for specifying DSP-oriented dataflow graphs - with constructs for supporting topological patterns, and we show how topological patterns can be effective in various aspects of embedded signal processing design flows using specific application examples.},
	keywords = {arrays, data flow graphs, Dataflow graphs, DIF language, Digital signal processing, directed graphs, DSP specification languages, embedded signal processing design flows, embedded systems, Field programmable gate arrays, graphical user interface, Graphical user interfaces, High-level languages, modelbased design, optimisation, optimizations, scalable dataflow graph structures representation, semantics, Signal processing, Signal processing systems, Specification languages, text based languages, Topological patterns, Topology, Transform coding},
	author = {Sane, N. and Kee, Hojin and Seetharaman, G. and Bhattacharyya, Shuvra S.}
}
@conference {15494,
	title = {An Extensible Heuristic-Based Framework for GUI Test Case Maintenance},
	booktitle = {Software Testing, Verification and Validation Workshops, 2009. ICSTW {\textquoteright}09. International Conference on},
	year = {2009},
	month = {2009/04//},
	pages = {251 - 254},
	abstract = {Graphical user interfaces (GUIs) make up a large portion of the code comprising many modern software applications. However, GUI testing differs significantly from testing of traditional software. One respect in which this is true is test case maintenance. Due to the way that GUI test cases are often implemented, relatively minor changes to the construction of the GUI can cause a large number of test case executions to malfunction, often because GUI elements referred to by the test cases have been renamed, moved, or otherwise altered. We posit that a general solution to the problem of GUI test case maintenance must be based on heuristics that attempt to match an applicationpsilas GUI elements across versions. We demonstrate the use of some heuristics with framework support. Our tool support is general in that it may be used with other heuristics if needed in the future.},
	keywords = {extensible heuristic-based framework, graphical user interface, Graphical user interfaces, GUI code, GUI test case maintenance, program testing, Software maintenance},
	doi = {10.1109/ICSTW.2009.11},
	author = {McMaster,S. and Memon, Atif M.}
}
@conference {15495,
	title = {Towards Dynamic Adaptive Automated Test Generation for Graphical User Interfaces},
	booktitle = {Software Testing, Verification and Validation Workshops, 2009. ICSTW {\textquoteright}09. International Conference on},
	year = {2009},
	month = {2009/04//},
	pages = {263 - 266},
	abstract = {Graphical user interfaces (GUIs) present an enormous number of potential event sequences to users. During testing it is necessary to cover this space, however the complexity of modern GUIs has made this an increasingly difficult task. Our past work has demonstrated that it is important to incorporate "context{\textquotedblright} into GUI test cases, in terms of event combinations, event sequence length, and by considering all possible starting and ending positions for each event. Despite the use of our most refined modeling techniques, many of the generated test cases remain unexecutable. In this paper, we posit that due to the dynamic state-based nature of GUIs, it is important to incorporate feedback from the execution of tests into test case generation algorithms. We propose the use of an evolutionary algorithm to generate test suites with fewer unexecutable test cases and higher event interaction coverage.},
	keywords = {adaptive automated test generation, computational complexity, event sequence length, evolutionary algorithm, evolutionary computation, graphical user interface, Graphical user interfaces, GUI test case, program testing},
	doi = {10.1109/ICSTW.2009.26},
	author = {Xun Yuan and Cohen,M. B and Memon, Atif M.}
}
@conference {15447,
	title = {Alternating GUI Test Generation and Execution},
	booktitle = {Practice and Research Techniques, 2008. TAIC PART {\textquoteright}08. Testing: Academic Industrial Conference},
	year = {2008},
	month = {2008///},
	pages = {23 - 32},
	abstract = {Users of today{\textquoteright}s software perform tasks by interacting with a graphical user interface (GUI) front-end via sequences of input events. Due to the flexibility offered by most GUIs, the number of event sequences grows exponentially with length. One ubiquitous challenge of GUI testing is to selectively generate those sequences that lead to potentially problematic states. This paper presents ALT, a new technique that generates GUI test cases in batches, by leveraging GUI run-time information from a previously run batch to obtain the next batch. Each successive batch consists of "longer" test cases that expand the state space to be explored, yet prune the "unimportant" states. The "alternating" nature of ALT allows it to enhance the next batch by leveraging certain relationships between GUI events (e.g., one enables the other, one alters the other{\textquoteright}s execution) that are revealed only at run-time and non-trivial to infer statically. An empirical study on four fielded GUI-based applications demonstrates that ALT is successful at identifying complex failure-causing interactions between GUI events.},
	keywords = {ALT, complex failure-causing interactions, event sequences, graphical user interface, Graphical user interfaces, GUI test generation, Testing},
	doi = {10.1109/TAIC-PART.2008.10},
	author = {Xun Yuan and Memon, Atif M.}
}
@article {17250,
	title = {Interactive Entity Resolution in Relational Data: A Visual Analytic Tool and Its Evaluation},
	journal = {IEEE Transactions on Visualization and Computer Graphics},
	volume = {14},
	year = {2008},
	month = {2008/10//Sept},
	pages = {999 - 1014},
	abstract = {Databases often contain uncertain and imprecise references to real-world entities. Entity resolution, the process of reconciling multiple references to underlying real-world entities, is an important data cleaning process required before accurate visualization or analysis of the data is possible. In many cases, in addition to noisy data describing entities, there is data describing the relationships among the entities. This relational data is important during the entity resolution process; it is useful both for the algorithms which determine likely database references to be resolved and for visual analytic tools which support the entity resolution process. In this paper, we introduce a novel user interface, D-Dupe, for interactive entity resolution in relational data. D-Dupe effectively combines relational entity resolution algorithms with a novel network visualization that enables users to make use of an entity{\textquoteright}s relational context for making resolution decisions. Since resolution decisions often are interdependent, D-Dupe facilitates understanding this complex process through animations which highlight combined inferences and a history mechanism which allows users to inspect chains of resolution decisions. An empirical study with 12 users confirmed the benefits of the relational context visualization on the performance of entity resolution tasks in relational data in terms of time as well as users{\textquoteright} confidence and satisfaction.},
	keywords = {algorithms, Computer Graphics, D-Dupe, data visualisation, database management systems, Databases, Factual, graphical user interface, Graphical user interfaces, human-centered computing, Image Interpretation, Computer-Assisted, Information Storage and Retrieval, Information Visualization, interactive entity resolution, relational context visualization, Relational databases, relational entity resolution algorithm, User interfaces, user-centered design, User-Computer Interface, visual analytic tool},
	isbn = {1077-2626},
	doi = {10.1109/TVCG.2008.55},
	author = {Kang,Hyunmo and Getoor, Lise and Shneiderman, Ben and Bilgic,M. and Licamele,L.}
}
@conference {15480,
	title = {Empirical evaluation of the fault-detection effectiveness of smoke regression test cases for GUI-based software},
	booktitle = {Software Maintenance, 2004. Proceedings. 20th IEEE International Conference on},
	year = {2004},
	month = {2004/09//},
	pages = {8 - 17},
	abstract = {Daily builds and smoke regression tests have become popular quality assurance mechanisms to detect defects early during software development and maintenance. In previous work, we addressed a major weakness of current smoke regression testing techniques, i.e., their lack of ability to automatically (re)test graphical user interface (GUI) event interactions - we presented a GUI smoke regression testing process called daily automated regression tester (DART). We have deployed DART and have found several interesting characteristics of GUI smoke tests that we empirically demonstrate in this paper. We also combine smoke tests with different types of test oracles and present guidelines for practitioners to help them generate and execute the most effective combinations of test-case length and test oracle complexity. Our experimental subjects consist of four GUI-based applications. We generate 5000-8000 smoke tests (enough to be run in one night) for each application. Our results show that: (1) short GUI smoke tests with certain test oracles are effective at detecting a large number of faults; (2) there are classes of faults that our smoke test cannot detect; (3) short smoke tests execute a large percentage of code; and (4) the entire smoke testing process is feasible to do in terms of execution time and storage space.},
	keywords = {daily automated regression tester, daily builds, fault-detection effectiveness, graphical user interface, Graphical user interfaces, GUI-based software, program testing, Quality assurance, Regression analysis, smoke regression test cases, software development, software fault tolerance, Software maintenance, Software quality, software quality assurance, test oracle complexity, test oracles, test-case length},
	doi = {10.1109/ICSM.2004.1357785},
	author = {Memon, Atif M. and Xie,Qing}
}
@conference {17155,
	title = {Extending the utility of treemaps with flexible hierarchy},
	booktitle = {Eighth International Conference on Information Visualisation, 2004. IV 2004. Proceedings},
	year = {2004},
	month = {2004/07/14/16},
	pages = {335 - 344},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Treemaps are a visualization technique for presenting hierarchical information on two-dimensional displays. Prior implementations limit the visualization to pre-defined static hierarchies. Flexible hierarchy, a new capability of Treemap 4.0, enables users to define various hierarchies through dynamically selecting a series of data attributes so that they can discover patterns, clusters and outliers. This work describes the design and implementation issues of flexible hierarchy. It then reports on a usability study, which led to enhancements to the interface.},
	keywords = {2D displays, Computer displays, Computer science, data visualisation, Data visualization, Educational institutions, flexible hierarchy, graphical user interface, Graphical user interfaces, hierarchical information, Nominations and elections, Switches, Tree data structures, Tree graphs, Treemap 4.0, Two dimensional displays, usability, visualization technique},
	isbn = {0-7695-2177-0},
	doi = {10.1109/IV.2004.1320166},
	author = {Chintalapani,G. and Plaisant, Catherine and Shneiderman, Ben}
}
@conference {15479,
	title = {DART: a framework for regression testing "nightly/daily builds" of GUI applications},
	booktitle = {Software Maintenance, 2003. ICSM 2003. Proceedings. International Conference on},
	year = {2003},
	month = {2003/09//},
	pages = {410 - 419},
	abstract = {"Nightly/daily building and smoke testing" have become widespread since they often reveal bugs early in the software development process. During these builds, software is compiled, linked, and (re)tested with the goal of validating its basic functionality. Although successful for conventional software, smoke tests are difficult to develop and automatically rerun for software that has a graphical user interface (GUI). In this paper, we describe a framework called DART (daily automated regression tester) that addresses the needs of frequent and automated re-testing of GUI software. The key to our success is automation: DART automates everything from structural GUI analysis; test case generation; test oracle creation; to code instrumentation; test execution; coverage evaluation; regeneration of test cases; and their re-execution. Together with the operating system{\textquoteright}s task scheduler, DART can execute frequently with little input from the developer/tester to retest the GUI software. We provide results of experiments showing the time taken and memory required for GUI analysis, test case and test oracle generation, and test execution. We also empirically compare the relative costs of employing different levels of detail in the GUI test cases.},
	keywords = {automated retesting, automatic test software, coverage evaluation, daily automated regression tester, DART, frequent retesting, graphical user interface, Graphical user interfaces, GUI software, instrumentation coding, program testing, regression testing, Software development management, Software development process, Software maintenance, Software quality, structural GUI analysis, Test Case Generation, test cases regeneration, Test execution, test oracle creation},
	doi = {10.1109/ICSM.2003.1235451},
	author = {Memon, Atif M. and Banerjee,I. and Hashmi,N. and Nagarajan,A.}
}
@conference {15428,
	title = {What test oracle should I use for effective GUI testing?},
	booktitle = {Automated Software Engineering, 2003. Proceedings. 18th IEEE International Conference on},
	year = {2003},
	month = {2003/10//},
	pages = {164 - 173},
	abstract = {Test designers widely believe that the overall effectiveness and cost of software testing depends largely on the type and number of test cases executed on the software. In this paper we show that the test oracle used during testing also contributes significantly to test effectiveness and cost. A test oracle is a mechanism that determines whether software executed correctly for a test case. We define a test oracle to contain two essential parts: oracle information that represents expected output; and an oracle procedure that compares the oracle information with the actual output. By varying the level of detail of oracle information and changing the oracle procedure, a test designer can create different types of test oracles. We design 11 types of test oracles and empirically compare them on four software systems. We seed faults in software to create 100 faulty versions, execute 600 test cases on each version, for all 11 types of oracles. In all, we report results of 660,000 test runs on software. We show (1) the time and space requirements of the oracles, (2) that faults are detected early in the testing process when using detailed oracle information and complex oracle procedures, although at a higher cost per test case, and (3) that employing expensive oracles results in detecting a large number of faults using relatively smaller number of test cases.},
	keywords = {empirical studies, graphical user interface, Graphical user interfaces, GUI testing, oracle information, oracle procedure, oracle space requirement, oracle time requirements, program testing, software engineering, Software testing, test cost, test effectiveness, test oracle},
	doi = {10.1109/ASE.2003.1240304},
	author = {Memon, Atif M. and Banerjee,I. and Nagarajan,A.}
}
@conference {17081,
	title = {Direct annotation: a drag-and-drop strategy for labeling photos},
	booktitle = {IEEE International Conference on Information Visualization, 2000. Proceedings},
	year = {2000},
	month = {2000///},
	pages = {88 - 95},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Annotating photographs is such a time-consuming, tedious and error-prone data entry task that it discourages most owners of personal photo libraries. By allowing the user to drag labels, such as personal names, from a scrolling list and drop them onto a photo, we believe we can make the task faster, easier and more appealing. Since the names are entered in a database, searching for all photos of a friend or family member is dramatically simplified. We describe the user interface design and the database schema to support direct annotation, as implemented in our PhotoFinder prototype},
	keywords = {Biomedical imaging, Cities and towns, Computer errors, Computer science, database indexing, database schema, Databases, digital libraries, direct annotation, direct manipulation, drag-and-drop strategy, Educational institutions, graphical user interface, Graphical user interfaces, History, hobby computing, image searching, label placement, Labeling, Laboratories, Libraries, personal information systems, personal names database, PhotoFinder prototype, photograph labelling, photographic libraries, Photography, scrolling list, user interface design, visual databases},
	isbn = {0-7695-0743-3},
	doi = {10.1109/IV.2000.859742},
	author = {Shneiderman, Ben and Kang,H.}
}
@article {16165,
	title = {Interface and data architecture for query preview in networked information systems},
	journal = {ACM Trans. Inf. Syst.},
	volume = {17},
	year = {1999},
	month = {1999/07//},
	pages = {320 - 341},
	abstract = {There are numerous problems associated with formulating queries onnetworked information systems. These include increased data volume and complexity, accompanied by slow network access. This article proposes a new approach to a network query user interfaces that consists of two phases: query preview and query refinement. This new approach is based on the concepts of dynamic queries and query previews, which guides users in rapidly and dynamically eliminating undesired records, reducing the data volume to a manageable size, and refining queries locally before submission over a network. Examples of two applications are given: a Restaurant Finder and a prototype for NASA{\textquoteright}s Earth Observing Systems Data Information Systems (EOSDIS). Data architecture is discussed, and user feedback is  presented.
},
	keywords = {direct manipulation, dynamic query, EOSDIS, graphical user interface, query preview, query refinement, science data},
	isbn = {1046-8188},
	doi = {10.1145/314516.314522},
	url = {http://doi.acm.org/10.1145/314516.314522},
	author = {Plaisant, Catherine and Shneiderman, Ben and Doan,Khoa and Bruns,Tom}
}
@article {14791,
	title = {IPS-2: the second generation of a parallel program measurement system},
	journal = {IEEE Transactions on Parallel and Distributed Systems},
	volume = {1},
	year = {1990},
	month = {1990/04//},
	pages = {206 - 217},
	abstract = {IPS, a performance measurement system for parallel and distributed programs, is currently running on its second implementation. IPS{\textquoteright}s model of parallel programs uses knowledge about the semantics of a program{\textquoteright}s structure to provide two important features. First, IPS provides a large amount of performance data about the execution of a parallel program, and this information is organized so that access to it is easy and intuitive. Secondly, IPS provides performance analysis techniques that help to guide the programmer automatically to the location of program bottlenecks. The first implementation of IPS was a testbed for the basic design concepts, providing experience with a hierarchical program and measurement model, interactive program analysis, and automatic guidance techniques. It was built on the Charlotte distributed operating system. The second implementation, IPS-2, extends the basic system with new instrumentation techniques, an interactive and graphical user interface, and new automatic guidance analysis techniques. This implementation runs on 4.3BSD UNIX systems, on the VAX, DECstation, Sun 4, and Sequent Symmetry multiprocessor},
	keywords = {4.3BSD UNIX systems, automatic guidance techniques, Automatic testing, Charlotte distributed operating system, CPA, DECstation, design concepts, distributed programs, graphical user interface, Graphical user interfaces, Instruments, interactive program analysis, IPS-2, measurement, message systems, network operating systems, Operating systems, parallel program measurement system, parallel programming, parallel programs, Performance analysis, performance analysis techniques, performance evaluation, performance measurement system, Power system modeling, program bottlenecks, program diagnostics, Programming profession, semantics, Sequent Symmetry multiprocessor, shared-memory systems, software tools, Springs, Sun, Sun 4, Unix, VAX},
	isbn = {1045-9219},
	doi = {10.1109/71.80132},
	author = {Miller, B. P and Clark, M. and Hollingsworth, Jeffrey K and Kierstead, S. and Lim,S. -S and Torzewski, T.}
}
