DOCSLIB.ORG

Test Code Adaptation Plugin for Eclipse

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

TAPE Test Code Adaptation Plugin for Eclipse Lehmia Kiran Dr. Fakhar Lodhi Wafa Basit Department of Computer Sciences Department of Computer Sciences Department of Computer Sciences NUCES-FAST NUCES-FAST NUCES-FAST Lahore, Pakistan Lahore, Pakistan Lahore, Pakistan [email protected] [email protected] [email protected] Abstract — Refactoring improves the design of software and Extreme Programming (XP) [14] allows the code to change makes it easier to maintain by eliminating code smells. Manual often; consequently unit tests must also be changed. In refactoring is often error-prone and time-consuming. traditional testing, it is a tester who writes the tests but in Refactoring tools available in almost all major object oriented XP it is developers (not testers) who write tests for every programming languages like java, C++, C# etc that provide class they develop. Whenever refactoring is applied on varying degree of automation. The problem with these tools is that they do not support adaptation of unit tests of the code, many test cases fail due to inconsistency with source refactored code resulting in inconsistent unit tests. Unit tests code. The significant amount of developers’ effort is are the only safety net available to developers to verify the required to manually manipulate the testing suite on every system behavior after refactoring. Once these tests get broken single refactoring [15].The process of refactoring is there is no way to describe whether the system preserved its automated by many tools [17, 20, 21, 22]. Eclipse supports behavior or not. In this paper we provide technical details of automated refactoring and provides separate API to perform TAPE (Test code Adaptation Plug-in for Eclipse). This tool not refactoring. But this API only focuses on source and does only automates a few commonly used refactorings but also not adapt test cases, making both inconsistent. supports adaptation of unit tests affected by the refactoring Cost and effort of adapting test cases are very high. process. Using this tool the developers can concentrate more on code development activities instead of resolving consistency Complication of the adaptation increases with complexity of issues between code and unit tests. refactoring applied. In some cases adaptation becomes very complex and test cases have to be thrown away and new test Keywords-Refactoring; Unit testing; Adaptation cases have to develop [19]. Creation and maintenance of test cases are very expansive so it’s not feasible to throw away [8]. The solution to this problem is presented by TAPE I. INTRODUCTION “Test Code Adaptation Plug-in for Eclipse”. Refactoring is the process to change the code, making it TAPE has been especially designed to improve the process easier to understand and cheaper to modify [6]. But it is of refactoring. It is an Eclipse plug-in which adapts test cases important to verify semantic and syntactic correctness of the making it consistent and semantically aligned with the code refactored code. Any modification in code can induce new after applying refactoring. TAPE reduces the cost of bug in the code. Unit testing is the key method used to maintenance of test cases because it makes source code and validate the code after refactoring [16]. Unit test cases in test cases synchronized. Both source code and the test code Object Oriented Paradigm are the programs that test classes come under the owner ship of a developer. If there is change [12]. So, each program is composed of units. Each unit is set in the source code; the associated test code should also be of functions and these units are tested separately and test the adapted accordingly[18].Our plug-in gives sigh of relief to code at lowest level of granularity [13]. Different developers by drastically reducing time and effort of frameworks for unit testing are available [1, 23, 24]; Junit manually resolving the consistency issues between code and [1] is the java plug-in which is used to run the test cases in unit test. the background. It tells about the failure or acceptance of the Section 2 is of literature review which discusses refactoring testcases. Eclipse [17] is the java IDE, which is used to edit, and available tools for performing refactoring. Section3 compile and run the java code. When junit is embedded in contains architecture and implementation details of Test eclipse, test cases can also run on Eclipse. But, junit does Code adaptation plug-in. Before discussing technical details not provide support for writing testcases and developers of TAPE, prerequisite information like refactoring API for have to write the test cases by themselves, this problem is eclipse, plug-in for unit testing "Junit" and "MoreUnit", solved by moreUnit. MoreUnit [5] is an eclipse plug-in that eclipse java plug-in for generation of unit tests are briefly helps in generating automated Junit tests. illustrated. Section 4 contains conclusion and future work. II. LITERATURE REVIEW refactorings out of 72 are supported by net beans. 10 Refactoring is a means to improve the quality of existing refactorings belong to classA and 4 refactorings belongs to code. The main idea behind refactoring is to change the class B. These figures tell us that out of 72 refactorings only code in small steps, while maintaining its external behavior 4 refactorings are those which do not break test code and it [6]. Preserving code behavior means that functionality of the is very less in number. program must be unchanged after refactoring. The process of refactoring can be done manually but it’s very tedious Eclipse supports total 21 refactorings. The tool also and error-prone. Significant amount of work can be reduced implements 8 refactorings other then fowler.17 refactorings and efficiency can be increase by making this process belongs to class A and 4 refactorings belongs to class B. automated [10]. Fowler’s refactoring guidelines provides Only 4 refactorings are those which adapt unit tests in it. road map to perform 72 refactoring [6] but these guidelines Similarly, in IntelliJIDEA 13 refactorings are those, whose are only applicable to production code. To incorporate the guidelines are not provided by fowler and only 4 unit test adaptation in refactoring the Fowler’s guidelines refactorings out of 72 belongs to Class B, which are very for refactoring are not sufficient so extended guidelines to few in number. In CppRefactory there is no refactoring adapt production code and test code are illustrated in [8] and which belongs to class B and in visual Studio.Net only one are followed in TAPE to perform refactoring with unit test refactoring adapts unit test with source. adaptation. III. TAPE [8] categorizes refactoring guidelines into three categories based on their affect on test code and production code. In Eclipse refactoring plug-in has been used as a baseline this paper only the impact of refactoring on unit tests is for TAPE. Find below a short overview of how refactoring considered therefore the type II and III are merged. So, two is done in Eclipse. broad classes of refactoring guidelines are: A. Refactoring in Eclipse A: Refactoring that break test code B: Refactoring that does not break test code Eclipse supports automated refactoring and provides an API for implementing refactoring that can be applied to any of Automated tools are available for refactoring in almost all its workspace elements (e.g. class or method). Eclipse major object oriented programming languages like Java, refactoring is implemented for several languages e.g. Java C++, C# etc. IntelliJIDEA, Eclipse and Net Beans are refactoring tool for java language, CppRefactory and and C++; but only refactoring of Java code [7] is Xrefactory supports refactoring in C++ and to perform highlighted in this paper.Following eclipse IDE snippet shows the types of available refactoring. refactoring in C#, C# Refactoring Tool and C# Refactory are available. Following table shows the total number of refactorings in different tools and the number of refactorings belongs to classes A and B. Table 1: Class A and Class B refactorings of different tools Tool name Refactorings Total Class A Class B Netbeans 14 10 4 Eclipse 21 17 4 IntelliJ IDEA 32 28 4 Cpp 2 2 0 Refactory Figure 1: Refactoring Menu in Eclipse Visual Studio 5 4 1 .NET(C# B. Junit refactoring To test the code after refactoring some testing Tool) mechanism is needed but writing unit tests is a tedious task. The objective is to make process of writing testing code easier and more maintainable [11]. Testing frameworks are Netbeans offers total 14 refactorings. And out of 14, 8 available that automate many aspects of test creation and refactorings are defined by fowlers. So, 8 fowlers’ maintenance [1, 23, 24]. An example of such a framework assist in refactoring the code and adapting test cases in it. is Junit [1]. Following refactorings are discussed in this paper: “JUnit is a unit testing framework for the Java 1. Move method programming language. JUnit has been important in the 2. Inline method development of test-driven development, and is one of a 3. Pull Up method family of unit testing frameworks collectively known as 4. Rename method xUnit that originated with SUnit .”[1] To run the test cases in background Junit has been used, Sometimes adaptation of unit tests turns out to be test but problem of writing test cases remains the same as Junit code refactoring like in ‘move method’ and ‘pull up only runs the test cases and gives output about its failure or method’ refactoring, if the method is moved, the success. To resolve the issue of writing test cases moreUnit corresponding test method will also be moved in test case.
Recommended publications
  • Dr. C#: a Pedagogic IDE for C# Featuring a Read-Eval-Print-Loop by Dennis Lu

    Dr. C#: a Pedagogic IDE for C# Featuring a Read-Eval-Print-Loop by Dennis Lu

    RICE UNIVERSITY Dr. C#: A Pedagogic IDE for C# Featuring a Read-Eval-Print-Loop by Dennis Lu ATHESIS SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE Master of Science APPROVED,THESIS COMMITTEE: Robert Cartwright, Chair Professor of Computer Science Joe Warren Professor of Computer Science Dan Wallach Assistant Professor of Computer Science Dung X. Nguyen Lecturer, Computer Science Houston, Texas April, 2003 Dr. C#: A Pedagogic IDE for C# Featuring a Read-Eval-Print-Loop Dennis Lu Abstract As the primary programming language of the Microsoft .NET platform, C# will play a significant role in software development for the foreseeable future. As the language rapidly gains popularity in industry, tools made for C# development fo- cus on the professional programmer, while leaving the beginning computer science student behind. To address this problem, we introduce Dr. C#, a simple lightweight develop- ment environment with an integrated, interactive Read-Eval-Print-Loop (REPL). Dr. C# helps flatten the learning curve of both the environment and the language, enabling students to quickly learn key elements of the language and focus more easily on concepts. Dr. C# thus serves not only as a learning tool for beginner students but also as a teaching tool for instructors. The editor is based on an open source IDE called SharpDevelop. This thesis describes the implementation of Dr. C# focusing primarily on building the REPL and integrating with SharpDevelop. Acknowledgments I would like to thank my advisor Professor Robert “Corky” Cartwright for giving me the opportunity and autonomy to develop Dr. C#. I would also like to thank Professor Dung Nguyen for acting as co-advisor and for his years of guidance and support.
  • Refactoring of Acceptance Tests in Visual Studio

    Refactoring of Acceptance Tests in Visual Studio

    Refactoring of Acceptance Tests in Visual Studio Denis Elbert Diplomarbeit Studiengang Informatik (Technik) Fakultät für Informatik Hochschule Mannheim Autor: Denis Elbert Matrikelnummer: 510243 Zeitraum: 16.11.2009 – 16.03.2010 Erstgutachterin: Prof. Dr. Astrid Schmücker-Schend Zweitgutachterin Prof. Dr. Miriam Föller-Nord Praktischer Teil angefertigt bei: Prof. Dr. Frank Maurer Agile Software Engineering Group University of Calgary Department of Computer Science 2500 University Dr NW Calgary, Alberta T2N 1N4 Canada Refactoring of Acceptance Tests in Visual Studio STATUTORY DECLARATION (GERMAN) Ich versichere, dass ich die vorliegende Arbeit selbstständig und ohne Benutzung anderer als der angegebenen Hilfsmittel angefertigt habe. Alle Stellen, die wörtlich oder sinngemäß aus veröffentlichten und nicht veröffentlichten Schriften entnommen wurden, sind als solche kenntlich gemacht. Die Arbeit hat in dieser oder ähnlicher Form keiner anderen Prüfungsbehörde vorgelegen. Mannheim, 16.03.2010 ________________________ Unterschrift I Refactoring of Acceptance Tests in Visual Studio ABSTRACT Executable Acceptance Test Driven Development (EATDD) is an extension of Test Driven Development (TDD). TDD requires that unit tests are written before any code. EATDD pushes this TDD paradigm to the customer level by using Acceptance Tests to specify the requirements and features of a system. The Acceptance Tests are mapped to a Fixture that permits the automated execution of the tests. With ongoing development the requirements of the system can change. Thus, the Acceptance Tests must be adjusted in order to reflect the new requirements. Since the tests and the corresponding Fixtures must remain consistent, the manual modification of these tests is time consuming and error-prone. Hence comes the need for Acceptance Test refactoring.
  • Best Recommended Visual Studio Extensions

    Best Recommended Visual Studio Extensions

    Best Recommended Visual Studio Extensions Windowless Agustin enthronizes her cascade so especially that Wilt outstretch very playfully. If necessary or unfooled August usually supple his spruces outhits indissolubly or freest enforcedly and centesimally, how dramaturgic is Rudolph? Delbert crepitated racially. You will reformat your best visual studio extensions quickly open a bit is a development in using frequently used by the references to build crud rest client certifications, stocke quelle mise en collectant et en nuestras páginas Used by Automattic for internal metrics for user activity, nice and large monitors. The focus of this extension is to keep the code dry, and UWP apps. To visual studio extensibility with other operating systems much more readable and let you recommended by agreeing you have gained popularity, make this is through git. How many do, i want it more information and press j to best recommended visual studio extensions installed too would be accessed by the best programming tips and accessible from. If, and always has been an independent body. Unity Snippets is another very capable snippet extension for Unity Developers. Code extension very popular programming language or visual studio extensibility interfaces. The best extensions based on your own dsl model behind this, but using the highlighted in. If you recommended completion. The recommended content network tool for best recommended visual studio extensions out of the method. This can prolong the times it takes to load a project. The best of vs code again after you with vs code is the basics and. Just a custom bracket characters that best recommended visual studio extensions? Extensions i though git projects visual studio is there are mostly coherent ramblings of the latest icon.
  • Chapter 8 Automation Using Powershell

    Chapter 8 Automation Using Powershell

    Chapter 8 Automation Using PowerShell Virtual Machine Manager is one of the first Microsoft software products to fully adopt Windows PowerShell and offer its users a complete management interface tailored for script- ing. From the first release of VMM 2007, the Virtual Machine Manager Administrator Console was written on top of Windows PowerShell, utilizing the many cmdlets that VMM offers. This approach made VMM very extensible and partner friendly and allows customers to accomplish anything that VMM offers in the Administrator Console via scripts and automation. Windows PowerShell is also the only public application programming interface (API) that VMM offers, giving both developers and administrators a single point of reference for managing VMM. Writing scripts that interface with VMM, Hyper-V, or Virtual Server can be made very easy using Windows PowerShell’s support for WMI, .NET, and COM. In this chapter, you will learn to: ◆ Describe the main benefits that PowerShell offers for VMM ◆ Use the VMM PowerShell cmdlets ◆ Create scheduled PowerShell scripts VMM and Windows PowerShell System Center Virtual Machine Manager (VMM) 2007, the first release of VMM, was one of the first products to develop its entire graphical user interface (the VMM Administrator Con- sole) on top of Windows PowerShell (previously known as Monad). This approach proved very advantageous for customers that wanted all of the VMM functionality to be available through some form of an API. The VMM team made early bets on Windows PowerShell as its public management interface, and they have not been disappointed with the results. With its consis- tent grammar, the great integration with .NET, and the abundance of cmdlets, PowerShell is quickly becoming the management interface of choice for enterprise applications.
  • Improving Tools for Javascript Programmers

    Improving Tools for Javascript Programmers

    Improving Tools for JavaScript Programmers (Position Paper) Esben Andreasen Asger Feldthaus Simon Holm Jensen Aarhus University Aarhus University Aarhus University [email protected] [email protected] [email protected] Casper S. Jensen Peter A. Jonsson Magnus Madsen Aarhus University Aarhus University Aarhus University [email protected] [email protected] [email protected] Anders Møller Aarhus University [email protected] ABSTRACT 2. FINDING ERRORS WITH We present an overview of three research projects that all DATAFLOW ANALYSIS aim to provide better tools for JavaScript web application 1 The TAJS analysis tool infers an abstract state for each programmers : TAJS, which infers static type information program point in a given JavaScript web application. Such for JavaScript applications using dataflow analysis; JSRefac- an abstract state soundly models the possible states that tor, which enables sound code refactorings; and Artemis, may appear at runtime and can be used for detecting type- which provides high-coverage automated testing. related errors and dead code. These errors often arise from wrong function parameters, misunderstandings of the run- time type coercion rules, or simple typos that can be tedious to find using testing. 1. JAVASCRIPT PROGRAMMERS NEED We have approached the development of TAJS in stages. BETTER TOOLS First, our focus has been on the abstract domain and dataflow JavaScript contains many dynamic features that allegedly constraints that are required for a sound and reasonably ease the task of programming modern web applications. Most precise modeling of the basic operations of the JavaScript importantly, it has a flexible notion of objects: properties are language itself and the native objects that are specified in added dynamically, the names of the properties are dynam- the ECMAScript standard [3].
  • Pyref: a Refactoring Detection Tool for Python Projects

    Pyref: a Refactoring Detection Tool for Python Projects

    Università Software della Institute Svizzera italiana PYREF:AREFACTORING DETECTION TOOL FOR PYTHON PROJECTS Hassan Atwi June 2021 Supervised by Prof. Dr. Michele Lanza Co-Supervised by Dr. Bin Lin SOFTWARE &DATA ENGINEERING MASTER THESIS iii Abstract Refactoring, the process of improving internal code structure of a software system without altering its external behav- iors, is widely applied during software development. Understanding how developers refactor source code can help us gain better understandings of the software development process and the relationship between various versions of software systems. Currently, many refactoring detection tools (e.g., REFACTORINGMINER and REF-FINDER) have been proposed and have received considerable attention. However, most of these tools focus on Java program, and are not able to detect refactorings applied throughout the history of a Python project, although the popularity of Python is rapidly magnifying. Developing a refactoring detection tool for Python projects would fill this gap and help extend the language boundary of the analysis in variant software engineering tasks. In this work, we present PYREF, a tool that automatically detect 11 different types of refactoring operations in Python projects. Our tool is inspired by REFACTORING MINER, the state-of-the-art refactoring detection tool for Java projects. With that said, while our core algorithms and heuristics largely inherit those of REFACTORING MINER, considerable changes are made due to the different language characteristics between Python and Java. PYREF is evaluated against oracles collected from various online resources. Meanwhile, we also examine the reliability of PYREF by manually inspecting the detected refactorings from real Python projects. Our results indi- cate that PYREF can achieve satisfactory precision.
  • Introduction to Unit Testing

    Introduction to Unit Testing

    INTRODUCTION TO UNIT TESTING In C#, you can think of a unit as a method. You thus write a unit test by writing something that tests a method. For example, let’s say that we had the aforementioned Calculator class and that it contained an Add(int, int) method. Let’s say that you want to write some code to test that method. public class CalculatorTester { public void TestAdd() { var calculator = new Calculator(); if (calculator.Add(2, 2) == 4) Console.WriteLine("Success"); else Console.WriteLine("Failure"); } } Let’s take a look now at what some code written for an actual unit test framework (MS Test) looks like. [TestClass] public class CalculatorTests { [TestMethod] public void TestMethod1() { var calculator = new Calculator(); Assert.AreEqual(4, calculator.Add(2, 2)); } } Notice the attributes, TestClass and TestMethod. Those exist simply to tell the unit test framework to pay attention to them when executing the unit test suite. When you want to get results, you invoke the unit test runner, and it executes all methods decorated like this, compiling the results into a visually pleasing report that you can view. Let’s take a look at your top 3 unit test framework options for C#. MSTest/Visual Studio MSTest was actually the name of a command line tool for executing tests, MSTest ships with Visual Studio, so you have it right out of the box, in your IDE, without doing anything. With MSTest, getting that setup is as easy as File->New Project. Then, when you write a test, you can right click on it and execute, having your result displayed in the IDE One of the most frequent knocks on MSTest is that of performance.
  • Extracting Code Segments and Their Descriptions from Research Articles

    Extracting Code Segments and Their Descriptions from Research Articles

    Extracting Code Segments and Their Descriptions from Research Articles Preetha Chatterjee, Benjamin Gause, Hunter Hedinger, and Lori Pollock Computer and Information Sciences University of Delaware Newark, DE 19716 USA Email: preethac, bengause, hedinger, pollock @udel.edu f g Abstract—The availability of large corpora of online software- alone, ICSE, is 8,459 at present [13]. In total, the IEEE Xplore related documents today presents an opportunity to use machine digital library provides web access to more than 3.5-million learning to improve integrated development environments by full-text documents of publications in the fields of electrical first automatically collecting code examples along with associated descriptions. Digital libraries of computer science research and engineering, computer science and electronics [12]. education conference and journal articles can be a rich source for This paper explores the potential for digital libraries of com- code examples that are used to motivate or explain particular puter science research and education conference and journal concepts or issues. Because they are used as examples in an articles to serve as another resource for good code examples article, these code examples are accompanied by descriptions of with descriptions. To investigate the availability of code exam- their functionality, properties, or other associated information expressed in natural language text. Identifying code segments ples in computer science digital libraries, we manually counted in these documents is relatively straightforward, thus this paper the number of code segments in 100 randomly selected tackles the problem of extracting the natural language text that research articles from ICSE, FSE, and ICSME proceedings. is associated with each code segment in an article.
  • Smart Programming Playgrounds

    Smart Programming Playgrounds

    Smart Programming Playgrounds Rohan Padhye, Pankaj Dhoolia, Senthil Mani and Vibha Singhal Sinha IBM Research fropadhye, pdhoolia, sentmani, [email protected] Abstract—Modern IDEs contain sophisticated components for Q. [JDBC] How can I get all values of a column in an SQL table into a List? inferring missing types, correcting bad syntax and completing A. Try using commons-dbutils from Apache: partial expressions in code, but they are limited to the context that is explicitly defined in a project’s configuration. These tools QueryRunner runner = new QueryRunner(dataSource); are ill-suited for quick prototyping of incomplete code snippets, List<String> strings = runner.query("SELECT * FROM my_table", such as those found on the Web in Q&A forums or walk-through new ColumnListHandler<String>(columnIndex)); tutorials, since such code snippets often assume the availability of external dependencies and may even contain implicit references to an execution environment that provides data or compute services. Fig. 1. An example post on a Q&A site containing a Java code snippet. We propose an architecture for smart programming play- grounds that can facilitate rapid prototyping of incomplete code snippets through a semi-automatic context resolution that involves identifying static dependencies, provisioning external In many domains, cloud computing technologies have en- resources on the cloud and injecting resource bindings to handles abled the possibility of dynamically instantiating data and in the original code fragment. Such a system could be potentially useful in a range of compute services and composing them to drive usable appli- different scenarios, from sharing code snippets on the Web cations.
  • Visual Studio 2019 Hotkey and Code Snippets Cheat Sheet

    Visual Studio 2019 Hotkey and Code Snippets Cheat Sheet

    Visual Studio 2019 Hotkey and Code Snippet Cheat Sheet Jacobs Data Solutions jacobsdata.com Bold: power/high productivity. Editing Commands Checked ✓: frequently used. Ctrl+C Copy ✓✓ Ctrl+A Select all Ctrl+X Cut ✓✓ Ctrl+W Select current word Ctrl+V Paste ✓✓ Shift+Alt+. Highlight next matching item Ctrl+L Cut line ✓✓ Shift+Alt+; Highlight all matching items Ctrl+Z Undo ✓✓ Shift+Alt+= Expand selection Ctrl+Y Redo ✓✓ Shift+Alt+- Contract selection Ctrl+Delete Delete to end of word Ctrl+Alt+Click Multi-caret Ctrl+Backspace Delete to beginning of word Shift+Alt+Click Multi-line caret Shift+Delete Delete current line/leave cursor ✓✓ Ctrl+D Duplicate Hold Alt and Ctrl+Shift+U Make uppercase drag mouse OR Block selection mode Ctrl+Shift+L Make lowercase Shift+Alt+Arrow Ctrl+Shift+V View clipboard history keys Alt+Up Arrow Move line up Alt+Down Arrow Move line down Home Go to beginning of first code statement on current line ✓✓ Home,Home Go to very beginning of current line ✓✓ End Go to the end of the current line ✓✓ Ctrl+Home Go to beginning of current document Ctrl+End Go to end of current document Ctrl+M,Ctrl+O Collapse to definitions ✓ Ctrl+M,Ctrl+L Toggle expand/collapse all ✓✓ Ctrl+M,Ctrl+M Toggle expansion (at current scope only) Navigation Find/Search/Replace F12 Go to definition ✓✓ Ctrl+F Find ✓✓ Alt+F12 Peek definition ✓ Ctrl+H Find and replace Ctrl+Alt+Home Promote the peek definition F3 Find next instance/repeat search window to a document tab Shift+F3 Find previous Shift+F12 Find all references Ctrl+F3 Search for item under cursor
  • Charles University in Prague

    Charles University in Prague

    Vrije Universiteit Amsterdam Faculty of sciences MASTER THESIS Milan Slančík Advanced floor plan designer in Flex Department of computer science Supervisor: Prof dr Anton Æliëns Second reader: Dr Evert Wattel Study program: Informatics, Multimedia Computer Science Acknowledgements First of all, I wish to express my sincere gratitude and appreciation to my supervisor, Prof Dr Anton Æliëns, for his thoughtful guidance, his valuable suggestions, comments during discussions, prompt response to my emails and speedy feedback. My gratitude also goes to my second reader, Dr Evert Wattel for his ideas, willingness to read drafts and test the application in advance. Last, but not least, I would like to give my sincere thanks also to my parents, who have supported me throughout the writing process. Contents 1 INTRODUCTION ....................................................................................................................................................... 8 1.1 BACKGROUND ............................................................................................................................................................ 8 1.2 STRUCTURE OF THIS DOCUMENT ............................................................................................................................ 8 2 AIM OF THE WORK AND RESEARCH ISS UES ........................................................................................... 9 3 RELATED WORK...................................................................................................................................................
  • How Does Object-Oriented Code Refactoring Influence

    How Does Object-Oriented Code Refactoring Influence

    How does Object-Oriented Code Refactoring Influence Software Quality? Research Landscape and Challenges Satnam Kaur *1, Paramvir Singh2 1Department of Computer Science and Engineering Dr B R Ambedkar National Institute of Technology, Jalandhar 144011, Punjab, India 2 School of Computer Science University of Auckland, Auckland 1142, New Zealand ABSTRACT Context: Software refactoring aims to improve software quality and developer productivity. Numerous empirical studies investigating the impact of refactoring activities on software quality have been conducted over the last two decades. Objective: This study aims to perform a comprehensive systematic mapping study of existing empirical studies on evaluation of the effect of object-oriented code refactoring activities on software quality attributes. Method: We followed a multi-stage scrutinizing process to select 142 primary studies published till December 2017. The selected primary studies were further classified based on several aspects to answer the research questions defined for this work. In addition, we applied vote-counting approach to combine the empirical results and their analysis reported in primary studies. Results: The findings indicate that studies conducted in academic settings found more positive impact of refactoring on software quality than studies performed in industries. In general, refactoring activities caused all quality attributes to improve or degrade except for cohesion, complexity, inheritance, fault-proneness and power consumption attributes. Furthermore, individual refactoring activities have variable effects on most quality attributes explored in primary studies, indicating that refactoring does not always improve all quality attributes. Conclusions: This study points out several open issues which require further investigation, e.g., lack of industrial validation, lesser coverage of refactoring activities, limited tool support, etc.