PTP/testing/1.x

Test Plan for PTP 1.x Release

This plan describes the tests that will be undertaken to verify the 1.x series of PTP releases. The following table shows the tests that apply to each release revision.

Test	v1.0	v1.1
CR_1	x	x
CR_2	x

Core/Runtime Tests

SETUP

1. Start on a bproc machine.
2. Make sure Open-MPI is setup and working (not part of this test, just required to utilize Open-MPI).
3. Start with a fresh Eclipse install (including workspace).
4. Install PTP.
5. Compile the PTP Open-MPI JNI library.
6. Acquire some set of nodes for a long period for testing.
7. Launch Eclipse and then launch a new Eclipse with the PTP plugins running.

Test CR_1: Views

1. Using the Parallel Development Preferences Page select the Simulated runtime system.
2. Using the menuing system, open the Machines View and Jobs View.
3. Confirm that the Jobs View shows no jobs since it is a clean start.
4. Confirm that the Machines View displays the current state of the machines. Use the drop-down menus to observe other machines that are known and confirm they too display the current machine state.
5. Create a set of nodes using the user interface and name the set.
6. Confirm that the user can switch between (focus on) the full set of nodes for the given machine and the newly created set.
7. Add a few more nodes to the new set.
8. Focus on a different machine and confirm that the set is no longer visible (since it pertains to the original machine).

Test CR_2: Job Launch

1. Create a new C project.
2. Create a new C-MPI source file in the project. The source file will have each process producing periodic output and run for a few minutes (so that the tests can be performed on a running job).
3. Compile the C-MPI application.
4. Create a new Run Configuration for this project, utilizing the Parallel Development configuration to specify the number of processes for this run and a chosen simulated machine.
5. Run the job (under simulated control).
6. Confirm that the appropriate node's change state in the Machines View to specify they contain a running job and that the job starts on the correct machine.
7. Focus on a node where one of the processes has been assigned. Confirm that the Machines View displays the processes on that node, including which job the process belongs to.
8. Double-click on one of the processes in the Machine View to bring up the Process View. Confirm that the MPI rank, node number, job number, and status are correct.
9. Observe process output in the output section of the Process View.
10. Wait for job to terminate.
11. Observe that the process state and exit code correctly display in the Process View, Machine View (for the appropriate node), and Jobs View (for the appropriate Job).
12. Bring the Jobs View to the foreground.
13. Confirm the Job previously run, as well as the processes contained within it, are listed and is shown as terminated.
14. Re-run the same job. Confirm the Job View displays the job as running and the processes as well.
15. Double-click on a process of the job, opening the Process View. Confirm the running state.
16. Terminate the job by using the terminate icon.
17. Confirm the Job View updates to show the terminated state.
18. Confirm the Process View updates to show the terminated state, including an exit-code.
19. Using the Parallel Development Preferences Page select the Open-MPI runtime system.
20. Using the Open MPI Preferences Page under the Parallel Development Preferences Page set the path and arguments to the ORTE daemon (ORTEd).
21. Run the same job from step #12 (under OMPI control).
22. Repeat steps #14 through #26 for this second runtime system (Open-MPI as opposed to simulation).
23. Switch back to the Machine View.
24. Using another terminal change the state of one of the nodes (reboot it, change ownership, etc) and confirm that the node's status changes in the Machine View (both the icon to match the legend as well as the detailed text information to display the new change(s)).

Debug Tests

SETUP

1. Make sure that the correct version of CDT and Eclipse are installed.
2. Check out these packages from dev.eclipse.org:/home/technology/org.eclipse.ptp:
   • org.eclipse.ptp.core
   • org.eclipse.ptp.debug.core
   • org.eclipse.ptp.debug.external
   • org.eclipse.ptp.debug.ui
   • org.eclipse.ptp.launch
   • org.eclipse.ptp.ui
