Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T23:20:25Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

=='''Code Cloning'''==
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

Clone Code Example [Baxter1998]

class Person
{
print 'name:'
print firstname + " " + lastname
}

class Doctor
{
print 'name:'
print firstname + " " + lastname + " M.D."
}

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.[Baxter1998]

Clones can enhance a product line development in a number of ways:

*Removal of redundant code
*Lowering maintenance costs
*Identification of domain concepts for use in the present system or the next
*Identification of parametrized reusable implementations
*Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning. [Baxter1995]

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==
All Clone Techniques Cited From Burd2002

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

[[Image:CloneImage1.jpg]]
[[Image:CloneImage2.jpg]]

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

*Several Questions need to be asked:
*What classes call the code?
*What functionality does the code provide?
*Who “owns” the code?
*How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.[http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html 1]

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

*Multi-threading for multi-core CPU
*AST-based preprocessing with an island-parser like parser.
*Search functions
*Users can adapt the tool to another programming languages or dialects.
*Analysis using metrics of code clone
*For interoperability with another tools, the tool can read/write data in tab separated values text format.
*Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

==References==
*[Baker1992] B.S. Baker, "A Program for Identifying Duplicated Code", Proc. Computing Science and Statistics: 24th Symposium on the Interface, 24, pp. 49-57 Mar. 1992.

*[Baker1995] B.S. Baker, "On finding Duplication and Near-Duplication in Large Software System", Proc. Second IEEE Working Conf. on Reverse Eng., pp. 86-95 Jul. 1995.

*[Balazinska1999] M. Balazinska, E. Merlo, M. Dagenais, B. Lague, and K.A. Kontogiannis, "Measuring Clone Based Reengineering Opportunities", Proc. 6th IEEE Int'l Symposium on Software Metrics (METRICS '99), pp. 292-303, Boca Raton, Florida, Nov. 1999.

*[Baxter1998] I.D. Baxter, A. Yahin, L. Moura, M. Sant'Anna, and L. Bier, "Clone Detection Using Abstract Syntax Trees", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '98, pp. 368-377, Bethesda, Maryland, Nov. 1998.

*[Burd2002] Elizabeth Burd, John Bailey, "Evaluating Clone Detection Tools for Use during Preventative Maintenance," Proc. 2nd IEEE International Workshop on Source Code Analysis and Manipulation (SCAM) 2002, pp. 36-43. Montreal, Canada, Oct. 2002.

*[Ducasse1999] S. Ducasse, M. Rieger, and S. Demeyer. "A Language Independent Approach for Detecting Duplicated Code", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '99, pp. 109-118. Oxford, England. Aug. 1999.

