@conference {15489,
	title = {Studying the Characteristics of a "Good" GUI Test Suite},
	booktitle = {Software Reliability Engineering, 2006. ISSRE {\textquoteright}06. 17th International Symposium on},
	year = {2006},
	month = {2006/11//},
	pages = {159 - 168},
	abstract = {The widespread deployment of graphical-user interfaces (GUIs) has increased the overall complexity of testing. A GUI test designer needs to perform the daunting task of adequately testing the GUI, which typically has very large input interaction spaces, while considering tradeoffs between GUI test suite characteristics such as the number of test cases (each modeled as a sequence of events), their lengths, and the event composition of each test case. There are no published empirical studies on GUI testing that a GUI test designer may reference to make decisions about these characteristics. Consequently, in practice, very few GUI testers know how to design their test suites. This paper takes the first step towards assisting in GUI test design by presenting an empirical study that evaluates the effect of these characteristics on testing cost and fault detection effectiveness. The results show that two factors significantly effect the fault-detection effectiveness of a test suite: (1) the diversity of states in which an event executes and (2) the event coverage of the suite. Test designers need to improve the diversity of states in which each event executes by developing a large number of short test cases to detect the majority of "shallow" faults, which are artifacts of modern GUI design. Additional resources should be used to develop a small number of long test cases to detect a small number of "deep" faults},
	keywords = {Fault detection, Fault diagnosis, graphical user interface testing, Graphical user interfaces, program debugging, program testing},
	doi = {10.1109/ISSRE.2006.45},
	author = {Xie,Qing and Memon, Atif M.}
}
@conference {14809,
	title = {Performance measurement using low perturbation and high precision hardware assists},
	booktitle = {, The 19th IEEE Real-Time Systems Symposium, 1998. Proceedings},
	year = {1998},
	month = {1998/12/02/4},
	pages = {379 - 388},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {We present the design and implementation of MultiKron PCI, a hardware performance monitor that can be plugged into any computer with a free PCI bus slot. The monitor provides a series of high-resolution timers, and the ability to monitor the utilization of the PCI bus. We also demonstrate how the monitor can be integrated with online performance monitoring tools such as the Paradyn parallel performance measurement tools to improve the overhead of key timer operations by a factor of 25. In addition, we present a series of case studies using the MultiKron hardware performance monitor to measure and tune high-performance parallel completing applications. By using the monitor, we were able to find and correct a performance bug in a popular implementation of the MPI message passing library that caused some communication primitives to run at one half their potential speed},
	keywords = {Clocks, Computerized monitoring, Counting circuits, Debugging, Hardware, hardware performance monitor, high precision hardware assists, low perturbation, measurement, MPI message passing library, MultiKron hardware performance monitor, MultiKron PCI, NIST, online performance monitoring tools, Paradyn parallel performance measurement tools, PCI bus slot, performance bug, performance evaluation, performance measurement, program debugging, program testing, real-time systems, Runtime, Timing},
	isbn = {0-8186-9212-X},
	doi = {10.1109/REAL.1998.739771},
	author = {Mink, A. and Salamon, W. and Hollingsworth, Jeffrey K and Arunachalam, R.}
}
@conference {14813,
	title = {MDL: a language and compiler for dynamic program instrumentation},
	booktitle = {, 1997 International Conference on Parallel Architectures and Compilation Techniques., 1997. Proceedings},
	year = {1997},
	month = {1997/11/10/14},
	pages = {201 - 212},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {We use a form of dynamic code generation, called dynamic instrumentation, to collect data about the execution of an application program. Dynamic instrumentation allows us to instrument running programs to collect performance and other types of information. The instrumentation code is generated incrementally and can be inserted and removed at any time. Our instrumentation currently runs on the SPARC, PA-RISC, Power 2, Alpha, and x86 architectures. Specification of what data to collect are written in a specialized language called the Metric Description Language, that is part of the Paradyn Parallel Performance Tools. This language allows platform independent descriptions of how to collect performance data. It also provides a concise way to specify, how to constrain performance data to particular resources such as modules, procedures, nodes, files, or message channels (or combinations of these resources). We also describe the details of how we weave instrumentation into a running program},
	keywords = {Alpha architecture, application program, application program interfaces, Application software, compiler generators, Computer science, dynamic code generation, Dynamic compiler, dynamic program instrumentation, Educational institutions, files, instrumentation code, Instruments, MDL, measurement, message channels, Message passing, Metric Description Language, modules, nodes, Operating systems, optimising compilers, PA-RISC, Paradyn Parallel Performance Tools, Parallel architectures, parallel programming, performance data, platform independent descriptions, Power 2 architecture, Power generation, procedures, program debugging, Program processors, running programs, Runtime, software metrics, SPARC, Specification languages, x86 architecture},
	isbn = {0-8186-8090-3},
	doi = {10.1109/PACT.1997.644016},
	author = {Hollingsworth, Jeffrey K and Niam, O. and Miller, B. P and Zhichen Xu and Goncalves,M. J.R and Ling Zheng}
}