3. Run the Eclipse Application
4. Create a simple Managed Make C Project with the name: "TestC"
5. Create the main program file with the name: "main.c"
6. Fill in "main.c" with any code since the Debug Simulator will not interpret the source code (it only gets the line number). Edit the file so that it contains only 20 lines.
7. Create the PTP Launch Configuration and fill in the necessary configuration, including the number of processes.
8. Create a C/C++ Project named as "TestC"
9. Create a file called "main.c"

Test DB_1: Debug Core

1. Switch to the Parallel Debug Perspective.
2. Double click the ruler at any line in the source code window to set the breakpoint, set another breakpoint after the first breakpoint.
3. Verify that the breakpoints have been set by looking at the Breakpoints view.
4. Click the debug button for the created PTP Launch Configuration.
5. Process 0 will be registered automatically in the Debug view, 2 Console views will also be opened (one for process 0, and the other for the debugger output).
6. After printing the output for process 0, which can be verified by opening the Console view for process 0, all processes (process 0 and others) will break at the first breakpoint (since the breakpoint applies for all processes).
7. Verify this by looking at the Debug view and see that process 0 is suspended. Look at the Parallel Debug view, all processes should change to yellow. Look at the # Console view for process 0, the output should stop. Look at the Console view for the debugger, there should be text saying that BreakpointEvent has been received.
8. Double click process 1 in the Parallel Debug view to register it to the Debug view. Look at the Debug view and see that process 1 has been registered and in the suspended state. Look at the Console view and verify that Console view for process 1 has been created.
9. Select process 0 and click the Step Over button in the Debug view. Look at the Console view for process 0 to verify that the action has been executed successfully. # Repeat and verify this action several time
10. Select process 1 and click the Step Into button in the Debug view. Look at the Debug view and see that the number of stackframes for process 1 increases by one. # Click Step Into to increase the stackframe and click Step Finish to decrease the stackframe. Repeat and verify this action several times. The maximum number of stackframes is 5.
11. Select the stackframe of process 0 and open the Variables view. Verify that there are 2 argument variables and 2 local variables.
12. Select process 0 and click the Resume button, it will then hit the second breakpoint. Click the Resume button again to run process 0 until completion (it prints 20 lines and then exits). Look at the Debug view and the Console view and verify that process 0 has exited.
13. Select process 1 and click the Terminate button. Look at the Debug view and the Console view and verify that process 1 has been terminated.

Test DB_2: Debug Launch

1. Parallel Debug View displays the status of processes after launching a parallel program in debug mode.
2. Debug icon of the job represent that it is in debug mode.
3. The new job will be selected at the start up and the all processes of this job will be displayed.
4. Unselected the job, the process view will be cleared.

Test DB_3: Debug View

1. Drag across a rectangular region to select some processes. Hold down the left mouse button, move the mouse, and release the button when the desired process is selected.
2. Click with the left mouse button while holding down the Shift key will extent selection.
3. Click with the left mouse button while holding down the Ctrl key will continue selection.
4. A dialog box will popup when press the Create set button. After enter set name, the view will change from root set to created set.
5. There is a validation to check whether a new set name already exist or not. If exists, the ok button will be disabled.
6. Only set can be created after the job is launched.
7. Press Ctrl-A key can select all the processes.
8. Press Page-up key can go up one page.
9. Press Page-down key can go down one page.
10. Auto scrolling while dragging further up or down the views.

Test DB_4: Breakpoints

1. The parallel breakpoint is created when double click on ruler of the C/C++ source editor.
2. If the parallel breakpoint is created in the condition that is no job running or unselected all the jobs, this breakpoint will belong to be global for all the jobs and there is an additional overlayered image on the breakpoint.
3. Tooltips displaying details of breakpoint (job name, set name, file name and line number) will appear when mouse hovers on the breakpoint.
4. Color of a breakpoint will change to green when it is created in the current set's process.
5. Color of a breakpoint will change to yellow when it does not exist in any of the set's process.
6. Color of a breakpoint will change to blue when it exists in one of the process in the current set but is not created in this set.
7. Double on the created breakpoint on ruler, the breakpoint will be removed.
8. The global breakpoint only can be created or removed when there is no job selected.
9. Multiple breakpoints can be created in the same source file and the same line number with different jobs.

