@conference {15462,
	title = {Covering array sampling of input event sequences for automated gui testing},
	booktitle = {Proceedings of the twenty-second IEEE/ACM international conference on Automated software engineering},
	series = {ASE {\textquoteright}07},
	year = {2007},
	month = {2007///},
	pages = {405 - 408},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {This paper describes a new automated technique to generate test cases for GUIs by using covering arrays (CAs). The key motivation is to generate long GUI event sequences that are systematically sampled at a particular coverage strength. CAs, to date, have not been effectively used in sampling event driven systems such as GUIs which maintain state. We leverage a "stateless" abstraction of GUIs that allows us to use CAs. Once the CAs have been generated, we reuse the abstractions to reinsert ordering relationships between GUI events, thereby creating executable test cases. A feasibility study on a well-studied GUI-based application shows that the new technique is able to detect a large number of previously undetected faults},
	keywords = {covering arrays, event driven software, GUI testing},
	isbn = {978-1-59593-882-4},
	doi = {10.1145/1321631.1321695},
	url = {http://doi.acm.org/10.1145/1321631.1321695},
	author = {Xun Yuan and Cohen,Myra and Memon, Atif M.}
}
@conference {15500,
	title = {Test suite prioritization by interaction coverage},
	booktitle = {Workshop on Domain specific approaches to software test automation: in conjunction with the 6th ESEC/FSE joint meeting},
	series = {DOSTA {\textquoteright}07},
	year = {2007},
	month = {2007///},
	pages = {1 - 7},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {Event-driven software (EDS) is a widely used class of software that takes sequences of events as input, changes state, and outputs new event sequences. Managing the size of tests suites for EDS is difficult as the number of event combinations and sequences grow exponentially with the number of events. We propose a new testing technique that extends software interaction testing. Traditional software interaction testing systematically examines all t-way interactions of parameters for a program. This paper extends the notion to t-way interactions over sequences of events. The technique applies to many classes of software; we focus on that of EDS. As a proof-of-concept, we prioritize existing test suites for four GUI-based programs by t-way interaction coverage. We compare the rate of fault detection with that of several other prioritization criteria. Results show that prioritization by interaction coverage has the fastest rate of fault detection in half of our experiments, making the most impact when tests have high interaction coverage.},
	keywords = {<i>t</i>-way interaction coverage, combinatorial interaction testing, covering arrays, event driven software, test suite prioritization},
	isbn = {978-1-59593-726-1},
	doi = {10.1145/1294921.1294922},
	url = {http://doi.acm.org/10.1145/1294921.1294922},
	author = {Bryce,Ren{\'e}e C. and Memon, Atif M.}
}
@conference {15429,
	title = {Using transient/persistent errors to develop automated test oracles for event-driven software},
	booktitle = {Automated Software Engineering, 2004. Proceedings. 19th International Conference on},
	year = {2004},
	month = {2004/09//},
	pages = {186 - 195},
	abstract = {Today{\textquoteright}s software-intensive systems contain an important class of software, namely event-driven software (EDS). All EDS take events as input, change their state, and (perhaps) output an event sequence. EDS is typically implemented as a collection of event-handlers designed to respond to individual events. The nature of EDS creates new challenges for test automation. In this paper, we focus on those relevant to automated test oracles. A test oracle is a mechanism that determines whether a software executed correctly for a test case. A test case for an EDS consists of a sequence of events. The test case is executed on the EDS, one event at a time. Errors in the EDS may "appear" and later {\textquotedblright}disappear" at several points (e.g., after an event is executed) during test case execution. Because of the behavior of these transient (those that disappear) and persistent (those that don{\textquoteright}t disappear) errors, EDS require complex and expensive test oracles that compare the expected and actual output multiple times during test case execution. We leverage our previous work to study several applications and observe the occurrence of persistent/transient errors. Our studies show that in practice, a large number of errors in EDS are transient and that there are specific classes of events that lead to transient errors. We use the results of this study to develop a new test oracle that compares the expected and actual output at strategic points during test case execution. We show that the oracle is effective at detecting errors and efficient in terms of resource utilization},
	keywords = {automated test oracles, Automatic testing, event driven software, Graphical user interfaces, persistent errors, program testing, resource allocation, resource utilization, software intensive systems, test case execution, transient errors},
	doi = {10.1109/ASE.2004.1342736},
	author = {Memon, Atif M. and Xie,Qing}
}
