- 2.5.2.1 Introduction
- 2.5.2.2 Testing Procedures
- 2.5.2.3 Testing Templates
- Exhibit 2.5.2-1 Project Folder Checklist
- Exhibit 2.5.2-2 Project Folder Checklist Instructions
- Exhibit 2.5.2-3 Testing Checklist
- Exhibit 2.5.2-4 Testing Checklist Instructions
- Exhibit 2.5.2-5 Test Plan
- Exhibit 2.5.2-6 Test Plan Instructions
- Exhibit 2.5.2-7 Test Case Specifications
- Exhibit 2.5.2-8 Test Case Specifications Instructions
- Exhibit 2.5.2-9 Files Communication Status Report (FCSR)
- Exhibit 2.5.2-10 Files Communication Status Report (FCSR) Instructions
- Exhibit 2.5.2-11 Requirements Traceability Verification Matrix
- Exhibit 2.5.2-12 Requirement Traceability Verification Matrix Instructions
- Exhibit 2.5.2-13 Glossary
-
This manual comprises the following subsections:
-
Introduction
-
Testing Procedures
-
Testing Templates
-
-
The Subsection 2.5.2.1, "Introduction" describes how this manual is organized, states the purpose of the manual, defines terms used in the manual, identifies personnel affected by the manual, and identifies other documents associated with the manual.
-
The Subsection 2.5.2.2, "Testing Procedures" summarizes and details the Agency's software testing procedures.
-
The Subsection 2.5.2.3, "Testing Templates" summarizes where the testing templates are stored and how to obtain copies.
-
This manual defines the standards for software development testing and the entry criteria for systems testing.
-
This manual defines and documents the testing procedures for developers who must develop or maintain software.
-
These testing procedures provide a standard framework for developers (including contractors working for Applications Development organizations) to follow and complete before releasing software to Production or Test, Assurance & Documentation (TAD) personnel for further testing.
-
The terminology used in this manual is defined in Exhibit 2.5.2-13
-
The controls established in this Internal Revenue Manual (IRM) apply to Agency personnel and contractors responsible for developing or maintaining IRS Software Systems. Agency personnel who contract for development or maintenance of these software systems shall ensure contracts comply with these controls.
-
The following documents have been referenced in this manual:
-
IRM 2.6.1 - Test, Assurance & Documentation (TAD) Standards and Procedures
-
IRM 2.16.1 - Enterprise Life Cycle (ELC) Guidance
-
IRM 2.25 - Web Services
-
IRM 2.25.14 - Portal Environment Usability Service
-
IRM 10.8.1 - Information Technology (IT) Security, Policy and Guidance
-
IRM 10.8.8 - Information Technology, Live Data (LD) Protection
-
IRM 11.2.1 - Privacy Advocate
-
-
All Software Systems developed and maintained within the Internal Revenue Service (IRS) or developed or maintained by contractors for the IRS are required to follow these testing procedures.
-
These testing procedures should be followed as efficiently and effectively as possible in order to find and correct as many defects as possible.
-
These testing procedures cover:
-
Unit Testing
-
Compatibility Testing
-
Integration Testing
-
Developer Integration Testing (DIT)
-
Development System Integration Testing (DSIT)
-
Final Integration Testing (FIT)
-
External Trading Partners Testing
-
Systems Acceptability Testing (SAT)
-
Independent Systems Acceptability Testing (ISAT)
-
Regression Testing
-
Usability Testing
-
Accessibility Testing (508 Compliance)
-
Performance Testing
-
Application Network Review
-
Security Testing
-
Web Testing
-
-
The activities that constitute the testing procedures are:
-
Prepare Software Product
-
Review/Update Project Folder(s)
-
Create/Update Requirements Traceability Verification Matrix (RTVM)
-
Conduct Software Desk Check
-
Conduct Peer Review
-
Create/Execute Test Plan
-
Create Test Case Specifications
-
Develop/Acquire Test Data
-
Coordinate Testing Environment
-
Conduct Unit Testing
-
Conduct Compatibility Testing
-
Conduct Integration Testing
-
Conduct Developer Integration Testing (DIT)
-
Conduct Development System Integration Testing (DSIT)
-
Coordinate Final Integration Testing (FIT), as required
-
Coordinate External Trading Partners Testing, as required
-
Review/Document Test Results
-
Coordinate Systems Acceptability Testing (SAT), as required
-
Conduct Independent Systems Acceptability Testing (ISAT), as required
-
Conduct Regression Testing, as required
-
Request Usability Testing, as required
-
Coordinate/Conduct Accessibility Testing (508 Compliance), as required
-
Conduct Performance Testing, as required
-
Coordinate Application Network Review (ANR), as required
-
Coordinate Security Testing, as required
-
Conduct Web Testing, as required
-
Prepare and Review Test Package
-
Transmit Software
-
-
Proper preparation of the Software Product improves the quality of testing to be performed.
-
Testing preparation should include but is not limited to the following activities:
-
Review, analyze, and coordinate software requirements;
-
Create project folder and maintain it in an approved repository;
Note:
All testing documentation should be included in the project folder. See Exhibit 2.5.2-1.
-
Review and update any pertinent Functional and Operational documentation. Examples include:
Functional Documentation
-
Interface Control Document (ICD)
-
Analysis Specification Package (ASP)
-
Business System Requirements Report (BSRR)
-
Design Specification Report Part 1 (DSR1)
-
Design Specification Report Part 2 (DSR2)
-
Functional Design Specifications (FDS)
-
Functional Specification Package (FSP)
-
Programming Requirement Package (PRP)
Operational Documentation
-
Computer Operator Handbook (COH)
-
File Specifications
-
Record layouts
-
Schematics
-
System Administrator Guides
-
User Guides
Note:
For additional program artifacts, see IRM 2.16.1 Enterprise Life Cycle (ELC) Guidance.
-
-
Review any Lessons Learned from previous testing efforts;
-
Create/update source code, review and modify test datasets, modules and runs; and
-
Create/update execution control language such as:
-
Job Control Language (JCL)
-
Executive Control Language (ECL)
-
JavaScript
-
Active Server Pages, etc.
-
-
Test results should be included in the project folder with the exception of taxpayer data. Refer to IRM 10.8.8, Information Technology, Live Data (LD) Protection for guidance.
-
Complete lines 1 a - f of the Testing Checklist, Exhibit 2.5.2-3.
-
The project folder(s) is a requirement for all projects. The project folder(s) contains all project and program documentation and correspondence and provides pointers to the location of all current project related information. Information that cannot be incorporated in the project folder, such as boxes of printed output, computer files, interface tape(s) and/or file backups must be cross-referenced in the project folder checklist to expedite location and access.
-
For the purpose of this IRM, the project folder term is used interchangeably to reference both project and program needs.
-
The project folder(s) is a useful resource document for auditing purposes, project planning, allocation of resources, and process improvement.
-
The project folder(s) must be maintained throughout the project lifecycle by the development team and at a minimum updated at each milestone. Subsequent reviews may be conducted as needed for test monitoring and oversight, and to verify the folder is updated on a regular basis to reflect tasks accomplished.
-
The project folder(s) must be stored in Document Management for Information Technology Projects (DocIT) or an approved repository or secure environment as designated by the project manager, Contract Officer Technical Representative (COTR) or supervisor. The project folder must be retained for two years beyond the scheduled program implementation date.
-
Content of the project folder should be verified by the developer prior to Unit Testing. During Unit Testing, the project folder checklist should be completed to reflect artifacts of Unit Testing.
-
The project folder(s) will be reviewed by the designated management representative at established intervals. At a minimum, the review must occur prior to production implementation.
-
For an example of a Project Folder Checklist, See Exhibit 2.5.2-1.
-
Depending on the project type (major, non-major or small/other), all artifacts listed on the project folder checklist may or may not be applicable. The project folder checklist may be tailored for project needs while ensuring the integrity of the checklist is preserved.
Note:
For guidance on the required program artifacts, see IRM 2.16.1, Enterprise Life Cycle (ELC) Guidance
.
-
Complete line 2 of the Testing Checklist, Exhibit 2.5.2-3.
-
Create/update the Requirements Traceability Verification Matrix (RTVM) to ensure that all requirements are met and enable the development of test plans. The RTVM is developed in phases over the course of the life cycle.
-
An RTVM is a mechanism to identify requirements and track satisfaction of the requirements through development and test phases.
-
Requirements Traceability maps requirements to business processes, system development document(s) and test cases. The RTVM correlates system requirements with test cases to ensure appropriate test coverage.
-
The RTVM is a required deliverable as part of the Test Plan
-
A new RTVM should be created for each release/production implementation to document a new baseline. For legacy projects, documenting the new requirements would be the first step in creating a new baseline of the existing (as-is) project.
-
AD projects that are currently using the Requirements and Demand Management (RADM) template (Excel Requirement Repository Spreadsheet) or RequisitePro should continue to maintain these repositories and are not required to complete the RTVM workbook template.
-
The RTVM, defined in the RTVM workbook template, is composed of the following worksheets: Requirements, RTVM (Unit Testing), RTVM (ISAT) and RTVM (SAT).
-
The column headings for all 4 worksheets will be the same. Only the leftmost 3 columns need to be filled out for the Requirements Worksheet. The Unit Test, ISAT, and SAT worksheets will be filled out completely
-
The Requirements Worksheet should be completed before a final response is prepared for the Unified Work Request (UWR) or Change Request (CR). The RTVM does not need to be developed for UWRs or CRs that are returned, withdrawn or disapproved.
-
The business and developers will complete the Requirements Worksheet. If TAD is performing the testing, then TAD will also participate in the completion of the Requirements Worksheet. The data entered in the Requirements Worksheet will automatically populate the other applicable worksheets to ensure that everyone is working from the same set of requirements.
-
The developer will complete the RTVM (Unit Testing) Worksheet. The data entered in the Functional/Operational Document Name/Item Reference Number and the Functional/Operational Document Version/Date fields will automatically populate in the corresponding fields of the other applicable worksheets.
-
AD projects not tested by TAD will complete the RTVM (ISAT) Worksheet to document independent test activities.
-
TAD will complete the RTVM (SAT) Worksheet to document test activities performed by TAD.
-
-
A clear audit trail must be documented in the RTVM when a requirement moves from one test status to another.
-
An RTVM workbook will provide, at a minimum, the following information:
-
Requirements Control Number
-
Requirements Item Reference
-
Requirement(s)
-
Functional/Operational Document Name/Item Reference Number
-
Functional/Operational Document Version/Date
-
Test Case ID Number
-
Test Condition
-
Test Date
-
Test Result
-
Problem Ticket Number
-
Remarks/Constraints
-
-
Create/Update RTVM steps:
-
Review any documentation pertinent to the test to assist in completing the RTVM.
-
Coordinate on the development of the Requirements Worksheet with the business and TAD
-
Develop the Requirements Worksheet of the RTVM.
Note:
The Requirements Worksheet must be completed before the final response to the UWR or CR. An RTVM does not need to be developed for UWRs or CRs that are returned, withdrawn or disapproved or if the project is using either the RADM template or the RequisitePro repository.
-
Complete the RTVM (Unit Testing) Worksheet.
-
Conduct a peer review of the RTVM (Unit Testing) Worksheet in conjunction with a review of test cases. Review of the RTVM should identify defects, omissions and inconsistencies in the product (e.g. requirements that do not have the required traceability attributes, orphaned child requirements or requirements without a trace of test cases).
-
Review the RTVM (Unit Testing) Worksheet to verify that all requirements have been successfully tested.
-
Provide the completed RTVM (Unit Testing) Worksheet to the testing organization 30 days prior to program delivery for SAT/ISAT.
-
TAD will complete the RTVM (SAT) Worksheet for projects tested by TAD. For projects not tested by TAD, development testers will complete the RTVM (ISAT) Worksheet.
-
-
An excel spreadsheet containing detailed instructions for completing the RTVM and the four worksheet templates (Requirements, Unit Testing, ISAT, and SAT) is stored in DocIT. See IRM 2.5.2.3(3) for the DocIT number. The RTVM (Unit Testing) Worksheet and instructions can be found in Exhibit 2.5.2-11 and Exhibit 2.5.2-12, respectively.
-
An RTVM must contain a Configuration Identification Index (CII). The CII is a unique identifier used to correlate documentation to the appropriate CI and will be placed in the footer of the RTVM. For example, CII identifier OS:CIO:AD:PMO:BPI:TMP-RTVM-V1.4-01262010.
-
OS:CIO:AD:PMO:BPI - Configuration field (code) or organizational code (organizational documents)
-
TMP - Identification field (should be pulled from MITS ID Field list located on the MITS CM Web)
-
RTVM - Index field (short name created by the author to easily identify the document)
-
V1.4 - Version field (should follow MITS version guidance)
-
01262010 - Date field
-
-
The RTVM must be stored in DocIT or an approved repository designated by the project manager.
-
Complete line 7 on the Testing Checklist, Exhibit 2.5.2-3.
-
Perform a Desk Check of the source code to eliminate logic and syntax errors.
-
A Desk Check of the software must be performed after developing the source code and completing preliminary tests to achieve a clean compile.
-
Desk Check Software steps:
-
Review the source code for omissions, logic, formatting and syntax errors;
-
Itemize discrepancies on a list or on the source code listing;
-
Create comments in source code;
-
Evaluate source code for adherence to source code standards;
-
Compile source code;
-
Fix failed test problems; and
-
Recompile code.
-
-
Complete line 3 on the Testing Checklist Exhibit 2.5.2-3.
-
Conduct a Peer Review on software and documentation to identify any defects and improvements.
-
Peer Reviews should be conducted if the complexity of change warrants it or when an inspection of test results indicate an unusual problem.
-
Four major types of Peer Reviews are:
-
Inspections - The developer or meeting facilitator follows a well-defined process to lead the meeting, present the material to the reviewers and record issues as they're brought up. At the end, the team agrees on what items are actually defects that will be reworked by the author.
Note:
For additional information on formal inspections, see the Requirements and Demand Management (RADM), Requirements Peer Review Guide at the following URL: http://mits.web.irs.gov/BRRM/cat/guide.htm#peer
-
Team Reviews /Walkthrough - The author of a work product conducts an informal review to describe it to a group of peers and solicits their comments. The participants receive materials several days prior to the meeting, and are expected to review the materials on their own. The team collects data on the review effort and the numbers of defects found. The overview and follow-up stages of the peer review is simplified or omitted.
-
Desk Check - An individual uses this assessment technique to find defects in a document. For example: testers check their test cases verifying all execution paths are covered and selected the appropriate mix of test data.
-
Ad hoc Reviews - Unstructured and unplanned reviews consist of the owner walking through a work product with one or more participants in an effort to solve a particular issue.
-
-
Peer Review process consists of the following six stages:
-
Planning - Identifies the work product to be inspected and sets the inspection schedule.
-
Overview - Optional stage where members of the peer review team who are unfamiliar with the work product to be inspected receive orientation. This stage is always optional.
-
Preparation - The work product is sent to the members of the peer review team, and they review it individually, looking for defects.
-
Meeting - Members of the inspection team meet to discuss possible defects in the work product.
-
Rework - The work product is revised based on defects that have been slated for resolving.
-
Follow up - The rework is verified, final peer review data is collected and summarized, and the peer review is closed.
-
-
The project manager will assign a peer review coordinator to perform the following steps:
-
Coordinate the peer review by designating the reviewer(s);
-
Provide the reviewer(s) with source code, documentation, and software requirements;
-
Inspect the source code for omission of software requirements;
-
Trace the source code logic flow to identify errors;
-
Evaluate source code for adherence to source code standards;
-
Record Peer Review Finding(s) and provide results to programmer;
-
Track Peer Review Finding(s) until resolved; and
-
Verify corrections and modifications identified in the Peer Review are carried out and re-tested.
Note:
If a walkthrough was conducted, complete Form 9219 Walkthrough Memorandum at the following URL http://core.publish.no.irs.gov/forms/internal/pdf/11493a90.pdf and place a copy in the project folder.
-
-
Complete line 4 on the Testing Checklist, Exhibit 2.5.2-3.
-
The Test Plan describes the overall approach, procedures, and defines the conditions to be tested based on functional requirements including conditions that exercise every path of new or changed logic.
-
After the requirements have been approved through the WR process, develop a Test Plan. See Exhibit 2.5.2-5 for an example of a Test Plan.
-
The following structure is required for a Test Plan:
-
Programmer Name and Telephone Number
-
Team Leader Name and Telephone Number
-
Section Chief Name and Telephone Number
-
Project Name
-
Organization Symbols
-
Work Request Title
-
Work Request Number
-
SAT Transmittal Number
-
SAT Transmittal Date
-
Production Transmittal Number
-
Production Transmittal Date
-
Purpose and Scope of Test
-
Project References
-
Items to be Tested
-
Acceptance Criteria
-
Test Coverage
-
Type(s) of Testing
-
Inputs/Outputs
-
File Exchanged With Other Software
-
File Exchanged Outside the IRS
-
JCL/ECL Procedures, if appropriate
-
Program Load Modules, if appropriate
-
Test Environment
-
Testing Tools
-
Testing Constraints
-
Approval of Test Plan
-
-
Creating and approving Test Plan steps:
-
Identify testing requirements;
-
Review any existing pertinent documentation, project folder or lessons learned;
-
Design the test coverage to include all pertinent test conditions;
-
Identify automated testing tools to be utilized where available;
-
Thoroughly inspect the program, and record all the possible structural paths that have been modified;
-
Ensure test plan provides sufficient detail to permit others to repeat the testing, if required;
-
Obtain approval from manager or designee on the Test Plan, if necessary; and
-
Place a copy of the Test Plan in the project folder.
-
-
Execute Test Plan steps:
-
Test all modifications to code, as reflected in Test Plan;
-
Check output against the expected results;
-
Evaluate any unexpected results;
-
Document deficiencies in tests, deficiencies found during testing, unplanned events, results deviations, and test results;
-
Verify all required corrections are carried out and re-tested; and
-
Verify that final testing components (conditions, input, and expected results) are accurate, complete, and documented in such a way to make them repeatable and re-usable.
-
-
Complete line 5 on the Testing Checklist, Exhibit 2.5.2-3.
-
To specify and document the conditions to be tested, create Test Case Specifications.
-
Test Case Specifications should be developed from the Test Plan and designed to "try to break the code" (test outside the normal or expected function) to find defects.
-
Each Test Case Specification must:
-
Test requirement as identified in the software requirement documents;
-
Reference specific test data and its expected results associated with specific program criteria and/or Work Request (WR) requirements; and
-
Match the documented expected output result in order to pass the test.
-
-
Test cases must meet the following attributes in order to be reusable in retesting, to provide an adequate test audit trail, and to perform problem resolution:
-
Repeatability - Each time the test case is run against the same configuration of code, under the same controls, it must produce the same result.
-
Controllability - All variables in the test, including test data and procedures, must be documented so they are known and can remain as controls for each execution of the test.
-
Observeability - When there exists an identified way to determine the results of the process being tested.
-
Objectivity - A tester is able to assess, by looking at the test results, whether the requirement being tested is satisfied or there is a defect.
-
-
Create Test Case Specifications for:
-
Valid, invalid and boundary conditions;
-
Every executable path in newly created source code;
-
Modified source code; and
-
Special formulas and extreme conditions.
-
-
Test Case Specifications must include all applicable components:
-
Programmer Name
-
Organization Symbols
-
Test Case Preparer Name
-
Project Name
-
Program
-
Work Request Number/Change Control #
-
Transmittal Number
-
Transmittal Date
-
Problem Ticket(s)
-
Date Opened
-
Date Closed
-
Test Case ID #
-
Unique Record Identifier
-
Dataset Name(s)
-
Condition Tested
-
Expected Results
-
Actual Results
-
Initial/Date
-
-
Verify Test Case Specifications are complete and consistent with software requirements.
-
See Exhibit 2.5.2-7 for the template of the Test Case Specifications.
-
Place a copy of the Test Case Specifications in the project folder.
-
Complete line 6 on the Testing Checklist, Exhibit 2.5.2-3.
-
Confirm that all systems documentation has been received and that requirements have been reviewed and accepted prior to test data creation.
-
Develop or acquire sufficient data to test that all requirements have been satisfied.
-
Test Data should be consistent with the software requirements to be tested.
-
Test Data should provide the input as required by modules, programs, applications, or systems.
-
Test Data must be protected as "Official Use Only" information and is intended solely for testing purposes.
Note:
Refer to IRM 10.8.8, Information Technology, Live Data (LD) Protection, for procedures on the use and approval process for live data.
-
Determine which of the following test data types are appropriate for the test:
-
Compatibility Data
-
External Trading Partner Data
-
Live Data
-
Programmer Created Data
-
Production Data
-
Sanitized Data
-
Simulated Data
-
-
Develop/Acquire Test Data steps:
-
Identify sufficient data sources to adequately test all requirements;
-
If live data is required for verification of test conditions, then acquire the data according to IRM 10.8.8, Information Technology, Live Data (LD) Protection;
-
Create new data or modify data from existing files;
-
Prepare new data or modified data for valid and invalid test conditions;
-
Identify the files necessary to evaluate the outcomes of each test;
-
Identify interface files; and
-
Verify that data is adequate to develop observable test cases.
-
-
Complete line 8 on the Testing Checklist, Exhibit 2.5.2-3.
-
Coordination of the testing environment will vary depending on the degree of complexity of the software changes, type(s) of testing required, practices of the customer, methodologies used to develop the software, and impact of the software being tested.
-
Identify the type of equipment, operating system(s) and all communications media needed.
Note:
The test environment should be similar, if not identical, to the production environment which the software will be implemented. If the test environment has already been set up for the test being executed, verify that the environment is correct.
-
Coordinating test environment steps:
-
Verify all software items listed in the test plan are available, which includes JCL/ECL, test tools, and test data files;
-
Prepare duplicate copies of items such as test tools or test data files, if necessary;
-
Distribute a copy of the Test Plan and Test Case Specifications to each participant for reference, if necessary;
-
Verify participants are prepared and provided with any required documents;
-
Verify all hardware items required for testing are functional and available at the appropriate scheduled date and time;
-
Contact each participant prior to the test to confirm that they are able to carry out their assigned role in the testing activities; and
-
Confirm that required checklists or approval sheets are prepared and available if necessary.
-
-
Complete line 9 on the Testing Checklist, Exhibit 2.5.2-3.
-
Unit Testing is a procedure used to validate that individual units of source code are working properly.
-
Unit Testing will test the smallest unit of the software and verify that the unit of code meets the detailed design specifications and is working properly.
-
The objective of Unit Testing is to test not only the functionality of the code, but also to determine whether the code is structurally sound and robust, and able to respond appropriately in all conditions.
-
Unit Testing should be conducted on individual modules and programs by the developer prior to integration. Unit tests are usually conducted in the development environment prior to system integration.
-
Unit tests should satisfy the design of the application and be traceable to the design documents and the RTVM.
-
The process of conducting the Unit test consists of the following steps:
-
Review the test plan;
-
Execute the Unit test plan;
-
Compare the actual result to the expected result;
-
Analyze all output to determine whether all test success criteria have been met;
-
If the test success criteria have been met, record the test as successful;
-
If there is a difference, record the discrepancy as a defect and determine if the discrepancy is the result of an error in the code or an error in the expected result;
-
If the code is in error, isolate the cause of the error, correct and recompile the program, and rerun the test; and
-
If the expected result is incorrect, correct the expected result within the test case, and rerun the test, if needed.
Note:
The project manager will determine the appropriate resolution timeframe and priority of any defects found.
-
-
When all tests have been executed and errors corrected, re-execute the full unit test to confirm that no new errors were created during the correction.
-
The unit test is completed when:
-
All test condition items in the Test Plan have been executed;
-
The developer is satisfied that the code matches the design;
-
The identified errors have been corrected and retested; and
-
All expected results have been verified as met and documented.
-
-
Complete line 10 on the Testing Checklist, Exhibit 2.5.2-3.
-
Compatibility testing is conducted to determine whether the program correctly exchanges files with other software.
Note:
Compatibility testing is also referred to as string testing.
-
Parties responsible for the programs impacted by the change must participate in Compatibility Testing.
-
The Section Chief or designee of the Originating Section and any Impacted Section must sign off on the Files Communication Status Report (FCSR).
-
See Exhibit 2.5.2-9 for the template of the FCSR.
-
Compatibility Testing steps:
-
Review the test plan;
-
Execute the Compatibility Test;
-
Review output for correctness;
-
Prepare a FCSR. Where many subsequent generations of a test file are anticipated, prepare separate copies of the FCSR forms;
-
Communicate the test results between the originating and impacted sections;
-
Perform compatibility testing until impacted sections concur with test results;
-
Sign and date the FCSR for concurrence with the test results; and
-
Place a copy of the FCSR in the project folder.
-
-
Complete line 11 on the Testing Checklist, Exhibit 2.5.2-3.
-
Integration Testing verifies that the system integrates properly and functions as required.
-
The purpose of Integration Testing is to accept, integrate and test system and software components until the entire system is operational and all agreed upon customer requirements have been validated.
-
Integration Testing occurs after unit testing has been completed for all units contained in the subsystems being tested.
-
Integration Testing takes modules that have been unit tested, groups them into larger aggregates, applies tests defined in an Integration Test Plan to those aggregates, and delivers as the integrated system ready for system testing.
-
The procedure for Integration Testing is as follows:
-
Review all relevant design documentation and attend all design overviews/walkthroughs;
-
Create an Integration Test Plan;
-
Create test data;
-
Review the Integration Test Plan for accuracy; update test plan to incorporate any necessary changes;
-
Execute the test according to the Integration Test Plan;
-
Identify any problems which are encountered or where the actual results do not agree with the defined expected results;
-
Take necessary action to resolve problems;
-
Rerun the test and update the test plan;
-
-
Test cases for Integration Testing are constructed to test that all components within assemblages interact correctly.
-
When creating the Integration Test Plan review the detailed design to determine which units (and therefore, which subsystems) are changing.
-
Complete line 12 on the Testing Checklist, Exhibit 2.5.2-3.
-
Determination on whether to conduct a Developer Integration Test (DIT) will be made by management.
-
After Unit Testing, a DIT combines the parts of an application to determine if they function together correctly. In its simplest form, two units that have already been tested are combined into a component and the interface between them is tested.
-
A component is an integrated aggregate of units or components. Multiple units are combined into components, which are in turn aggregated into larger components and then into the application. The idea is to test combinations of components to find interface defects and eventually expand the process to test all the integrated parts of the application.
-
The purpose of DIT is to accept, integrate and test application components until the entire application is operational and all agreed upon customer requirements have been validated. DIT verifies that the application system integrates properly and functions as required.
-
DIT can start when units appropriate for integration have been tested. DIT can be done in parallel with some unit testing.
-
The procedure for DIT is as follows:
-
Review all relevant documentation. Ensure any additional requirement changes have been incorporated and requirements are traceable to the documentation.
-
Create a DIT Test Plan. When creating the DIT Test Plan, review the detailed design to determine which units and/or which subsystems are changing. See Exhibit 2.5.2-5, Test Plan.
-
Create test cases/scripts
-
Create test data
-
Verify that the DIT entrance criteria have been satisfied:
-
All requirements have been recorded in the RTVM or in one of the approved requirements repositories
-
Unit level testing has been completed on all components being integrated
-
Ensure a testing environment is available and ready
-
-
Review the DIT Test Plan for accuracy and update test plan to incorporate any necessary changes
-
Execute test according to the DIT Test Plan
-
Report testing status to TAD
-
Problem Reporting:
-
Identify any problems that are encountered or where the actual results do not agree with the predetermined results
-
Take necessary action to resolve problems
-
Rerun the test and update the appropriate test information
-
Report defect status at completion
-
-
Verify that the DIT exit criteria have been satisfied:
-
All requirements have been recorded, tested, and baselined
-
All defects that cause a work stoppage or impact test process have been resolved
-
All documents have been updated
-
-
-
A Test Readiness Review (TRR) will be conducted after the DIT.
-
If a DSIT will also be performed, an informal TRR will be conducted by the project team.
-
If TAD will be performing a SAT, a TRR must be conducted by the SAT team prior to their receipt of the application.
-
If the project is not supported by TAD, the TRR will be conducted by the ISAT team.
-
-
Complete line 13 on the Testing Checklist, Exhibit 2.5.2-3.
-
Determination on whether to conduct a DSIT will be made by management.
-
Development System Integration Testing (DSIT) is a logical extension of DIT testing. After the individual projects have been independently integrated into applications, tested in a DIT, and meet their respective requirements, they will be integrated into a complete system and tested in DSIT.
-
DSIT occurs after both unit testing and DIT have been completed
-
DSIT verifies that all component application systems integrate properly and function together as required.
-
The procedure for DSIT is as follows:
-
Review all relevant documentation. Ensure any additional requirement changes have been incorporated and requirements are traceable to the documents.
-
Create a DSIT Test Plan. When creating the DSIT Test Plan, review the detailed design to determine which units and/or which subsystems are changing. See Exhibit 2.5.2-5, Test Plan.
-
Create test cases/scripts
-
Create test data
-
Verify that the DSIT entrance criteria have been satisfied:
-
All component projects have individually passed DIT
-
Ensure a testing environment is available and ready
-
-
Review the DSIT Test Plan for accuracy and update test plan to incorporate any necessary changes
-
Execute test according to the DSIT Test Plan
-
Establish the Defect Review Board (DRB). see TPO website for DRB procedures
-
Problem Reporting
-
Identify any problems that are encountered or where the actual results do not agree with the predetermined results
-
Submit problem tickets using ITAMS on all defects found
-
Take necessary action to resolve problems
-
Rerun the test and update the appropriate test information
-
-
Verify that the DSIT exit criteria have been satisfied:
-
All requirements have been recorded, tested, and baselined
-
All defects that cause a work stoppage or impact test process have been resolved (e.g. Priority 1 and 2 or Severity 1 and 2)
-
Defect log has been completed and placed in the approved repository (e.g. DocIT)
-
-
-
A Test Readiness Review (TRR) will be conducted after the DSIT has been performed.
-
If TAD will be performing a SAT, a TRR must be conducted by the SAT team prior to their receipt of the application.
-
If the project is not supported by TAD, the TRR will be conducted by the ISAT team.
-
-
Complete line 14 on the Testing Checklist, Exhibit 2.5.2-3.
-
Final Integration Test (FIT) is the integrated test of multiple systems that support the high level business requirements of the IRS.
-
A determination to include a particular system in FIT is negotiated between TAD and the customers after evaluating interfaces, dependencies and the business role of the System.
-
No one outside of TAD can perform FIT Testing. If FIT is an appropriate test for your system, complete and submit a Final Integration Test Request Form for approval by using the following URL: http://tad.web.irs.gov/fit/AB_About/FIT_Form-New.asp
-
FIT is conducted:
-
Annually before the start of the new tax year in an integrated environment similar to production;
-
With a copy of production data and consists of activities designed to ensure the interoperability of systems at the release level with the current processing environment; and
-
Up to four times a year to verify that new releases of interrelated systems and hardware platforms can collectively support the IRS business functions.
Note:
For guidance on coordination for FIT, see IRM 2.6.1 Test, Assurance and Documentation (TAD) Standards and Procedures.
-
-
Complete line 15 on the Testing Checklist, Exhibit 2.5.2-3.
-
External Trading Partner Testing is special testing that is conducted on programs that exchange files with an entity outside the IRS. All security guidelines must be adhered to. See IRM 2.5.2.2.25 Coordinate Security Testing for additional information and references.
-
External Trading Partner testing is required if the program exchanges files outside the IRS.
-
The External Trading Partner must create and make available external trading partner's data.
-
The development organization will coordinate with all External Trading Partners to ensure that a thorough test is conducted between IRS and external processes.
-
The Section Chief or designee of the Originating Section and any Impacted Section must sign off on the Files Communication Status Report (FCSR).
-
See Exhibit 2.5.2-9 for a template of the FCSR.
-
External Trading Partners Testing steps:
-
Customers communicate with External Trading Partners on testing setup;
-
Test any files exchanged (input or output) with entities outside the IRS;
-
Obtain acknowledgment on testing status;
-
Contact the External Trading Partner to determine if the test data ran successfully through both systems; and
-
Perform testing until all parties involved concur with test results.
-
-
Complete line 16 on the Testing Checklist, Exhibit 2.5.2-3.
-
Review test results to verify accuracy.
-
The complexity of the requirements will determine the level of testing.
-
Developers should encourage customers to assist in reviewing the test results.
-
Review Test Results steps:
-
Examine the Test Case Specifications to confirm that all tests were executed;
-
Create issues/problem log to document and track ownership and status of each problem;
-
Perform/review file compare results, test data, or printed output such as reports, notices/letters;
-
Record any issues/problems detected on the issue/problem log;
-
If expected results are not obtained, modify program code, test data, and test plan as appropriate and rerun the test. Update documentation, if necessary;
-
Examine the completed Test Case Specifications to verify that all tests were executed successfully;
-
Record lessons learned for future reference, if applicable; and
-
Obtain management acceptance of test results, if required.
-
-
Complete line 17 on the Testing Checklist, Exhibit 2.5.2-3.
-
Coordinate Systems Acceptability Testing (SAT) with TAD.
-
TAD will independently assess the quality of the application software by testing with controlled data to determine conformance to customer requirements and to aid the customer and developer in determining the system's production readiness.
-
SAT is usually performed after unit and (initial) Compatibility/Integration Testing has been completed by the development organization.
Note:
For guidance on coordination for SAT, see IRM 2.6.1, Test, Assurance and Documentation (TAD) Standards and Procedures.
-
Complete line 18 on the Testing Checklist, Exhibit 2.5.2-3.
-
Independent Systems Acceptability Test (ISAT) is required if SAT is not performed by the TAD organization.
Note:
When performing an ISAT, conduct the same activities as described in the SAT section of IRM 2.6.1 Test, Assurance and Documentation Standards and Procedures.
-
ISAT will assess the quality of the application software by testing with controlled data to determine conformance of the system to customer requirements and to aid the customer and developer in determining the systems' production readiness.
-
ISAT is used primarily by Current Processing Environment (CPE) projects.
-
ISAT activities may include but are not limited to the following:
-
Review the requirements to determine the test criteria and test plan;
-
Develop test data to match criteria needs. If live data is used, see IRM 10.8.8, Information Technology, Live Data (LD) Protection;
-
Review the Test Case Specifications for expected results;
-
Execute test(s) as outlined in test plan;
-
Compare the output results against the expected results;
-
Document problem(s) and determine source;
-
Resolve any identified problems;
-
Rerun the test again, if applicable;
-
Ensure all test criteria are met; and
-
Update project folder.
-
-
Complete line 19 on the Testing Checklist, Exhibit 2.5.2-3.
-
Regression testing is performed to determine whether changes to the application have adversely affected previously tested functionality. Regression Testing demonstrates system integrity after changes are made to the configuration or environment of a system.
-
Regression Testing repeats key tests performed in the past and compares results of the new tests to the recorded actual results of the previously executed tests.
-
Perform regression testing when there are changes to:
-
Code;
-
Called library function;
-
Operating system; and/or
-
Build procedures.
-
-
Regression testing can be performed for the complete product or it can be selective.
-
Data must be consistent from test to test to make the results comparable.
-
Test cases for regression testing should be selected based on:
-
Previous system defect fixes, enhancement or changes; and
-
Impact of these changes on the criticality of that system functionality.
-
-
Only portions of the systems affected by modifications/enhancements and/or problem corrections are tested. However, in many cases, changes to one portion of the system may necessitate retesting, verifying, and updating other applicable documentation.
-
Regression Test steps:
-
Evaluate any error found or enhancements suggested by the customers before program has been released;
-
Ensure approval has been made on enhancements to the system;
-
Update test cases, if new functionality is added;
-
Test the portions of the system affected by modifications/enhancements and /or problem corrections;
-
Review expected results and resolve any new errors;
-
Re-run previous test against the changed software to determine whether the changes made in the current software affect the functionality of the existing software;
-
Verify the system produces the expected results after changes/corrections to the system have been applied;
-
Document the regression test results; and
-
Update project folder.
-
-
Complete line 20 on the Testing Checklist, Exhibit 2.5.2-3.
-
The goal of Usability Testing is to analyze the user experience through direct observation and evaluation.
-
At its simplest level, usability testing will determine whether a system works from the users perspective or whether it requires rework.
-
Usability Testing usually requires specific lab configurations and testing equipment.
-
Usability Testing should ideally involve direct user feedback and indirect feedback (observed behavior).
-
The activities listed below are designed to obtain user feedback through usability testing, thereby producing elements for the Usability Review, which summarizes the results of testing:
-
Each participant receives a short overview of the project site, an explanation of the test purpose, and a statement on how he/she will be observed and taped. He/she also must sign a video release.
-
Each participant performs his/her assigned task or tasks.
-
A final interview is held with the participant.
-
The data is analyzed, both qualitatively (comments of observers) and quantitatively (metrics involving time to completion of tasks, number of errors, etc.), problems diagnosed, and recommendations made.
-
Usability Review is finalized.
-
-
It is the development project's responsibility to ensure that all usability activities are completed.
Note:
See IRM 2.25.14, Portal Environment Usability Services for guidance on Usability Testing.
-
Complete line 21 on the Testing Checklist, Exhibit 2.5.2-3.
-
The Rehabilitation Act of 1973, as amended, requires Electronic and Information Technology (EIT) developed, maintained, used, or procured by the Federal government be accessible to persons with disabilities.
-
In 1998, Congress amended the Rehabilitation Act to add Section 508, which eliminates barriers in information technology. This made available new opportunities for people with disabilities, and encouraged the development of technologies to achieve these goals. The enforceable provisions of Section 508 apply to a broad range of EIT, from computer hardware and software to office equipment, such as fax and copy machines. Under Section 508 (29 U.S.C. 794d), agencies must give disabled employees and members of the public access to information that is comparable to the access available to others.
-
Accessibility testing determines whether EIT satisfies federal law for accessibility to people with disabilities. Typical disabilities can be classified into the following four groups, each of them with different access difficulties and issues:
-
Visual impairments - blindness, low or restricted vision, or color blindness. Assistive technology software that reads content aloud is available for users with visual impairments. User with weak vision can also make text larger with browser setting or magnification setting of operating system.
-
Motor skills - the inability to use a keyboard or mouse, or to make fine movements.
-
Hearing impairments - reduced or total loss of hearing.
-
Cognitive abilities - reading difficulties, dyslexia or memory loss.
Note:
Information on available services, accommodations, testing guidance and accessibility can be found on the Information Resources Accessibility Program (IRAP) website at http://irap.no.irs.gov/default.asp
-
-
Complete line 22 on the Testing Checklist, Exhibit 2.5.2-3.
-
Performance testing determines whether the system undergoing testing can effectively process transactions under expected normal and peak workload conditions, within acceptable response time thresholds.
-
During systems evaluation planning or systems test planning activities, the Project/Program manager, TAD, system owner and other stakeholders make the decision whether to execute a performance test.
-
Performance testing is designed to uncover any bottlenecks and capacity constraints that may not have occurred during normal functional testing.
-
Effective performance testing can identify the nature or location of a software-related performance problem.
-
Performance tests can be broadly classified into:
-
Load test
-
Stress test
-
Volume test
-
Capacity test
-
-
Each type of performance test plays a critical role in fine-tuning the system, discovering degradation points, and eliminating system bottlenecks.
-
A Load test identifies peak load conditions at which the program will fail to handle required processing loads within the required time. The number of users is gradually increased until the application fails.
-
A Stress test is conducted to evaluate a system or component at or beyond the limits of its specified requirements to determine when it will fail and how it behaves at failure. Often Stress testing is performed using the same process as Performance testing but employing a very high level of simulated load. Stress testing is load testing over an extended period of time to validate an application's stability and reliability.
-
Volume tests will seek to verify the physical and logical limits to a system's capacity and ascertain whether such limits are acceptable to meet the projected capacity of the organization’s business processing. Volume tests are also executed to ensure that the anticipated numbers of transactions are able to be processed and that they satisfy the stated performance requirements.
-
Capacity tests are performed against different aspects of a system. It is best to focus testing effort on one aspect of the system at a time. Capacity testing is related to Stress testing. It determines the server’s ultimate failure point.
-
Complete line 23 on the Testing Checklist, Exhibit 2.5.2-3.
-
The Application Network Review (ANR) process is performed to:
-
confirm deployed applications provide the intended performance levels;
-
make efficient use of network infrastructure resources; and
-
evaluate whether the enterprise network is efficiently configured to support the deployed application
-
-
The ANR process requires the development organization and the Enterprise Networks organization to define the application operational performance requirements and to ensure the application and network infrastructure are able to achieve the performance objectives in the production environment.
-
Application performance issues used to be considered a matter of hardware resources only. Performance problems are now more likely to originate with system configurations, network and server architecture, application code, application messages between servers and the user, and external systems.
-
Adding network bandwidth or server hardware to resolve performance issues in production is costly and often may not correct the root cause of the poor performance.
-
Application performance testing will be required for all mission critical systems. The following systems will also be required to undergo ANR testing:
-
Applications with front-end web servers and back-end database servers with critical performance requirements;
-
Applications that process imaged documents across the network;
-
Applications that use load balancers to distribute transactions across multiple servers;
-
Applications that will be accessed on a regular basis by users in 20 or more small posts of duty;
-
Applications where it is critical that a specific number of transactions be completed within seconds;
-
Applications that transfer large amounts of data to or from related systems (i.e., patch management systems, backup systems, subscription systems, video, training systems, etc.); and
-
Applications that introduce new network protocols and/or new application architecture.
-
-
The above criteria for ANR testing are taken from Appendix A, ANR Screening Guidelines from the ANR Process Description.
-
The requirements and guidance for performing ANR may be found in the ANR Process Description. The document can be found on the Process Asset Library (PAL) by using the following URL: http://paig.ds.irsnet.gov/pal/assets.htm
-
Complete line 24 on the Testing Checklist, Exhibit 2.5.2-3.
-
Security Test and Evaluation (ST&E) is conducted in the IRS production environment and consists of activities designed to ensure that the system’s security safeguards are in place and functioning as intended.
-
ST&E is conducted by MITS Cybersecurity. Cybersecurity usually assigns security experts to support the ST&E and they maintain the standards for conducting the test.
-
Program/Project Manager must coordinate with MITS Cybersecurity and Enterprise Services early in a project’s life cycle to ensure security requirements are addressed.
-
For additional information regarding Cybersecurity, visit the MITS Cybersecurity web site by using the following URL: http://mits.web.irs.gov/Cybersecurity
Note:
For information on Security Test and Evaluation (ST&E), see IRM 10.8.1, Information Technology (IT) Security Policy & Standards – IT Security Policy & Guidance.
-
The Privacy Impact Assessment (PIA) is a process the system owner and information developer use to address privacy issues in a program or Internet website under development.
-
The PIA process provides a means to assure compliance with applicable laws and regulations governing taxpayer and employee privacy.
-
The approved PIA is required as part of the overall Certification and Accreditation process necessary for all IRS programs collecting personally identifiable information.
Note:
For additional information of Privacy Impact Assessment, see IRM 11.2.1, Privacy Advocate.
-
Complete line 25 on the Testing Checklist, Exhibit 2.5.2-3.
-
Web testing is a computer-based test delivered via the internet and written in the "language" of the internet, HTML and possibly enhanced by scripts .
-
The Communications and Liaison Department (C&L) is responsible for managing the IRS intranet. The content and usability standards are implemented on all IRS intranet sites and updated periodically. These standards are intended to help ensure that intranet sites present content that is properly managed and easy to use and understand. Refer to the C&L Division web site, http://cl.no.irs.gov/intranet
-
Testing considerations for web applications may include, but are not limited to the following:
-
Testing Browser and Operating System Compatibility – Test applications with as many browsers as possible (both well-known and less-known) as well as testing with older version of the same browsers (where applicable).
-
Applets and Cookies – When the user attaches to the application, the cookies or applets may be nonexistent on the users computer, existent but an earlier release/version, existent but corrupted, or existent and at the current level. Some users have security set to levels that prevent applets and cookies from being stored on their computers.
-
Capacity Testing – Use automated testing tools to simulate production use. Test for limits of the environment, volume the system can handle, simultaneous access to critical resources, system performance at known limits, and implement real-life, worst-case scenarios.
-
Security Testing – Measures that control various types of access to the web site: external intrusion and secure transactions.
-
Usability Testing – Verify that the site is easy to use and understand, users know how to use and interpret information received, site navigation is clear and correct.
-
Testing Recoverability – Verify that system can recover lost connections and timeouts, backups can be generated, the system can be restored properly from a backup, procedures exist to recover from crashes, orders that are "in progress" or in queue are not lost.
-
-
Testing tools can improve testing reusability, predictability and testing time. The IRS organization will evaluate tools, gain an understanding of the expected benefits offered by different categories of tools, ensure that selected tools are appropriate for their environment and applications, and train testers in the use of the tools.
-
Web sites must be tested after development and periodically while in maintenance to ensure compliance to accessibility standards. Accessibility standards are established to ensure that potential users with disabilities have the comparable access to web sites as users without disabilities.
-
IRS approved testing tools must be used to verify accessibility on MITS/AD Web sites. The following are information accessibility standards that MITS/AD enforces:
-
Sections 508 compliance and certification is required by IRS. All web pages and elements must be fully accessible to all potential users with disabilities, as defined in the 1998 Rehabilitation Act, Section 508 (29 U.S.C.’794d).
-
World Wide Web Consortium (W3C) accessibility standards are recommended by IRS. W3C provides methods and standards beyond minimal Section 508 compliance.
-
IRS requires specific testing and/or certification using AccVerify®, JAWS®, and IRAP procedures to ensure compliance with Section 508.
-
AccMonitor is an automated web-testing tool, which is now available for web and application developers to evaluate and monitor IRS Internet and Intranet web sites for Section 508 compliance.
-
-
JAWS (Job Access with Speech) is an assistive technology product for people with visual impairments. It provides users with information about software and websites via speech. JAWS relies on software and web developers to make sure their products conform to accessibility standards. JAWS is used for testing the functional performance of a product and identification of accessibility issues that may not be easily caught via manual (keyboard only) or software testing (AccVerify).
Note:
For rules and guidelines for creating accessible web content and applications on internal and external IRS web sites, refer to IRM 2.25.5, Accessibility Guidelines for the Web or the IRAP web site at http://irap.no.irs.gov/508/testing.asp
-
Web Services standards for the development of IRS websites include content authoring languages, programming/scripting languages, and back-end applications, along with applications that provide developing interfaces.
-
Development Methodology standards refer to the tools, applications, and languages acceptable for use in the production and maintenance of web sites in the IRS Intranet. These standards are primarily determined by the Portal Program Management Office. The Portal Program Management Office has the responsibility for providing detailed guidance on uniform database naming conventions, script naming, and software components within the IRS Intranet environment.
-
Complete line 26 on the Testing Checklist, Exhibit 2.5.2-3.
-
Review the test package to determine completeness and adherence to systems development standards.
-
The Test Package must be reviewed to determine whether the overall test strategy and test package elements validate the software requirements, and whether the test case specifications provides sufficient coverage for any new software functionality.
-
Prepare and Review Test Package steps:
-
Gather Test Plan, Test Case Specifications, Testing Checklist, and relevant documentation to prepare Test Package;
-
Review the completed Test Package;
-
Compare the software requirements against the Test Plan and the Test Case Specifications;
-
Record findings;
-
Recommend changes and improvements to the Test Package;
-
Revise the Test Package to incorporate the changes into the Test Plan or Test Case Specifications;
-
Verify that all discrepancies have been resolved and that all changes have been successfully incorporated;
-
Complete the transmittal checklist generated from the applicable transmittal systems;
-
Submit completed Test Package for approval;
-
Update project folder checklist, if applicable;
-
Ensure all project documents are stored appropriately.
-
-
Complete line 27 on the Testing Checklist, Exhibit 2.5.2-3.
-
While most projects transmit software into production under configuration management control of the Source Code and Documentation Control (SCDC) Branch within TAD, there are some that do not. Historically, each project not under SCDC control has used its own method for transmittal. This section describes the procedure that development projects using the services of SCDC must follow.
-
Once testing is completed and the test results are satisfactory, complete project folder and transmit software to SCDC in accordance with IRM 2.6.1, Test, Assurance & Documentation (TAD) Standards and Procedures.
-
SCDC Branch serves as an independent version control entity for all of the source code running in SQuA, ENDEVOR and ClearCase. SCDC serves as a control center for the movement of transmittals from the development environment to the SAT, FIT, Martinsburg Application Development Systems (MADS) production files, and the Submission Processing Center (SPC) for production processing.
-
Identify and document the software version control procedures used to transmit the software.
-
ECC-Martinsburg (ECC-MTB) or ECC-Memphis (ECC-MEM).
-
Transmittal systems are set up with their own checklists to be included with the transmittal.
-
Tier 1 IBM environment - ENDEVOR is used to control the movement of components to the SAT testing and production areas.
-
Tier 1 UNISYS environment - the SQuA Software Quality Assurance tool is used.
-
Tier 2 and 3 UNIX/Windows environment - IBM/Rational ClearCase is used to control the movement of source code and Tivoli is used to transmit to the production sites.
-
-
The ENDEVOR ACM tool provides a robust and controlled environment for test, development, and storage of software elements and documentation. It provides version control for the IBM Program Source Code, JCL, memo, and etc. This tool allows developers to simultaneously work on multiple versions of the same source code element. Control is exercised by designating code in production libraries as the official version and level.
-
ENDEVOR Package Processing:
Note:
The detailed procedures are available at TAD Website by using the following URL: http://adweb.irs.gov/DomainAreas/TestAssuranceDocumentation/SourceCodeandDocControlBranch/default.aspx.
-
ClearCase is a configuration management tool designed to help software development teams track the files and directories used to create software. ClearCase enables you to manage the development and build process and to enforce your site-specific development policies.
-
SCDC Tiers 2/3 Version Control Process using ClearCase describes how SCDC performs version control and promotes software changes through the Version Description Document (VDD) build process. It focuses on the primary activities performed to process VDDs submitted by development projects.
Note:
SCDC Tiers 2/3 Version Control Process for IRS Developers and Integrators is available at TAD Website by using the following URL: http://adweb.irs.gov/DomainAreas/TestAssuranceDocumentation/SourceCodeandDocControlBranch/Tier23ConfigurationSection/default.aspx.
-
Software Quality Assurance (SQuA) Automated Configuration Management (ACM) tool ensures that controlled Production libraries contain the official version, or baseline, of all existing IRS UNISYS application source code. SQuA facilitates easy access to the baseline version of the source code as a starting point for the development activity. It also significantly reduces the effort required to transmit software to the production sites after development and testing and ensures that modified source elements do not move into production libraries until the appropriate implementation date.
Note:
Procedures for Using SQuA (User's Guide), can be found on the TAD website by using the following URL: http://adweb.irs.gov/DomainAreas/TestAssuranceDocumentation/SourceCodeandDocControlBranch/Tier1ConfigurationSection/Projects/defaul t.aspx.
-
Transmit Software steps:
-
Verify all steps of the developer’s testing process have been completed;
-
Determine if other elements can be grouped in one transmittal;
-
Prepare software transmittal and transmittal memo referring to the appropriate URL listed above to construct the memo and transmittal/package requirements;
-
Incorporate the purpose of the transmittal into the title;
-
Request review of transmittal and transmittal memo by team leader or other peer for accuracy and completeness;
-
Make any corrections to the transmittal or transmittal memo, if necessary;
-
Obtain approval of software transmittal from Section Chief;
-
Prepare pertinent documentation;
-
Submit software transmittal, transmittal memo, and necessary documentation to SCDC of TAD; and
-
Place a copy of the transmittal and transmittal memo in the project folder.
-
-
Complete line 28 a - b on the Testing Checklist, Exhibit 2.5.2-3.
-
The software testing procedures are controlled and driven by the testing templates. A high level reference and audit trail that must be used to track movement of the testing process from preparing the product through transmitting the software.
-
The testing templates are stored in DocIT.
-
The testing templates consist of the following:
-
Exhibit 2.5.2-1. Project Folder Checklist (DocIT # 8020c88e)
-
Exhibit 2.5.2-3. Testing Checklist (DocIT # 8020c894)
-
Exhibit 2.5.2-5. Test Plan (DocIT # 8020c969)
-
Exhibit 2.5.2-7. Test Case Specifications (DocIT # 8020c971)
-
Exhibit 2.5.2-9. File Communication Status Report (FCSR) (DocIT # 8020c975)
-
Exhibit 2.5.2-11. Requirements Traceability Verification Matrix (DocIT # 80216056)
-
-
In order to access the testing templates, an "Advanced Search" in DocIT will need to be performed. Click on the Advanced tab, enter the DocIT# and click search.
-
Testing templates may be tailored for project needs while ensuring the integrity of each template is preserved.
Note:
Help for using DocIT is provided through on-line help at http://docit.web.irs.gov/docit/help/en/default.htm and the TAD home page at http://tad.web.irs.gov/docIT/docIT.htm.
| Project Folder Checklist | |||
|---|---|---|---|
| Project Information | |||
| Project Name | Date | ||
| Developer/Analyst Name | Office Symbols | ||
| Telephone Number | Project Folder Location | ||
| Requirements Document(s) | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| Business Systems Requirements Report (BSRR) | |||||
| Work Requests (WRs) | |||||
| WR Response | |||||
| WR Coordination Meeting Minutes | |||||
| Task Order | |||||
| Statement of Work (SOW) or Contractor Work Request | |||||
| Project Schedule/Work Breakdown Structure (WBS) | |||||
| Project Impact Assessment (PIA) | |||||
| Requirement Traceability Verification Matrix (RTVM) |
| Functional Document(s) | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| Interface Control Document (ICD) | |||||
| Design Specification Package (DSP) | |||||
| Design Specification Report (DSR) | |||||
| Functional Design Specification (FDS) | |||||
| Functional Specification Package (FSP) | |||||
| Program Requirements Package (PRP) |
| Operational Documents(s) | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| File Descriptions and Definitions | |||||
| Components List | |||||
| Computer Operator Handbook (COH) | |||||
| Program Specific Documentation | |||||
| Record Layouts/Program Run Descriptions | |||||
| Schematics | |||||
| Structure Charts/Flowcharts | |||||
| User Manual |
| Correspondence | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| Decision Documents (customer contact forms, email) | |||||
| Requirement Source Information (tax law changes, customer, etc.) |
| Walkthrough/Milestone Concurrence | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| Peer Review(s) Agenda/Minutes | |||||
| Peer Review Documentation |
| Developers Testing | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| Run Program/Files | |||||
| Library Reference for SAT/Production Job Control Language (JCL), Executive Control Language (ECL) and Programs | |||||
| Developer's Test Plan | |||||
| Project Schedule/Work Breakdown Structure (WBS) | |||||
| Developer's Testing Checklist | |||||
| Developer's Test Case Specification | |||||
| Test Logs/Results | |||||
| Lessons Learned | |||||
| External Trading Partners List | |||||
| Compatibility tests for specific run |
| Project Specific Plans/Documents | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| Acquisition Management Plan | |||||
| Change Management Evaluation Form | |||||
| Communication Plan | |||||
| Configuration Management (CM) Plan | |||||
| Contingency Plan | |||||
| Exhibit 53 or Exhibit 300 | |||||
| Project Charter | |||||
| Project Management Plan (PMP) (including Cost and Technical Proposals, Estimates & Worksheets) | |||||
| Quality Management Plan | |||||
| Requirement Management Plan | |||||
| Risk Management Plan (including Risk Analysis, Risk Assessment & Release Readiness Worksheets) | |||||
| Tailoring Plan | |||||
| Training Plan | |||||
| Quality Assurance (QA) Documents |
| Assessments/Packages | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| Health Assessment | |||||
| Privacy Package/Privacy Impact Assessment | |||||
| 508 Accessibility and Mitigation Package | |||||
| Security Certification & Accreditation Package |
| System Acceptability Testing (SAT) | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| SAT Plan with Memorandum for Distribution | |||||
| SAT Transmittal/Version Description Document (VDD) | |||||
| Test Readiness Review (TRR) Agenda/Minutes | |||||
| TRR Checklist | |||||
| TRR Memorandum | |||||
| End of Test Status Report (EOTSR) | |||||
| Post Implementation Review Report |
| Transmittal/Problem Ticket | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| ITAMS/Problem Tickets & Related Documentation | |||||
| Transmittal Package |
| Agreements/Reports | Repository/DocIT # | Yes | No | N/A | Dates/Comments |
|---|---|---|---|---|---|
| Memorandum of Agreement/Understanding (MOA/MOU) | |||||
| Service Level Agreement (SLA) | |||||
| Release Readiness Schedule and Status Report(s) | |||||
| Exception Report | |||||
| Team Leader/Project Leader & Developer Status Reports |
| Verification of Project Folder | |
|---|---|
Reviewer's Signature: ______________Date:_____________ Developer's/Analyst's Signature: _______________Date:____________ |
Additional Comments |
| The Project Folder Checklist must be used to review the project folder contents for completeness and accuracy. The Project Name, Developer/Analyst Name, Date, Project Folder Location, Office Symbols and Telephone number must be filled out/completed. Each item on the checklist must have a check in the appropriate box and a Repository/DocIT number, if applicable. |
|---|
| 1. Repository/DocIT Number – Enter the corresponding document number from DocIT if applicable. |
| 2. YES – Checklist item in question is represented in the folder. If item is not in folder, cross reference its location in dates/comments. |
| 3. NO – Checklist item in question is not represented in the folder, explanatory comment(s) are required. |
| 4. N/A – Checklist item in question does not pertain to this project, explanatory comment(s) are optional. |
| 5. Date/Comments - Enter current date and any additional information relating to the status of project testing and documentation. |
| 6. Verification of Project Folder - Enter Reviewer and Developer/Analyst signatures and date, with possible comments. |
| Programmer Information | |||
|---|---|---|---|
| Programmer Name | Telephone # | ||
| Team Leader Name | Telephone # | ||
| Section Chief Name | Telephone # | ||
| Project Information | |||
| Project Name | Org. Symbols | ||
| Work Request Title | Work Request Number | ||
| SAT Transmittal # | SAT Transmittal Date | ||
| No. | Test Activities | Yes | No | N/A | Signature/Date |
| 1. | Prepare Software Product | ||||
| a | Review, analyze and coordinate Software Requirements | ||||
| b | Verify Project Folder exist | ||||
| c | Review/update pertinent Documents (FSP, PRP, COH, etc.) | ||||
| d | Review Lessons Learned | ||||
| e | Create/update Source Code | ||||
| f | Create/update Execution Control Language (ECL, JCL, etc.) | ||||
| 2. | Review/Update Project Folder | ||||
| 3. | Conduct Software Desk Check | ||||
| 4. | Conduct Peer Review | ||||
| 5. | Create/Execute Test Plan | ||||
| 6. | Create Test Case Specifications | ||||
| 7. | Create/Update Requirement Verification Traceability Matrix | ||||
| 8. | Develop/Acquire Test Data (Including data to test for "Invalid Conditions" ) | ||||
| 9. | Coordinate Testing Environment | ||||
| 10. | Conduct Unit Testing | ||||
| 11. | Conduct Compatibility Testing | ||||
| 12. | Conduct Integration Testing | ||||
| 13. | Conduct Developer Integration Testing (DIT) | ||||
| 14. | Conduct Development System Integration Testing (DSIT) | ||||
| 15. | Coordinate Final Integration Testing (FIT) | ||||
| 16. | Coordinate External Trading Partners Testing | ||||
| 17. | Review/Document Test Results | ||||
| 18. | Coordinate Systems Acceptability Testing (SAT) | ||||
| 19. | Conduct Independent Systems Acceptability Testing (ISAT) | ||||
| 20. | Conduct Regression Testing | ||||
| 21. | Request Usability Testing | ||||
| 22. | Coordinate/Conduct Accessibility Testing (508 Compliance) | ||||
| 23. | Conduct Performance Testing | ||||
| 24. | Coordinate Application Network Review (ANR) | ||||
| 25. | Coordinate Security Testing | ||||
| 26. | Conduct Web Testing | ||||
| 27. | Prepare and Review Test Package |
| (Complete steps 1-25 before transmitting, then complete steps 26-27 as appropriate). | |||||
| 28. | Transmit Software | ||||
| a | Was software transmitted for SAT? | ||||
| b | Was software transmitted for Production? | ||||
| 29. | Update Project Folder | ||||
| Programmer Information |
|---|
| Programmer Name - Enter the name of the programmer. |
| Telephone # - Enter telephone number of the programmer. |
| Team Leader Name - Enter the name of the team leader. |
| Telephone # - Enter the telephone number of the team leader. |
| Section Chief Name - Enter the name of the section chief. |
| Telephone # - Enter the telephone number of the section chief. |
| Project Information |
| Project Name- Enter the name of the project. |
| Org. Symbols - Enter the symbols of the programmer organization. |
| Work Request Title - Enter the title of the Work Request. |
| Work Request Number(s) - Enter the Work Request number(s). |
| SAT Transmittal Number - Enter the SAT transmittal number. |
| SAT Transmittal Date - Enter the SAT transmittal date. |
| Test Activities |
| Complete all testing activities starting with Prepare Product through Transmit Software. Check appropriate box items 1-25, verify task is complete, sign and date for each task. |
| Transmit Software |
| Enter the transmittal number, and transmittal date in the Project Information section on the checklist. Check appropriate box items 26a & 26b, verify task is complete, sign and date for each task. |
| Update Project Folder |
| Ensure all system test materials have been placed in the project folder. Check appropriate box item 27, verify task is complete, sign and date for each task. |
| Programmer Information | |||||||
| Programmer Name | Telephone # | ||||||
| Team Leader Name | Telephone # | ||||||
| Section Chief Name | Telephone # | ||||||
| Project Information | |||
| Project Name | Org. Symbols | ||
| Work Request Title(s) | Work Request Number(s) | ||
| SAT Transmittal # | SAT Transmittal Date | ||
| Production Transmittal # | Production Transmittal Date | ||
| Purpose of Test (Check appropriate box) | ||
|---|---|---|
| WR | Problem Ticket(s) | Other |
| LINE | ITEMS | ENTRY | |||
|---|---|---|---|---|---|
| 1. | Purpose & Scope of Test | ||||
| 2. | Project References | ||||
| 3. | Items to be Tested | ||||
| 4. | Acceptance Criteria | ||||
| 5. | Test Coverage | ||||
| 6. | Type(s) of Testing | ||||
| 7. | Inputs | ||||
| 8. | Outputs | ||||
| 9. | Files exchanged with other software? If yes, check YES and complete the Files Communication Status Report. If no, check NO. | YES | NO | ||
| 10. | Files exchanged outside the IRS? If yes, check YES and list the files and the External Trading Partners Point-of-Contact (POC). If no, check NO. | YES | NO | ||
| Files: | |||||
| External Trading Partner POC: | |||||
| 11. | JCL/ECL Procedures | ||||
| 12. | Program Load Modules | ||||
| 13. | Test Environment | ||||
| 14. | Testing Tools | ||||
| 15. | Testing Constraints | ||||
| 16. | Approval of Test Plan | ||||
| Team Leader: | |||||
| Date: | |||||
| Programmer Information - Enter programmer information (Programmer Name, Telephone Number, Team Leader Name, Telephone Number, and Section Chief Name). |
| Project Information - Enter project information (Project Name, Project Symbols, Work Request Title(s), Work Request Number(s), SAT Transmittal #, SAT Transmittal Date, Production Transmittal #, and Production Transmittal Date). |
| Purpose & Scope - Describe the purpose of the test plan. Multiple components can be incorporated into one test plan. |
| Project References - List any documentation referenced in the test plan. |
| Items to be Tested - Identify the fields or units to be tested based on the Test Case Specifications such as particular field and expected values. |
| Acceptance Criteria - Enter the acceptance criteria that will be used to decide whether the test is acceptable or not. |
| Test Coverage - The units and modules of an application being tested with the specified test data using the applicable Test Plan. |
| Type(s) of Testing - Identify the type(s) of testing to be utilized such as compatibility, unit, regression, etc. |
| Inputs - List or describe the input files or input command codes to be used. |
| Outputs - List or describe the output files or any messages that will be displayed. |
| Files exchanged with other software YES/NO - If yes, check YES and complete the Files Communication Status Report (FCSR), Exhibit 2.5.2–9. |
| Files exchanged outside the IRS? YES/NO - If yes, check YES and list the files and the external trading partners point-of-contact. |
| JCL/ECL Procedures - List the JCL/ECL used to run job. |
| Program Load Modules - List the load modules to be used. |
| Test environment - List any special test requirements such as access to a database, printer requirements, etc. |
| Testing Tools - List any testing tools you may want to use such as @COMPARE, XDC, etc. |
| Testing Constraints - Describe any constraints that may cause you to limit your testing. This may include time and resource constraints, specialized equipment, such as laser printers, etc. |
| Approval of Test Plan - The team leader should sign and date the test plan. |
| Programmer Information | |
|---|---|
| Programmer Name | |
| Org. Symbols | |
| Test Case Preparer Name | |
| Project Information | |
|---|---|
| Project Name | |
| Program | |
| Work Request/Change Control # | |
| Transmittal # | |
| Transmittal Date | |
| Problem Ticket Information | ||
|---|---|---|
| Problem Ticket # | Date Opened | Date Closed |
| Test Information | ||||||
|---|---|---|---|---|---|---|
| Test Case ID# | ||||||
| No. | Test Reference # | Dataset Name(s) | Condition Tested | Expected Results | Actual Results | Initial/Date |
| 1. | ||||||
| 2. | ||||||
| 3. | ||||||
| 4. | ||||||
| 5. | ||||||
| 6. | ||||||
| 7. | ||||||
| 8. | ||||||
| 9. | ||||||
| 10. | ||||||
| Programmer Information - Enter the programmer name, Organization symbols and Test Case Preparer Name. |
| Project Information - Enter project information (Project Name, Program, Work Request/Change Control #, Transmittal #, and Transmittal Date). |
| Problem Ticket Information - Enter problem ticket number, date opened and date closed. |
| Test Case ID# - Unique ID number to be used for reference to this test case document. For example, TC-1-2009-1 (Test Case Jan 2009 Test 1). |
| No. - Numbering for multiple test cases under the same test case ID#. |
| Test Reference #- Links the test case ID# to the unit or compatibility test which validated this test case. |
| Dataset Name - Enter the unique identifier for the record, for example record number for the condition to be tested. |
| Condition Tested - Enter the condition to be tested and the technique (logic driven or data driven) to be employed. |
| Expected Results - List or describe the expected values for each record. |
| Actual Results - List or describe the actual values for each record. |
| Initial/Date - The programmer or Team Leader must initial and date this column to confirm that the expected results were achieved. |
| Test Reference # | |||
| Originator Information | |||
| Originator Name | Date | ||
| Telephone # | Org. Symbols | ||
| Testing Conditions | |
| File(s) creation date | Recipient for impacted section (name, telephone & symbols) | File ID(s) | DSN (Data-set name) | Comments/Status |
| Concurrences | |||
|---|---|---|---|
| Originating Section Chief | Date | ||
| Impacted Section Chief | Date | ||
| Impacted Section Chief | Date | ||
| Impacted Section Chief | Date | ||
| Test Reference # - Unique ID number to be used for reference to this compatibility test document. For example, CT-1-2009-1 (Compatibility Test Jan 2009 Test 1). |
|---|
| Originator Information - Enter originator name, date, telephone number and organization symbols. |
| Testing Conditions - Enter the condition to be tested and associated test case document ID. |
| File(s) creation date - Enter the date the test file was created. |
| Recipient for impacted section - Enter the name, telephone, and symbols. |
| File ID(s) - Enter the identification numbers of the test file(s). |
| DSN - Enter the actual data-set name for the test data. |
| Comments/Status - Enter any information relating to the status of the test to date, description of data file(s), documentation of problems and solutions, volume figures, output-codes, etc. Note the specific absence of types of data from the test file. |
| Concurrences - The originating section chief must enter the date the FCSR was forwarded to the first impacted section chief. The impacted section chief(s) must enter the date their part of the compatibility testing was completed. |
| Requirements Traceability Verification Matrix | |
|---|---|
| Version Number and Date: | |
| Project Name and Release/Production Implementation: | |
| Requirements Control Number | Requirements Item Reference Number | Requirement(s) | Functional/ Operational Document Name/Item Reference Number | Functional/ Operational Document Version/Date | Test Case ID Number | Test Condition | TestDate | TestResults | Problem Ticket Number | Remarks/Constraints |
|---|---|---|---|---|---|---|---|---|---|---|
| Requirements Traceability Verification Matrix (RTVM) InstructionsComplete the header information for the following rows: RTVM Version Number, Date, and Project Name. |
| Requirements Control Number - Enter the UWR.. |
| Requirements Item Reference Number- Enter the Item reference number within the UWR. |
| Requirement(s) - Enter the exact wording of the requirement as written in the UWR. |
| Functional/Operational Document Name/Item Reference Number- Enter the name and item reference number within the Functional/Operational Document associated with the test case. |
| Functional/Operational Document Version/Date- Enter the version number and date of the Functional/Operational document used to test the requirement, such as FSP, PRP, COH, etc. |
| Test Case ID Number- Unique ID number used as reference for each test case. |
| Test Condition- Enter description and expected result of the test case. |
| Test Date - Enter the date the test case was validated. |
| Test Results - Did the test pass or fail? |
| Problem Ticket Number- Enter the identifying number for the failed test case. |
| Remarks/Constraints - Enter any additional Information concerning the test case. |
The following table defines key terms used in this document.
| Accessibility Testing — Testing to determine whether a product satisfies Federal law that IT products used by the Federal government are accessible to persons with disabilities. |
| Agenda — A schedule of topics to be dealt with in a meeting. |
| Analysis Specification Package (ASP) — Primary deliverable and/or functional requirements document that results from structured analysis. |
| Application Network Review (ANR) — Enables the IRS to determine how applications will perform in the IRS network infrastructure before the applications are put into production. |
| Artifacts — The tangible result (output) of an activity or task performed by a project during the life cycle. Artifacts may be designated as work products or deliverables. |
| Business Rules and Requirements Management (BRRM) — Provide practices, methodologies, and services supporting IRS projects to achieve desired business goals. |
| Business System Requirements Report (BSRR) — A report that documents a feasible, quantifiable, verifiable set of requirements that define and bound the business system or sub-systems(s) being developed or enhanced by the project. |
| Capacity Testing — Testing the system under heavy load with a large number of inputs to determine the maximum effective capacity of the application. |
| Compatibility Data — Data that is passed through a run stream during development or systems acceptability testing. |
| Compatibility Testing — A process of testing which ensures that unit and string tested programs accurately process data received from external programs/systems and accurately pass this data forward to subsequent programs/systems. The emphasis of this testing should be on data format, physical media (block/record length), blocking factors, padding and controls. |
| Computer Operator Handbook (COH) — Provides detailed instructions to a computer operator on the proper execution and validation of a run or program. |
| Computer Program Book (CPB) — A set of books that document processing and operating requirements. |
| Create Test Case Specifications — The activity that develops the document that describes the test cases used to verify program instructions, features, or the combination of features to be tested. |
| Create Test Package —The activity in which the developer develops the test plan and the test case specifications. |
| Create Test Plan — The activity in which the developer prepares the test plan which describes the overall strategy for the testing of new or modified code. This document identifies the inputs, outputs, hardware, software, documentation and any other items needed to execute the test cases. |
| Customer — A generic term which denotes a customer of an information processing service. The customer or user is usually a National Office or a field organization with an established information processing need. |
| Design Specification Package (DSP) — A functional requirement specification which traces to one or more components during the design/development phase. |
| Design Specification Report (DSR) — Consist of two parts. The DSR Part 1, documents the logical design of the data and application perspectives. The DSR Part 2, documents physical design of the solution from all applicable perspectives. |
| Desk Checking — The manual simulation of program execution or flow to detect errors and defects. |
| Document Management for Information Technology (DocIT) — A web-based electronic document management system that has replaced Hummingbird DM. The tool provides documentation control for IT projects within the IRS. |
| Enterprise Life Cycle (ELC) — The approach used by the IRS to manage and effect business change. The ELC provides the direction, processes, tools, and assets for accomplishing business change in a repeatable and reliable manner. |
| Execute Test Plan — The activity of conducting test activities as specified in the test plan. |
| Executive Control Language (ECL) — UNISYS language used to identify software and hardware resources when running a job. |
| Existing Software Products — Software items such as code, documentation, JCL, and test data which already exist and are related to the created or revised software to be tested. |
| External Trading Partner (ETP) — An entity outside the IRS which exchanges data with the IRS. Integration Testing with ETPs is a mandatory testing activity. |
| External Trading Partner Data — Data that is created by the external trading partner and transmitted to the IRS; or data generated by the IRS that is transmitted to the external trading partner. |
| External Trading Partner Testing — Special testing conducted on programs that exchange files with an entity outside the IRS. |
| File Specifications — Unique file identifier and related information about the file. |
| Files Communication Status Report (FCSR) for Compatibility Testing — The form identifies stakeholders and documents compatibility testing conditions/files. |
| Final Integration Testing — A system test consisting of integrated end-to-end testing of mainline tax processing systems to verify that new releases of interrelated systems and hardware platforms can collectively support the IRS business functions allocated to them. |
| Final Test Results — Test outcomes which have been determined to be within acceptable limits for release and transmittal to production or Test, Assurance and Documentation. |
| Functional Design Specification (FDS) — A document used by companies in a pre-development phase to translate all notes, concepts, and scope into a complete requirements document. The document can include items such as flowcharts, screenshots, wire frames and any other design documentation items. At a minimum, an FDS will contain an organized list of requirements that can be used for development, testing, and client sign-off. |
| Functional Specifications Package (FSP) — A document that shows the structured analysis and communicates the functional requirements of the system under development; the major components of the FSP are data flow diagrams, data definitions, and process specifications. |
| Independent Systems Acceptability Testing (ISAT) — Testing similar to Systems Acceptability Testing that is conducted by someone other than the developer when TAD cannot perform such testing. |
| Integration Testing — Testing of combined parts of an application to determine if they function together correctly, performed after unit testing. |
| Interface Control Document (ICD) — An agreement between multiple organizations that must collaborate to produce the design of the solution interface. |
| Interface Testing — Testing conducted to ensure that the program or system components pass information and control correctly. |
| JAWS — Job access with Speech - Sec. 508 disability compliance. |
| Job Control Language (JCL) — IBM language used to identify software and hardware resources when running a job. |
| Lessons Learned — A written record of ways to improve or obstacles to be avoided that were noted during dynamic testing of a software product. |
| Live Data — Any unmodified data extracted from taxpayer files, which can identify specific individual or corporate taxpayers. The use of live data must have a justification and its use is strictly prohibited without approval. |
| Load Test — Performance test to check system behavior under load to determine at what point the system's response time degrades or fails. |
| Milestone — Represents the completion of key activities within the project's life cycle used to measure progress and to provide a review point for approval. |
| New/Revised Software — Software products that the programmer/developer has determined are ready for unit testing. |
| Peer Review — Peer review is the review of work products performed by peers during development of the work products to identify defects for correction. |
| Performance Testing — Determines whether the system undergoing testing can effectively process transactions under expected normal and peak workload conditions, within acceptable response time thresholds. Performance testing will uncover any bottlenecks and capacity constraints that may not have occurred during normal functional testing. |
| Prepare Product — Developer reviews and analyzes the software requirements for accuracy, updates relevant documentation (such as FSP, PRP, CPB, etc.), changes the program code, changes JCL or ECL code and updates the project file documentation (project folder and/or softcopy project file) |
| Production Data - Data extracted from production files. Production data can be sanitized or unsanitized and is often used for volume test and file compares. |
| Programmer Created Data - Data created or collected by the programmer to be used for later testing. The volume is low and allows for easier manipulation of records and for complete review of specific results. |
| Programming Requirements Package (PRP) — A document that communicates the requirements of the system under development. |
| Project Folder(s) — Contains copies of all critical test documentation and may vary in volume depending on the size and/or complexity of the project. |
| Record Layout — Define the order, size and contents of the various fields in a record. |
| Regression Testing — Testing that is performed to determine whether an improvement or repair to a program has introduced problems in other areas of the program. |
| Requirements Traceability Verification Matrix (RTVM) — A tool showing the relationship between test requirement and test cases. |
| Review Test Results — Review of the output from the completed test plan. This could be any type of data output resulting from the execution of the test plan. These results should match those documented in the test package and be coordinated with the test specifications, and, if necessary, could be validated back to the software requirements. |
| Revised Test Package — The modified test package which incorporates the changes from the test package review. |
| Sanitized Data — Production data that has been altered after extraction from production files to obscure the identity and location of the taxpayer. At a minimum, sanitization involves changes to taxpayer names, taxpayer identification number (TIN), address and zip code. Sanitized data should be treated as live data. |
| Schematics — A diagram that represents the elements of a system using abstract, graphic symbols rather than realistic pictures. |
| Security Testing — Testing to evaluate how well a program protects against unauthorized access. |
| Service Level Agreement (SLA) — An agreement between the service provider and a customer that specifies, usually in measurable terms, the level of service, providing a common understanding about services, priorities, responsibilities, etc. Agreements between MITS and entities external to MITS are called SLAs. |
| Simulated Data — Data that realistically imitates actual taxpayer files but does not contain live data. |
| Software Desk Check — An inspection of code for omission, logic, formatting and syntax errors by a programmer (possibly other than the developer). |
| Stress Testing — Testing the system beyond its specifications to check when and how it fails. |
| System Administrator Guides — Contains procedures the administrator must perform to ensure smooth and efficient operation of all services. |
| Systems Acceptability Testing (SAT) — Testing performed by TAD to independently assess the quality of the application software to aid the customer and developer in determining the system's production readiness. |
| TAD — Test, Assurance & Documentation Organization who conducts SAT Testing. |
| Test Activities — The activity that creates and finalizes test data, based upon the test case specifications, and executes the test steps as described in the test plan. The test results would then be reviewed against the software requirements in the test case specifications. |
| Test Case— A document specifying the test approach for a software feature or combination or features and the inputs, predicted results and execution conditions for the associated tests. |
| Test Case Specification — The creation of test scenarios to produce valid and invalid results for the software requirements requested. |
| Test Data — Any material (computer records, paper records, databases, etc.) which simulates data as it appears in actual taxpayer files. |
| Test Environment — The preliminary setup of hardware, resources, data, utilities, etc., required to run a successful test. |
| Test Package — The set of all items required to conduct testing on a specific unit of code. The test package includes the test plan, test case specifications, checklist and any additional documentation required to execute the test. |
| Test Package Review — The review of the test package to verify that the test strategy properly verifies the requested requirements. |
| Test Plan — Is a document that describes the objectives, scope, approach, and focus of a software testing effort. |
| Test Results — A documented summary or printed output resulting from the execution of the test plan. |
| Test Success Criteria — The expected outcome of tests which verify that a software unit meets its requirements. |
| Transmit Software — Prepare, approve, and deliver the software transmittal package to TAD or production. |
| Transmittal Package — Includes the software and files to be deployed, instructions for their deployment, and various documentation such as a description of features and improvements in the new software. |
| Unit Testing — Independent testing of the smallest units (module or object) of code by the developer. |
| Usability Testing — Testing to determine whether people can easily use something (such as web, computer, document or device) for its intended purpose. |
| User Guides — A document designed to assist the individual or organization that uses the system to perform specific functions. |
| Version Control — Provide a means to systematically retain chronological copies of revised programs and program documentation. |
| Version Description Document — Is how Source Code and Documentation Control (SCDC) Branch within the TAD organization performs version control and promotes software changes through the VDD build process. |
| Volume Testing — Determines the system's behavior under various workloads. |
| Web Testing — Is a computer-based test delivered via the internet and written in the "language" of the internet, HTML and possibly enhanced by scripts |