TS 60 Refactoring3

Refactoring Test Specification for

Author: Milan Kubec, Jiri Prox
Version: Revision: 1.1
Last update: Date: 2006/05/23 05:52:48
Introduction:

       This document is test specification for several kinds of refactoring provided by NetBeans IDE. Refactoring is an action changing inner structure of the code without influencing behaviour of the whole application. It's used above all for simplifying and reorganization of the code. This testspec concerns following types of refactoring:

• Pull Up
• Push Down
• Move Inner to Outer Level
• Convert Anonymous Class to Inner
• Use Supertype Where Possible

Comments:

Specifications:

Pull Up, Push Down, Move Inner to Outer Level, Convert Anonymous Class to Inner, Use Supertype Where Possible.

Contents 1 Refactoring Test Specification for 1.1 Test suite: Pull Up 1.2 Test suite: Push Down 1.3 Test suite: Inner to Outer 1.4 Test suite: Anonymous to Inner 1.5 Test suite: Use Supertype

Test suite: Pull Up

Purpose: Pull Up moves elements of the class to the super class. Moved elements can be fields, methods, inner classes and implemented interfaces. When moving private elements its modifier must be changed to protected in order to be accessible from original class.
Setup: Unzip and open project PushPull.

1. Pull Up Availability
   1. Check presence of Pull Up item in menu Refactor
   2. Select package pull in the project windows and check in Pull Up is disabled both in Refactor | Pull Up and context menu.
   3. Select node corresponding to VIPCustomer.java in project view and call Pull Up
   4. Open VIPCustomer class in editor and call Pull Up .
   • {{result|EXPECTED RESULT: Pull Up is present in the menu and is disabled for package scope. When called in the class scope and in editor the dialog is opened. It has correct title and provides all inner elements which can be pulled up.

1. Pull Up basic
   1. Invoke Refactor | Pull Up for VIPCustomer class
   2. Select class Customer as a target
   3. Select all elements and press Preview
   4. Review all changes and click Do Refactoring
   • EXPECTED RESULT: In the dialog, there are listed all pull-able elements. Methods have extra checkbox Make abstract. After confirming action, all elements are moved to the superclass. (There is error in RegularCustomer class after the refactoring - invalid method overriding)

1. Pull Up two and more levels
   1. Invoke Refactor
      

Test suite: Push Down

Purpose: Push down moves selected elements lower to the subclasses. If the actual class has more subclasses the elements are propagated to all of them. All elements such fields, methods, inner classes and implemented interfaces can be pulled down, regardless of their modificators.

Setup: Unzip and open project PushPull

1. Push Down basic
   1. Invoke Refactor | Push Down for SuperBaseClass class
   2. Select all elements and press Preview
   3. Review all changes and click Do Refactoring
   • EXPECTED RESULT: All elements should be moved to all subclasses. Note that there is warning about field fieldString , which already exists in one of the subclasses. When refactoring is performed, the declaration of fieldString is doubled in one of the subclasses. Necessary imports are added to all subclasses.

1. Push Down selected element
   1. Open SuperBaseClass in editor
   2. Put caret on element which can be pushed down (note: this doesn't work for elements with further inner elements such as classes, inner ifaces etc..)
   3. Call Refactor | Push Down
   • EXPECTED RESULT: When caret is located in pushable element the relevant checkbox is checked in the refactoring dialog

1. Push Down implemented interface
   1. Invoke Refactor
      

Test suite: Inner to Outer

Purpose: This type of refactoring moves inner class one level up. If it was originally in the top level class it is moved to separate file. The problem with accessing elements in the original outer class is solved by adding parameter to constructor passing instance of outer class.
Setup: Unzip and open project ConvertClasses

1. Inner to Outer - basic
   1. Put caret in the body of class Inner1 located in OuterClass
   2. Call Move Inner to Outer Level
   3. In the dialog change Class Name to Rename,Field Name to orig
   4. Click Preview, inspect all changes and confirm by Do Refactoring
   • EXPECTED RESULT: New file with class Renamed is created. Its constructor has one parameter orig of type OuterClass . The occurrences of Inner1 is replaced with the new name. The modifiers of field and privMethod are changed to package public. The getInner() method of the original outer class contains return new Renamed(this); . Class User has correct reference to new class.

1. Inner to Outer - static class
   1. Call Move Inner to Outer Level for class Inner2 located in OuterClass
   2. Keep all options as default
   3. Click Preview, review all changes and confirm by Do Refactoring
   • EXPECTED RESULT: The class is moved into new file as top-level class. Class User has correct reference to moved class. Filed referring to original class is not generated.

1. Inner to Outer - interfaces
   1. Call Move Inner to Outer Level for class InnerIface located in OuterClass
   2. In the dialog change Class Name
   3. Click Preview, review all changes and confirm by Do Refactoring
   • EXPECTED RESULT: Interface is moved to separate file. Reference in class User is updated

1. Inner to Outer - enum
   1. Call Move Inner to Outer Level for enum InnerEnum located in OuterClass
   2. In the dialog change Class Name
   3. Click Preview, review all changes and confirm by Do Refactoring
   • EXPECTED RESULT: Enum is moved to separate file. Reference in class User is updated

1. Inner to Outer - annotations
   1. Call Move Inner to Outer Level for class InnerAnot located in OuterClass
   2. In the dialog change Class Name
   3. Click Preview, review all changes and confirm by Do Refactoring
   • EXPECTED RESULT: Annotation is moved to separate file. Reference in class User is updated

1. Inner to Outer - fix imports
   1. Call Move Inner to Outer Level for class FileHandler located in Wrapper class
   2. Keep all defaults and perform refactoring
   • EXPECTED RESULT: Class is moved to a separate file with all necessary imports.

1. Inner to Outer - constructors
   1. Call Move Inner to Outer Level for class InnerClass located in Wrapper class
   2. In the dialog, leave all options as default
   3. Click Preview, review all changes and confirm by Do Refactoring
   • EXPECTED RESULT: New separate file with class Inner is created. All constructors are updated to accept reference to outer class as additional parameter.

1. Inner to Outer - two levels
   1. Call Move Inner to Outer Level for class InnerInnerClass located in Wrapper class
   2. Keep all as default, perform refactoring
   3. Call Move Inner to Outer Level for class InnerInnerClass again
   4. Keep all as default, perform refactoring
   • EXPECTED RESULT: The InnerInnerClass class is step by step propagated to outer level. The reference to previous outer classes are added to constructor.

1. Inner to Outer - w/o preview
   1. Call Move Inner to Outer Level for class Inner1 located in OuterClass
   2. In the dialog uncheck Preview All Changes
   3. Click Refactor
   • EXPECTED RESULT: Action is performed w/o preview

1. Inner to Outer - cancel
   1. Call Move Inner to Outer Level for class Inner1 located in OuterClass
   2. Click Preview
   3. In preview click Cancel
   • EXPECTED RESULT: There are no changes in the code

1. Inner to Outer - refresh
   1. Call Move Inner to Outer Level for class Inner1 located in OuterClass
   2. In the dialog change Class Name and Field Name
   3. Click Preview
   4. In preview click Refresh (button with the green arrow)
   • EXPECTED RESULT: The refactoring dialog is reopened, all values are restored

Test suite: Anonymous to Inner

Purpose: This refactoring converts selected anonymous class to regular inner class. Comments: This is implemented in Java/hints module.
Setup: Unzip and open project [[../data/ConvertClasses_TS_60_Refactoring3.zip| ConvertClasses]]

1. Anon to Inner availability
   1. Check presence of Convert Anonymous Class to Inner item in menu Refactor
   2. Select package node and class node and check that menu item is disabled
   3. Open some java file and put carent into it -> the menu item is enabled
   4. Place cursor over identifier of supertype in anonymous class declaration (e.g. over second word Runnable in "Runnable r = new Runnable() { ... }") -> hint Convert anonymous ... is provided
   • EXPECTED RESULT: The menu item is avaiable and it's enable/disable status follow previous description.

1. Anon to Inner - basic
   1. Open ClassA in editor and call refactoring for its anonymous class.
   2. Type new name
   3. Use editor undo for taking the changes back
   • EXPECTED RESULT: New inner class is created. It's name is derived from original name by appending "Impl", the body of anonymous class is move to the newly introduced class and at original place, there is call of its constructor. The instant-rename for name of new class is on, so when the user is typing the new class is beeing renamed. Enter ends the renaming. Undo reverts all changes.

1. Anon to Inner - constructor
   1. Open ClassB in editor and call refactoring for its anonymous class.
   • EXPECTED RESULT: The new inner class is created. It's constructor accepts one parameter and delegates is to super class.

1. Anon to Inner - static
   1. Open ClassD in editor and call refactoring for its anonymous class.
   • EXPECTED RESULT: The new class is declared as static, since it used in static context

Test suite: Use Supertype

Purpose: This kind of refactoring tries to use selected supertype where possible, e.g. changes the type of variable to the supertype if it doesn't use methods or fields of any its subtype.
Setup: Unzip and open project [[../data/ConvertClasses_TS_60_Refactoring3.zip| ConvertClasses]]

1. Use Supertype - availability
   1. Check presence of Use Supertype Where Possible item in menu Refactor
   2. Browse through the structure of class usesupertype.Sub in projects window, call Use Supertype Where Possible for each type of element.
   3. Open Sub in editor and call refactoring from various position in the class
   • EXPECTED RESULT: Use Supertype Where Possible is enabled available for classes, e.g form node corresponding to java file and form node corresponding directly to the class.

1. Use Supertype - basic
   1. Call Use Supertype Where Possible for class Sub
   2. Select java.lang.Object from the list and check Preview All Changes
   3. Click Preview, review all changes and confirm by Do Refactoring
   • EXPECTED RESULT: Occurrence is found, check the class User , there should be s6 retyped to Object .

1. Use Supertype - select type
   1. Call Use Supertype Where Possible for class Sub
   2. Select one item form the list
   3. Click Preview, review all changes and confirm by Do Refactoring
   • EXPECTED RESULT: The identifiers s? should be typed according to the selected type

1. Use Supertype - w/o preview
   1. Call Use Supertype Where Possible for class Sub
   2. Select one item from the list, uncheck Preview All Changes
   3. Click Refactor
   • EXPECTED RESULT: The action is performed w/o preview

1. Use Supertype - cancel
   1. Call Use Supertype Where Possible for class Sub
   2. Select one item from the list,
   3. Click Preview.
   4. In the preview click Cancel
   • EXPECTED RESULT: Refactoring is canceled, no changes are made to the code.

1. Use Supertype - refresh
   1. Call Use Supertype Where Possible for class Sub
   2. Select one item from the list
   3. Click Preview
   4. In preview click Refresh (button with the green arrow)
   • EXPECTED RESULT: Dialog is reopened, previous selection is restored