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

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

Goal

test polish items that got added for RC2
test areas that might got broken by bug fixes done in RC2
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

eclipse-SDK-3.1RC2

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

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

Java Editor in Single Method mode (Martin, 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)

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, 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 (Tobas, David)

Automatic workspace refresh (Markus, Dirk, Dani)

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

3.1 RC2 items

Bug verification (all)

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

Search engine and impact on Refactorings (David, Tobias FAQ: Markus)

Test rename method and Change Method Signature on methods whose parameters contain type variables and that are overridden in subclasses where the type variables are bound to a concrete type. e.g.

class Top<E> {
void add(E e) {}
}
class Sub extends Top<String> {
void add(String s) {}
}

and clients calling both add methods

Infer Generic Type Arguments (Dirk, Martin FAQ: Markus)

sanity check that it doesn't do too weird things with big projects:

is cancellable
heap consumption < 300MB
only leaves zero or a few compile errors

sanity check with "normal" code using collections

Refactorings (David, Dani FAQ: Tobias)

Convert Anonymous: Correctly works with references to enum constants, respects naming conventions
Extract Interface/Use Supertype Where Possible: Verify on generic classes with parameterized superclasses/interfaces that all references are updated
Move Member Type to New File: Verify on generic classes, nested enums
Move Static: Verify moving of generic static methods
Add Constructor From Superclass: Proposes correct constructors for generic class hierarchies containing abstract classes, inserts the selected one correctly
Test extract method inside methods with type parameters. Test with cases where the type parameter is directly referenced by the selection or indirectly through the fact that a local or parameter gets generated which refers to the type parameter.

Source Actions (Markus, Martin FAQ: Tobias)

Override/Implement Method: Verify on generic classes, verify sorting
Generate Delegate: Verify on generic classes, verify sorting, test that no synchronized statements are generated and no TODO tags, test that the selected methods are correctly associated with the corresponding fields in the generated code
Add Constructor from superclass: verify that all avaible constructors are proposed and that no constrcutors are proposed which already exist in the class (since they have the same signature as the constructor from the superclass).
Code Assist for anonymous types: Verify that the Override Method dialog shows up on classes only and that the correct methods are generated. Test for normal top level classes, secondary top level classes, member types both static and non static and from withing the same CU and different CU.
Surround With try catch: test the action with comments in front/back of the statement to be surrounded. Test with comment selected and not selected. Make sure that comments don't get lost and don't get duplicated. Also test with the expression throwing the exception being the initializer of a variable declaration (e.g. URL url= file.toURL()).

Java Editor (Dani, Tobias)

test hovers on generic types, inner types, signatures with varargs, signatures with primitive types, ... (FAQ: Martin)
Occurrence Marking (FAQ: Dani)
- look for cheese
- implements/overrides occurrence marking
- test with 5.0 code
Code Assist (disable sorting of proposals) (FAQ: Dani)
- test code assist at various locations and verify that the proposals make sense and are correct
- test code assist with 5.0 code
- performance: test if performance is acceptable
- initial list
- narrowing down the list while typing

Text Editor (Dani, David) FAQ: Dani)

Typing
- stress indent command (Ctrl+I) in the Java editor
- test move/copy lines
- type code and verify that performance is acceptable

Undo (David, Tom FAQ: Dani)

make changes in different files and switch between them while performing undo and redo
verify that the undo/redo menu labels are correct (e.g. 'Typing' for text changes)
go through the various undo bugs from M7 to now and re-verify them
test undo when mixing refactorings ands text changes. Especially test wih refactoring that on't provide an undo (for example moving fields). Make sure that editor undo stack isn't corrupted and that the move can be undone by undoing the textual changes in the source and target editor.

Saving (Tobias, Martin) test both, Text and Java editor) (FAQ: Dani)

'save as' over existing filessave external files
behavior when file gets deleted outside Eclipse
with auto-refresh
without auto-refresh
test that messages in dialogs make sense

Folding and segmented mode (Tom, Markus FAQ: Dani)

verify correct folding
verify that semantic highlighting for expanded code is there
test each mode on its own
toggle between the modes
test that opening a member from Type Hierarchy and Package Explorer correctly appears in segmented mode