Test DB_5: Breakpoint View

1. All breakpoints will be displayed ordered by the set name when clicking the drop down menu in the breakpoint view and then the parallel breakpoint set.
2. Unchecked the breapoint in Breakpoint View, the breakpoint will be disabled. Check it again, it will be enabled again.
3. Right click on the breakpoint in Breakpoint View and select Goto Set action, the parallel debug view will change to the job and the set indicated in the selected breakpoint.

Test DB_6: Register / Unregister Process

1. Double click on the process in parallel debug view and the process will be registered into the debug view. A registered process is presented by a black rectangle.
2. Selecting multiple processes in the parallel debug view and then click the register button will register all of them in the debug view.
3. If more than 10 processes have been selected to register, a dialog will popup and ask for confirmation.
4. Double click on the registered process will unregister it from the debug view. The black rectangle representing the registration will be removed.
5. Selecting multiple registered processes in the parallel debug view and then click the unregister button will unregister all of them in the debug view.
6. The debug view will only display registered processes which is according to the current job and current set.

Test DB_7: Annotation

1. If a breakpoint location contains multiple markers, annotations for both these markers will be overlapped when the breakpoint is hit. The registered process marker should appear on top. Tooltips will display process task id of each marker set in this location, grouped by its marker.
2. The annotation will change to another color(not created) when switch to another set.
3. The process icon appears in yellow process is in suspended mode.
4. The process icon appears in green when in running mode.
5. The process icon appears in red when in terminate mode.
6. The resume button and all step buttons in the parallel debug view will only be enabled when one of the processes is suspended.
7. The suspend button in the parallel debug view will only be enabled when one of the processes is running.
8. The terminate button in the parallel debug view will only be enabled when one othe processes is either running or suspended.
9. Resume button in the parallel debug view resumes all suspended processes in the current set.
10. Suspend button in the parallel debug view pauses all running processes in the current set.
11. Terminate button in the parallel debug view stops all suspended and running processes in the current set.
12. Step buttons in the parallel debug view can step into, step over and step return all suspended processes in the current set.
13. Resume button in the debug view can resume selected suspended process(es).
14. Suspend button in the debug view can pause selected running process(es).
15. Terminate button in the parallel debug view can stop any suspended or running process(es).
16. Step buttons in the debug view can step into, step over and step return any suspended process(es).

Parallel Language Development Tools

(See help files in the plug-in for more details on these)

Test PLDT_1: MPI Artifacts

1. Launch eclipse with PTP (incl. CDT)
2. Help -> Help Contents, PTP MPI Tools
3. Follow instructions in "Setup for PTP MPI tools". Basically, create a CDT project, a source file with MPI apis (a sample is included in help), and use Preferences to locate MPI header files.
4. Follow instructions in "Running PTP MPI tools" to set up Open MPI artifacts view (Do we need to explicitly add the actions to the toolbar?)

select source vile in Navigator, then select MPI action to run analysis.

1. MPI artifact view should be populated with markers, listing API name, source file name and line number, and artifact type (function or constant)
2. Double-click on any artifact, this should take you to the source file and line locating the artifact.
3. In source file, icon should be in marker bar, and squiggles should be under the artifact (e.g. function name)
4. Click on column headings in artifact view to sort by values in that column.

Test PLDT_2: Command Completion

1. In editor, type e.g. MPI_ and hit ctrl-space. Possible completions should appear.
2. Continue to type a few characters; possible completions should diminish to match string.
3. Hitting ENTER or double-clicking on any choice should insert the completed API into the file.

Test PLDT_3: Hover Help

1. Hover on any MPI API, see yellow popup info on API and arguments.

