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

[Kai-Uwe Maetzel <kai-uwe_maetzel@xxxxxxxxxx>]

Attached you find the test plan for
the next two days. As in the past, this is a
combined test plan for JDT UI, JDT Text,
Platform Compare, Platform Search,
and Platform Text.




Focus is on testing the components,
rather than fixing bugs. Once the test
pass is complete, we will decide what
to fix for RC2. The policy for the 
fix pass is given at
http://dev.eclipse.org/viewcvs/index.cgi/~checkout~/eclipse-project-home/plans/3_0/freeze_plan.html


Kai

Title: Fix Pass

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

Goal

• test corner cases
• test setups which we typically don't use during development (for example no Plug-in developement)
• handling of error situations
  • watch log
  • error messages

General Items (everybody)

• Whenever you have to fill in data in dialogs try to foul 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 (Kai & Andre)
• use linked resources (Markus)
  • 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 & inclustion 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 (Danny)

Java Editor in Single Method mode (Martin, Andre, Kai, Erich, Markus)

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

Multiple Windows (Kai, Erich, Markus, Danny, Dirk)

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

Multiple Editor Areas (Tom, Markus, Andre, Erich)

• 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

Browsing perspective (Martin, Kai, Tom, Dirk)

• half of the team tests in browsing perspective

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

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

Accessability Testing (Tom, Markus)

• verify mnemonics in wizards/dialogs/menus
• initial focus in dialogs
• combination of color, form, and text.
• status line information

Hierarchical Layout in Package Explorer and Packages View (Martin, Kai)

• test add and delete of package
• test add and remove of compilation units to empty leaf and non leaf packages
• test filters which filter packages (empty parent package, empty package, ....)
• test logical packages in packages view

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 (Andre, Martin)

• Check-out code from the repository in CVS Watch/Edit mode (stores file in read-only mode)
• Test Edit, Source and Refactoring actions on files that are read-only
• Check the new editor functions explicitly. Check if available the functions in the default text editor.
  • move lines
  • copy lines on move
  • to upper case, to lower case
  • smart ;{
  • add/remove block comment
  • correct indentation
  • toggle comment
• Expected result: actions should complete without errors

Compilation Units not on Build Path (Danny, Christof)

• 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

Formatter settings and code manipulation (Dirk, Tom)

• test quick fix, quick assist, source and refactoring actions with "unusual" code formatter settings.
  • different indentation
  • use spaces instead of tabs
  • different argument and field prefixes and suffixes
• check if code is formatter/created according to the formatter settings

Javadoc (Kai, Markus)

• Javadoc for libraries (rt.jar) class, source folders
  • Test that Shift+F2 opens correct Javadoc
  • Test Javadoc in archives, URL or file location
• Generation of Javadoc (use of Export to Javadoc)

Packages Explorer (Martin, Andre)

• Rendering of Plug-in class path container
  • when resolved required projects are in workspace
  • when resolved required projects are external
  • test goto action on resolved entries

Refactoring (Martin, Andre)

• Test refactoring undo/redo
  • perform undo/redo with unsaved files not affected by the undo
  • perform undo/redo with unsaved files effected by the undo.
  • perform build after refactoring and ensure that undo is still possible.
  • test executing multiple refactorings and then the corresponding undo/redo sequence
  • change Java element (e.g save file): ensure that undo stack gets flushed.
• Sanity check
  • Introduce Paramter, Introduce Factory, Generalize Type refactorings
  • Move of public static final fields between classes and interfaces and static inner types between classes
  • Excpetion support in change method signature refactoring

Search (Danny, Martin)

• Removing selected matches from the tree view: make sure the correct items are removed.
• Navigation (previous, next) in the tree view: cases where we have matches in inner nodes
• Match highlighting and editing/refactoring/source operations (for example organize imports): make sure highlights are properly updated.
• Multilple background searches: test cancel and switching between multiple background searches
• Mulit-window behaviour: switching between searches, search shows up in right window
• Text Search/Replace behaviour
  • Test replace, replace all in file, replace all, skip, skip file
  • Search & Replace with regular expessions
  • Make sure changes by internal or external editing are detected before replacing
  • Editor reuse
• test the flat layout search result layout
• Java Search
  • test search for local variables

Task Tag (Danny, Christof)

• Set different task tags as default (Preferences->Java->Task Tag)
• Check if default tag is used in source and refactorings actions

JUnit (Danny, Christof)

• run a single test method
• run all tests inside a package

Source Actions (Danny, Christof)

• Sanity check source actions (Override/Implements, Generate getter/setter, Generate Delegate methods, Constructor using fields, Add Constructor from Superclass and Add Javadoc comment)
• check code generation insertion point (where available)
• Javadoc generation for new method
• Visibility control for new methods
• Sort Members actions: check sorting members within a category by visibility

Compare (Dirk, Kai)

• exercise "Compare with Each Other" on files with different encodings
• exercise "Compare with Each Other" and new Progress Services: compare large folder hierarchies containing large files with lots of differences

Workspace compatibility (Christof, Dirk)

• upgrade a 2.1 workspace to 3.0

Additional text items

Preferences (Markus, Tom)

• check all preference settings for the default text editor
• check all preference settings for the java editor
• check inheritenance of perferences

New editor functionality

Sanity check new editor functionality. Where available in the default text editor.

Block 1 (Danny, Andre)

• move lines
• copy lines on move
• to upper case, to lower case
• smart ;{
• add/remove block comment
• correct indentation
• toggle comment
• camel case navigation
• smart home/end
• typing modes
• caret width
• linked mode improvements and customization
• go to next/previous annotation (configurable)
• incremental content assist
• roll over hovers
• italic syntax highlighting
• background highlighting for annotations
• control visibility of annotations in the vertical ruler
• override indicators
• mark occurrences

Block 2 (Dirk, Kai)

• quick diff
• semantic syntax highlighting
• Java doc formatting
• format element
• quick outline
  • inherited members
  • resize shell
  • move shell
  • filters, top level element
• Find/Replace
  • content assist
  • regex
• templates
  • create/edit/remove templates
  • restore templates to default

Block 3 (Erich, Markus)

• Folding
  • preference settings
  • initial folding
  • interaction (auto expansion) with actions such as
    • incremental find
    • find/replace
    • format element
    • format
    • un/redo
    • correct indentation
    • shift right/left
  • corner cases
    • folding, formatting, un/redo
    • switching between segmented mode and folding

New functionality (Andre, Tom)

Sanity check new functionality.

• Javadoc view
• Declarations view
• open external files

File buffers with annotation model suport (Kai, Martin)

• files open in multiple, different editors, check hot updating of content and annotations
• refactor/format files not open in editor, checking the update of markers and search results
• encoding scenarios
  • set and change explicit encoding
  • work with content/parent derrived encoding
  • corner case: test for workspace and external files

Memory scenarios (Erich, Christof, Danny)

• Replace all 'e' by xxx in a larger file in the default editor and Java editor
• Shift all lines to the right in a larger file in the default and the Java editor
• Comment all lines in a larger file in the Java editor