@conference {15485,
	title = {Introducing a test suite similarity metric for event sequence-based test cases},
	booktitle = {Software Maintenance, 2009. ICSM 2009. IEEE International Conference on},
	year = {2009},
	month = {2009/09//},
	pages = {243 - 252},
	abstract = {Most of today{\textquoteright}s event driven software (EDS) systems are tested using test cases that are carefully constructed as sequences of events; they test the execution of an event in the context of its preceding events. Because sizes of these test suites can be extremely large, researchers have developed techniques, such as reduction and minimization, to obtain test suites that are ldquosimilarrdquo to the original test suite, but smaller. Existing similarity metrics mostly use code coverage; they do not consider the contextual relationships between events. Consequently, reduction based on such metrics may eliminate desirable test cases. In this paper, we present a new parameterized metric, CONTeSSi(n) which uses the context of n preceding events in test cases to develop a new context-aware notion of test suite similarity for EDS. This metric is defined and evaluated by comparing four test suites for each of four open source applications. Our results show that CONT eSSi(n) is a better indicator of the similarity of EDS test suites than existing metrics.},
	keywords = {event driven software systems, event sequence-based test cases, open source systems, program testing, public domain software, software metrics, Software testing, test suite similarity metric},
	doi = {10.1109/ICSM.2009.5306305},
	author = {Brooks,P.A. and Memon, Atif M.}
}
@article {14708,
	title = {Modular Information Hiding and Type-Safe Linking for C},
	journal = {IEEE Transactions on Software Engineering},
	volume = {34},
	year = {2008},
	month = {2008/06//May},
	pages = {357 - 376},
	abstract = {This paper presents CMod, a novel tool that provides a sound module system for C. CMod works by enforcing four rules that are based on principles of modular reasoning and on current programming practice. CMod{\textquoteright}s rules flesh out the convention that .h header files are module interfaces and .c source files are module implementations. Although this convention is well-known, existing explanations of it are incomplete, omitting important subtleties needed for soundness. In contrast, we have proven formally that CMod{\textquoteright}s rules enforce both information hiding and type-safe linking. To use CMod, the programmer develops and builds their software as usual, redirecting the compiler and linker to CMod{\textquoteright}s wrappers. We evaluated CMod by applying it to 30 open source programs, totaling more than one million LoC. Violations to CMod{\textquoteright}s rules revealed more than a thousand information hiding errors, dozens of typing errors, and hundreds of cases that, although not currently bugs, make programming mistakes more likely as the code evolves. At the same time, programs generally adhere to the assumptions underlying CMod{\textquoteright}s rules, and so we could fix rule violations with a modest effort. We conclude that CMod can effectively support modular programming in C: it soundly enforces type-safe linking and information-hiding while being largely compatible with existing practice.},
	keywords = {C language, CMOD, Code design, Coding Tools and Techniques, compiler, data encapsulation, Information hiding, modular information hiding, modular reasoning, modules, object-oriented programming, open source programs, packages, program compilers, public domain software, reliability, software reusability, type-safe linking},
	isbn = {0098-5589},
	doi = {10.1109/TSE.2008.25},
	author = {Srivastava,S. and Hicks, Michael W. and Foster, Jeffrey S. and Jenkins,P.}
}
@conference {15469,
	title = {Using GUI Run-Time State as Feedback to Generate Test Cases},
	booktitle = {Software Engineering, 2007. ICSE 2007. 29th International Conference on},
	year = {2007},
	month = {2007/05//},
	pages = {396 - 405},
	abstract = {This paper presents a new automated model-driven technique to generate test cases by using feedback from the execution of a "seed test suite" on an application under test (AUT). The test cases in the seed suite are designed to be generated automatically and executed very quickly. During their execution, feedback obtained from the AUT{\textquoteright}s run-time state is used to generate new, "improved" test cases. The new test cases subsequently become part of the seed suite. This "anytime technique" continues iteratively, generating and executing additional test cases until resources are exhausted or testing goals have been met. The feedback-based technique is demonstrated for automated testing of graphical user interfaces (GUIs). An existing abstract model of the GUI is used to automatically generate the seed test suite. It is executed; during its execution, state changes in the GUI pinpoint important relationships between GUI events, which evolve the model and help to generate new test cases. Together with a reverse- engineering algorithm used to obtain the initial model and seed suite, the feedback-based technique yields a fully automatic, end-to-end GUI testing process. A feasibility study on four large fielded open-source software (OSS) applications demonstrates that this process is able to significantly improve existing techniques and help identify/report serious problems in the OSS. In response, these problems have been fixed by the developers of the OSS in subsequent versions.},
	keywords = {application under test, automated test case generation, Feedback, feedback-based technique, Graphical user interfaces, GUI run-time state, model-driven technique, open-source software, program testing, public domain software, reverse engineering, reverse-engineering algorithm, seed test suite},
	doi = {10.1109/ICSE.2007.94},
	author = {Xun Yuan and Memon, Atif M.}
}
@conference {19182,
	title = {Unifying artifacts and activities in a visual tool for distributed software development teams},
	booktitle = {26th International Conference on Software Engineering, 2004. ICSE 2004. Proceedings},
	year = {2004},
	month = {2004},
	pages = {387 - 396},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {In large projects, software developers struggle with two sources of complexity - the complexity of the code itself, and the complexity of the process of producing it. Both of these concerns have been subjected to considerable research investigation, and tools and techniques have been developed to help manage them. However, these solutions have generally been developed independently, making it difficult to deal with problems that inherently span both dimensions. We describe Augur, a visualization tool that supports distributed software development processes. Augur creates visual representations of both software artifacts and software development activities, and, crucially, allows developers to explore the relationship between them. Augur is designed not for managers, but for the developers participating in the software development process. We discuss some of the early results of informal evaluation with open source software developers. Our experiences to date suggest that combining views of artifacts and activities is both meaningful and valuable to software developers.},
	keywords = {Augur, complexity management, distributed programming, distributed software development teams, open source software developers, program visualisation, Programming, public domain software, software artifacts, software engineering, software tools, visual representations, visual tool, visualization tool},
	isbn = {0-7695-2163-0},
	author = {Jon Froehlich and Dourish,P.}
}