Test PLDT_4: F1 Help

1. Click on any MPI API and hit F1 to see Help view appear
2. C\lick on API in that view and see detailed info on that API.

Fortran Development Tools

SETUP

1. In a new workspace, check out the following CDT components from dev.eclipse.org:/cvsroot/tools
   • org.eclipse.cdt-build/
   • org.eclipse.cdt.make.core
   • org.eclipse.cdt.make.ui
   • org.eclipse.cdt.managedbuilder.core
   • org.eclipse.cdt.managedbuilder.gnu.ui
   • org.eclipse.cdt.managedbuilder.ui
   • org.eclipse.cdt-core/
   • org.eclipse.cdt.core
   • org.eclipse.cdt.core.ARCH
   • org.eclipse.cdt.ui
   • org.ecipse.cdt-debug/
   • org.eclipse.cdt.debug.core
   • org.eclipse.cdt.debug.mi.core
   • org.eclipse.cdt.debug.mi.ui
   • org.eclipse.cdt.debug.ui
   • org.eclipse.cdt-launch/
   • org.eclipse.cdt.launch
   • org.eclipse.cdt-doc/
   • org.eclipse.cdt.doc.isv
   • org.eclipse.cdt.doc.user
2. Next check out the FDT components from dev.eclipse.org:/cvsroot/technology
   • org.eclipse.ptp/lang/
   • org.eclipse.fdt.core
   • org.eclipse.fdt.managedbuilder.core
   • org.eclipse.fdt.managedbuilder.ui
   • org.eclipse.fdt.managedbuilder.tests
   • org.eclipse.fdt.ui
   • cdt_changes
3. From a shell, cd to Eclipse workspace and execute the shell script cdt_changes/install
4. Select org.eclipse.cdt.* projects one by one and refresh them.
5. Verify that workspace builds correctly without any errors.

Test: FT_1: User Interface

1. Create Eclipse Application launch configuration (FDT) and run it.
2. Examine icons (set left of debug icon) and make sure that project, folder, and file wizard icons are "M" based not "C" based. Also check that there is a "Make" perspective and a "Make Projects" window.
3. Examine menus corresponding to these icons and make sure they don't have C/C++ in labels.
4. Right click in "Make Project" window and examine icons and menu labels as in #6 and #7 above.

Test: FT_2: Managed Make 1

1. Use menu in project icon to create a new "Managed Make" project, name it HelloWorld (check icon).
2. Select Gnu Fortran for project type and click Finish.
3. Use menu in file icon to create a new source file. Name it hello.f90; make sure the file extension is acceptable and check icon and click Finish.
4. Check that new file is automatically opened.
5. Copy contents of org.eclipse.fdt.managedbuilder.tests/src/HelloWorld/hello.f90 into the new file and save the file.
6. Check console to see that "Build complete for project HelloWorld"
7. Create new "Local Application"
   • Run target. Ensure that label in the configurations window is "Local Application" and icon has an "M". Name the configuration HelloWorld and set the Project and #* Application fields. Set a debugger and click Run.
8. Check that "Hello from Fortran Main." is printed in the console window. Select the HelloWorld target from the Run menu and check console output again.

Test FT_3: Managed Make 2

1. Redo FT_2 for the directory, org.eclipse.fdt.managedbuilder.tests/src/Components. That is, create a Managed Make project named Components and build an application the files.
2. Open Debug/subdir.mk and ensure the dependencies are as follows:
   • Driver.o: MonteCarloIntegrator.o
   • MonteCarloIntegrator.o: LinearFunction.o
   • MonteCarloIntegrator.o: RandNumGenerator.o
3. Make sure the project will build and run.

Test FT_4: Managed Make 3

1. Redo FT_2 for the directory, org.eclipse.fdt.managedbuilder.tests/src/Mixed. That is, create a Managed Make project named Mixed and build an application the files.
2. Make sure the mixed language project will build and run