Test Pass Two: JDT UI, JDT Text, Platform Compare, Platform Text, and Platform Search

Testers: Martin, Dani, Markus, David, Benjamin, Tobias, Tom, Dirk

Goal

• test polish items that got added for RC1
  
• test Java 5.0 functionality. Whenever you create some test code please use 5.0 language features whenever possible. For example add a type parameter to every new class, ...
• test corner cases
• test setups which we typically don't use during development (for example no Plug-in development)
• handling of error situations
  • watch log
  • error messages

Setup / Introduction

Build

Platforms

• Linux-GTK FedoraCore (Tom)
• Mac OS (Tobias, Tuesday)
  
• Windows XP (all others test)
  

General Items (everybody)

• Whenever you have to fill in data in dialogs try to fool the dialog by providing incomplete or bogus input
• Watch for view updating (package explorer, browsing perspective, outliner) when source content gets changed

Use of different fonts (everybody)

• change font for text editor and dialogs to different font
• check that dialogs are rendered correctly
  • specified dialog font is used
  • no buttons and labels clipped

Test Multiple Monitor setup (Martin)

• detached views
• dialogs pop up on correct monitor

Workspace Setup

Setup workspace in a way unusual compared to your normal setup. Testing should take place in one of the following workspace setups. When setting up the workspace test also the functionality to setup this workspace style:

• use external projects (Dirk & Martin)
• use linked resources (Benjamin & Tom)
  • linked output folders
  • linked source folders
  • linked and nested source folders
  • test rendering in views
  • linked class folders
• use multiple output folder (David)
• use combination of exclusion & inclusion filters (Tobias)
• use user defined library containers (JUnit as a user defined library) (Dani)
  • quick fixes for unbound user libraries
  • quick fixes for build path problems
• full source workspace (Markus)

Java Editor in Single Method mode (Dirk, Tom, Dani, David)

• half of the team should test with editor in single edit mode
• corner case
  • segmented mode, formatting, undo/redo

Multiple Windows (Dani, Tom, Benjamin, Martin)

• half of the team tests with multiple windows.
• switch between windows for different actions
• watch for wrong window popping to front
• watch for wrong dialog parenting

Multiple Editor Areas (Dani, David, Martin)

• test with multiple editor areas, i.e. multiple editor tab folders
• watch for focus problems
• watch for positioning problems when opening dialogs and info pops

Java Perspective / Browsing Perspective / Working Set mode

• third of the team tests in browsing perspective (Martin, Benjamin, Markus)
  
• third of the team tests in Java perspective using project mode in package explorer (Dirk, Dani, Tom)
  
• third of the team tests in Java perspective using the working set mode in the package explorer (Tobias, David)
  

Automatic workspace refresh (Tom, David, Martin)