==Links==
*1 - [http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html Code Clone Related Tools]
*2 - [http://research.cs.queensu.ca/home/cordy/Papers/RCK_SCP_Clones.pdf SCP Clones]
*3 - [http://www3.interscience.wiley.com/journal/112136397/abstract?CRETRY=1&SRETRY=0 Wiley Journal]
*4 - [http://www.computer.org/portal/web/csdl/doi/10.1109/ICSTW.2009.18 Mutation and Injection]
*5 - [http://www.cis.uab.edu/softcom/visual/ Visualizations of Code Clone Detection]
*6 - [http://www4.informatik.tu-muenchen.de/~juergens/publications/ICSE2009_FRD_0232_Juergens.pdf Code Clone Technical]

CSC/ECE 517 Fall 2009/wiki3 22 SN

2009-11-22T23:19:50Z

Cjjacks2:

CSC/ECE 517 Fall 2009/wiki3 22 SN

2009-11-22T20:57:54Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

=='''Code Cloning'''==
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.[Baxter1998]

Clones can enhance a product line development in a number of ways:

*Removal of redundant code
*Lowering maintenance costs
*Identification of domain concepts for use in the present system or the next
*Identification of parametrized reusable implementations
*Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning. [Baxter1995]

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==
All Clone Techniques Cited From Burd2002

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

[[Image:CloneImage1.jpg]]
[[Image:CloneImage2.jpg]]

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

*Several Questions need to be asked:
*What classes call the code?
*What functionality does the code provide?
*Who “owns” the code?
*How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.[http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html 1]

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

*Multi-threading for multi-core CPU
*AST-based preprocessing with an island-parser like parser.
*Search functions
*Users can adapt the tool to another programming languages or dialects.
*Analysis using metrics of code clone
*For interoperability with another tools, the tool can read/write data in tab separated values text format.
*Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

==References==
*[Baker1992] B.S. Baker, "A Program for Identifying Duplicated Code", Proc. Computing Science and Statistics: 24th Symposium on the Interface, 24, pp. 49-57 Mar. 1992.

*[Baker1995] B.S. Baker, "On finding Duplication and Near-Duplication in Large Software System", Proc. Second IEEE Working Conf. on Reverse Eng., pp. 86-95 Jul. 1995.

*[Balazinska1999] M. Balazinska, E. Merlo, M. Dagenais, B. Lague, and K.A. Kontogiannis, "Measuring Clone Based Reengineering Opportunities", Proc. 6th IEEE Int'l Symposium on Software Metrics (METRICS '99), pp. 292-303, Boca Raton, Florida, Nov. 1999.

*[Baxter1998] I.D. Baxter, A. Yahin, L. Moura, M. Sant'Anna, and L. Bier, "Clone Detection Using Abstract Syntax Trees", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '98, pp. 368-377, Bethesda, Maryland, Nov. 1998.

*[Burd2002] Elizabeth Burd, John Bailey, "Evaluating Clone Detection Tools for Use during Preventative Maintenance," Proc. 2nd IEEE International Workshop on Source Code Analysis and Manipulation (SCAM) 2002, pp. 36-43. Montreal, Canada, Oct. 2002.

*[Ducasse1999] S. Ducasse, M. Rieger, and S. Demeyer. "A Language Independent Approach for Detecting Duplicated Code", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '99, pp. 109-118. Oxford, England. Aug. 1999.

==Links==
*1 - [http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html Code Clone Related Tools]
*2 - [http://research.cs.queensu.ca/home/cordy/Papers/RCK_SCP_Clones.pdf SCP Clones]
*3 - [http://www3.interscience.wiley.com/journal/112136397/abstract?CRETRY=1&SRETRY=0 Wiley Journal]
*4 - [http://www.computer.org/portal/web/csdl/doi/10.1109/ICSTW.2009.18 Mutation and Injection]
*5 - [http://www.cis.uab.edu/softcom/visual/ Visualizations of Code Clone Detection]
*6 - [http://www4.informatik.tu-muenchen.de/~juergens/publications/ICSE2009_FRD_0232_Juergens.pdf Code Clone Technical]

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T20:39:24Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

=='''Code Cloning'''==
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.[Baxter1998]

Clones can enhance a product line development in a number of ways:

*Removal of redundant code
*Lowering maintenance costs
*Identification of domain concepts for use in the present system or the next
*Identification of parametrized reusable implementations
*Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning. [Baxter1995]

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==
All Clone Techniques Cited From Burd2002

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

[[Image:CloneImage1.jpg]]
[[Image:CloneImage2.jpg]]

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

*Several Questions need to be asked:
*What classes call the code?
*What functionality does the code provide?
*Who “owns” the code?
*How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.[http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html 1]

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

*Multi-threading for multi-core CPU
*AST-based preprocessing with an island-parser like parser.
*Search functions
*Users can adapt the tool to another programming languages or dialects.
*Analysis using metrics of code clone
*For interoperability with another tools, the tool can read/write data in tab separated values text format.
*Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

==References==
*[Baker1992] B.S. Baker, "A Program for Identifying Duplicated Code", Proc. Computing Science and Statistics: 24th Symposium on the Interface, 24, pp. 49-57 Mar. 1992.

*[Baker1995] B.S. Baker, "On finding Duplication and Near-Duplication in Large Software System", Proc. Second IEEE Working Conf. on Reverse Eng., pp. 86-95 Jul. 1995.

*[Balazinska1999] M. Balazinska, E. Merlo, M. Dagenais, B. Lague, and K.A. Kontogiannis, "Measuring Clone Based Reengineering Opportunities", Proc. 6th IEEE Int'l Symposium on Software Metrics (METRICS '99), pp. 292-303, Boca Raton, Florida, Nov. 1999.

*[Baxter1998] I.D. Baxter, A. Yahin, L. Moura, M. Sant'Anna, and L. Bier, "Clone Detection Using Abstract Syntax Trees", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '98, pp. 368-377, Bethesda, Maryland, Nov. 1998.

*[Burd2002] Elizabeth Burd, John Bailey, "Evaluating Clone Detection Tools for Use during Preventative Maintenance," Proc. 2nd IEEE International Workshop on Source Code Analysis and Manipulation (SCAM) 2002, pp. 36-43. Montreal, Canada, Oct. 2002.

*[Ducasse1999] S. Ducasse, M. Rieger, and S. Demeyer. "A Language Independent Approach for Detecting Duplicated Code", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '99, pp. 109-118. Oxford, England. Aug. 1999.

==Links==
*1 - [http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html Code Clone Related Tools]
*2 - [http://research.cs.queensu.ca/home/cordy/Papers/RCK_SCP_Clones.pdf SCP Clones]
*3 - [http://www3.interscience.wiley.com/journal/112136397/abstract?CRETRY=1&SRETRY=0 Wiley Journal]
*4 - [http://www.computer.org/portal/web/csdl/doi/10.1109/ICSTW.2009.18 Mutation and Injection]
*5 - [http://www.cis.uab.edu/softcom/visual/ Visualizations of Code Clone Detection]
*6 - [http://www4.informatik.tu-muenchen.de/~juergens/publications/ICSE2009_FRD_0232_Juergens.pdf Code Clone Technical]

File:CloneImage2.jpg

2009-11-22T20:38:21Z

Cjjacks2:

File:CloneImage1.jpg

2009-11-22T20:38:02Z

Cjjacks2:

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T20:30:01Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

=='''Code Cloning'''==
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.[Baxter1998]

Clones can enhance a product line development in a number of ways:

*Removal of redundant code
*Lowering maintenance costs
*Identification of domain concepts for use in the present system or the next
*Identification of parametrized reusable implementations
*Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning. [Baxter1995]

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==
All Clone Techniques Cited From Burd2002

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

*Several Questions need to be asked:
*What classes call the code?
*What functionality does the code provide?
*Who “owns” the code?
*How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.[http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html 1]

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

*Multi-threading for multi-core CPU
*AST-based preprocessing with an island-parser like parser.
*Search functions
*Users can adapt the tool to another programming languages or dialects.
*Analysis using metrics of code clone
*For interoperability with another tools, the tool can read/write data in tab separated values text format.
*Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

==References==
*[Baker1992] B.S. Baker, "A Program for Identifying Duplicated Code", Proc. Computing Science and Statistics: 24th Symposium on the Interface, 24, pp. 49-57 Mar. 1992.

*[Baker1995] B.S. Baker, "On finding Duplication and Near-Duplication in Large Software System", Proc. Second IEEE Working Conf. on Reverse Eng., pp. 86-95 Jul. 1995.

*[Balazinska1999] M. Balazinska, E. Merlo, M. Dagenais, B. Lague, and K.A. Kontogiannis, "Measuring Clone Based Reengineering Opportunities", Proc. 6th IEEE Int'l Symposium on Software Metrics (METRICS '99), pp. 292-303, Boca Raton, Florida, Nov. 1999.

*[Baxter1998] I.D. Baxter, A. Yahin, L. Moura, M. Sant'Anna, and L. Bier, "Clone Detection Using Abstract Syntax Trees", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '98, pp. 368-377, Bethesda, Maryland, Nov. 1998.

*[Burd2002] Elizabeth Burd, John Bailey, "Evaluating Clone Detection Tools for Use during Preventative Maintenance," Proc. 2nd IEEE International Workshop on Source Code Analysis and Manipulation (SCAM) 2002, pp. 36-43. Montreal, Canada, Oct. 2002.

*[Ducasse1999] S. Ducasse, M. Rieger, and S. Demeyer. "A Language Independent Approach for Detecting Duplicated Code", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '99, pp. 109-118. Oxford, England. Aug. 1999.

==Links==
*1 - [http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html Code Clone Related Tools]
*2 - [http://research.cs.queensu.ca/home/cordy/Papers/RCK_SCP_Clones.pdf SCP Clones]
*3 - [http://www3.interscience.wiley.com/journal/112136397/abstract?CRETRY=1&SRETRY=0 Wiley Journal]
*4 - [http://www.computer.org/portal/web/csdl/doi/10.1109/ICSTW.2009.18 Mutation and Injection]
*5 - [http://www.cis.uab.edu/softcom/visual/ Visualizations of Code Clone Detection]
*6 - [http://www4.informatik.tu-muenchen.de/~juergens/publications/ICSE2009_FRD_0232_Juergens.pdf Code Clone Technical]

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T20:23:09Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

=='''Code Cloning'''==
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.

Clones can enhance a product line development in a number of ways:

*Removal of redundant code
*Lowering maintenance costs
*Identification of domain concepts for use in the present system or the next
*Identification of parametrized reusable implementations
*Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning.

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

*Several Questions need to be asked:
*What classes call the code?
*What functionality does the code provide?
*Who “owns” the code?
*How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.[http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html 1]

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

*Multi-threading for multi-core CPU
*AST-based preprocessing with an island-parser like parser.
*Search functions
*Users can adapt the tool to another programming languages or dialects.
*Analysis using metrics of code clone
*For interoperability with another tools, the tool can read/write data in tab separated values text format.
*Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

==References==
*[Baker1992] B.S. Baker, "A Program for Identifying Duplicated Code", Proc. Computing Science and Statistics: 24th Symposium on the Interface, 24, pp. 49-57 Mar. 1992.

*[Baker1995] B.S. Baker, "On finding Duplication and Near-Duplication in Large Software System", Proc. Second IEEE Working Conf. on Reverse Eng., pp. 86-95 Jul. 1995.

*[Balazinska1999] M. Balazinska, E. Merlo, M. Dagenais, B. Lague, and K.A. Kontogiannis, "Measuring Clone Based Reengineering Opportunities", Proc. 6th IEEE Int'l Symposium on Software Metrics (METRICS '99), pp. 292-303, Boca Raton, Florida, Nov. 1999.

*[Baxter1998] I.D. Baxter, A. Yahin, L. Moura, M. Sant'Anna, and L. Bier, "Clone Detection Using Abstract Syntax Trees", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '98, pp. 368-377, Bethesda, Maryland, Nov. 1998.

*[Burd2002] Elizabeth Burd, John Bailey, "Evaluating Clone Detection Tools for Use during Preventative Maintenance," Proc. 2nd IEEE International Workshop on Source Code Analysis and Manipulation (SCAM) 2002, pp. 36-43. Montreal, Canada, Oct. 2002.

*[Ducasse1999] S. Ducasse, M. Rieger, and S. Demeyer. "A Language Independent Approach for Detecting Duplicated Code", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '99, pp. 109-118. Oxford, England. Aug. 1999.

==Links==
*1 - [http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html Code Clone Related Tools]
*2 - [http://research.cs.queensu.ca/home/cordy/Papers/RCK_SCP_Clones.pdf SCP Clones]
*3 - [http://www3.interscience.wiley.com/journal/112136397/abstract?CRETRY=1&SRETRY=0 Wiley Journal]
*4 - [http://www.computer.org/portal/web/csdl/doi/10.1109/ICSTW.2009.18 Mutation and Injection]
*5 - [http://www.cis.uab.edu/softcom/visual/ Visualizations of Code Clone Detection]
*6 - [http://www4.informatik.tu-muenchen.de/~juergens/publications/ICSE2009_FRD_0232_Juergens.pdf Code Clone Technical]

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T20:19:21Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

=='''Code Cloning'''==
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.

Clones can enhance a product line development in a number of ways:

*Removal of redundant code
*Lowering maintenance costs
*Identification of domain concepts for use in the present system or the next
*Identification of parametrized reusable implementations
*Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning.

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

*Several Questions need to be asked:
*What classes call the code?
*What functionality does the code provide?
*Who “owns” the code?
*How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.[http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html 1]

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

*Multi-threading for multi-core CPU
*AST-based preprocessing with an island-parser like parser.
*Search functions
*Users can adapt the tool to another programming languages or dialects.
*Analysis using metrics of code clone
*For interoperability with another tools, the tool can read/write data in tab separated values text format.
*Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

==References==
*[Baker1992] B.S. Baker, "A Program for Identifying Duplicated Code", Proc. Computing Science and Statistics: 24th Symposium on the Interface, 24, pp. 49-57 Mar. 1992.

*[Baker1995] B.S. Baker, "On finding Duplication and Near-Duplication in Large Software System", Proc. Second IEEE Working Conf. on Reverse Eng., pp. 86-95 Jul. 1995.

*[Balazinska1999] M. Balazinska, E. Merlo, M. Dagenais, B. Lague, and K.A. Kontogiannis, "Measuring Clone Based Reengineering Opportunities", Proc. 6th IEEE Int'l Symposium on Software Metrics (METRICS '99), pp. 292-303, Boca Raton, Florida, Nov. 1999.

*[Baxter1998] I.D. Baxter, A. Yahin, L. Moura, M. Sant'Anna, and L. Bier, "Clone Detection Using Abstract Syntax Trees", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '98, pp. 368-377, Bethesda, Maryland, Nov. 1998.

*[Burd2002] Elizabeth Burd, John Bailey, "Evaluating Clone Detection Tools for Use during Preventative Maintenance," Proc. 2nd IEEE International Workshop on Source Code Analysis and Manipulation (SCAM) 2002, pp. 36-43. Montreal, Canada, Oct. 2002.

*[Ducasse1999] S. Ducasse, M. Rieger, and S. Demeyer. "A Language Independent Approach for Detecting Duplicated Code", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '99, pp. 109-118. Oxford, England. Aug. 1999.

==Links==
*1 - [http://sel.ist.osaka-u.ac.jp/cdtools/index-e.html Code Clone Related Tools]
*2 - [http://research.cs.queensu.ca/home/cordy/Papers/RCK_SCP_Clones.pdf SCP Clones]

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T16:55:07Z

Cjjacks2: /* References */

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

=='''Code Cloning'''==
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.

Clones can enhance a product line development in a number of ways:

*Removal of redundant code
*Lowering maintenance costs
*Identification of domain concepts for use in the present system or the next
*Identification of parametrized reusable implementations
*Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning.

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

*Several Questions need to be asked:
*What classes call the code?
*What functionality does the code provide?
*Who “owns” the code?
*How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

*Multi-threading for multi-core CPU
*AST-based preprocessing with an island-parser like parser.
*Search functions
*Users can adapt the tool to another programming languages or dialects.
*Analysis using metrics of code clone
*For interoperability with another tools, the tool can read/write data in tab separated values text format.
*Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

==References==
*[Baker1992] B.S. Baker, "A Program for Identifying Duplicated Code", Proc. Computing Science and Statistics: 24th Symposium on the Interface, 24, pp. 49-57 Mar. 1992.

*[Baker1995] B.S. Baker, "On finding Duplication and Near-Duplication in Large Software System", Proc. Second IEEE Working Conf. on Reverse Eng., pp. 86-95 Jul. 1995.

*[Balazinska1999] M. Balazinska, E. Merlo, M. Dagenais, B. Lague, and K.A. Kontogiannis, "Measuring Clone Based Reengineering Opportunities", Proc. 6th IEEE Int'l Symposium on Software Metrics (METRICS '99), pp. 292-303, Boca Raton, Florida, Nov. 1999.

*[Baxter1998] I.D. Baxter, A. Yahin, L. Moura, M. Sant'Anna, and L. Bier, "Clone Detection Using Abstract Syntax Trees", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '98, pp. 368-377, Bethesda, Maryland, Nov. 1998.

*[Burd2002] Elizabeth Burd, John Bailey, "Evaluating Clone Detection Tools for Use during Preventative Maintenance," Proc. 2nd IEEE International Workshop on Source Code Analysis and Manipulation (SCAM) 2002, pp. 36-43. Montreal, Canada, Oct. 2002.

*[Ducasse1999] S. Ducasse, M. Rieger, and S. Demeyer. "A Language Independent Approach for Detecting Duplicated Code", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '99, pp. 109-118. Oxford, England. Aug. 1999.

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T16:54:23Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

=='''Code Cloning'''==
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.

Clones can enhance a product line development in a number of ways:

*Removal of redundant code
*Lowering maintenance costs
*Identification of domain concepts for use in the present system or the next
*Identification of parametrized reusable implementations
*Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning.

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

*Several Questions need to be asked:
*What classes call the code?
*What functionality does the code provide?
*Who “owns” the code?
*How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

*Multi-threading for multi-core CPU
*AST-based preprocessing with an island-parser like parser.
*Search functions
*Users can adapt the tool to another programming languages or dialects.
*Analysis using metrics of code clone
*For interoperability with another tools, the tool can read/write data in tab separated values text format.
*Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

==References==
[Baker1992] B.S. Baker, "A Program for Identifying Duplicated Code", Proc. Computing Science and Statistics: 24th Symposium on the Interface, 24, pp. 49-57 Mar. 1992.
[Baker1995] B.S. Baker, "On finding Duplication and Near-Duplication in Large Software System", Proc. Second IEEE Working Conf. on Reverse Eng., pp. 86-95 Jul. 1995.
[Balazinska1999] M. Balazinska, E. Merlo, M. Dagenais, B. Lague, and K.A. Kontogiannis, "Measuring Clone Based Reengineering Opportunities", Proc. 6th IEEE Int'l Symposium on Software Metrics (METRICS '99), pp. 292-303, Boca Raton, Florida, Nov. 1999.
[Baxter1998] I.D. Baxter, A. Yahin, L. Moura, M. Sant'Anna, and L. Bier, "Clone Detection Using Abstract Syntax Trees", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '98, pp. 368-377, Bethesda, Maryland, Nov. 1998.
[Burd2002] Elizabeth Burd, John Bailey, "Evaluating Clone Detection Tools for Use during Preventative Maintenance," Proc. 2nd IEEE International Workshop on Source Code Analysis and Manipulation (SCAM) 2002, pp. 36-43. Montreal, Canada, Oct. 2002.
[Ducasse1999] S. Ducasse, M. Rieger, and S. Demeyer. "A Language Independent Approach for Detecting Duplicated Code", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '99, pp. 109-118. Oxford, England. Aug. 1999.
[Fowler1999] Martin Fowler. Refactoring: improving the design of existing code. Addison Wesley. 1999.
[Kontogiannis1996] K. Kontogiannis, R. DeMori, E. Merlo, M. Galler, and M.Bernstein, "Pattern Matching Techniques for Clone Detection," Journal of Automated Software Engineering, Kluwer Academic Publishers, Vol. 3. pp.77-108, 1996.
[Imai2002] T. Imai, Y. Kataoka, and T. Fukaya, "Evaluating software maintenance cost using functional redundancy metrics," In Proc. 26th International Computer Software and Applications Conference (compsac 2002), pp.299-306, 2002.
[Johnson1994] J. H. Johnson, "Substring Matching for Clone Detection and Change Tracking", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '94, pp. 120-126. Victoria, British Columbia, Canada. Sep. 1994.
[Mayrand1996] J. Mayland, C. Leblanc, and E. M. Merlo. "Experiment on the Automatic Detection of Function Clones in a Software System Using Metrics", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '96, pp. 244-253, Monterey, California, Nov. 1996.
[Laguë1997] B. Laguë, E.M. Merlo, J. Mayrand, and J. Hudepohl. "Assessing the Benefits of Incorporating Function Clone Detection in a Development Process", Proc. IEEE Int'l Conf. on Software Maintenance (ICSM) '97, pp. 314-321, Bari, Italy. Oct. 1997.
[Prechelt2000] Prechelt, L.; Malpohl, G.; Philippsen, M. "JPlag: Finding plagiarisms among a set of programs," Technical Report, University of Karlsruhe, Department of Informatics, 2000.

CSC/ECE 517 Fall 2009/wiki3 22 SN

2009-11-22T16:45:16Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

=='''Code Cloning'''==
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.

Clones can enhance a product line development in a number of ways:

*Removal of redundant code
*Lowering maintenance costs
*Identification of domain concepts for use in the present system or the next
*Identification of parametrized reusable implementations
*Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning.

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

*Several Questions need to be asked:
*What classes call the code?
*What functionality does the code provide?
*Who “owns” the code?
*How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

*Multi-threading for multi-core CPU
*AST-based preprocessing with an island-parser like parser.
*Search functions
*Users can adapt the tool to another programming languages or dialects.
*Analysis using metrics of code clone
*For interoperability with another tools, the tool can read/write data in tab separated values text format.
*Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T16:44:15Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

=='''Code Cloning'''==
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.

Clones can enhance a product line development in a number of ways:

*Removal of redundant code
*Lowering maintenance costs
*Identification of domain concepts for use in the present system or the next
*Identification of parametrized reusable implementations
*Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning.

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

*Several Questions need to be asked:
*What classes call the code?
*What functionality does the code provide?
*Who “owns” the code?
*How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

*Multi-threading for multi-core CPU
*AST-based preprocessing with an island-parser like parser.
*Search functions
*Users can adapt the tool to another programming languages or dialects.
*Analysis using metrics of code clone
*For interoperability with another tools, the tool can read/write data in tab separated values text format.
*Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T16:32:49Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

'''Code Cloning'''
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.

Clones can enhance a product line development in a number of ways:
Removal of redundant code
• Lowering maintenance costs
• Identification of domain concepts for use in the present system or the next
• Identification of parameterized reusable implementations
• Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning.

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

===Parameterized Matching===
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

===Other Techniques===
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.

PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.

Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

==Clone Manipulation==
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.

Several Questions need to be asked:
What classes call the code?
What functionality does the code provide?
Who “owns” the code?
How many systems depend on the code?

Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.

==Clone Dr==
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

==SHINOBI==
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones.

==CCFinderX==

CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.

• Multi-threading for multi-core CPU
• AST-based preprocessing with an island-parser like parser.
• Search functions
• Users can adapt the tool to another programming languages or dialects.
• Analysis using metrics of code clone
• For interoperability with another tools, the tool can read/write data in tab separated values text format.
• Interactive analysis with multiple views of GUI front-end GemX.

==Conclusion==
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T16:26:50Z

Cjjacks2:

'''Clone Detection and Clone Manipulation'''

=='''Thesis'''==
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).

'''Code Cloning'''
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.

There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.

== '''Clone Detection'''==

Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.

Clones can enhance a product line development in a number of ways:
Removal of redundant code
• Lowering maintenance costs
• Identification of domain concepts for use in the present system or the next
• Identification of parameterized reusable implementations
• Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning.

Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

==Clone Detection Techniques==

===String Based ===
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.

===Simple Line Matching===
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.

===Parameterized Line Matching===
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

===Token Based===
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.

Parameterized Matching
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

Other Techniques
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.
PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.
Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

Clone Manipulation
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.
Several Questions need to be asked:
What classes call the code?
What functionality does the code provide?
Who “owns” the code?
How many systems depend on the code?
Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.

Clone Dr
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

SHINOBI
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones
CCFinderX
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.
• Multi-threading for multi-core CPU
• AST-based preprocessing with an island-parser like parser.
• Search functions
• Users can adapt the tool to another programming languages or dialects.
• Analysis using metrics of code clone
• For interoperability with another tools, the tool can read/write data in tab separated values text format.
• Interactive analysis with multiple views of GUI front-end GemX.

Conclusion
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

CSC/ECE 517 Fall 2009/wiki3 2 SN

2009-11-22T16:23:07Z

Cjjacks2:

Clone Detection and Clone Manipulation
The DRY principle says that a particular code fragment should not be repeated more than once in a program. But it happens. And when it does, it is good to be able to find the multiple code "clones." A variety of tools have been designed for this, and some of them even allow joint editing of the clones. Survey the techniques for dealing with the problem, and compare the effectiveness with refactoring (e.g., Extract Method).
Code Cloning
Often in computer systems whether small or large, code can become complex. As systems become larger and larger and more and more people work on the system there are often cases when the code becomes duplicated. Sometimes based on system architecture this is unavoidable. However often times replicated code can be avoided and should be as much as possible. It is always best approach to replace, reuse, and refactor code as much as possible.
There are times when code cloning is unavoidable. Factors such as design, security restrictions, rights of code, and class interaction can all be factors on why code cannot be manipulated in a way in which code cloning is not cannot be fixed.
Clone Detection
Clone detection finds code in large software systems that has been replicated and modified by hand.
Remarkably, clone detection works because people copy conceptually identifiable blocks of code, and make only a few changes. This means the same syntax is detectably repeated. Each identified clone thus indicates the presence of a useful problem domain concept, and simultaneously provides an example implementation. Differences between the copies identify parameters or points of variation.
Clones can enhance a product line development in a number of ways:
• Removal of redundant code
• Lowering maintenance costs
• Identification of domain concepts for use in the present system or the next
• Identification of parameterized reusable implementations
• Sometimes reveal code bugs directly by inspection of parameter bindings with inconsistent actual or conceptual types

There is much hidden knowledge in open source software that can be valuable for improving software quality and productivity. For example, if we want to implement a new feature and know there exists code with similar functionalities in other projects, either reusing the existing code or simply using it for reference will likely shorten development time. Other examples include if a know software fault may occur within a particular context, we can quickly locate all similar defects. To uncover the hidden knowledge, a requisite step is to create an effective code search tool that can scale to the whole open source world, which contains hundreds of billions, even trillions of lines of code. An important aspect of code search is to find copied-and-pasted code or code that looks similar which is code cloning.
Taken the approach that there is much to gain from code clone detection there is a need to compare the effectiveness of clone manipulation when a clone is found.

Clone Detection Techniques
String Based
String based techniques use basic string transformation and comparison algorithms which makes them independent of programming languages. Techniques in this category differ in underlying string comparison algorithm. Comparing calculated signatures per line, is one possibility to identify for matching substrings. Line matching, which comes in two variants, is an alternative which is selected as representative for this category because it uses general string manipulations.
Simple Line Matching
Simple Line Matching is the first variant of line matching in which both detection phases are straightforward. Only minor transformations using string manipulation operations, which can operate using no or very limited knowledge about possible language constructs, are applied. Typical transformations are the removal of empty lines and white spaces. During comparison all lines are compared with each other using a string matching algorithm. This results in a large search space which is usually reduced using hashing buckets.
Parameterized Line Matching
Parameterized Line Matching is another variant of line matching which detects both identical as well as similar code fragments. The idea is that since identifier–names and literals are likely to change when cloning a code fragment, they can be considered as changeable parameters. Therefore, similar fragments which differ only in the naming of these parameters, are allowed.

Token Based
Token based techniques use a more sophisticated transformation algorithm by constructing a token stream from the source code. The presence of such tokens makes it possible to use improved comparison algorithms. Next to parameterized matching with suffix trees, which acts as representative, we include in this category because it also transforms the source code in a token-structure which is afterwards matched. The latter tries to remove much more detail by summarizing non interesting code fragments.
Parameterized Matching
Parameterized Matching With Suffix Trees consists of three consecutive steps manipulating a suffix tree as internal representation. In the first step, a lexical analyser passes over the source text transforming identifiers and literals in parameter symbols, while the typographical structure of each line is encoded in a non-parameter symbol. One symbol always refers to the same identifier, literal or structure. The result of this first step is a parameterized string or p-string.
Once the p-string is constructed, a criterion to decide whether two sequences in this p-string are a parameterized match or not is necessary. Two strings are a parameterized match if one can be transformed into the other by applying a one-to-one mapping renaming the parameter symbols. An additional encoding prev(S) of the parameter symbols helps us verifying this criterion. In this encoding, each first occurrence of a parameter symbol is replaced by a 0. All later occurrences are replaced by the distance since the previous occurrence of the same symbol. Thus, when two sequences have the same encoding, they are the same except for a systematic renaming of the parameter symbols.
After the lexical analysis, a data structure called a parameterized suffix tree (p-suffix tree) is built for the pstring. A p-suffix tree is a generalisation of the suffix tree data structure [16] which contains the prev()-encoding of every suffix of a P-string. Concatenating the labels of the arcs on the path from the root to the leaf yields the prev( )-encoding of one suffix. The use of a suffix tree allows a more efficient detection of maximal, parameterized matches.

Other Techniques
AST-based techniques use parsers to first obtain a syntactical representation of the source code, typically an abstract syntax tree (AST). The clone detection algorithms then search for similar subtrees in this AST.
PDG-based approaches go one step further in obtaining a source code representation of high abstraction. Program dependence graphs (PDGs) contain information of semantically nature, such as control- and data flow of the program.
Metrics-based techniques are related to hashing algorithms. For each fragment of a program the values of a number of metrics is calculated, which are subsequently used to find similar fragments.

Clone Manipulation
So what happens when clone code is? Once the clone detection tools have found code what techniques are available for the tools to solve the issues. The first step is to investigate why the clone code is there.
Several Questions need to be asked:
What classes call the code?
What functionality does the code provide?
Who “owns” the code?
How many systems depend on the code?
Once these questions have been answered and it has been decided that this code cloning needs to be resolved then there are different techniques in solving the code clone issue. There are many tools out there to use for code detection and manipulation. Described below are the different tools researched and some information on the techniques used.

Clone Dr
The CloneDR™ is built with the DMS/Software Reengineering Toolkit. This technology identifies not only exact, but near-miss duplicates in software systems and can be used on a wide variety of languages. Using compiler technology rather than string matching, it will find clones in spite of changed comments, white spaces, line breaks, case changes, different variable names and even different expressions in the clone body. It detects clones in code and/or data declarations. Detected clones can be filtered by size, and automatically or interactively removed. Clones can be removed by replacing them with equivalent preprocessor macros, type declarations, subroutine calls, or inlined subroutine calls (dependent on language and options), without changing the system functionality. The replacement is automatically generated from the detected clones.

SHINOBI
SHINOBI is supported as an Add-In of Microsoft Visual Studio 2005. It automatically detects clones without the programmer's clear intention at the time of opening and editing source code, and constantly displays the detected clones on the view in IDE. SHINOBI displays the detected clones in order of the ranking f the similarity between the source code on the cursor and the detected clones, and the information in the CVS repository, such as message logs and committed dates of the source code that is detected clones
CCFinderX
CCFinder can be applied to huge source codes. From a source code with approximately a million lines, CCFinder can detect code clones within several minutes to several hours using a PC/AT compatible. By lexical analysis and transformation based on the syntax of the programming languages, CCFinder can extract code clones correctly from source files, even in cases where the names of variables have been changed. CCFinder can run for C/C++, Java, COBOL, Fortran, etc.
• Multi-threading for multi-core CPU
• AST-based preprocessing with an island-parser like parser.
• Search functions
• Users can adapt the tool to another programming languages or dialects.
• Analysis using metrics of code clone
• For interoperability with another tools, the tool can read/write data in tab separated values text format.
• Interactive analysis with multiple views of GUI front-end GemX.

Conclusion
There are many different ways to go about code clone detection. Code clones can be detected on an exact match basis. Unfortunately, using exact match criteria for code clone detection may not be sufficient in all cases. For instance, a programmer may copy a particular piece of code, paste it to another location in the system and proceed to change the pasted code such that it remains syntactically similar to the original code, but not exactly similar. Thus, some form of near-exact clone detection must be employed. Parameterized matching (representative for the token-based approaches) provides a precise picture of a given piece of duplicated code and is robust against rename operations. Therefore it works best in combination with fine-grained refactoring tools that work on the level of statements. This is similar to how the refactoring methods of Extract Method, Move Behaviour, Close to Data, and Transform Conditionals into Polymorphism work.
Although there are different techniques use than the refactoring code methods the software tools seem to work nicely and continue to get better. The tools take a variety of techniques and make them work at an efficient level. As the technology advances the tools will become more and more useful to detect code clone issues.

CSC/ECE 517 Fall 2009/wiki3 22 SN

2009-11-19T19:55:41Z

Cjjacks2:

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T12:16:27Z

Cjjacks2: /* '''Why Mock?''' */

== Comparison of Mock Frameworks ==

When performing tests, it's convenient to have the objects be in a particular configuration, so that boundary cases can be tested. Setting up the objects can sometimes be complicated. There are different Mock Frameworks out in the development community that can be used to develop these tests. This page attempts to define and compare these different types of [http://en.wikipedia.org/wiki/Framework frameworks].

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [http://en.wikipedia.org/wiki/Mock_object 3]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable [http://en.wikipedia.org/wiki/Application_programming_interface APIs] that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented program] is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.[http://msdn.microsoft.com/en-us/magazine/dd882516.aspx 2]

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like [http://en.wikipedia.org/wiki/Spring_Framework Java Spring] have increase in popularity because they allow the ability to inject the proxy objects without modifying code.
[http://www.carlosble.com/?p=348 Proxy]

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.
[http://download.oracle.com/docs/cd/E13189_01/kodo/docs324/ref_guide_mapping_classmapping.html Class Mapping]

== Examples of Mocking ==

Lets say you have a an interface that looks like this:

public interface FileInterface
{
public void openFile(String filename) ;
public void closeFile() ;
public String readFile() ;
}

Then you have a class that looks like this:

public class FileManipulator implements FileInterface
{
private BufferedReader in;
private boolean error = false;
public void openFile(String filename)
{
try
{
in = new BufferedReader(new FileReader(filename));
} catch (FileNotFoundException e) {}
}
public void closeFile()
{
try
{
in.close();
} catch (IOException e) {}
}
public String readFile()
{
String s;
try
{
s = in.readLine();
} catch (IOException e) {}

return s;
}
}

The Mock File would look something like this:

public class MockFileManipulator implements FileInterface
{
private boolean initialized = false;
private boolean error = false;
private String filename;
public void openFile(String filename)
{
if (filename == null || filename.equals(""))
{
Assert.fail("Name of file is either null or blank");
}
this.filename = filename;
initialized = true;
}
public void closeFile()
{
if (!initialized)
{
Assert.fail("Trying to close before open");
}
}
public String readFile()
{
if (!initialized)
{
Assert.fail("Trying to read before open");
return null;
}
if (filename.equals("readerror"))
{
error = true;
return "";
}
return null;
}
}

Then when you have a test class or the class that you use the FileManipulator class, instead of:

FileManipulator fileChanger = new FileManipulator ();
fileChanger.openFile("MyTestFile.txt")
fileChanger.readFile();
fileChanger.closeFile();

Use the MockFileManipulator constructor to define the data object.

MockFileManipulator fileChanger = new MockFileManipulator ();
fileChanger.openFile("MyTestFile.txt")
fileChanger.readFile();
fileChanger.closeFile();

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

4. [http://javaboutique.internet.com/tutorials/mock_objects/ Java Mock Objects]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T12:15:54Z

Cjjacks2: /* Definition */

== Comparison of Mock Frameworks ==

When performing tests, it's convenient to have the objects be in a particular configuration, so that boundary cases can be tested. Setting up the objects can sometimes be complicated. There are different Mock Frameworks out in the development community that can be used to develop these tests. This page attempts to define and compare these different types of [http://en.wikipedia.org/wiki/Framework frameworks].

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [http://en.wikipedia.org/wiki/Mock_object 3]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable [http://en.wikipedia.org/wiki/Application_programming_interface APIs] that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.[http://msdn.microsoft.com/en-us/magazine/dd882516.aspx 2]

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like [http://en.wikipedia.org/wiki/Spring_Framework Java Spring] have increase in popularity because they allow the ability to inject the proxy objects without modifying code.
[http://www.carlosble.com/?p=348 Proxy]

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.
[http://download.oracle.com/docs/cd/E13189_01/kodo/docs324/ref_guide_mapping_classmapping.html Class Mapping]

== Examples of Mocking ==

Lets say you have a an interface that looks like this:

public interface FileInterface
{
public void openFile(String filename) ;
public void closeFile() ;
public String readFile() ;
}

Then you have a class that looks like this:

public class FileManipulator implements FileInterface
{
private BufferedReader in;
private boolean error = false;
public void openFile(String filename)
{
try
{
in = new BufferedReader(new FileReader(filename));
} catch (FileNotFoundException e) {}
}
public void closeFile()
{
try
{
in.close();
} catch (IOException e) {}
}
public String readFile()
{
String s;
try
{
s = in.readLine();
} catch (IOException e) {}

return s;
}
}

The Mock File would look something like this:

public class MockFileManipulator implements FileInterface
{
private boolean initialized = false;
private boolean error = false;
private String filename;
public void openFile(String filename)
{
if (filename == null || filename.equals(""))
{
Assert.fail("Name of file is either null or blank");
}
this.filename = filename;
initialized = true;
}
public void closeFile()
{
if (!initialized)
{
Assert.fail("Trying to close before open");
}
}
public String readFile()
{
if (!initialized)
{
Assert.fail("Trying to read before open");
return null;
}
if (filename.equals("readerror"))
{
error = true;
return "";
}
return null;
}
}

Then when you have a test class or the class that you use the FileManipulator class, instead of:

FileManipulator fileChanger = new FileManipulator ();
fileChanger.openFile("MyTestFile.txt")
fileChanger.readFile();
fileChanger.closeFile();

Use the MockFileManipulator constructor to define the data object.

MockFileManipulator fileChanger = new MockFileManipulator ();
fileChanger.openFile("MyTestFile.txt")
fileChanger.readFile();
fileChanger.closeFile();

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

4. [http://javaboutique.internet.com/tutorials/mock_objects/ Java Mock Objects]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T12:15:34Z

Cjjacks2: /* Definition */

== Comparison of Mock Frameworks ==

When performing tests, it's convenient to have the objects be in a particular configuration, so that boundary cases can be tested. Setting up the objects can sometimes be complicated. There are different Mock Frameworks out in the development community that can be used to develop these tests. This page attempts to define and compare these different types of [http://en.wikipedia.org/wiki/Framework frameworks].

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [http://en.wikipedia.org/wiki/Mock_object 3]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable [ http://en.wikipedia.org/wiki/Application_programming_interface APIs] that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.[http://msdn.microsoft.com/en-us/magazine/dd882516.aspx 2]

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like [http://en.wikipedia.org/wiki/Spring_Framework Java Spring] have increase in popularity because they allow the ability to inject the proxy objects without modifying code.
[http://www.carlosble.com/?p=348 Proxy]

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.
[http://download.oracle.com/docs/cd/E13189_01/kodo/docs324/ref_guide_mapping_classmapping.html Class Mapping]

== Examples of Mocking ==

Lets say you have a an interface that looks like this:

public interface FileInterface
{
public void openFile(String filename) ;
public void closeFile() ;
public String readFile() ;
}

Then you have a class that looks like this:

public class FileManipulator implements FileInterface
{
private BufferedReader in;
private boolean error = false;
public void openFile(String filename)
{
try
{
in = new BufferedReader(new FileReader(filename));
} catch (FileNotFoundException e) {}
}
public void closeFile()
{
try
{
in.close();
} catch (IOException e) {}
}
public String readFile()
{
String s;
try
{
s = in.readLine();
} catch (IOException e) {}

return s;
}
}

The Mock File would look something like this:

public class MockFileManipulator implements FileInterface
{
private boolean initialized = false;
private boolean error = false;
private String filename;
public void openFile(String filename)
{
if (filename == null || filename.equals(""))
{
Assert.fail("Name of file is either null or blank");
}
this.filename = filename;
initialized = true;
}
public void closeFile()
{
if (!initialized)
{
Assert.fail("Trying to close before open");
}
}
public String readFile()
{
if (!initialized)
{
Assert.fail("Trying to read before open");
return null;
}
if (filename.equals("readerror"))
{
error = true;
return "";
}
return null;
}
}

Then when you have a test class or the class that you use the FileManipulator class, instead of:

FileManipulator fileChanger = new FileManipulator ();
fileChanger.openFile("MyTestFile.txt")
fileChanger.readFile();
fileChanger.closeFile();

Use the MockFileManipulator constructor to define the data object.

MockFileManipulator fileChanger = new MockFileManipulator ();
fileChanger.openFile("MyTestFile.txt")
fileChanger.readFile();
fileChanger.closeFile();

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

4. [http://javaboutique.internet.com/tutorials/mock_objects/ Java Mock Objects]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T12:14:56Z

Cjjacks2: /* Comparison of Mock Frameworks */

== Comparison of Mock Frameworks ==

When performing tests, it's convenient to have the objects be in a particular configuration, so that boundary cases can be tested. Setting up the objects can sometimes be complicated. There are different Mock Frameworks out in the development community that can be used to develop these tests. This page attempts to define and compare these different types of [http://en.wikipedia.org/wiki/Framework frameworks].

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [http://en.wikipedia.org/wiki/Mock_object 3]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable APIs that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.[http://msdn.microsoft.com/en-us/magazine/dd882516.aspx 2]

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like [http://en.wikipedia.org/wiki/Spring_Framework Java Spring] have increase in popularity because they allow the ability to inject the proxy objects without modifying code.
[http://www.carlosble.com/?p=348 Proxy]

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.
[http://download.oracle.com/docs/cd/E13189_01/kodo/docs324/ref_guide_mapping_classmapping.html Class Mapping]

== Examples of Mocking ==

Lets say you have a an interface that looks like this:

public interface FileInterface
{
public void openFile(String filename) ;
public void closeFile() ;
public String readFile() ;
}

Then you have a class that looks like this:

public class FileManipulator implements FileInterface
{
private BufferedReader in;
private boolean error = false;
public void openFile(String filename)
{
try
{
in = new BufferedReader(new FileReader(filename));
} catch (FileNotFoundException e) {}
}
public void closeFile()
{
try
{
in.close();
} catch (IOException e) {}
}
public String readFile()
{
String s;
try
{
s = in.readLine();
} catch (IOException e) {}

return s;
}
}

The Mock File would look something like this:

public class MockFileManipulator implements FileInterface
{
private boolean initialized = false;
private boolean error = false;
private String filename;
public void openFile(String filename)
{
if (filename == null || filename.equals(""))
{
Assert.fail("Name of file is either null or blank");
}
this.filename = filename;
initialized = true;
}
public void closeFile()
{
if (!initialized)
{
Assert.fail("Trying to close before open");
}
}
public String readFile()
{
if (!initialized)
{
Assert.fail("Trying to read before open");
return null;
}
if (filename.equals("readerror"))
{
error = true;
return "";
}
return null;
}
}

Then when you have a test class or the class that you use the FileManipulator class, instead of:

FileManipulator fileChanger = new FileManipulator ();
fileChanger.openFile("MyTestFile.txt")
fileChanger.readFile();
fileChanger.closeFile();

Use the MockFileManipulator constructor to define the data object.

MockFileManipulator fileChanger = new MockFileManipulator ();
fileChanger.openFile("MyTestFile.txt")
fileChanger.readFile();
fileChanger.closeFile();

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

4. [http://javaboutique.internet.com/tutorials/mock_objects/ Java Mock Objects]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T12:10:31Z

Cjjacks2: /* Links */

== Comparison of Mock Frameworks ==

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [http://en.wikipedia.org/wiki/Mock_object 3]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable APIs that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.[http://msdn.microsoft.com/en-us/magazine/dd882516.aspx 2]

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like [http://en.wikipedia.org/wiki/Spring_Framework Java Spring] have increase in popularity because they allow the ability to inject the proxy objects without modifying code.
[http://www.carlosble.com/?p=348 Proxy]

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.
[http://download.oracle.com/docs/cd/E13189_01/kodo/docs324/ref_guide_mapping_classmapping.html Class Mapping]

== Examples of Mocking ==

Lets say you have a an interface that looks like this:

public interface FileInterface
{
public void openFile(String filename) ;
public void closeFile() ;
public String readFile() ;
}

Then you have a class that looks like this:

public class FileManipulator implements FileInterface
{
private BufferedReader in;
private boolean error = false;
public void openFile(String filename)
{
try
{
in = new BufferedReader(new FileReader(filename));
} catch (FileNotFoundException e) {}
}
public void closeFile()
{
try
{
in.close();
} catch (IOException e) {}
}
public String readFile()
{
String s;
try
{
s = in.readLine();
} catch (IOException e) {}

return s;
}
}

The Mock File would look something like this:

public class MockFileManipulator implements FileInterface
{
private boolean initialized = false;
private boolean error = false;
private String filename;
public void openFile(String filename)
{
if (filename == null || filename.equals(""))
{
Assert.fail("Name of file is either null or blank");
}
this.filename = filename;
initialized = true;
}
public void closeFile()
{
if (!initialized)
{
Assert.fail("Trying to close before open");
}
}
public String readFile()
{
if (!initialized)
{
Assert.fail("Trying to read before open");
return null;
}
if (filename.equals("readerror"))
{
error = true;
return "";
}
return null;
}
}

Then when you have a test class or the class that you use the FileManipulator class, instead of:

FileManipulator fileChanger = new FileManipulator ();
fileChanger.openFile("MyTestFile.txt")
fileChanger.readFile();
fileChanger.closeFile();

Use the MockFileManipulator constructor to define the data object.

MockFileManipulator fileChanger = new MockFileManipulator ();
fileChanger.openFile("MyTestFile.txt")
fileChanger.readFile();
fileChanger.closeFile();

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

4. [http://javaboutique.internet.com/tutorials/mock_objects/ Java Mock Objects]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T12:09:42Z

Cjjacks2: /* Examples of Mocking */

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T11:55:40Z

Cjjacks2:

== Comparison of Mock Frameworks ==

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [http://en.wikipedia.org/wiki/Mock_object 3]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable APIs that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.[http://msdn.microsoft.com/en-us/magazine/dd882516.aspx 2]

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like [http://en.wikipedia.org/wiki/Spring_Framework Java Spring] have increase in popularity because they allow the ability to inject the proxy objects without modifying code.
[http://www.carlosble.com/?p=348 Proxy]

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.
[http://download.oracle.com/docs/cd/E13189_01/kodo/docs324/ref_guide_mapping_classmapping.html Class Mapping]

== Examples of Mocking ==

Lets say you have a an interface that looks like this:

public interface FileInterface
{
public void openFile(String filename) ;
public void closeFile() ;
public String readFile() ;
}

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T11:43:48Z

Cjjacks2:

== Comparison of Mock Frameworks ==

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [http://en.wikipedia.org/wiki/Mock_object 3]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable APIs that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.[http://www.michaelminella.com/testing/the-concept-of-mocking.html 1]

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.[http://msdn.microsoft.com/en-us/magazine/dd882516.aspx 2]

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like [http://en.wikipedia.org/wiki/Spring_Framework Java Spring] have increase in popularity because they allow the ability to inject the proxy objects without modifying code.
[http://www.carlosble.com/?p=348 Proxy]

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.
[http://download.oracle.com/docs/cd/E13189_01/kodo/docs324/ref_guide_mapping_classmapping.html Class Mapping]

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T11:42:12Z

Cjjacks2: /* '''Why Mock?''' */

== Comparison of Mock Frameworks ==

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [FROM http://en.wikipedia.org/wiki/Mock_object ]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable APIs that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.[1 http://www.michaelminella.com/testing/the-concept-of-mocking.html]

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.[1 http://www.michaelminella.com/testing/the-concept-of-mocking.html]

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like [http://en.wikipedia.org/wiki/Spring_Framework Java Spring] have increase in popularity because they allow the ability to inject the proxy objects without modifying code.
[http://www.carlosble.com/?p=348 Proxy]

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.
[http://download.oracle.com/docs/cd/E13189_01/kodo/docs324/ref_guide_mapping_classmapping.html Class Mapping]

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T11:38:30Z

Cjjacks2: /* Proxy */

== Comparison of Mock Frameworks ==

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [FROM http://en.wikipedia.org/wiki/Mock_object ]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable APIs that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like [http://en.wikipedia.org/wiki/Spring_Framework Java Spring] have increase in popularity because they allow the ability to inject the proxy objects without modifying code.
[http://www.carlosble.com/?p=348 Proxy]

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.
[http://download.oracle.com/docs/cd/E13189_01/kodo/docs324/ref_guide_mapping_classmapping.html Class Mapping]

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-17T11:35:25Z

Cjjacks2:

== Comparison of Mock Frameworks ==

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [FROM http://en.wikipedia.org/wiki/Mock_object ]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable APIs that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like Java Spring have increase in popularity because they allow the ability to inject the proxy objects without modifying code.
[http://www.carlosble.com/?p=348 Proxy]

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.
[http://download.oracle.com/docs/cd/E13189_01/kodo/docs324/ref_guide_mapping_classmapping.html Class Mapping]

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-14T16:11:23Z

Cjjacks2: /* Comparison of Mock Frameworks */

== Comparison of Mock Frameworks ==
'''NOTE:''' THIS SECTION WILL BE REMOVED FROM THE FINAL VERSION

Assignment:
Mock objects and mock frameworks. When performing tests, it's convenient to have the objects be in a particular configuration, so that boundary cases can be tested. Setting up the objects can sometimes be complicated. The Wikipedia article for mock objects lists several, but does not compare them. Compare different systems for mock objects, and mock frameworks (which are used to set up mock objects).

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [FROM http://en.wikipedia.org/wiki/Mock_object ]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable APIs that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like Java Spring have increase in popularity because they allow the ability to inject the proxy objects without modifying code.

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-13T18:54:01Z

Cjjacks2: /* Definition */

== Comparison of Mock Frameworks ==
'''NOTE:''' THIS SECTION WILL BE REMOVED FOR FINAL VERSION

Assignment:
Mock objects and mock frameworks. When performing tests, it's convenient to have the objects be in a particular configuration, so that boundary cases can be tested. Setting up the objects can sometimes be complicated. The Wikipedia article for mock objects lists several, but does not compare them. Compare different systems for mock objects, and mock frameworks (which are used to set up mock objects).

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [FROM http://en.wikipedia.org/wiki/Mock_object ]

Mock frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable APIs that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like Java Spring have increase in popularity because they allow the ability to inject the proxy objects without modifying code.

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]

CSC/ECE 517 Fall 2009/wiki 1a 9b SJ

2009-09-13T18:49:21Z

Cjjacks2: /* References */

== What is Code Refactoring ==

According to the famous book "Refactoring: Improving the Design of Existing Code " by Martin Fowler: Refactoring is the process of applying behavior-preserving transformations
to a program with the objective of improving the program’s design. Intuitively people refer to code refactoring as "cleaning it up."

=== Motivation of Refactoring ===

Refactoring is very useful for software engineer to maintain the quality of their code in different environment. In fact, no software can be guaranteed to be perfect when it is first developed.
Usually when the source code is applied to different customer needs, we want to improve the inner-structure without modify the external behavior. The ability to refactor your code takes
the pressure off the design phase of software development. Refactoring gives you the ability to change the design of the code at a later stage. This means that you don’t have to get the
design absolutely right before you write any code. You can get a rough design worked out, code it up and then if (when) you spot a better design you can refactor your code towards the
better design.

=== List of Common Refactorings ===

In the following we list some popular refactoring to specify how refactoring transform the code. For more detail information, the reader please refer to the section 2.1.2 of the
thesis of Thomas Corbat[1]. [1] provide Ruby example for each refactoring this list.

{|
| 1. Merge Class Parts
|-
| 2. Convert Local Variable to Field
|-
| 3. Encapsulate Field
|-
| 4. Extract Method
|-
| 5. Inline Class
|-
| 6. Inline Method
|-
| 7. Move Field
|-
| 8. Move Method
|-
| 9. Rename Class
|-
| 10. Rename Field
|-
| 11. Rename Local Variable
|-
| 12. Rename Method
|-
| 13. Replace Temporary Variable with Query
|-
| 14. Split Temporary Variable
|}

=== Ruby Example of Refactoring ===

before rename:

def badRenameMethod
puts("Hello World");
end

after rename:

def hello
puts("Hello World");
end

before encapsulation:

class SomeClass
def initialize
@field = 0;
end
end

after encapsulation:

class SomeClass
def initialize
@field = 0;
end

def field
@field
end
private :field

def field= field
@field = field
end
private :field=
end

=== Java Example of Refactoring ===

before rename:

public class rename_method
{
static void badRenameMethod()
{
System.out.println("Hello, world!");
}
}

after rename:

public class rename_method
{
static void hello()
{
System.out.println("Hello, world!");
}
}

before encapsulation:

public class encap_field
{
public String field;
}

after encapsulation:

public class encap_field
{
private int field;

public void setField(int field)
{
this.field = field;
}

public int getField()
{
return field;
}
}

== Refactoring support for Current Ruby IDE ==

This the following table we summary the current ruby IDE and their refactoring support situation.
{|
| Current Ruby IDE || Refactoring Support (Y/N)
|-
| ActiveState Komodo || N
|-
| NetBeans || N
|-
| Arachno Ruby || N
|-
| FreeRIDE || N
|-
| Mondrian Ruby IDE || N
|-
| Ruby in Steel || N
|-
| RubyMine || Y
|-
| Eclipse (Aptana) || Y
|}

=== Example of Using Ruby Refactoring Tools in Eclipse ===
Here the renaming of the method "badRenameMethod" to "Hello" is illustrated for Ruby. The source code is shown in section 1.3.
{|
| [[Image:r00.jpg|thumb|upright|alt= rename step 1]]
| [[Image:r01.jpg|thumb|upright|alt= rename step 2]]
| [[Image:r02.jpg|thumb|upright|alt= rename step 3]]
| [[Image:r03.jpg|thumb|upright|alt= rename step 4]]
| [[Image:r04.jpg|thumb|upright|alt= rename step 5]]
|}

Here the encapsulation of the field "field" is illustrated for Ruby. The source code is show in section 1.3.
{|
| [[Image:r05.jpg|thumb|upright|alt= encapsulation step 1]]
| [[Image:r06.jpg|thumb|upright|alt= encapsulation step 2]]
| [[Image:r07.jpg|thumb|upright|alt= encapsulation step 3]]
| [[Image:r08.jpg|thumb|upright|alt= encapsulation step 4]]
| [[Image:r09.jpg|thumb|upright|alt= encapsulation step 5]]
|}

=== Example of Using Java Refactoring Tools in Eclipse ===
Here the renaming of the method "badRenameMethod" to "Hello" is illustrated for Java. The source code is show in section 1.4.

{|
| [[Image:j00.jpg|thumb|upright|alt= rename step 1]]
| [[Image:j01.jpg|thumb|upright|alt= rename step 2]]
| [[Image:j02.jpg|thumb|upright|alt= rename step 3]]
| [[Image:j03.jpg|thumb|upright|alt= rename step 4]]
| [[Image:j04.jpg|thumb|upright|alt= rename step 5]]
| [[Image:j05.jpg|thumb|upright|alt= rename step 6]]
|}
Here the encapsulation of the field "field" is illustrated for Java. The source code is show in section 1.4.

{|
| [[Image:j06.jpg|thumb|upright|alt= encapsulation step 1]]
| [[Image:j07.jpg|thumb|upright|alt= encapsulation step 2]]
| [[Image:j08.jpg|thumb|upright|alt= encapsulation step 3]]
| [[Image:j09.jpg|thumb|upright|alt= encapsulation step 4]]
|}

== Comparison of Ruby and Java Refactoring Tools ==
Comprehensiveness comparison:

{|
|1. Refactoring Options for Java in Eclipse |||| 2. Refactoring Options in Eclipse for Ruby
|-
|Rename || || Rename
|-
|Move || || Move
|-
|Change Method Signature || || Merge Class Parts in File
|-
|Extract Local Variable || || Pull Up
|-
|Extract Constant || || Pull Down
|-
|Inline || || Merge With External Class Parts
|-
|Convert Anonymous Class to Nested || || Split Local Variable
|-
|Convert Member to Top Level || || Merge With External Class Parts
|-
|Convert Local Variable to Field || || Inline
|-
|Extract Super Class || || Extract Constant
|-
|Extract Interface || || Encapsulate Field
|-
|Extract Class || || Convert Local Variable to Field
|-
|Use Supertype where possible
|-
|Pull Up
|-
|Pull Down
|-
|Introduce Parameter Object
|-
|Introduce Indirection
|-
|Introduce Factory
|-
|Introduce Parameter
|-
|Encapsulate Field
|-
|Generalize Declared Type
|-
|Infer Generic Type Arguments
|}

The refactoring options for Ruby and Java cover all the basic refactorings. The differences in the number of options mainly come from the difference in the two languages.
Ruby is a dynamically typed language, has unbounded polymorphism, and all classes are open to extension. On the other hand, Java is a statically typed language,
polymorphism is mainly implemented via interfaces and inheritance, and classes cannot be extended at runtime. The given examples (in section 1.3, 1.4)
illustrate the ease of use of the refactoring tools for both Ruby and Java and how well these tools are integrated into the Eclipse IDE.

== References ==

[1] Thomas Corbat, Lukas Felber, Mirko Stocker
Refactoring Support for the Eclipse Ruby Development Tools, Diploma Thesis, HSR University of Applied Sciences Rapperswil Institute for Software.

[2] code refactoring wiki, http://en.wikipedia.org/wiki/Code_refactoring.

[3] the first workshop on refactoring, https://netfiles.uiuc.edu/dig/RefactoringWorkshop

[4] refactoring tutorial on ruby on rail, http://www.good-tutorials.com/tutorials/ruby-on-rails/refactoring

CSC/ECE 517 Fall 2009/wiki1a 2 sn

2009-09-12T15:29:59Z

Cjjacks2:

== Comparison of Mock Frameworks ==
'''NOTE:''' THIS SECTION WILL BE REMOVED FOR FINAL VERSION

Assignment:
Mock objects and mock frameworks. When performing tests, it's convenient to have the objects be in a particular configuration, so that boundary cases can be tested. Setting up the objects can sometimes be complicated. The Wikipedia article for mock objects lists several, but does not compare them. Compare different systems for mock objects, and mock frameworks (which are used to set up mock objects).

== Definition ==
In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts. [FROM http://en.wikipedia.org/wiki/Mock_object ]

Mock Frameworks are the environments that are available to create these mock objects and mock tests.
There are many different types of frameworks for different platforms. They are a set of programmable APIs that allow creation of mock and stub objects in relative easy fashion. Mock frameworks save the developer from the need to write repetitive code to test or simulate object interactions.

== Concepts ==

==='''Why Mock?'''===

*The concept behind mock objects is that there is a need to create an object that will take the place of the real object. This mock object will expect a certain method to be called with certain parameters and when that happens, it will return an expected result. When writing units tests for a class that would normally use the real object, we can instead supply it with a mock object. This allows us a new level of flexibility in testing.

*Ease of modifying the mock object during separate tests to get it to get it to return a range of different data. Test can pass in valid, invalid, and extreme ranges to test how the code calling it handles such situations.

*Simulation of failures, such as the inability to connect to a database, to test the failure mode of classes.

*Encourages better structured tests and, more importantly, improved domain code by preserving encapsulation, reducing dependencies and clarifying the interactions between classes. A running Object-Oriented program is a web of objects that collaborate by calling methods on each other. There sometimes can be many dependencies that have to be met in order to call certain objects. To make the complex dependencies be easily testable, mock objects are created in order to “mock” the stages that the object needs to be in, in order to call upon another object.

*Often times in programming, only the changes in state of an object are tested. This would be acceptable only if there was one object. However, many real world applications contain hundreds upon hundreds of different objects. Mock objects have changed the focus of test from thinking about the changes in state of an object to thinking about its interactions with other objects.

==='''Different Types'''===

====Proxy====
A proxy object is an object that is used to take the place of a real object. This is the original concept for all mock frameworks. In the case of mock objects, a proxy object is used to imitate the real object your code is dependent on. The proxy object is created with the mocking framework, and then set it on the object using either a setter or constructor. One has to be able to set the dependency up through an external means. This is one of the reasons Dependency Injection frameworks like Java Spring have increase in popularity because they allow the ability to inject the proxy objects without modifying code.

====Class Remapping====
The second form of mocking is to remap the class file in the class loader. The concept is relatively new and is provided by the new java.lang.Instrument class. The basic idea is that the framework tells the class loader to remap the reference to another class file it will load which will be the mocked class. This allows one to be able to mock objects that are created by using the new operator much like other Object Oriented languages. Although this approach provides more functionality than the proxy object approach, it is much more complex and harder to write and fully understand.

== Comparison of Different Systems ==

==='''EasyMock'''===
*EasyMock has been the first dynamic Mock Object generator, relieving users of hand-writing Mock Objects, or generating code for them.
*Dynamic creation of Mock Objects
*Supports re-factoring-safe Mock Objects
*Ability to return values and exceptions.
*Method order checking
http://easymock.org/

==='''MOQ'''===
*Moq is the only mocking library for .NET developed from scratch to take full advantage of .NET 3.5 and C# 3.0 features.
*Supports mocking interfaces as well as classes.
*Supports the overriding of expectations where the test can set default expectations in a fixture setup, and override as needed on certain tests
*Intercept and raise events on mocks
http://code.google.com/p/moq/.

==='''NMock'''===
*NMock is a dynamic mock object library for .NET.
*Dynamic creation of Mock Objects
*Allows expectations to be defined and fails the test if any expectations are violated
*Expectations are specified beforehand and verified on the fly as the code under test is being executed, rather than afterward using assertions
*Implementations of interfaces are generate on the fly at runtime
http://www.nmock.org/index.html

==='''Rhino Mocks'''===
*Only supports mocks of interfaces, delegates and classes, including those with parametrized constructors.
*Expectations on the called methods by using strongly typed mocks instead of strings.
*Recursive mocking
http://ayende.com/projects/rhino-mocks.aspx

==='''jMock'''===
*Forces test to be explicit about the argument values that will be passed to the expected methods
*Ability to write custom stubs, constraints, and Invocation Matchers
*Works well with the auto completion and refactoring features of your IDE
http://www.jmock.org/index.html

==='''Mocha'''===
*Similar to jMock only for Ruby
*Supports testing frameworks: Test::Unit, RSpec, test/spec, expectations, Dust, MiniTest and JtestR.
http://mocha.rubyforge.org/

==='''Test::MockObject'''===
*Similar to jMock only for Perl
*Simple testing techniques
http://search.cpan.org/dist/Test-MockObject/lib/Test/MockObject.pm

==='''JMockit'''===

*Simpler and more succinct APIs for writing tests with behavior verification or state verification
*Provides other tools for supporting the creation of large test suites
*Uses class remapping instead of the original proxy dependencies
https://jmockit.dev.java.net/

== Conclusion ==

A mock object framework can make sure that the method under test, when executed, will in fact call certain functions on the mock object and that the method under test will react in an appropriate way to whatever the mock objects do. Most parts of a software system do not work in isolation, but collaborate with other parts to get their job done. Writing tests provides a framework to think about functionality, Mock Objects provides a framework for making assertions about those relationships and for simulating responses. Mock Objects also allows programmers to make their tests only as precise as they need to be.

The different frameworks provide a myriad of options for software developers to produce the correct mock tests for their software. The more complex the system, the more important it is when selecting the mock framework. Support for the framework is essential as well.

== Links ==
1. [http://www.sizovpoint.com/2009/03/java-mock-frameworks-comparison.html Java Mock Framework Comparisons]

2. [http://msdn.microsoft.com/en-us/magazine/dd882516.aspx Using Mocks And Tests To Design Role-Based Objects]

3. [http://en.wikipedia.org/wiki/Mock_object Wikipedia - Mock object]