R

ROI: Return on Investment. A performance measure used to evaluate the efficiency of an investment or to compare the efficiency of a number of different investments. To calculate ROI, the benefit (return) of an investment is divided by the cost of the investment; the result is expressed as a percentage or a ratio.

                                                    (Gain from Investment - Cos of Investment)
                                         ROI = ---------------------------------------------
                                                                    Cost of Investment

Ramp Testing: Continuously raising an input signal until the system breaks down.

Random Testing: A Black-Box Testing approach in which software is tested by choosing an arbitrary subset of all possible input values. Random testing helps to avoid the problem of only testing what you know will work.

Re-testing: Testing that runs test cases that failed the last time they were run, in order to verify the success of corrective actions.

Recoverability: The capability of the software product to re-establish a specified level of performance and recover the data directly affected in case of failure.

Recovery Testing: The activity of testing how well the software is able to recover from crashes, hardware failures and other similar problems. Recovery testing is the forced failure of the software in a variety of ways to verify that recovery is properly performed.

Examples of recovery testing:

• While the application running, suddenly restart the computer and after the check the validness of application's data integrity.
• While application receives data from the network, unplug and then in some time plug-in the cable, and analyze the application ability to continue receiving of data from that point, when network connection disappeared.
• To restart the system while the browser will have definite number of sessions and after rebooting check, that it is able to recover all of them.

Recreation Materials: A script or set of results containing the steps required to reproduce a desired outcome.

Regression Testing: Any type of software testing which seeks to uncover regression bugs. Regression bugs occur whenever software functionality that previously worked as desired, stops working or no longer works in the same way that was previously planned. Typically regression bugs occur as an unintended consequence of program changes. Common methods of regression testing include re-running previously run tests and checking whether previously fixed faults have re-emerged.

Experience has shown that as software is developed, this kind of reemergence of faults is quite common. Sometimes it occurs because a fix gets lost through poor revision control practices (or simple human error in revision control), but often a fix for a problem will be "fragile" in that it fixes the problem in the narrow case where it was first observed but not in more general cases which may arise over the lifetime of the software. Finally, it has often been the case that when some features is redesigned, the same mistakes will be made in the redesign that were made in the original implementation of the feature.

Therefore, in most software development situations it is considered good practice that when a bug is located and fixed, a test that exposes the bug is recorded and regularly retested after subsequent changes to the program. Although this may be done through manual testing procedures using programming techniques, it is often done using Automated Testing Tools.

Such a 'test suite' contains software tools that allow the testing environment to execute all the regression test cases automatically; some projects even set up automated systems to automatically re-run all regression tests at specified intervals and report any regressions. Common strategies are to run such a system after every successful compile (for small projects), every night, or once a week. Those strategies can be automated by an external tool, such as TestDrive-Gold from Original Software.

Relational Operator: Conditions such as "is equal to" or "is less than" that link an attribute name with an attribute value in a rule's premise to form logical expressions that can be evaluated true or false.

Release Candidate: A pre-release version, which contains the desired functionality of the final version, but which needs to be tested for bugs (which ideally should be removed before the final version is released).

Release Note: A document identifying test items, their configuration, current status and other delivery information delivered by development to testing, and possibly other stakeholders, at the start of a test execution phase.

Reliability: The ability of the system/software to perform its required functions under stated conditions for a specified period of time, or for a specified number if operations.

Reliability Requirements: A specification of the required reliability for the system/software.

Reliability Testing: Testing to determine whether the system/software meets the specified reliability requirements.

Requirement: A capability that must be met or possessed by the system/software (requirements may be functional or non-functional).

Requirements-based Testing: An approach to testing in which test cases are designed based on test objectives and test conditions derived from requirements. For example: tests that exercise specific functions or probe non-functional attributes such as reliability or usability.

Result: The consequence or outcome of a test.

Review: A process or meeting during which a work product, or set of work products, is presented to project personnel, managers, users or other interested parties for comment or approval.

Risk: A chance of negative consequences.

Risk Management: Systematic application of procedures and practices to the tasks of identifying, analyzing, prioritizing, and controlling risk.

Robustness: The degree to which a component or system can function correctly in the presence of invalid inputs or stressful environmental conditions.

Root Cause: An underlying factor that caused a non-conformance and possibly should be permanently eliminated through process improvement.

Rule: A statement of the form: if X then Y else Z. The "if" part is the rule premise, and the "then" part is the consequent. The "else" component of the consequent is optional. The rule fires when the if part is determined to be true or false.

Rule Base: The encoded knowledge for an expert system. In a rule-based expert system, a knowledge base typically incorporated definitions of attributed and rules along with control information.