What is Orthogonal Array Testing (OATS)? (Tools, Techniques, Example)

Software TestingAutomation TestingTesting Tools

Test teams are frequently faced with the problem of how to properly test an application under short timeframes.

Exhaustive Testing becomes problematic in such situations, posing problems such as a huge number of Test Scripts to execute, how to prioritize the scripts, human error, and tiredness if too many scripts are done by the same individual, and so on.

As a result, Applied Statistics is utilized in the testing of an application in order to meet such problems. As a result, a larger range of test scripts may be run without affecting the test's quality or efficiency. The Orthogonal Array Testing approach, which will be explained in-depth in this article, is one of the most significant Applied Statistics procedures.

The reader will have a comprehensive knowledge of the implementation of Orthogonal Array Testing in their own application, as well as its benefits and application approach, at the end of this article.

Orthogonal Array Testing (OATS)?

The Orthogonal Array Testing methodology is a statistical method for examining pair-wise interactions. The majority of the flaws I've seen are the result of contact and integration.

This interaction or integration can occur inside various objects, components, options on an application page, or configuration settings in a file. The application functions as a consequence of such a combination of objects and components.

It is apparent that some of the combinations are not tested, resulting in inadequate testing. As a result, Orthogonal Array Testing is utilized to cover the complete functionality in the testing scope with the appropriate number of alternatives to be evaluated.

This is a Combinational Test Technique that ensures that the whole functionality of an application is evaluated with a restricted and proportionate number of combinations under test without sacrificing testing quality

The benefit of this method is that it maximizes coverage with a relatively small number of test cases. The identified pairs of parameters should be independent of one another. Because it is a black-box method, we do not need to understand the system's implementation, as we do with other BB techniques. The goal here is to find the appropriate pair of input parameters.

There are several CTD approaches, the most common of which being the OATS (Orthogonal Array Testing Technique).

What is the purpose of OAT (Orthogonal Array Testing)?

Due to the complexity of the code, providing a quality software product to the client has become difficult in the current situation.

Test suites in the traditional technique comprise test cases created from any combination of input values and pre-conditions. As a result, there must be a certain number of test cases covered.

However, in a real-world scenario, testers will not have the time to run all of the test cases to find all of the defects because there are other processes to consider during the testing phase, such as documentation, suggestions, and customer feedback

As a result, the test managers sought to optimize the quantity and quality of test cases to achieve maximum test coverage with little effort. This is referred to as Test Case Optimization.

  • A methodical and statistical approach to testing pairwise interactions

  • Interactions and integration points are significant sources of flaws.

  • Execute a set of well-defined, succinct test cases that are likely to find the majority (but not all) of the problems.

  • The orthogonal method ensures that all variables are covered pairwise.

OATS Implementation Methodology

The phases in the Orthogonal Array Testing method are as follows −

  • Determine how many variables will be evaluated for interaction. These variables should be mapped to the array's factors.

  • Determine the maximum number of possible values for each independent variable. These values should be mapped to the array's levels.

  • Select an orthogonal array that has the fewest number of runs. Various websites may be used to calculate the number of runs. Here is a link to one such website.

  • Create an array with the factors and levels.

  • Convert them into appropriate Test Cases.

  • Keep an eye out for any remaining or unique Test Cases (if any)

After completing the procedures above, your Array will be ready to test, covering all potential combinations.

How are OATs represented?

To compute, use the Orthogonal Array Testing (OAT) formula.

  • Runs (N) – The number of rows in the array, which corresponds to the number of test cases created.

  • Factors (K) – The array's number of columns, which corresponds to the maximum number of variables that may be handled.

  • Levels (V) - Maximum number of possible values for a single factor.

Two to three inputs are examined for each factor. The Levels are determined by the maximum number of inputs.


In many registration forms, such as first-time app installation or any other Government website, we submit our personal information such as Name, Age, Qualification, and so on.

The following is an example of such an application form. Consider the following scenario: there are four fields in a registration form (webpage) with specific sub-options.

