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

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

Goal

• test new 3.1 M7 functionality
  
• 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 X (Christof)
  
• 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 (Benjamin, Tobias)
• use linked resources (David)
  • linked output folders
  • linked source folders
  • linked and nested source folders
  • test rendering in views
  • linked class folders
• use multiple output folder (Christof)
• use combination of exclusion & inclusion filters (Martin)
• use user defined library containers (JUnit as a user defined library) (Dirk)
  • quick fixes for unbound user libraries
  • quick fixes for build path problems
• full source workspace (Markus)

Java Editor in Single Method mode (Martin, Benjamin, Tobias, Markus)

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

Multiple Windows (Tobias, Markus, David, Dirk)

• 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 (Tom, Markus, Benjamin)

• 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 (Dirk, Tom, David)
  
• third of the team tests in Java perspective using project mode in package explorer (Martin, Tobias, Benjamin)
  
• third of the team tests in Java perspective using the working set mode in the package explorer (Dani, Christof, Markus)
  

Automatic workspace refresh (Benjamin, Markus, Christof, Dirk)

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

3.1 M7 items

Bug verification (all)

• Verify all P1 & P2 bugs fixed during M7 (total 27) (JDT/UI & JDT/Text, Platform/Text).

Undo/Redo (Markus, Tom; 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
  

New Open Type dialog (David, Martin; FAQ: Dirk)

• Test new open type dialog and history (know problem [93668])
• removing elements from the history using delete key or context menu
• dialog doesn't show stale types in history

Refactoring Capture Binding (Dani, Benjamin; FAQ: Markus)

• Test refactoring and capture bindings (known problem [93541]):
• test all refactorings that deal with expressions (extract local, constants, extract method) and create new type signature. The expression to be extract should be of a generic type using wildcards. For example extract foo() to a local variable where foo is declared as follows: List<?> foo();

Build Path (Dani, Benjamin; 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)
  

Preferences (Markus, Tom; FAQ: Martin)

• All preferences and property pages have meaningful keywords. Try to navigate to a preference page using a keyword that should match and validate that the page is shown
• Check editor preferences. They got converted back to tab style. Verify that nothing is clipped, tabs are visible, layout is correct

Compiler (Markus, Tom; FAQ: Martin)

• New compiler settings for @SuppressWarnings annotation

Quick Fix/Assist (Dani, Benjamin; FAQ: Martin)

• Add missing @Deprecated and @Override annotation
• Quick fixes and wild card types: New variable with a wildcard type, change method signature, new method....
  
• Quick fix/assist direct shortcuts
  

Add Imports (Dani, Benjamin; FAQ: Martin)

• Add import that introduces a star import removes unused fully qualified import
  

Platform-Text (David, Martin; FAQ: Tom, Dani)

• Verify syntax coloring and highlighting interaction (verify there is no cheese due to optimizations)
• Use Window > New Editor on a text editor and verify that they behave property
  

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

• 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

Search (Dani, Benjamin; 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
  

J2SE 5.0

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

• Rename
  
• 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)
• Move CU/Type
• annotations, enum, generic & parameterized types
  
• Move (method & static members)
• 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
• signature with type parameters, varargs, parameterized types
• methods in annotations, enums, generic & parameterized types
• Convert Anonymous to nested
• annotations, enum, generic & parameterized types
• Move member type to new file
• annotations, enum, generic & parameterized types
• code that refers to static imports
• code that refers to type parameters
• Pull Up & PushDown
• 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
• enum and annotations
  
• generic and parameterized types
• method with varargs, type parameters, parameterized types
  
• Generalize Type
• enums and annotations
• generic and parameterized types
• Extract/Inline Method
• 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
• expression which resolve to parameterized types, annotations, enums  and type parameters (or the concrete type for parameterized types)
• Extract/Inline constant
• in enums, annotations, generic and parameterized types
• Introduce parameter
• 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
• for generic and parameterized types
• destination type is generic or parameterized
• Convert local variable to field
• declaring type is parameterized types, annotations, enums  and type parameters (or the concrete type for parameterized types)
• Self encapsulate field
• field type is parameterized types, annotations, enums  and type parameter
• in enums, parameterized types and generic types.
• Infer type arguments
  
• test for collection classes
• test for own generic classes
• test for classes with n type parameters
  

Source Actions (Christof, Markus, Benjamin; 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 (Dani, Benjamin; 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

Quick Fix & Quick assist (Tom, Markus; FAQ: Martin)

• Test convert to enhanced for loop (currently only available for arrays)
  
• Javadoc tags for type parameters (handled special. creates <T>)
• quick fix helps you changing the compliance settings when you try to enter 5.0 constructs in a 1.4 project. Note that a 1.5 JRE is required which has to be added in the 'Installed JRE's' preference page

Java Editor (Tobias, Martin; 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)

Preferences (Tobias; FAQ: Martin)

• test that you can navigate from project specific settings to the global settings and vice versa
• test project specific settings for formatter, compiler, code style settings, Javadoc locations
• test the new hyperlinks on Text Editor and Java preference pages: verify that
• link is correctly shown
• hover is correct
  
• clicking navigates to correct preference page
  

Search (Dani, Christof; FAQ: Dirk)

• Test different rendering of filtered / non filtered search result matches
• occurrence search
• Implementing Methods
  
• Throwing Exception

Quick fixes (Benjamin, Dani FAQ: Martin)

• Serial version Id
  

Text Editor (Tobias, Martin; FAQ: Dani, Tom)

• URL hyperlinking: verify that
• link is correctly indicated
• clicking shows the URL in a browser
• test new encoding support
• 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
  

Java Editor (Martin, Dirk; FAQ: Dani, Tom)

• semantic coloring for deprecated members
• verify the new underline and strikethrough syntax coloring styles
• 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
  

NLS Tooling (Dirk, David; FAQ: Dani)

• test Externalize Strings wizard with new Eclipse-style message bundles
• test Externalize Strings wizard with old-style message bundles
• linking in CU and Class File editor to properties entry and vice versa (only works for old-style NLSing)
• hovering over NLS key in CU and Class File editor show externalized string (only works for old-style NLSing)
• Java Properties File editor
• syntax coloring - verify that colors can be changed via preferences
• spell checking
  

New Source Folder wizard page (David; 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

Accessibility Testing (Tom)

• verify mnemonics in wizards/dialogs/menus
  Note: mnemonics on Platform Text and JDT Text preference pages are not yet done.
• initial focus in dialogs
• combination of color, form, and text.
• status line information

Operations and Locked Workspace (Dirk, Christof)

• To lock the workspace use the org.eclipse.ui.examples.job plug-in from the Eclipse repository
• Test Edit, Source and Refactoring actions when the workspace is locked
• Test modifying project properties (build path, compiler settings, ...) when workspace is locked
• You should always get the blocking dialog
• Cancel the user action. Make sure that no OperationCancelException or other exceptions appear in the log

Validate-Edit (Tobias; 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
• Expected result: actions should complete without errors

Compilation Units not on Build Path (Dirk, Christof; FAQ: Dani, Dirk) 

• Test Edit, Source and Refactoring actions for compilation units not on the build path.
• Test for:
  • editors opened on repository files
  • editors opened on Java file excluded from the build path
  • editors opened on Java files stored in Simple projects
• Actions should either operate without an error, not be present or present a dialog that the CU is not on the build path

Workspace compatibility (Markus)

• upgrade a 3.0 workspace to 3.1
• upgrade a 2.1 workspace to 3.1