Sirs:
The accompanying document describes the overall design of an on-line student registration system for General University. This design accommodates the specific modifications suggested by General University to our original proposal.
In particular, the system incorporates a graphical user interface, which will allow new users to rapidly adapt to the system. As well, multi-level access provides different sets of functions for different classes of users. This design allows for easy extension of the system to accommodate new functions and new classes of users.
The function of major modules are described, along with specifics of data types, how the modules will interact, and illustrations of screen images that users will view.
Sincerely,
Students additionally have recorded their faculty, the maximum course load they are allowed, a list and count of the courses they are registered in and a transcript of courses taken.
An Entity Relationship Diagram (ERD) illustrates the relations between courses and students in the system. A data dictionary specifies the types of individual data items in the system.
This document describes the functions of each subsystem. A pictorial overview is supplied as a structure chart.
After the user clicks on the "Login" button on the welcome screen, the login screen appears. Users will see two boxes on this screen that require him/her to type in his/her student identification number and password. There are three buttons on this screen: clear, ok and quit. These buttons can be presed by using the mouse or by using the tab key to select and the return key for the action. The clear button will clear both fields. The ok button is used to proceed after both fields are entered. Pressing return after entering a password has the same function as ok. The quit button returns the system to the welcome screen.
From the entered identification number the system distinguishes which mode it will be in: student mode or administrator mode. Upon entering a valid identification number, the system continues by requiring a password for entry into the system. The password is echoed to the screen as asterisks to confirm the keystrokes to the user. If the identification number given is that of an administrative user, the system will display the administrative main menu, otherwise the student registration main menu is displayed. If the user inputs an invalid password and/or identification number, an error message and a prompt for re-entry will be displayed.
In the upper left corner of the screen, the student can see an area which contains their personal information. It includes the student's name, identification number, address, faculty, major/minor, status (full-time or part-time) and year of program. This information serves to confirm to the user that their information is correct and up to date. The student is not given access to change any of this information directly.
Under the student information is another sub-window containing the student's personal timetable. This timetable displays all of the courses that the student is currently registered in. The courses are displayed in a time slot so with a quick visual inspection a student can check the days, start time, duration time and location of a specific course. The timetable is set up so that it displays the times in the left margin and the days of the week in the top margin. The timetable is scrollable both horizontally and vertically. Underneath the timetable are 3 buttons: "Drop a Course", "Change a Course" and "Print Timetable". These buttons allow the student to perform the respective operations. More information regarding these functions follows.
In the upper right corner important dates are displayed. Today's "Date", "Last day of Registration" and "Drop Date" serve to remind the student of registration deadlines. Students cannot change these dates.
Below these dates, there is a sub-window called "Course Listing". This sub-window basically allows the student to view all of the lectures, labs and tutorials for a course along with their times, section number, duration, days offered and location. The student would have to first click on the "Department" drop-down menu and pick the discipline of where the course belongs and then move along the the "Course" drop-down menu to specify a course to list. Under these drop-down menus there are 3 columns; one for all of the lecture sections, one for all laboratory sections and finally one for all tutorial sections.
There are three buttons and a status bar displayed at the bottom of the screen. The buttons are "Help", "Change Password" and "Quit". If student clicks the mouse on the "Help" button, a help menu will be displayed to provide help for the user. The user can scroll through the entire online help facility or get help on specific functions. "Change Password" lets the student change their password for access to the system. The button "Quit" will bring the student back to the "Welcome Screen".
The status bar called the "Context Sensitive Help" displays helpful messages for users. As the student moves the mouse around the screen a helpful message about the use of a button is displayed in this area.
To fulfill these requirements, the system will allow access to only the appropriate information that need be supplied. For example, by 'graying out' all of the areas in the course listings box except the department section, the user can see that they must enter a department to move onto the next section; Courses. When a department is chosen, the selection is displayed in the 'Department' window and the 'Courses' window becomes active (un-grayed). Now the user selects the course related to the department, where this too is followed by the selection being displayed in the window. The remaining boxes, specifically lectures, labs, and tutorials are activated for inputs. For a more detailed description, read below.
As described earlier, the timetable area where the student's current courses are listed is to the left side of the screen. A course is dropped by clicking once to highlight it within this area and then clicking the "Drop a Course" button.
Upon selecting drop a course, the user is prompted, by means of a pop up window in the center of the screen, to confirm that the selected course is to be dropped. This is to eliminate mistakes on the users behalf, and to provide a way out before actual removal. This prompt is answered with a yes/no selection. Single clicking on 'Yes' results in the user being informed of the action and the menu is returned to the foreground. The course dropped will no longer appear in the timetable window. Single clicking on 'No' results in cancellation of the dropping process. There will be no changes to the users timetable and the main menu is returned to the foreground.
The course to be modified must first be highlighted in the timetable area by moving the mouse to where the course is in the timetable and clicking on it. If the student accidentally clicked the course by mistake or now wishes to change the course they want to modify, he/she can just click on another course. After a course has been selected, the student can then press the "Change a Course" button to make the changes.
Once the "Change a Course" button has been pressed, the course listing (located below the Course listings box) will display all of the selected course's available lectures, labs and tutorials along with their times and associated information. All of the sections that conflict with the student's schedule, or are full, will be grayed out (or have a "FULL" status beside it -- the administrator can still select these). The student's current sections will be highlighted. The student now can look at all of the other available lecture sections, laboratory sections, and tutorial sections and decide which to modify to best suit their schedule.
The student can now make the changes by clicking on the lecture, lab, or tutorial they wish to switch to. When a section is clicked on, it becomes highlighted to show that it has been selected. After that, the student can press the button "Change A Course" at the bottom of the timetable so the system can process the request. The system then displays an "Are You Sure" dialog box. The student must press on the "Yes" button or the "No" button. If "Yes" is clicked then the system continues with the processing. If "No" is clicked, the system stops processing and returns to the foreground.
After the "Yes" is clicked, if the request is successful, the system will automatically update the new sections on the timetable and display a success message in the status line at bottom of screen. A course conflict is not possible because the system will not allow a student to choose a course that is in conflict with their present schedule. A selection may be unsuccessful if the course happens to become full in the time it takes for the student to view and then select a new section. The system will then display a dialog box with the following error message: - "Modification unsuccessful. Lecture section is full." ("Lecture" may be replaced by "Lab" or "Tutorial") Administrators may enroll a student in a full section ,in that case the system will display: - "Modification successful. Warning -- Lecture section is full." ("Lecture" may be replaced by "Lab" or "Tutorial") Users must press the "OK" button at the bottom of this dialog box in order return control back to the main menu. The user can try other sections and press the "Change A Course" button again.
Engineering General Studies Management Mathematics Social Science ScienceA department must be selected by the user before selecting the course. If the user tried to select a course before a department was selected, an error message would be displayed. After a department is selected, a course can be chosen using the same procedure as picking a department. Note that all departments and courses offered by Gen U are displayed, but those that are seen as a conflict to the user's current course schedule are grayed out on the list. This prevents the user from selecting that particular course or department because it conflicts with the user's schedule. If the user tries to select a grayed out item, a dialogue box will appear to tell the user that the department or the course will conflict with his/her current schedule. If a course listing currently exists, that is, the user has already inquired about a course, and the user wants to list information for another course, then the user simply re-selects the course and/or department desired. When department and courses are selected, the selection is displayed on top of the pull down menu.
Lecture Start Duration Location Days section time (minutes) Lec01 12:00 120 SB105 MW Lec02 08:00 50 ST111 MWF Lec03 13:00 50 ST110 MWFSimilarly, a typical list of the laboratory sections:
Lab Start Duration Location Days section time (minutes) Lab01 12:00 50 SB112 MW Lab02 08:00 50 ST96 MWF Lab03 13:00 50 ST10 MWFThe tutorial listing:
Tutorial Start Duration Location Days section time (minutes) Tut01 12:00 50 MS115 MW Tut02 08:00 50 ST10 MWF Tut03 13:00 50 ST05 MWF
The password change may be unsuccessful because the old password the user typed
in did not match the password on file or their new password did not verify.
In either case the user is informed by a error window and they must click
cancel to make this box disappear. They are then back at the Change
Password window where they can try again.
In the upper left corner of the screen, specific student information is
displayed. The information includes student identification number, student
name, address, faculty, major, minor, status and program year.
Beside this sub-window are four buttons that allow the administrator to "Add", "Delete", "Modify" and "Find" a student. After the administrator clicks on the "Add" they can then enter information. Similarly, "Delete" and "Modify" allow the administrator to remove or change student information. "Find" allows a user to search for a specific student by entering the student's identification number.
Below the "Student Information" is the student's timetable. It is identical to the time table displayed in student mode. Again, there are three buttons at the bottom of the timetable: "Drop a Course", "Change a Course" and "Print Time Table". The administrator can use these functions just as the student can use them.
Below the date box is the "Course Listing" sub-window. The administrator uses this window in the same manner as the student's system, with one additional function. The administrator may print a class list by clicking on the "Print Class List" button.
At the bottom of the screen, the user can click on the "Help" button to access the help menu. The administrator can then scroll through the entire help text or call up help on specific functions.
The "Change password" button allows the user change their password. The "Quit" button ends a user's session and then returns to the "Login Screen".
The status bar called "Context Sensitive Help" displays helpful messages for users. As the administrator moves the mouse around the screen a helpful message about the use of the button they are on is displayed in this area.
A possible error is not enough fields entered and the system will create an error box denoting the missed field to the user. After the user clicks cancel to confirm that they have read the error message they are returned to the Student Information data entry screen with all of the information that they have entered so far still there and from there they can correct the error and continue.
Possible errors are an invalid student number or a nonexistent student number in the Find Student function. The system error message is specific and it will not disappear until the user clicks cancel to acknowledge the message.
First we will talk about the type of system required to run the registration system. A UNIX based machine, such as a SUN workstation, is necessary since the registration system will be an xwindows application. This type of machine will be required for all registration locations. More information regarding the necessary hardware will be made available to you in the near future.
As was mentioned before, three levels of programming will be needed for this product. The main level is C code. Almost everything will be written in C. We also need a database to store student information and course information. This is solved by using C calls to Sybase, a database system. General University also desired a graphical user interface. Since this is cumbersome and tedious in C we have decided to use Tcl/Tk to implement this. Calls from C to link it all together. With this type of implementation, we will be able to provide this product as desired by General University.
Procedure LOGIN display Login Window if "CLEAR" button clicked then { clear "ID" and "Password" edit boxes } if "OK" button clicked then { search user database for user's ID# if ID# is not found then { clear "ID" and "Password" edit boxes display error window with "User not found" start Procedure LOGIN again } else { if password is correct { hide Login Window if user status = ADMIN then { display Main Admin Window } else { display Main Student Window } else { clear "ID" and "Password" edit boxes display error window with "Incorrect password" start Procedure LOGIN again } } }
Procedure CHANGE_PASSWORD { display Change Password Window if "CANCEL" button clicked then { hide Change Password window and exit from this function } if "OK" button clicked then { search user database for student (by ID#) if student's old password entered is incorrect then { display error window with "Incorrect old password" and clear all of the password edit boxes } if the two new passwords entered do not match then { display error window with "New Passwords don't match" and clear the new password edit boxes } else { store the new password for the user into the database hide Change Password Window } }
Procedure ADD_COURSE { display Add/Modify_Course Window if "CANCEL" button clicked then { hide Add/Modify_Course Window exit add_course } if "CLEAR" button clicked then { clear each of the following edit boxes: - DEPARTMENT, COURSE, LECTURE, LAB, TUTORIAL } if "OK" button clicked then { if there is missing info then { display error window with "Incorrect course selection" and some suggestions for the user } else { display "Course Added" response Window with course information as a confirmation search user database for student (by ID#) add course to student's list of courses - update schedule & course information sub- windows on the main screen - if count(courses) > 2 then change student status to FULL TIME hide Add/Modify_Course Window } }
Procedure MODIFY_COURSE { display Add/Modify_Course Window - display present choices made my student in the following edit boxes: - DEPARTMENT, COURSE, LECTURE, LAB, TUTORIAL if "CANCEL" button clicked then { hide Add/Modify_Course Window exit modify_course } if "CLEAR" button clicked then { clear each of the following edit boxes: - DEPARTMENT, COURSE, LECTURE, LAB, TUTORIAL } if "OK" button clicked then { if there is missing info then { display error window with "Incorrect course selection" and some suggestions for the user } else { display "Course Modified" response Window with course information as a confirmation search user database for student (by ID#) change course in student's list of courses - update schedule & course information sub- windows on the main screen - if count(courses) > 2 then change student status to FULL TIME - if count(courses) < 3 then change student status to PART TIME hide Add/Modify_Course Window } }
Procedure DELETE_COURSE { search user database for student (by ID#) display R_U_Sure window if "NO" button clicked then { hide R_U_Sure window } else { delete course with corresponding lec#, lab#, tut# from the student's record update database hide R_U_Sure_window if count(courses) < 3 then change student status to PART TIME }
Procedure PRINT_TIMETABLE { search user database for student (by ID#) /* The following will format the student's record into a timetable-style format for GUIs and Text-based output */ Direct the following output to the printer for every hour (ie. 0800, 0900, 1000, etc) { for every day (ie. M, T, W, R, F) { Check course schedule to see if anything in that time slot If yes, then print that course in that position on the chart } /* Continue moving horizontally */ } Turn off the redirection of the output to the printer
Procedure VIEW_TIMETABLE { search user database for student (by ID#) for every hour (ie. 0800, 0900, 1000, etc) { for every day (ie. M, T, W, R, F) { Check course schedule to see if anything in that time slot If yes, then print that course in that position on the chart } /* Continue moving horizontally */ }
Procedure LIST_COURSES { display List Courses Window (if not already up) if Department entered into the Drop Down list box then { search course database (by department selected) display all possible info of matches in the list box } if "CLOSE" button clicked then { hide List Courses Window }
Procedure ADD_STUDENT { - Clear all student info fields - Show "O.K." and "Cancel" buttons bellow student information - Make student info editable - Gray out all other options If "Cancel" { - Make student info uneditable - Hide "O.K." and "Cancel" buttons - Ungrey other options - Exit } If "O.K." { If Some info is missing { - Prompt user } Else { - Store student info in user database - Generate password and I.D. number - Prompt user with password and I.D. number } - Hide "O.K." and "Cancel" buttons - Make student info fields uneditable - Ungrey other options } }
Procedure MODIFY_STUDENT { - Show "O.K." and "Cancel" buttons bellow student info - Make student info editable - Grey out all other options If "Cancel" { - Make student info uneditable - Hide "O.K." and "Cancel" buttons - Ungrey other options - Exit If "O.K." { If Some info is missing { - Prompt user } Else { - Store student info in user database - Prompt user with confirmation } } - Hide "O.K." and "Cancel" buttons - Make student info fields uneditable - Ungrey other options }
Procedure FIND_STUDENT { - Show Id_Search window If "Cancel" { - Hide window - Exit } Else "O.K." { - Search user database for I.D. number If I.D. not found { - Prompt user } Else { - Move students records into student info and course schedule } - Hide window } }
Procedure DELETE_STUDENT { - Show R_U_Sure window with deleting student I.D. number If "No" { - Hide window - Exit } Else "Yes" { - Delete student record from user database } - Hide Window }
Procedure MODIFY_DROP_DATE { - Make Drop_Date editable If "Return" { If Format incorrect { - Prompt user - Make drop date uneditable - Exit } Else { - Change Drop_Date to New Drop_Date - Make Drop_Date uneditable } } }
Procedure MODIFY_ADD_DATE { - Make Add_Date editable If "Return" { If Format incorrect { - Prompt user - Make Add date uneditable - Exit } Else { - Change Add_Date to New Add_Date - Make Add_Date uneditable } } }
Procedure PRINT_CLASS_LIST { - Show Class_List window If "Cancel" { - Hide window - Exit } If "O.K." { If Information is incorrect { - Prompt user } Else { - Search user database in Student_Courses with Course_Name and Section - Print all matches } } - Hide window }
Individual members of the QA team will be responsible for the design of various tests that will check the code and the actual implementation of these tests on the code. They will report bugs and their severity to the QA team manager and they will work together with the coders to assure the final removal of the bug, making certain that fixes do not have any adverse affects on the remainder of the program.
Several different areas of the test plan will help to minimize the occurrence of bugs in the final product. The implementation of a very thorough bug tracking system will have the direct effect that all found bugs are properly noted. As a programming team we will know what needs to be corrected, and where to concentrate testing to ensure that these changes in the code have been effective. The testing schedule as implemented is thought to be essential to the maintenance of schedules associated with the project, and should result in the product being delivered on time, with a minimum of bugs in it. Finally, the testing methods used in each area of the project are chosen in order to find as many bugs as possible, with as efficient a way of finding the bugs as possible.
The success criteria will no doubt differ for each module and component of the project, as follows:
The criteria of success for integration testing is quite critical. A module may be perfect in every regard with respect to unit testing, but if that module does not fit into the greater scheme of the program, or it does not co-exist well with other modules calling it, the module is essentially useless to the program. The success criteria for integration testing is that the module(s) must function seamlessly with the modules into which it is being integrated. Anything less will have a disastrous effect on the project as a whole.
The criteria of success for performance testing is that module(s) perform in a time that is deemed acceptable to the final user of the product. For example, if a search function took exponential time, the entire program and any modules requiring this function would suffer severely in performance. If exponential time is the best possible for a given function, then it will considered successful at this level. If however, a functions performance can be improved to polynomial time, it will cause a drastic improvement in the functions speed. This performance level will be aimed at by the programmers. Programming time will need to be considered for the performance testing however. If it is determined that a method could be made more efficient to save a small amount of time for the end user, but these changes would add a layer of complexity to the program, and/or would require a great deal of programmer time, these changes may or may not be made. Instead, they will each be accessed on a case by case basis by the programmers.
The criteria for success of acceptance testing is that the module performs correctly all of the conceivable trials and tasks as set out by the customers. If the entire testing procedure did not cause an error to be found up until this point, the error must be inherent to the understanding of the requirements between the customer and supplier. Changed requirements by the customer at this stage of the project should not be corrected and should not be considered a failure of the acceptance tests. These changed requirements should be addressed in a later revision of the project.
The severity of the bug will be classified on one of four levels, namely A, B, C, and D. Level A bugs roughly correspond to the most severe, disastrous bugs. These bugs are ones that crash the program, hang the operating system, or cause data loss to the user. Level B bugs and level C bugs are not as bad as those in level A, in that they do not cause the program to crash, or cause data loss to the user, but that they indicate some key feature of the program is not working correctly or not working as expected. The key distinction between level B and level C bugs comes in whether or not a work around to the bug can be created that will cause the function to behave as expected. Level B bugs have no such work arounds, while level C bugs have the possibly of a work around. Lastly, there are the level D bugs. These bugs are cosmetic and rather minor to the functioning of the program. They may be as simple as a spelling mistake, or an incorrectly located pop-up menu.
Each bug will also come with a full text description of it. This report will be comprised of several key descriptive areas including:
Finally, each bug will be given a status. This status field will have five possible choices, namely: NEW, CONFIRMED, FIXING, FIXED, and CLEARED. All bugs will be initially assigned the NEW designation. This will signal to the programmers that this is an entirely new bug. Once the bug has proven to be reproducible by the programmers, it will be assigned the CONFIRMED designation. When a person has been assigned to and is commencing to fix the bug, the bug will receive the FIXING designation. When the bug has been corrected by the programmer, it will receive the FIXED designation. Finally, when the bug has be confirmed to be removed by the quality assurance team, it will be given the CLEARED designation, indicating that it is no longer a bug is the program, in this revision at least.
All bugs will then be transferred to the programming team. Bugs will usually be assigned to the programmer(s) responsible for that particular module of the overall program in which the bug was found, but where severe bugs exist, or bugs that transcend the boundaries between modules are found, several programmer may be assigned to the correction of each bug.
The first area of testing will be the user interface. While none of the internal code of the program may be working yet, the interface so far developed can be tested for its usability. While the interface of the project has been developed and spelled out in full as above in the document, there will most likely be difficulties that will arise and its implementation. It will be important that the testing team thinks as a user is this stage of the testing, judging all aspects of the interface from the user's point of view. In performing this stage of the testing adequately, we will hopefully end up with an interface that is very usable to the Gen U community.
Testing will then move on to testing of the basic functionality of the code and the software as the various components are implemented. By testing that all of the basic functions of the code work as specified in the functional specification, we can make sure that all aspects fit with the user's expectations of the project.
When the various engines of the projects i.e. the database engine are implemented, testing on them will begin to make sure that they work correctly and perform their basic functions well as required.
When all aspects of the project have been implemented the Alpha Testing stage of the testing will begin. This stage will begin to move beyond the basic functionality testing above, and will move into the whole software project testing. Errors in how the various aspects of the project and the various engines of the code work together will be tested and hopefully no bugs will be found. Bugs that are found will be corrected to the best of our abilities. Further testing of the bug fixes will report whether bugs have been corrected, and/or whether more bugs have been introduced. By the following of the Test Plan, which has yet to be developed, the QA team will perform testing of the software, moving on to later and later testing stages until finally the software is in a deliverable form.
The following dates are subject to change as deemed necessary by the QA team. Nevertheless, the final delivery date is firm and as such, the project must be delivered on time. Testing that takes longer amounts of time in one area will have to be balanced out by testing by that takes shorter amounts of time in another area, or the delivery date will be missed.
March 6, 1996 Testing of the program interface to begin. Ken, Bryan and Sung.
March 10, 1996 Walkthrough testing of the interface to be completed at this time. Does the interface fit with the descriptions given of it in the overall design document? Do the various buttons and menus send the user to the correct place as specified? In addition, are there any user interaction problems with the interface apparent at this stage of the programming that are necessary to correct? This testing will be completed when all user interaction problems have been corrected, and all menus and buttons function as specified in the overall design document. Some testing of the interface by the customer group may be done at this time at their discretion. Ken, Bryan, and Sung.
March 10, 1996 Functional testing of the add course database function to be completed. Are courses added to the database correctly? Completed when courses are added without problem. Hugh.
March 10, 1996 Functional testing of the modify course database function to be completed. Can courses already in the database be modified correctly, as specified in the overall design document? Completed when courses are modifiable without difficulty, as specified in the overall design document. Doug K.
March 10, 1996 Functional testing of the delete course database function to be completed. Can courses already in the database be deleted correctly, as specified in the overall design document? Completed when courses can be deleted without difficulty. Mike.
March 10, 1996 Functional testing of the add student database function to be completed. Can students be added to the database correctly? Completed when students can be added without problem, as specified in the overall design document. Colin.
March 10, 1996 Functional testing of the modify student database function to be completed. Can students already in the database be modified correctly, as specified in the overall design document? Completed when students are modifiable without difficulty, as specified in the overall design document. Pat.
March 10, 1996 Functional testing and performance testing of the find student database function to be completed. Can students already known to be in the database be found correctly, as specified in the overall design document? A large, prepared database of students will be used to determine the typical performance for the search. Success when students in the database can be found in a reasonable time, linear with the number of students in the database. Joe
March 11, 1996 Performance testing of all previously tested modules and functions to be completed. Performance will be tested and whether the performance is acceptable or not will be reviewed with the testers and the programmers on a case by case basis. Assigned to persons as above.
March 13, 1996 Functional testing of the login function. Do correct student id and respective passwords allow the user to enter the system? Are incorrect student ids and/or passwords denied access to the system? Is the password echoed as asterisks correctly? Does this function correctly interface with the database? Completed when the function allows authorized users to enter the system and does not allow unauthorized users access. Howell.
March 14, 1996 Basic integration testing of the database engine with the various database functions to be completed at this time. Basic input/output testing of the database engine of the program to be commenced at this time. These tests should include random addition, modification, and deletion of both student information and course information, and examining what the result is on the various databases inherent to the program. Massive, repeating scripts to test for the limits of the database size, and what is necessary to cause it to crash. Completed when integration of all of the database functions is complete. Douglas T., Barb, and Mike.
March 17, 1996 Basic input/output testing of the database engine to be completed, as above. Douglas T., Barb, and Mike.
March 17, 1996 Functional testing of the print timetable function to be completed. Do the courses a student is registered in appear on the timetable without errors? Does the correct student information appear on the timetable? Do the courses appear under the correct times and days of the week? Completed when a correctly formatted time table, with all required information will print for all students. Colin.
March 17, 1996 Functional testing of the print class list function to be completed. Do all of the students registered in a class appear on the printout? Completed when a correctly formatted class list, including all of the students in a given class, appears at the printer, without errors. Pat.
March 19, 1996 Integration testing of the print class list and the print timetable function into the database engine. Do the two functions still work correctly within the added complexity of the database engine code? Completed when the two functions perform as specified in the overall design document. Colin, Pat, Douglas T. and Doug K.
March 21, 1996 Primary testing of the integration of the interface and the database engine to be completed. Ken, Sung, Hugh, Barb, Douglas T., and Mike.
March 28, 1996 Testing of the integration of the interface, database engine, print timetable, print class list, and the login screen to be completed. Completed when all functions work as designed in the overall design document and when interface manipulation by the user causes the desired changes to occur in the database component of the program. Whole group.
March 30, 1996 Performance testing of the project to be completed. Completed when desired actions are completed in time limits set out by customer group. Whole Group.
April 3, 1996 Acceptance testing of the program to be completed. Success if the program meets the qualifications as set out by the customer group in their original functional specification. Whole Group.
April 3, 1996 Alpha testing of the whole program to be completed, including the repair of all found bugs in the testing procedure. Additional testing should focus on performance testing of the program for maximum speed benefits. Some testing of the functionality interface and the program as a whole by the customer group may be done at this time. Completed when the program is no longer easily improved, and where bugs are not apparent. Whole group.
In addition, at the completion of each testing stage for their area of the project, the person(s) responsible for the testing will submit a report outlying the results of their testing to the QA team. This report will include but not be limited to, where applicable:
If testing cannot be completed by the given date, a report should be submitted as above, including why testing could not be completed on time. Testing must be completed as soon as possible, so that delays do not occur to subsequent areas of the project. Therefore, additional person(s) to test and fix bugs will be assigned by the QA team to complete testing as soon as possible, and minimize delays.
The QA team and the programmers will go over these reports and note where further testing of the code and fixes in the code are required. They will work to ensure that the testing procedure used have not missed any key areas of the program or of a particular function. They will also work to ensure problematic areas of the code are well covered to ensure fewer errors in these critical areas. Additional resources may be devoted by the QA team to the repair or further testing of certain modules as they feel is required.
While it would be best to correct all bugs perfectly, situations will no doubt arise which will be difficult to correct. Where a level C bug which has an easily implemented work around is available, this work around route may be taken to minimize time and maximize efficiency of the programmers. Level A and B bugs on the other hand, must be fixed correctly and properly without work arounds, owing to their importance to the overall program, and their severe effects to the user. While level D bugs are minor, these must also be corrected to the best of our abilities. While these are only cosmetic to the program as a whole, the appearance of the program to the end user is very important. An end user may never come across a level C bug in their uses, but they will readily notice these small cosmetic errors inherent in the level D bugs. As a result, we will pursue the correction of all level D bugs.
The relationship between the various menus and dialog boxes has also been spelled out above through the means of various DFDs and pseudo code. This should serve as a guide to what the typical inputs should be, and the various outputs that the program will produce.
In general, ESP Inc. looks forward to the implementation of this project.
To see the User Manual for the system, please click here.