Age range −

  • less than 18 years old

  • more than 18

  • More than 60

Gender fields are available.

  • Male

  • Female

  • NA

Highest Qualification −

  • High School

  • Graduation

  • Post-Graduation

Mother Tongue −

  • Hindi

  • English

  • Other

  • Step 1 − Determine the number of independent variables in Hindi and English. There are four independent variables (registration form fields) = four factors.

  • Step 2 − Establish the maximum number of possible values for each variable. There are three values (three sub-options in each field) = three levels.

  • Step 3 − Create an orthogonal array with four factors and three levels. Using the link, we calculated the number of rows needed, which is nine.

  • The orthogonal array follows the LRuns pattern (LevelsFactors). As a result, the Orthogonal Array in our case will be L9 (34).

RunsFactor 1Factor 2Factor 3Factor 4
Run 10000
Run 20121
Run 30212
Run 41022
Run 51110
Run 61201
Run 72011
Run 82102
Run 92220
  • Step 4 − Map the produced Array's Factors and Levels.

  • AGE will take the place of "Factor 1."

    Gender will take the place of "Factor 2."

    The highest Qualification will take the place of "Factor 3."

    Mother Tongue will take the place of "Factor 4."

    Each sub-option under their respective Factor will replace 0, 1, 2. (field).

    The Orthogonal Array will look like this once you've mapped the Factors and Levels −

RunAgeGenderHigher QualificationMother Tongue
Run 1Less than 18MaleHigh SchoolHindi
Run 2Less than 18FemalePost-GraduationEnglish
Run 3Less than 18NAGraduationOther
Run 4More than 18MalePost-GraduationOther
Run 5More than 18FemaleGraduationHindi
Run 6More than 18NAHigh SchoolEnglish
Run 7More than 60MaleGraduationEnglish
Run 8More than 60FemaleHigh SchoolOther
Run 9More than 60NAPost-GraduationHindi
  • Step 5 − Each Run in the above table indicates a test case that will be addressed during the testing process. A test condition is added to each run.

Advantages of OAT

  • Ensures that all pair-wise combinations of the chosen variables are tested.

  • The number of test cases is reduced.

  • Reduces the number of test cases required to cover all possible combinations of variables

  • It is possible to create a complicated combination of variables.

  • Is easier to produce and less prone to errors than test sets made by hand.

  • Integration Testing is a good application of it.

  • Reduced test cycles and testing periods increase productivity.

OATS' Limitations

There is no way to ensure 100 percent coverage with any of the testing methods. Each methodology has its method for determining test conditions. In a similar vein, there are several drawbacks to utilizing this method −

  • If we don't identify the good pairings, the testing will fail.

  • Probability of failing to recognize the most significant combination, resulting in the loss of a defect.

  • If we don't know the interactions between the pairings, this approach will fail.

  • This method alone will not provide comprehensive coverage.

  • It can only identify faults that occur as a result of pairs as input parameters.

Errors or mistakes made during the OAT

  • The focus of the testing effort should not be on the incorrect part of the application.

  • Picking the wrong parameters to combine is a big no-no.

  • If you only want to test a few things, avoid utilizing Orthogonal Array Testing.

  • Manually doing Orthogonal Array Testing

  • For high-risk applications, Orthogonal Array Testing is used.


Orthogonal Array testing is a method of assessing pair-wise interactions that is systematic and statistical. Small groups of test cases are derived from a large number of situations, and elements and levels that appear numerous times in the combinatorial outputs are given priority.

Orthogonal Array testing may be used in our day-to-day application testing by −

  • Creating statistical pair-wise combinations of components across their levels in a methodical way.

  • Creating a test suite that uses fewer test scenarios and generates negative test case optimization.

  • All single, double, and triple mode faults in the supplied input combinations are detected.

  • Executing a small set of tests and finding the majority of the problems.

Now that you've mastered the implementation of Orthogonal Array testing, you can quickly include it into your application or webpage, covering all elements of the program's functioning in a small number of test cases.

Updated on 24-Sep-2021 08:34:25