@article {Simula.simula.3150,
	title = {aToucan: an Automated Framework to Derive UML Analysis Models From Use Case Models},
	journal = {ACM Transactions on Software Engineering and Methodology},
	volume = {24},
	number = {13},
	year = {2015},
	month = {05/2015},
	pages = {1-52},
	publisher = {ACM New York, NY, USA},
	address = {New York},
	abstract = {The transition from an informal requirements specification in natural language to a structured, precise specification is an important challenge in practice. It is particularly so for object-oriented methods, defined in the context of the OMG{\textquoteright}s Model Driven Architecture (MDA), where a key step is to transition from a use case model to an analysis model. However, providing automated support for this transition is challenging, mostly because requirements are in practice expressed in natural language and are much less structured than other kinds of development artifacts. Such an automated transformation would enable at least the generation of an initial, likely incomplete, analysis model and enable automated traceability from requirements to code, through various intermediate models. In this paper, we propose a method and a tool called aToucan, building on existing work, to automatically generate a UML analysis model comprising class, sequence and activity diagrams from a use case model and to automatically establish traceability links between model elements of the use case model and the generated analysis model. Note that our goal is to save effort through automated support, not to replace human abstraction and decision making. Seven (six) case studies were performed to compare class (sequence) diagrams generated by aToucan to the ones created by experts, Masters students, and trained, fourth year undergraduate students. Results show that aToucan performs well regarding consistency (e.g., 88\% class diagram consistency) and completeness (e.g., 80\% class completeness) when comparing generated class diagrams with reference class diagrams created by experts and Masters students. Similarly, sequence diagrams automatically generated by aToucan are highly consistent with the ones devised by experts and are also rather complete, e.g., 91\% and 97\% message consistency and completeness, respectively. Further, statistical tests show that aToucan significantly outperforms fourth year engineering students with that respect, thus demonstrating the value of automation. We also conducted two industrial case studies demonstrating the applicability of aToucan in two different industrial domains. Results showed that the vast majority of model elements generated by aToucan are correct and that therefore, in practice, such models would be good initial models to refine and augment so as to converge towards to correct and complete analysis models. A performance analysis shows that the execution time of aToucan (when generating class and sequence diagrams) is dependent on the number of simple sentences contained in the use case model and remains within a range of a few minutes. Five different software system descriptions (18 use cases altogether) were performed to evaluate the generation of activity diagrams. Results show that aToucan can generate 100\% complete and correct control flow information of activity diagrams and on average 85\% data flow information completeness. Moreover, we show aToucan outperforms three commercial tools in terms of activity diagram generation.},
	author = {Yue, Tao and Briand, Lionel and Labiche, Yvan}
}
@article {Simula.simula.812,
	title = {Facilitating the Transition From Use Case Models to Analysis Models: Approach and Experiments},
	journal = {ACM Transactions on Software Engineering and Methodology},
	volume = {22},
	number = {1},
	year = {2013},
	publisher = {ACM},
	abstract = {Use case modeling, including use case diagrams and use case specifications (UCSs), is commonly applied to structure and document requirements. UCSs are usually structured but unrestricted textual documents complying with a certain use case template. However, because Use Case Models (UCMods) remain essentially textual, ambiguity is inevitably introduced. In this paper, we propose a use case modeling approach, called Restricted Use Case Modeling (RUCM), which is composed of a set of well-defined restriction rules and a modified use case template. The goal is two-fold: (1) restrict the way users can document UCSs in order to reduce ambiguity and (2) facilitate the manual derivation of initial analysis models which, when using the Unified Modeling Language (UML), are typically composed of class diagrams, sequence diagrams, and possibly other types of diagrams. Though the proposed restriction rules and template are based on a clear rationale, two main questions need to be investigated. First, do users find them too restrictive or impractical in certain situations? In other words, can users express the same requirements with RUCM as with unrestricted use cases? Second, do the rules and template have a positive, significant impact on the quality of the constructed analysis models? To investigate these questions, we performed and report on two controlled experiments, which evaluate the restriction rules and use case template in terms of (1) whether they are easy to apply while developing UCMods and facilitate the understanding of UCSs, and (2) whether they help users manually derive higher quality analysis models than what can be generated when they are not used, in terms of correctness, completeness, and redundancy. This paper reports on the first controlled experiments that evaluate the applicability of restriction rules on use case modeling and their impact on the quality of analysis models. The measures we have defined to characterize restriction rules and the quality of analysis class and sequence diagrams can be reused to perform similar experiments in the future, either with RUCM or other approaches. Results show that, the restriction rules are overall easy to apply and that RUCM results into significant improvements over traditional approaches (i.e., with standard templates, without restrictions) in terms of class correctness and class diagram completeness, message correctness and sequence diagram completeness, and understandability of UCSs.},
	author = {Yue, Tao and Briand, Lionel Claude and Labiche, Yvan}
}
@article {Simula.approve.46,
	title = {UML/MARTE Model Analysis Method for Uncovering Scenarios Leading to Starvation and Deadlocks in Concurrent Systems},
	journal = {IEEE Transactions on Software Engineering},
	volume = {38},
	number = {2},
	year = {2012},
	publisher = {IEEE},
	abstract = {Concurrency problems, such as starvation and deadlocks, should be identified early in the design process. As larger, more complex concurrent systems are being developed, this is made increasingly difficult. We propose here a general approach, based on the analysis of specialized design models expressed in the Unified Modeling Language (UML) that uses a specifically designed genetic algorithm to detect concurrency problems. Though the current paper addresses deadlocks and starvation, we will show how the approach can be easily tailored to other concurrency issues. Our main motivations are (1) to devise solutions that are applicable in the context of the UML design of concurrent systems without requiring additional modeling and (2) to use a search technique to achieve scalable automation in terms of concurrency problem detection. To achieve the first objective, we show how all relevant concurrency information is extracted from systems{\textquoteright} UML models that comply with the UML Modeling and Analysis of Real-Time and Embedded Systems (MARTE) profile. For the second objective, a tailored genetic algorithm is used to search for execution sequences exhibiting deadlock or starvation problems. Scalability in terms of problem detection is achieved by showing that the detection rates of our approach are in general high and are not strongly affected by large increases in the size of complex search spaces.},
	author = {Shousha, Marwa and Briand, Lionel Claude and Labiche, Yvan}
}
@article {Simula.SE.403,
	title = {Assessing, Comparing, and Combining State Machine-Based Testing and Structural Testing: a Series of Experiments},
	journal = {IEEE Transactions on Software Engineering},
	volume = {37},
	number = {2},
	year = {2011},
	publisher = {IEEE},
	author = {Mouchawrab, Samar and Briand, Lionel Claude and Labiche, Yvan and Di Penta, Massimiliano}
}
@article {Simula.simula.684,
	title = {Automating Image Segmentation Verification and Validation by Learning Test Oracles},
	journal = {Information and Software Technology},
	volume = {53},
	number = {12},
	year = {2011},
	pages = {1337-1348},
	publisher = {Elsevier},
	abstract = {Context: An Image Segmentation Algorithm delineates (an) object(s) of interest in an image. Its output is referred to as a segmentation. Developing these algorithms is a manual, iterative process involving repetitive verification and validation tasks. This process is time-consuming and depends on the availability of experts, who may be a scarce resource (e.g., medical experts). Objective: We see the task of validating and verifying these algorithms as an instance of the oracle problem and provide a framework referred to as Image Segmentation Automated Oracle (ISAO) to help automate this process, saving substantial resources and improving efficiency. Method: ISAO uses machine learning to construct an automated oracle. During the initial learning phase, segmentations from the first few (optimally two) versions of the segmentation algorithm are manually verified by experts. The similarity of successive segmentations of the same images is also measured in various ways. This information is then fed to a machine learning algorithm to construct a classifier that distinguishes between consistent and inconsistent segmentation pairs (as determined by an expert) based on the values of the similarity measures associated with each segmentation pair. Once the accuracy of the classifier is deemed satisfactory to support a consistency determination, the classifier is then used to determine whether the segmentations that are produced by subsequent versions of the algorithm under test, are (in)consistent with already verified segmentations from previous versions. This information is then used to automatically draw conclusions about the correctness of the segmentations. Results: We have successfully applied this approach to 3D segmentations of the cardiac left ventricle obtained from CT scans and have obtained promising results (accuracies of 95\%). Conclusion: ISAO has demonstrated the ability to increase the quality and testing efficiency of image segmentation algorithms. The framework also gives informative feedback to the developer as the segmentation algorithm evolves and provides a systematic means of testing different parametric configurations of the algorithm.},
	doi = {10.1016/j.infsof.2011.06.009},
	author = {Frouchni, Kambiz and Briand, Lionel and Labiche, Yvan and Grady, Leo and Subramanyan, Rajesh}
}
@inproceedings {Simula.simula.672,
	title = {On the Effectiveness of Contracts As Test Oracles in the Detection and Diagnosis of Race Conditions and Deadlocks in Concurrent Object-Oriented Software},
	journal = {ACM/IEEE Int. Symposium on Empirical Software Engineering and Measurement (ESEM)},
	year = {2011},
	pages = {10-19},
	publisher = {IEEE Computer Society},
	type = {Conference},
	address = {Banff, AB},
	abstract = {The idea behind Design by Contract (DbC) is that a method defines a contract stating the requirements a client needs to fulfill to use it, the precondition, and the properties it ensures after its execution, the postcondition. Though there exists ample support for DbC for sequential programs, applying DbC to concurrent programs presents several challenges. We have proposed a solution to these challenges in the context of Java as programming language and the Java Modeling language as specification language. This paper presents our findings when applying our DbC technique on a case study to evaluate the ability of contract-based, runtime assertion checking code at detecting and diagnosing race conditions and deadlocks during system testing. The case study is a highly concurrent industrial system from the telecommunications domain, with actual faults. It is the first work to systematically investigate the impact of contract assertions for the detection of race conditions and deadlocks, along with functional properties, in an industrial system.},
	isbn = {978-1-4577-2203-5},
	author = {Araujo, Wladimir and Briand, Lionel Claude and Labiche, Yvan}
}
@inproceedings {Simula.simula.190,
	title = {Enabling the Runtime Assertion Checking of Concurrent Contracts for the Java Modeling Language},
	journal = {ACM/IEEE Int. Conference on Software Engineering (ICSE)},
	year = {2011},
	pages = {786-795},
	publisher = {ACM New York, NY, USA},
	type = {Conference},
	abstract = {Though there exists ample support for Design by Contract (DbC) for sequential programs, applying DbC to concurrent programs presents several challenges. In previous work, we extended the Java Modeling Language (JML) with constructs to specify concurrent contracts for Java programs. We present a runtime assertion checker (RAC) for the expanded JML capable of verifying assertions for concurrent Java programs. We systematically evaluate the validity of system testing results obtained via runtime assertion checking using actual concurrent and functional faults on a highly concurrent industrial system from the telecommunications domain.},
	isbn = {978-1-4503-0445-0},
	author = {Araujo, Wladimir and Briand, Lionel and Labiche, Yvan},
	editor = {Harald Gall Richa {Taylor} and Medvidovic, Nenad}
}
@article {Simula.approve.62,
	title = {A Systematic Review of Transformation Approaches Between User Requirements and Analysis Models},
	journal = {Requirements Engineering},
	volume = {16},
	number = {2},
	year = {2011},
	pages = {75-99},
	publisher = {Springer},
	abstract = {Model transformation is one of the basic principles of Model Driven Architecture. To build a software system, a sequence of transformations is performed, starting from requirements and ending with implementation. However, requirements are mostly in the form of text, but not a model that can be easily understood by computers; therefore automated transformations from requirements to analysis models are not easy to achieve. The overall objective of this systematic review is to examine existing literature works that transform textual requirements into analysis models, highlight open issues, and provide suggestions on potential directions of future research. The systematic review led to the analysis of 20 primary studies (16 approaches) obtained after a carefully designed procedure for selecting papers published in journals and conferences from 1996 to 2008 and Software Engineering textbooks. A conceptual framework is designed to provide common concepts and terminology, and to define a unified transformation process. This facilitates the comparison and evaluation of the reviewed papers.},
	author = {Yue, Tao and Briand, Lionel and Labiche, Yvan}
}
@inproceedings {Simula.approve.20,
	title = {An Automated Approach to Transform Use Cases Into Activity Diagrams},
	journal = {6th European Conference on Modelling Foundations and Applications (ECMFA 2010)},
	volume = {6138},
	year = {2010},
	pages = {337-353},
	publisher = {Springer},
	type = {Conference},
	abstract = {Use cases are commonly used to structure and document requirements while UML activity diagrams are often used to visualize and formalize use cases, for example to support automated test case generation. Therefore the automated support for the transition from use cases to activity diagrams would provide significant, practical help. Additionally, traceability could be established through automated transformation, which could then be used for instance to relate requirements to design decisions and test cases. In this paper, we propose an approach to automatically generate activity diagrams from use cases while establishing traceability links. Data flow information can also be generated and added to these activity diagrams. Our approach is implemented in a tool, which we used to perform five case studies. The results show that high quality activity diagrams can be generated. Our analysis also shows that our approach outperforms existing academic approaches and commercial tools.},
	isbn = {978-3-642-13594-1},
	author = {Yue, Tao and Briand, Lionel and Labiche, Yvan},
	editor = {K{\"u}hne et {al.}}
}
@techreport {25321,
	title = {Automatically Deriving a UML Analysis Model from a Use Case Model},
	year = {2010},
	note = {This technical report is an early version of a published article.},
	publisher = {Simula Research Laboratory},
	author = {Yue, Tao and Lionel C. {Briand} and Labiche, Yvan}
}
@techreport {25326,
	title = {Automatically Deriving UML Sequence Diagrams from Use Cases},
	year = {2010},
	note = {This technical report is an early version of a published article.},
	publisher = {Simula Research Laboratory},
	author = {Yue, Tao and Lionel C. {Briand} and Labiche, Yvan}
}
@techreport {25320,
	title = {Facilitating the Transition From Use Case Models to Analysis Models: Approach and Experiments},
	year = {2010},
	note = {This technical report is an early version of a published article. The published version can be found here:https://www.simula.no/publications/facilitating-transition-use-case-models-analysis-models-approach-and-experiments},
	publisher = {Simula Research Laboratory},
	author = {Yue, Tao and Lionel C. {Briand} and Labiche, Yvan}
}
@article {Simula.SE.407,
	title = {Improving the Coverage Criteria of UML State Machines Using Data Flow Analysis},
	journal = {Software Testing, Verification and Reliability},
	volume = {20},
	number = {3},
	year = {2010},
	month = {September},
	author = {Briand, Lionel and Labiche, Yvan and Lin, Qin}
}
@article {Simula.SE.635,
	title = {Solving the Class Responsibility Assignment Problem in Object-Oriented Analysis With Multi-Objective Genetic Algorithms},
	journal = {IEEE Transactions on Software Engineering},
	volume = {36},
	number = {6},
	year = {2010},
	month = {November-December},
	pages = {817-837},
	abstract = {In the context of object-oriented analysis and design (OOAD), class responsibility assignment is not an easy skill to acquire. Though there are many methodologies for assigning responsibilities to classes, they all rely on human judgment and decision making. Our objective is to provide decision-making support to re-assign methods and attributes to classes in a class diagram. Our solution is based on a multi-objective genetic algorithm (MOGA) and uses class coupling and cohesion measurement for defining fitness functions. Our MOGA takes as input a class diagram to be optimized and suggests possible improvements to it. The choice of a MOGA stems from the fact that there are typically many evaluation criteria that cannot be easily combined into one objective, and several alternative solutions are acceptable for a given OO domain model. Using a carefully selected case study, this article investigates the application of our proposed MOGA to the class responsibility assignment problem, in the context of object-oriented analysis and domain class models. Our results suggest that the MOGA can help correct suboptimal class responsibility assignment decisions and perform far better than simpler alternative heuristics such as hill climbing and a single objective GA.},
	author = {Bowman, Mike and Briand, Lionel and Labiche, Yvan}
}
@article {Simula.SE.243,
	title = {Automated Traceability Analysis for UML Model Refinements},
	journal = {Information and Software Technology},
	volume = {51},
	number = {2},
	year = {2009},
	publisher = {Elsevier},
	author = {Briand, Lionel and Labiche, Yvan and Yue, Tao}
}
@techreport {Simula.SE.639,
	title = {Automating Image Segmentation Verification and Validation by Learning Test Oracles},
	number = {TR SCE-09-06},
	year = {2009},
	publisher = {Carleton University},
	abstract = {An Image Segmentation Algorithm is an algorithm that delineates (an) object(s) of interest in an image. The output of the image segmentation algorithm is referred to as a segmentation. Developing image segmentation algorithms is a manual, iterative process involving repetitive verification and validation tasks. This process is time-consuming and depends on the availability of medical experts, who are a scarce resource. We propose a procedure that uses machine learning to construct an oracle, which can then be used to automatically verify the correctness of image segmentations, thus saving substantial resources. During the initial learning phase, segmentations from the first few (optimally two) revisions of the segmentation algorithm are manually verified by experts. The similarity of successive segmentations of the same images is also measured. This information is then fed to a machine learning algorithm to construct a classifier that distinguishes between consistent and inconsistent segmentation pairs based on the values of the similarity measures associated with each segmentation pair. Once the accuracy of the classifier is deemed satisfactory for the purposes of the application, the classifier is then used to determine whether the segmentation, systems{\textquoteright} output by subsequent versions of the algorithm under test, are (in)consistent with already verified segmentations from previous versions. This information is then used to automatically make conclusions about the (in)correctness of the segmentations. To demonstrate the performance of the approach, the proposed solution was successfully applied to 3D segmentations of the cardiac left ventricle obtained from CT scans.},
	author = {Frounchi, Kambiz and Briand, Lionel and Grady, Leo and Labiche, Yvan}
}
@article {Simula.SE.303,
	title = {Automating Regression Test Selection Based on UML Designs},
	journal = {Information and Software Technology},
	volume = {51},
	number = {1},
	year = {2009},
	author = {Briand, Lionel and Labiche, Yvan and He, Siyuan}
}
@article {Simula.SE.277,
	title = {A UML-Based Quantitative Framework for Early Prediction of Resource Usage and Load in Distributed Real-Time Systems},
	journal = {Software and Systems Modeling},
	volume = {Volume 8},
	number = {Number 2},
	year = {2009},
	pages = {275-302},
	publisher = {Springer},
	author = {Garousi, Vahid and Briand, Lionel and Labiche, Yvan}
}
@inproceedings {Simula.SE.645,
	title = {A UML/MARTE Model Analysis Method for Detection of Data Races in Concurrent Systems},
	journal = {ACM/IEEE MODELS 2009},
	year = {2009},
	publisher = {Springer-Verlag Berlin, Heidelberg},
	type = {Conference},
	abstract = {The earlier concurrency problems are identified, the less costly they are to fix. As larger, more complex concurrent systems are developed, early detection of problems is made increasingly difficult. Meant to be used in the context of Model Driven Development, we have developed a general approach, based on the analysis of design models expressed in the Unified Modeling Language (UML) that uses specifically designed genetic algorithms to detect concurrency problems. All relevant concurrency information is extracted from systems{\textquoteright} UML models that comply with the UML Modeling and Analysis of Real-Time and Embedded Systems profile. Our approach was previously shown to work for both deadlocks and starvation. The current paper addresses data race detection, further illustrating how our approach can be tailored to other concurrency issues. Our main motivations are (1) to devise practical solutions that are applicable in the context of UML design of concurrent systems without requiring additional modeling and (2) to achieve scalable automation. Results on a case study inspired from the Therac-25 radiation machine show that our approach is effective in the detection of data races.},
	isbn = {978-3-642-04424-3},
	author = {Shousha, Marwa and Briand, Lionel and Labiche, Yvan},
	editor = {Sch{\"u}rr, Andy and Selic, Bran}
}
@inproceedings {Simula.SE.627,
	title = {A Use Case Modeling Approach to Facilitate the Transition Towards Analysis Models: Concepts and Empirical Evaluation},
	journal = {IEEE/ACM MODELS 2009 Proceedings},
	year = {2009},
	publisher = {Springer-Verlag Berlin, Heidelberg},
	type = {Conference},
	abstract = {Use case modeling is commonly applied to document requirements. Use case specifications (UCSs) are usually structured, textual documents complying with a certain template. However, because they remain essentially textual, ambiguities are inevitable. In this paper, we propose a new use case modeling approach, which is composed of a set of well-defined restriction rules and a template. The goal is to reduce ambiguity and facilitate automated analysis, though the later point is not addressed in this paper. We also report on a controlled experiment which evaluates the restriction rules and template in terms of their ease of application during use case modeling, and the quality of the analysis models derived from them by trained individuals. Results show that the restriction rules are overall easy to apply and that our use case modeling approach results in significant improvements regarding the correctness of derived class diagrams and the understandability of UCSs.},
	isbn = {978-3-642-04424-3},
	author = {Yue, Tao and Briand, Lionel and Labiche, Yvan},
	editor = {Sch{\"u}rr, Andy and Selic, Bran}
}
@article {Simula.SE.641,
	title = {Using Machine Learning to Refine Category-Partition Test Specifications and Test Suites},
	journal = {Information and Software Technology},
	volume = {21},
	number = {11},
	year = {2009},
	abstract = {In the context of open source development or software evolution, developers often face test suites which have been developed with no apparent rationale and which may need to be augmented or refined to ensure sufficient dependability, or even reduced to meet tight deadlines. We refer to this process as the re-engineering of test suites. It is important to provide both methodological and tool support to help people understand the limitations of test suites and their possible redundancies, so as to be able to refine them in a cost effective manner. To address this problem in the case of black-box, Category-Partition testing, we propose a methodology and a tool based on machine learning that has shown promising results on a case study involving students as testers.},
	author = {Briand, Lionel and Labiche, Yvan and Bawar, Zaheer and Spido, Nadia}
}
@inproceedings {Simula.SE.283,
	title = {Concurrent Contracts for Java in JML},
	journal = {IEEE International Symposium on Software Reliability Engineering (ISSRE)},
	year = {2008},
	type = {Conference},
	author = {Araujo, Wladimir and Briand, Lionel and Labiche, Yvan}
}
@article {Simula.SE.179,
	title = {Traffic-Aware Stress Testing of Distributed Real-Time Systems Based on UML Models Using Genetic Algorithms},
	journal = {Journal of Systems and Software},
	volume = {81},
	number = {2},
	year = {2008},
	month = {February},
	pages = {161-185},
	abstract = {This paper presents a model-driven, stress test methodology aimed at increasing chances of discovering faults related to network traffic in distributed real-time systems (DRTS). The technique uses the UML 2.0 model of the distributed system under test, augmented with timing information, and is based on an analysis of the control flow in sequence diagrams. It yields stress test requirements that are made of specific control flow paths along with time values indicating when to trigger them. The technique considers different types of arrival patterns (e.g., periodic) for real-time events (common to DRTSs), and generates test requirements which comply with such timing constraints. Though different variants of our stress testing technique already exist (that stress different aspects of a distributed system), they share a large amount of common concepts and we therefore focus here on one variant that is designed to stress test the system at a time instant when data traffic on a network is maximal. Our technique uses genetic algorithms to find test requirements which lead to maximum possible traffic-aware stress in a system under test. Using a real-world DRTS specification, we design and implement a prototype DRTS and describe, for that particular system, how the stress test cases are derived and executed using our methodology. The stress test results indicate that the technique is significantly more effective at detecting network traffic-related faults when compared to test cases based on an operational profile.},
	author = {Garousi, Vahid and Briand, Lionel and Labiche, Yvan}
}
@inproceedings {Simula.SE.279,
	title = {A UML/SPT Model Analysis Methodology for Concurrent Systems Based on Genetic Algorithms},
	journal = {ACM/IEEE 11th International Conference in Model Driven Engineering Languages and Systems (MODELS 2008)},
	year = {2008},
	type = {Conference},
	author = {Shousha, Marwa and Briand, Lionel and Labiche, Yvan}
}
@inproceedings {Simula.SE.251,
	title = {Using Machine Learning to Refine Black-Box Test Specifications and Test Suites},
	journal = {Eigth IEEE International Conference on Quality Software},
	year = {2008},
	type = {Conference},
	author = {Briand, Lionel and Labiche, Yvan and Bawar, Zaheer}
}
@inproceedings {Simula.SE.148,
	title = {Assessing, Comparing, and Combining Statechart-Based Testing and Structural Testing: an Experiment},
	journal = {International Symposium on Empirical Software Engineering and Measurement (ESEM)},
	year = {2007},
	type = {Annual},
	abstract = {An important number of studies have addressed the importance of models in software engineering, mainly in the design of robust software systems. Although models have been proven to be helpful in a number of software engineering activities, such as providing a better medium for communication among designers and customers, there is still significant resistance to model-driven development in many software organizations. The main reason is that it is perceived to be expensive and not necessarily cost-effective. This paper investigates one specific aspect of this larger problem. It addresses the impact of using statecharts for testing class clusters that exhibit a state-dependent behavior. More precisely, it reports on a controlled experiment that investigates their impact on testing fault-detection effectiveness and cost. Code-based, structural testing is compared to statechart-based testing and their combination is investigated to determine whether they are complementary. Results show that there is no significant difference between the fault detection effectiveness of the two test strategies but that they are significantly more effective when combined. This implies that a cost-effective strategy could be to specify statechart-based test cases early on, execute them when the source code becomes available, and then complete them with code-based test cases based on coverage analysis. This article also investigates the reasons for undetected faults and how the statechartbased testing of source code could be improved.},
	author = {Mouchawrab, Samar and Briand, Lionel and Labiche, Yvan}
}
@inproceedings {Simula.SE.146,
	title = {Multi-Objective Genetic Algorithms to Support Class Responsibility Assignment},
	journal = {International Conference on Software Maintenance (ICSM 2007)},
	year = {2007},
	type = {Annual},
	abstract = {Class responsibility assignment is not an easy skill to acquire. There is ample evidence that this is hard to teach and apply. Though there are many methodologies for assigning responsibilities to classes, they all rely on human judgment and decision making. In this paper, our objective is to provide decision-making help to re-assign methods and attributes to classes in a class diagram. Our solution is based on a multi-objective genetic algorithm (MOGA) and uses class coupling and cohesion measurement. Our MOGA takes as input a class diagram to be optimized, typically produced during the analysis phase of software development and evolution (i.e., a domain model) in the context of Model-Driven Development, and suggests possible improvements to the diagram. The choice of a MOGA stems from the fact that there are typically many evaluation criteria that cannot be easily combined into one objective, and several alternative solutions are acceptable for a given OO domain model. This article presents our approach in details, our decisions regarding the multi-objective genetic algorithm, and reports on a case study. Our results suggest that the MOGA can help correct suboptimal class responsibility assignment decisions.},
	author = {Bowman, Michael and Briand, Lionel and Labiche, Yvan}
}
@inproceedings {Simula.SE.147,
	title = {A UML Profile for Developing Airworthiness-Compliant (RTCA DO-178B) Safety-Critical Software},
	journal = {International Conference on Model Driven Engineering Languages},
	year = {2007},
	type = {Annual},
	abstract = {Many safety-related and certification standards exist for developing safety-critical systems. Safety assessments are performed in practice, and system certification according to a standard requires the submitting information about the software. The airworthiness standard, RTCA DO-178B, is the software de-facto standard for commercial and military aerospace programmes. The objective of this research is to propose an approach to improve the line of communication between safety engineers and software engineers by proposing a Unified Modeling Language (UML) profile that allows software engineers to model safety related concepts and properties in UML, the de-facto software modeling language. In this research, the list of safety-related concepts is extracted from RTCA DO- 178B, and then a UML profile is presented to enable modeling them. Then, approaches to generate certification-related information from UML models are presented. This new approach is illustrated through a case study on developing an aircraft{\textquoteright}s navigation controller subsystem},
	author = {Zoughbi, Gregory and Briand, Lionel and Labiche, Yvan}
}
@inproceedings {Simula.SE.145,
	title = {Using Machine Learning to Support Debugging With Tarantula},
	journal = {International Symposium on Software Reliability Engineering (ISSRE)},
	year = {2007},
	type = {Annual},
	abstract = {Using a specific machine learning technique, this paper proposes a way to identify suspicious statements during debugging which is based on principles similar to Tarantula but addresses its main flaw: Its difficulty to deal with the presence of multiple faults as it assumes that failing test cases execute the same fault(s). The improvement we present in this paper results from the use of C4.5 decision trees to identify various failure conditions based on information regarding the test cases{\textquoteright} inputs and outputs. Failing test cases executing under similar conditions are then assumed to fail due to the same fault(s). Statements are then considered suspicious if they are covered by a large proportion of failing test cases that execute under similar conditions. We report on a case study that demonstrates improvement over the original Tarantula technique in terms of statement ranking. Another contribution of the paper is to show that failure conditions as modeled by a C4.5 decision tree accurately predict failures and can therefore be used as well to help debugging.},
	author = {Briand, Lionel and Labiche, Yvan and Liu, Xuetao}
}
@inproceedings {Garousi.2006.2,
	title = {Analysis and Visualization of Behavioral Dependencies Among Distributed Objects Based on UML Models},
	journal = {ACM/IEEE MoDELS},
	year = {2006},
	pages = {365-379},
	publisher = {Springer},
	type = {Conference},
	isbn = {3-540-45772-0},
	author = {Garousi, Vahid and Briand, Lionel and Labiche, Yvan},
	editor = {Nierstrasz, Oscar and Whittle, Jon and Harel, David and Reggio, Gianna}
}
@inproceedings {Briand.2006.1,
	title = {Automated, Contract-Based User Testing of Commercial-Off-the-Shelf Components},
	journal = {ACM/IEEE International Conference on Software Engineering (ICSE)},
	year = {2006},
	publisher = {ACM Press},
	type = {Conference},
	abstract = {Commercial-off-the-Shelf (COTS) components provide a means to construct software (component-based) systems in reduced time and cost. In a COTS component software market there exist component vendors (original developers of the component) and component users (developers of the component-based systems). The former provide the component to the user without source code or design documentation, and as a result it is difficult for the latter to adequately test the component when deployed in their system. In this article we propose a framework that clarifies the roles and responsibilities of both parties so that the user can adequately test the component in a deployment environment and the vendor does not need to release proprietary details. Then, based on this framework we combine and adapt two specification-based testing techniques and describe (and implement) a method for the automated generation of adequate test sets. An evaluation of our approach on a case study demonstrates that it is possible to automatically generate cost effective test sequences and that these test sequences are effective at detecting complex errors.},
	isbn = {1-59593-375-1},
	author = {Briand, Lionel and Labiche, Yvan and Sowka, Michal},
	editor = {Anderson, Ken}
}
@article {Simula.SE.23,
	title = {Automated Impact Analysis of UML Models},
	journal = {Journal of Systems and Software},
	volume = {79},
	number = {3},
	year = {2006},
	pages = {339-352},
	author = {Briand, Lionel and Labiche, Yvan and O{\textquoteright}Sullivan, L. and Sowka, Michal}
}
@inproceedings {Simula.SE.127,
	title = {Automatic Evaluation of Intrusion Detection Systems},
	journal = {22nd Annual Computer Security Applications Conference},
	year = {2006},
	pages = {361-370},
	type = {Conference},
	abstract = {An Intrusion Detection System (IDS) is a crucial element of a network security posture. Although there are many IDS products available, it is rather difficult to find information about their accuracy. Only a few organizations evaluate these products. Furthermore, the data used to test and evaluate these IDS is usually proprietary. Thus, the research community cannot easily evaluate the next generation of IDS. Toward this end, DARPA provided in 1998, 1999 and 2000 an Intrusion Detection Evaluation Data Set. However, no new data set has been released by DARPA since 2000, in part because of the cumbersomeness of the task. In this paper, we propose a strategy to address certain aspects of generating a publicly available documented data set for testing and evaluating intrusion detection systems. We also present a tool that automatically analyzes and evaluates IDS using our proposed data set.},
	isbn = {1063-9527},
	author = {Massicotte, Frederic and Gagnon, Fran{\c c}ois and Labiche, Yvan and Briand, Lionel and Couture, Mathieu}
}
@inproceedings {Simula.SE.56,
	title = {Guiding the Application of Design Patterns Based on UML Models},
	journal = {IEEE International Conference on Software Maintenance (ICSM)},
	year = {2006},
	publisher = {Publisher},
	type = {Conference},
	isbn = {0000000000},
	author = {Briand, Lionel and Labiche, Yvan and Sauv{\'e}, Alexandre}
}
@article {Arisholm.2006.3,
	title = {The Impact of UML Documentation on Software Maintenance: an Experimental Evaluation},
	journal = {IEEE Transactions on Software Engineering},
	volume = {32},
	number = {6},
	year = {2006},
	month = {June},
	pages = {365-381},
	abstract = {The Unified Modeling Language (UML) is becoming the de-facto standard for software analysis and design modeling. However, there is still a significant resistance to model-driven development in many software organizations as it is perceived to be expensive and not necessarily cost-effective. It is therefore important to investigate the benefits obtained through modeling. As a first step in this direction, this paper reports on controlled experiments, spanning across two locations, which investigate the impact of UML documentation on software maintenance. Results show that, for complex tasks and past a certain learning curve, the availability of UML documentation may result in significant improvements of the functional correctness of changes as well as their design quality. On the other hand, there does not seem to be any resulting time saving. For simpler tasks, the time needed to update the UML documentation may be substantial compared with the potential benefits, thus motivating the need for UML tools with better support for software maintenance.},
	author = {Arisholm, Erik and Briand, Lionel and Siw Elisabeth {Hove} and Labiche, Yvan}
}
@inbook {Dzidek.2006.1,
	title = {Lessons Learned From Developing a Dynamic OCL Constraint Enforcement Tool for Java},
	booktitle = {Satellite Events at the MoDELS 2005 Conference: MoDELS 2005 International Workshops OCLWS, MoDeVA, MARTES, AOM, MTiP, WiSME, MODAUI, NfC, MDD, WUsCAM, Montego Bay, Jamaica, October 2-7, 2005, Revised Selected Papers},
	series = {Lecture Notes in Computer Science, Vol. 3844},
	year = {2006},
	month = {January},
	pages = {10-19},
	publisher = {Springer},
	organization = {Springer},
	abstract = {Analysis and design by contract allows the definition of a formal agreement between a class and its clients, expressing each party{\textquoteright}s rights and obligations. Contracts written in the Object Constraint Language (OCL) are known to be a useful technique to specify the precondition and postcondition of operations and class invariants in a UML context, making the definition of object-oriented analysis or design elements more precise while also helping in testing and debugging. In this article, we report on the experiences with the development of ocl2j, a tool that automatically instruments OCL constraints in Java programs using aspect-oriented programming (AOP). The approach strives for automatic and efficient generation of contract code, and a non-intrusive instrumentation technique. A summary of our approach is given along with the results of an initial case study, the discussion of encountered problems, and the necessary future work to resolve the encountered issues.},
	isbn = {3-540-31780-5},
	author = {Dzidek, James and Briand, Lionel and Labiche, Yvan},
	editor = {Bruel, Jean-Michel}
}
@inproceedings {Elaasar.2006.1,
	title = {A Metamodeling Approach to Pattern Specification and Detection},
	journal = {Proc. of ACM/IEEE International Conference on Model Driven Engineering Languages and Systems (MoDELS)},
	year = {2006},
	pages = {484-498},
	publisher = {Springer},
	type = {Conference},
	isbn = {3-540-45772-0},
	author = {Elaasar, Maged and Briand, Lionel and Labiche, Yvan},
	editor = {Nierstrasz, Oscar and Whittle, Jon and Harel, David and Reggio, Gianna}
}
@article {Simula.SE.18,
	title = {Towards the Reverse Engineering of UML Sequence Diagrams for Distributed Java Software},
	journal = {IEEE Transactions on Software Engineering},
	volume = {32},
	number = {9},
	year = {2006},
	author = {Briand, Lionel and Labiche, Yvan and Leduc, Johanne}
}
@inproceedings {Garousi.2006.1,
	title = {Traffic-Aware Stress Testing of Distributed Systems Based on UML Models},
	journal = {ACM/IEEE International Conference on Software Engineering (ICSE)},
	year = {2006},
	pages = {391-400},
	publisher = {ACM Press},
	type = {Conference},
	abstract = {A stress test methodology aimed at increasing chances of discovering faults related to network traffic in distributed systems is presented. The technique uses the UML 2.0 model of the distributed system under test, augmented with timing information and is based on an analysis of the control flow in sequence diagrams. It yields stress test requirements that are made of specific control flow paths along with time values indicating when to trigger them. Different variants of our stress testing technique already exist (they stress different aspects of a distributed system) and we focus here on one variant that is designed to identify and to stress test the system at the instant when data traffic on a network is maximal. Using a real-world distributed system specification, we design and implement a prototype distributed system and describe, for that particular system, how the stress test cases are derived and executed using our methodology. The stress test results indicate that the technique is significantly more effective at detecting network traffic-related faults when compared to test cases based on an operational profile.},
	isbn = {1-59593-375-1},
	author = {Garousi, Vahid and Briand, Lionel and Labiche, Yvan},
	editor = {Anderson, Ken}
}
@article {Simula.SE.19,
	title = {Using Genetic Algorithms for Early Schedulability Analysis and Stress Testing in Real-Time Systems},
	journal = {Journal of Genetic Programming and Evolvable Machines},
	volume = {7},
	number = {2},
	year = {2006},
	author = {Briand, Lionel and Labiche, Yvan and Shousha, Marwa}
}
@article {Andrews.2006.1,
	title = {Using Mutation Analysis for Assessing and Comparing Testing Coverage Criteria},
	journal = {IEEE Transactions on Software Engineering},
	volume = {32},
	number = {8},
	year = {2006},
	month = {August},
	pages = {608-624},
	abstract = {The empirical assessment of test techniques plays an important role in software testing research. One common practice is to seed faults in subject software, either manually or by using a program that generates all possible mutants based on a set of mutation operators. The latter allows the systematic, repeatable seeding of large numbers of faults, thus facilitating the statistical analysis of fault detection effectiveness of test suites; however, we do not know whether empirical results obtained this way lead to valid, representative conclusions. Focusing on four common control and data flow criteria (Block, Decision, C-Use, and P-Use), this paper investigates this important issue based on a middle size industrial program with a comprehensive pool of test cases and known faults. Based on the data available thus far, the results are very consistent across the investigated criteria as they show that the use of mutation operators is yielding trustworthy results: Generated mutants can be used to predict the detection effectiveness of real faults. Applying such a mutation analysis, we then investigate the relative cost and effectiveness of the above-mentioned criteria by revisiting fundamental questions regarding the relationships between fault detection, test suite size, and control/data flow coverage. Although such questions have been partially investigated in previous studies, we can use a large number of mutants, which helps decrease the impact of random variation in our analysis and allows us to use a different analysis approach. Our results are then compared with published studies, plausible reasons for the differences are provided, and the research leads us to suggest a way to tune the mutation analysis process to possible differences in fault detection probabilities in a specific environment.},
	author = {James H. {Andrews} and Briand, Lionel and Labiche, Yvan and Akbar Sami {Namin}}
}
@article {Simula.SE.24,
	title = {Automated Support for Deriving Test Requirements From UML Statecharts},
	journal = {Software and Systems Modeling},
	volume = {4},
	number = {12},
	year = {2005},
	pages = {399-423},
	author = {Briand, Lionel and Labiche, Yvan and Cui, J.}
}
@inproceedings {Simula.SE.59,
	title = {Control Flow Analysis of UML 2.0 Sequence Diagrams},
	journal = {European Conference on Model Driven Architecture-Foundations and Applications (ECMDA-FA)},
	year = {2005},
	publisher = {Publisher},
	type = {Conference},
	isbn = {0000000000},
	author = {Garousi, Vahid and Briand, Lionel and Labiche, Yvan}
}
@article {Simula.SE.22,
	title = {An Experimental Investigation of Formality in UML-Based Development},
	journal = {IEEE Transactions on Software Engineering},
	volume = {vol. 31},
	number = {nr. 10},
	year = {2005},
	pages = {p. 833-849},
	author = {Briand, Lionel and Labiche, Yvan and Di Penta, Massimiliano and H. D. {Yan-Bondoc}}
}
@techreport {Arisholm.2005.2,
	title = {The Impact of UML Documentation on Software Maintenance: an Experimental Evaluation},
	number = {2005-14},
	year = {2005},
	month = {August},
	publisher = {Simula Research Laboratory},
	abstract = {The Unified Modeling Language (UML) is becoming the de-facto standard for software analysis and design modeling. However, there is still a significant resistance to model-driven development in many software organizations as it is perceived to be expensive and not necessarily cost-effective. It is therefore important to investigate the benefits obtained through modeling. As a first step in this direction, this paper reports on controlled experiments, spanning across two locations, which investigate the impact of UML documentation on software maintenance. Results show that, for complex tasks and passed a certain learning curve, the availability UML documentation may result into significant improvements of the functional correctness of changes as well as their design quality. On the other hand, there does not seem to be any resulting time saving. For simpler tasks, the time needed to update the UML documentation may be substantial compared with the potential benefits, thus motivating the need for UML tools with better support for performing model changes.},
	author = {Arisholm, Erik and Briand, Lionel and Siw Elisabeth {Hove} and Labiche, Yvan}
}
@inproceedings {Simula.SE.58,
	title = {Improving Statechart Testing Criteria Using Data Flow Information},
	journal = {IEEE Int. Symposium on Software Reliability Engineering (ISSRE)},
	year = {2005},
	publisher = {Publisher},
	type = {Conference},
	isbn = {0000000000},
	author = {Briand, Lionel and Labiche, Yvan and Lin, Qin}
}
@inproceedings {Briand.2005.1,
	title = {Instrumenting Contracts With Aspect-Oriented Programming to Increase Observability and Support Debugging},
	journal = {21st IEEE International Conference on Software Maintenance (ICSM), Budapest, Hungary, September 25-30},
	year = {2005},
	note = {Use of the attached PDF is subject to the IEEE terms found here: http://www.computer.org/portal/pages/csdl/content/Terms.html},
	pages = {687-690},
	publisher = {IEEE},
	type = {Conference},
	abstract = {Analysis and design by contract allows the definition of a formal agreement between a class and its clients, expressing each party{\textquoteright}s rights and obligations. Operation contracts and class invariants are known to be a useful technique to specify the precondition and postcondition of operations and the legal states of class instances in an object-oriented context, making the definition of object-oriented analysis or design elements more precise. Furthermore, it is also useful to check such contracts and invariants at run time in order to help testing and debugging during corrective maintenance. Indeed, experiments report a substantial gain when relying on instrumented contracts during those two activities. However, the instrumentation of such contracts is a time consuming activity. In this paper we report on how Aspect-Oriented Programming (AOP), using AspectJ, can be employed to automatically and efficiently instrument contracts and invariants in Java. The paper focuses on (1) the AspectJ templates to instrument preconditions, postconditions, and class invariants, (2) the necessary instrumentation for compliance-checking to the Liskov Substitution Principle.},
	isbn = {0-7695-2368-4},
	author = {Briand, Lionel and Dzidek, James and Labiche, Yvan},
	editor = {IEEE Computer {Society}}
}
@article {Simula.SE.21,
	title = {A Measurement Framework for Object-Oriented Software Testability},
	journal = {Information and Software Technology},
	volume = {47},
	number = {12},
	year = {2005},
	author = {Mouchawrab, S. and Briand, Lionel and Labiche, Yvan}
}
@inproceedings {Simula.SE.62,
	title = {Is Mutation an Appropriate Tool for Testing Experiments?},
	journal = {IEEE International Conference on Software Engineering (ICSE{\textquoteright}05)},
	year = {2005},
	publisher = {Publisher},
	type = {Conference},
	isbn = {0000000000},
	author = {Briand, Lionel and Andrews, James and Labiche, Yvan}
}
@inproceedings {Simula.SE.60,
	title = {Tracing Distributed Systems Executions Using AspectJ},
	journal = {IEEE International Conference on Software Maintenance (ICSM 2005)},
	year = {2005},
	publisher = {Publisher},
	type = {Conference},
	isbn = {0000000000},
	author = {Briand, Lionel and Labiche, Yvan and Leduc, Johanne}
}
@inproceedings {Simula.SE.144,
	title = {Tracing Distributed Systems Executions Using AspectJ},
	journal = {21st IEEE International Conference on Software Maintenance (ICSM{\textquoteright}05)},
	year = {2005},
	month = {September},
	pages = {81-90},
	publisher = {IEEE Computer Society},
	type = {Conference},
	abstract = {This article addresses the generation of traces to monitor the execution of distributed Java systems, and investigates the use of Aspect-Oriented Programming (AOP) as the instrumentation strategy to get the necessary information at runtime. The overall objective is to gather enough information to help people understand program executions by abstracting out design details related to thread and distributed communications, for instance under the form of UML sequence diagrams. We show how AspectJ, the main Java implementation of AOP, can be used to solve such issues, assuming RMI is the distribution middleware and thread communications employ specific data structures. The most important aspects are discussed and experiments on a case study are reported.},
	isbn = {0-7695-2368-},
	author = {Briand, Lionel and Labiche, Yvan and Leduc, Johanne},
	editor = {Briand, Lionel}
}
@inproceedings {Simula.SE.61,
	title = {Using Aspect-Oriented Programming to Instrument OCL Contracts in Java},
	journal = {IEEE International Conference on Software Maintenance (ICSM 2005)},
	year = {2005},
	publisher = {Publisher},
	type = {Conference},
	isbn = {0000000000},
	author = {Briand, Lionel and Wojciech James {Dzidek} and Labiche, Yvan}
}
@inproceedings {Simula.SE.63,
	title = {A Controlled Experiment on the Impact of the Object Constraint Language in UML-Based Development},
	journal = {IEEE Conference on Software Maintenance (ICSM 2004)},
	year = {2004},
	publisher = {Publisher},
	type = {Conference},
	isbn = {0000000000},
	author = {Briand, Lionel and Labiche, Yvan and Han Daphne {Yan} and Di Penta, Massimiliano}
}
@techreport {SE.7.Briand.2004,
	title = {Using Aspect-Oriented Programming to Instrument OCL Contracts in Java},
	number = {SCE-04-03},
	year = {2004},
	publisher = {Carleton University},
	abstract = {Analysis and design by contract allows the definitions of a formal agreement between a class and its clients, expressing each party{\textquoteright}s rights and obligations. Contracts written in the Object-Constraint Language (OCL) are known to be a useful technique to specify the precondition and postcondition of operations and class invariants in a UML context, making the definition of object-oriented analysis or design elements more precise. In this report, we introduce the ocl2j approach to automatically instrument OCL constraints in Java programs using aspect-oriented programming (AOP). One of the many possible applications of checking contract assertions at run time is to help testing and debugging. The approach strives for automatic, efficient generation of contract code and a nonintrusive instrumentation technique. It is assessed on a case study and initial results show that the approach is viable. We conclude by discussing strategies to optimize instrumentation so as to further decrease overhead.},
	author = {Briand, Lionel and Dzidek, James and Labiche, Yvan}
}
@inproceedings {Simula.SE.64,
	title = {Using Simulation to Empirically Investigate State Coverage Criteria Based on Statecharts},
	journal = {ACM International Conference on Software Engineering (ICSE{\textquoteright}04)},
	year = {2004},
	publisher = {Publisher},
	type = {Conference},
	author = {Briand, Lionel and Labiche, Yvan and Wang, Yunlan}
}
@inproceedings {Simula.SE.68,
	title = {Impact Analysis and Change Management of UML Models},
	journal = {IEEE International Conference on Software Maintenance (ICSM{\textquoteright}03)},
	year = {2003},
	pages = {256-265},
	publisher = {Publisher},
	type = {Conference},
	author = {Briand, Lionel and Labiche, Yvan and O{\textquoteright}Sullivan, L.}
}
@article {Simula.SE.28,
	title = {Investigating the Use of Analysis Contracts to Improve the Testability of Object Oriented Code},
	journal = {Software: Practice and Experience},
	volume = {33},
	number = {7},
	year = {2003},
	author = {Briand, Lionel and Labiche, Yvan and Sun, H.}
}
@article {Simula.SE.29,
	title = {Revisiting Strategies for Ordering Class Integration Testing in the Presence of Dependency Cycles},
	journal = {IEEE Transactions on Software Engineering},
	volume = {29},
	number = {7},
	year = {2003},
	author = {Briand, Lionel and Labiche, Yvan and Wang, Y.}
}
@inproceedings {Simula.SE.66,
	title = {Toward a Comprehensive and Systematic Methodology for Class Integration Testing},
	journal = {IEEE International Symposium on Software Reliability Engineering (ISSRE{\textquoteright}03)},
	year = {2003},
	pages = {14-25},
	publisher = {Publisher},
	type = {Conference},
	isbn = {0000000000},
	author = {Briand, Lionel and Labiche, Yvan and Wang, Y.}
}
@inproceedings {Simula.SE.67,
	title = {Towards Automated Support for Deriving Test Data From UML Statecharts},
	journal = {ACM/IEEE International Conference on the Unified Modeling Language (UML{\textquoteright}03)},
	year = {2003},
	pages = {249-264},
	type = {Conference},
	author = {Briand, Lionel and Cui, J. and Labiche, Yvan}
}
@inproceedings {Simula.SE.65,
	title = {Towards the Reverse Engineering of UML Sequence Diagrams},
	journal = {IEEE Working Conference on Reverse Engineering (WCRE{\textquoteright}03)},
	year = {2003},
	pages = {57-66},
	type = {Conference},
	author = {Briand, Lionel and Labiche, Yvan and Miao, Y.}
}
@inproceedings {Simula.SE.71,
	title = {Automating Impact Analysis and Regression Test Selection Based on UML Designs},
	journal = {IEEE International Conference on Software Maintenance (ICSM)},
	year = {2002},
	type = {Conference},
	author = {Briand, Lionel and Labiche, Yvan and Soccar, G.}
}
@inproceedings {Simula.SE.72,
	title = {An Experiment Using the Round-Trip Strategy for State-Based Class Testing},
	journal = {IEEE International Symposium on Software Reliability Engineering (ISSRE)},
	year = {2002},
	type = {Conference},
	author = {Briand, Lionel and Antoniol, G. and Di Penta, Massimiliano and Labiche, Yvan}
}
@inproceedings {Simula.SE.69,
	title = {Investigating the Use of Analysis Contracts to Support Fault Isolation in Object Oriented Code},
	journal = {ACM International Symposium on Software Testing and Analysis (ISSTA)},
	year = {2002},
	pages = {70-80},
	type = {Conference},
	author = {Briand, Lionel and Labiche, Yvan and Sun, H.}
}
@article {Simula.SE.30,
	title = {A UML-Based Approach to System Testing},
	journal = {Software and Systems Modeling},
	volume = {1},
	number = {1},
	year = {2002},
	author = {Briand, Lionel and Labiche, Yvan}
}
@inproceedings {Simula.SE.70,
	title = {Using Genetic Algorithms and Coupling Measures to Devise Optimal Integration Test Orders},
	journal = {ACM International Conference on Software Engineering and Knowledge Engineering (SEKE)},
	year = {2002},
	pages = {43-50},
	type = {Conference},
	author = {Briand, Lionel and Feng, J. and Labiche, Yvan}
}
@inproceedings {Simula.SE.73,
	title = {Revisiting Strategies for Ordering Class Integration Testing in the Presence of Dependency Cycles},
	journal = {IEEE Symposium on Software Reliability Engineering (ISSRE)},
	year = {2001},
	type = {Conference},
	author = {Briand, Lionel and Labiche, Yvan and Wang, Y.}
}
@inproceedings {Simula.SE.74,
	title = {A UML Approach to System Testing},
	journal = {IEEE International Conference on the Unified Modeling Langauge},
	year = {2001},
	type = {Conference},
	author = {Briand, Lionel and Labiche, Yvan}
}