• half of the team tests with automatic workspace refresh enabled (Preferences > Workbench > Refresh workspace automatically

3.1 RC1 items

Bug verification (all)

• Verify ALL bugs fixed during RC1 (JDT/UI & JDT/Text, Platform/Text,Platform/Search).

New class wizard (Dirk; FAQ Markus):

• test code assist in interface list
  

New Open Type dialog (Markus; FAQ: Dirk)

• Test new view menu in open type dialog
• test working set support (ensure that not to many types get filtered)
  

Quick Fix/Assist (Ben, Tobias; FAQ: Martin, Tobias)

• Test new quick fixes to switch the compliance level or JRE to 5.0 when using 5.0 language constructs (note that a 1.5 JRE is required which has to be added in the 'Installed JRE's' preference page)
• Test new quick fixes for @SuppressWarnings annotation
• Javadoc tags for type parameters (handled special. creates <T>)
• Test convert to enhanced for loop for iterators
  

New default line separate preference (Markus, Tom; FAQ: Dani & Tobias)

• Check that all newly generated files respect the new line delimiter setting avaible on project and workspace. Tests include all new wizards, refactorings that create new files like extract method, move member type to new file and NLS refactorings
• Check that refactorings and source actions don't mess up line delimiters (e.g respect existing line delimiters). >> Dani you have a plug-in to check line delimiters. May be we should advertise it and everybody should run it over its workspace from time to time.

Editor bound to Content type (Martin, Dani: FAQ: Dani)

• for internal and external *.java files Java editor comes up
• Associate file extension with Java editor
• Binding other editors to *.java (for example Ant). Both must show up in Open With...

Content assist with access restricitions (Martin, Dani: FAQ: Dani)

• Test access restrictions for content assist (see Java Editor->Code assist preferences). Note that you have to define some access restrictions for the test project
  
• Check that "access restricted" types don't show up in context assist

Editor opening (Martin, Dirk: FAQ: Dani)

• Try combinations of folding (on/off) and segemented mode (on/off)
• Try single and double click open mode
  

J2SE 5.0

Refactoring (David, Benjamin, Tom: coordinate the effort; FAQ: Dirk, Markus, Tobias)

• Rename (Ben)
  
• annotations, annotation members (especially the special case value), enum, enum member, type parameters, vararg parameters
• with varargs, type parameters, generic & parameterized types in the signature (field, method, local)
• rename of methods that are overridden or override/implement other method. Focus on methods with varargs and type parameters
  
• Move CU/Type (Ben)
• annotations, enum, generic & parameterized types
  
• Move (method & static members) (Ben)
• enums and annotations as members in types
• signature with type parameters, varargs, parameterized types
• methods in generic & parameterized types
• methods that refer to a static import or type parameters from class
  
• Change method signature (Ben)
• signature with type parameters, varargs, parameterized types
• methods in annotations, enums, generic & parameterized types
• Convert Anonymous to nested (Ben)
• annotations, enum, generic & parameterized types
• Move member type to new file (Ben)
• annotations, enum, generic & parameterized types
• code that refers to static imports
• code that refers to type parameters
• Pull Up & PushDown (Tom)
  
• methods in generic & parameterized types
• methods that refer to a static import
• methods with type parameters, varargs, parameterized types
• between generic, normal and parameterized types
• enums and annotations as members in types
• Extract Interface / Use Supertype where possible (Tom)
• enum and annotations
  
• generic and parameterized types
• method with varargs, type parameters, parameterized types
  
• Generalize Type (Tom)
• enums and annotations
• generic and parameterized types
• Extract/Inline Method (Tom)
• Code in generic & parameterized types and enums
  
• Code that refer to type parameters (from class and method)
• vararg usages
• code with references to static imports
• code with autoboxing
• Extract/Inline local (Tom)
• expression which resolve to parameterized types, annotations, enums  and type parameters (or the concrete type for parameterized types)
• Extract/Inline constant (David)
  
• in enums, annotations, generic and parameterized types
• Introduce parameter (David)
  
• expression which resolve to parameterized types, annotations, enums  and type parameters (or the concrete type for parameterized types)
  
• signature to be changed contains varargs, type parameters, parameterized types
• Introduce Factory (David)
  
• for generic and parameterized types
• destination type is generic or parameterized
• Convert local variable to field (David)
  
• declaring type is parameterized types, annotations, enums  and type parameters (or the concrete type for parameterized types)
• Self encapsulate field (David)
  
• field type is parameterized types, annotations, enums  and type parameter
• in enums, parameterized types and generic types.
• Infer type arguments (David)
  
• test for collection classes
• test for own generic classes
• test for classes with n type parameters
  

Source Actions (Dirk, Martin; FAQ: Tobias)

• Organize import / add import
• organize import. Define static import groups in the preference
• add import on Math.max should add a static import on max add should remove Math in code.
• Override/Implement methods
• methods with type parameters, varargs, parameterized types
• from generic and parameterized types
• from annotations
• Generate Getter/Setter
• field type is parameterized types, annotations, enums  and type parameters
• in enums, parameterized types and generic types
• Generate Delegate Methods
• field type is enum, annotation
• field type is type parameter or parametrized type
• Generate Constructor Using fields
• field type is enum, annotation
• field type is type parameter or parametrized type
• Add Constructor from Superclass
• super class is generic or parameterized type
• constructor with type parameters, varargs, parameterized types
• Sort members
• members with type parameters, varargs, ...
• types with enums, annotations, generic and parameterized types as members
  
• sort enum, annotations, generic and parameterized types
  

Search (Tobias, Markus; FAQ: Markus, Martin, Dirk)

• test searching for enums, annotations, generic types and methods, parameterized types and methods and type variables
• test new filters for incompatible and inexact matches

Java Editor (Dani, Tobias; FAQ: Tom)

• new syntax colorings
• auto(un)boxed expressions
• new keywords (enum, @interface)
  
• annotations
• annotation element references
• parameter variables
  
• code assist
• enums
• static imports
  
• generics
• type parameter proposals
• enum constant proposals
• annotations
  
• argument guessing for parameterized types
• verify that the Java Outline displays new J2SE 5.0 constructs correctly
• verify that occurrence marking handles new J2SE 5.0 elements correctly (check bugzilla first: there are already some bug reports)
• verify that folding works correctly for J2SE 5.0 elements
• test new 'foreach' template
• hovers for new J2SE 5.0 constructs (e.g. hovering over parametrized types)
• format CUs with J2SE 5.0 constructs and verify that they get correctly formatted according to the current formatter settings
  

New 3.1 Functionality (in addition to J2SE 5.0)

Build Path (Dirk, David; FAQ: Martin)

• Test new access rule user interface. Access rules are defined via the build path. Don't test it for plug-in projects since PDE takes care of access rule here
• Test user interface for adding native libraries to the build path (build path page, attribute of JARs and class folders)

Undo/Redo (Martin, Dani; FAQ: Dani, Dirk)

• Test that Refactor > Undo/Redo is gone
  
• Execute various refactorings from different views and check that Edit > Undo allows undoing the refactoring (note that not all refactoring are undoable. So best test rename, extract method, ..)
• Test undo/redo of typing inside the editor (without mixing it with refactoring undo)
  
• Execute refactorings and change the state of affected resource and check that the undo is no longer valid. State changes are: content changes, bringing it out of sync with the workspace and changing read-only state. Changing the state should not automatically flush the undo stack anymore. Check that restoring the original state will allow undoing the refactoring (if the file got modified and save in the Java editor simply undo the text change. This will now restore the state).
  
• Execute refactoring from within the Java editor and check that the undos appear on the editor's undo stack. Test undo/redo of the refactorings
  
• Test mixing refactoring and typing in the editor and test undo/redoing these.
  
• Check that undoing a refactoring from withing the Java editor should show a confirmation box when other resources than the file currently being edited are affected by the undo (for example rename a method that is referenced in a second CU and try yo undo it from the editor that contains the declaration).
• Check that undoing the last change remove the dirty indication in the editor tab

Search (Dirk, David; FAQ: Martin)

• Test text search
• Focus searching in large file with regex patterns which spawn multiple line - larger code blocks
• Have an eye on performance

Preferences (Tom, Dani; FAQ: Martin)

• Test that all JDT and Text preferences have meaningful keywords.
  

Text Editor (Ben, Markus; FAQ: Dani, Tom)

• URL hyperlinking: verify that
• link is correctly indicated
• clicking shows the URL in a browser
• open Properties dialog from active editor
• test 'Convert Line Delimiter To' commands on active editor and on a folder or project
• test 'Remove Trailing Whitespace' command on active editor and on a folder or project
• test 'Word Completion' (Ctrl + /)
• verify that the new undo history size preference correctly works
• Use Window > New Editor on a text editor and verify that they behave property

Java Editor (Tobias, David; FAQ: Dani, Tom)

• semantic coloring for deprecated members
• new occurrence markings
• inherited methods
• implements occurrences
• folding
• header folding: test different variants of headers
  
• better caption when Javadoc or code is folded
• test that the browser widget is used for Javadoc information presentation (F2)
• verify that performance is acceptable
• Code assist
• auto insertion behavior
• parameter guessing correctness
• type parameter guesses (e.g. in List<String> l= new ArrayList<??> should guess something meaningfully for ??)
• auto insert behavior
• auto-boxing coloring: verify that it colors the same places as the compiler warns about (enable corresponding compiler warning)
• Move lines - check performance
• verify that new folding artwork looks good - try with different fonts
• icons
• line in vertical rule
• Use Window > New Editor on a Compilation Unit editor and verify that both behave property
• Use Window > New Editor on a Class File editor and verify that both behave property

New Source Folder wizard page (Dirk, Ben; FAQ: Martin)

• setup project on existing source using the new source folder wizard page.
• Source to setup should have:
• multiple source folders
• need to exclude some portion of the code
  

General items

Validate-Edit (Markus, Martin; FAQ: Dani)

• Check-out code from the repository in CVS Watch/Edit mode (stores file in read-only mode)
• Test Editing, Source and Refactoring actions on files that are read-only. Don't forget source actions like organize import or format on packages and source folders.
  
• Expected result: actions should complete without errors

Workspace compatibility (Tobias, Tom)

• upgrade a 3.0 workspace to 3.1