URL Hyperlinking (Dirk, Martin FAQ: Dani)

test in Text and Java editor
test that the General > Web Browser preferences are honored

File Associations, Content Types and opening of editors (Tom, Markus FAQ: Dani)

test that text, Java and properties file content type are present
test that the corresponding editors open
test that other editors can be bound to such files and appear in 'Open With'
test that other editors can be set as the default editor

Externalize Strings wizard (Tobias, Dirk FAQ: Dani)

test initial externalization
test with a file that's partially externalized
test 'normal' and Eclipse externalization mode

New Project Wizard (Dirk, David FAQ: Martin)

Test the JDK compliance mode on the first place. Verify that the compiler compliance setting is updated as well as a JDK is choosen which at least supports the requested level.
Verify that removing a linked folder from the build path shows dialog to choose whether to unlink the folder as well.
Go through the examples in the Project configuration tutorial and check how the new wizard helps to link existing sources into a project.

Build path (Dani, Dirk, FAQ: Martin)

test add/remove, include/exclude and change output folder using the actions from the Build Path sub menu. Always check the inclusion/exclusion side effects. Check for all dialogs the behaviour on cancel.

Build path dialog (Tom, Markus FAQ: Dirk, Martin)

modify every single attribute that can be modified by the build path dialog. After every single modification close the dialog and check that the modification got correctly applied. Test add, change and remove of attributes. Don't forget source locations, javadoc, native libraries, access restrictions, ...

Quick Fix (Markus, Tom FAQ: Martin)

Test quick fixes suppress warnings, access restriction references, changing to 5.0 compliance
Test quick fixes that create/corrrect methods/fields with wildcards, variables.
Enhanced for loop: Shows only up for 1.4 projects, works on arrays and any java.lang.Iterable, respects naming conventions, offers completion proposals in linked mode, proposals include already existing element

Open External Javadoc (Tobias, Dani FAQ: Martin)

Test the javadoc attribute in containers, e.g. user libraries and verify that the javadoc correctly opens

Project specific settings (Tobias, David FAQ: Martin better steps needed here)

Modify formatter profiles that are used in other projects or workspace

JUnit (Markus, Dirk FAQ: Tobias)

JUnit Test Case Wizard: Verify that the wizard works on generic classes as well, test the generated method stubs for meaningful signatures, verify correctness of comments
JUnit View: Verify that all context menus are displayed, no error in log, run button is correctly disabled if no test can be run, using keepalive feature: verify that indication is shown when test is finished, verify that selected testcase is accessible by Enter key
Recreate Test Suite: Verify that recreate test suite is still possible when renaming the test suite to a name ending with ...Tests
Search Referring Tests: Verify that menu entry is correctly enabled/disabled on selection changes
Test new view menu option Active on Error/Failuer only. Test that the option is shared between all JUnit views (e.g when changed in one it also changes in another view).

Open Type Dialog (Dani, Tobias FAQ: Dirk)

Check that the open type dialog waits until the initialize after load job is completed (quick try to open the dialg after Eclipse has started)
Check that secondary top level types which share the same name prefix as the top level type itself (e.g.NameTop, NameSecond) both show up the dialog and can be norrowed down to.

Package Explorer (Tom, David FAQ: Dirk)

Test working set setup where the project is part of more than one working set. Test that adding, chancing and removing elements are reflected in all working sets that contain the element.

New synthetic method filter (Markus, Tom FAQ: Dirk)

Test new sythetic method filter. Test that the methods are correctly filtered and the no methods are filtered that aren't synthetic.

Drag and Drop (Dirk, Dani FAQ: Tobias)

Move/ Drag&Drop: Verify that an element cannot be moved to a child element (eg. a type to a field). Test that all other moves of elements of a compilation unit are allowed in the same CU and to another CU.

Preferences (David, Dani FAQ: Tobias, Dani)

Test searching for common and more specific keywords (Java vs. autoboxing, compiler vs. deprecated, editor vs. projectspecific). Make sure that the pages show up as expected.

Realize a project (everybody)

When done with your assigned items from above start realizing whatever "small" project you want. Setup new projects, adjust preferences settings to your normal programming style. Implement the project using J2SE 5.0 features. The goal is to test functionality not covered by your daily developement.