Распараллеливание тестов Selenium+TestNG(Junit)

Распараллеливание тестов Selenium+TestNG(Junit)

Думаю полезность распараллеливаня тестов вполне понятна,тесты которые выполняются последовательно около 20 минут, в несколько потоков выполнятся быстрее в разы.

Я покажу как это сделать при помощи TestNG(и Junit)+Maven+SeleniumWD.

Допустим у нас есть 2 теста (не прикапываемся к написанию,это для примера)

  @Test
    public void testRobert() throws Exception {
       driver.get("http://google.ru");
       driver.findElement(By.name("q")).sendKeys("Роберт");
       driver.findElement(By.id("gbqfb")).click();
       driver.findElement(By.linkText("Роберт — Википедия")).click();
    }
    @Test
    public void testPolson() throws Exception {
        driver.get("http://google.ru");
        driver.findElement(By.name("q")).sendKeys("Полсон");
        driver.findElement(By.id("gbqfb")).click();
        driver.findElement(By.linkText("Полсон, Генри — Википедия")).click();
    }

Если решим распараллелить их через TestNG,то добавим методы выполняющиеся перед и после каждого теста.

 
@BeforeMethod
 public void setUp() throws Exception {
  driver = new FirefoxDriver();

 } 
@AfterMethod
 public void tearDown() throws Exception {
  driver.quit();
  }
 }

И  testng.xml делаем такого вида:

Теперь собственно сам запуск.
1.Через Maven:

  

            
                org.apache.maven.plugins
                maven-surefire-plugin
                2.12.3
                
                    
                        TestNG.xml
                    
                
            
        

2.Через Java код:

 TestNG testng = new TestNG();
        List suites = Lists.newArrayList();
        suites.add("TestNG.xml");
        testng.setSuiteThreadPoolSize(2);
        testng.setTestSuites(suites);
        testng.run();

Если используем Junit, то в Maven указываем:

  
     
                org.apache.maven.plugins
                maven-surefire-plugin
                2.12.4
                
                    methods
                    2
                
                
                    
                        org.apache.maven.surefire
                        surefire-junit47
                        2.12.4
                    
                
            

 Сравним результаты:
Без распараллеливания

При распараллеливании:

Результат очевиден.

Вот собственно и все. Наслаждаемся скоростью.

Техники тестирования

Техники тестирования

Техники, базирующиеся на интуиции и опыте тестировщика (Based on the software engineer’s intuition and experience)

Специализированное тестирование (Ad hoc testing)
Возможно, наиболее широко практикуемая техника. Тесты основываются на опыте, интуиции и знаниях инженера, рассматривающего проблему с точки зрения имевшихся ранее аналогий. Данный вид тестирования может быть полезен для идентификации тех тестов, которые не охватываются рассматривавшимеся выше более формализованными техниками.
Исследовательское тестирование (Exploratory testing)
Такое тестирование определяется как одновременное обучение, проектирование теста и его исполнение. Данный вид тестирования заранее не определяется в плане тестирования и такие тесты создаются, выполняются и модифицируются динамически, по мере необходимости. Эффективность исследовательских тестов напрямую зависит от знаний инженера, формируемых на основе поведения тестируемого продукта в процессе проведения тестирования, степени знакомства с приложением, платформой, типами возможных сбоев и дефектов, рисками, ассоциированными с конкретным продуктом и т.п.

Техники, базирующиеся на спецификации (Specification-based techniques)

Эквивалентное разделение (Equivalence partitioning)
Рассматриваемая область приложения разделяется на коллекцию наборов или эквивалентных классов, которые считаются эквивалентными с точки зрения рассматриваемых связей и характеристик <спецификации>. Репрезентативный набор тестов (иногда – только один тест) формируется из тестов эквивалентных классов (или наборов классов).
Анализ граничных значений (Boundary-value analysis)
Тесты строятся с ориентацией на использование тех величин, которые определяют предельные характеристики тестируемой системы. Расширением этой техники являются тесты оценки живучести (robustness testing) системы, проводимые с величинами, выходящими за рамки специфицированных пределов значений.
Таблицы принятия решений (Decision table)
Такие таблицы представляют логические связи между условиями (могут рассматриваться в качестве “входов”) и действиями (могут рассматриваться как “выходы”). Набор тестов строится последовательным рассмотрением всех возможных кросс-связей в такой таблице.
Тесты на основе конечного автомата (Finite-state machine-based)
Строятся как комбинация тестов для всех состояний и переходов между состояниями, представленных в соответствующей модели (переходов и состояний приложения).
Случайное тестирование (Random testing)
В отличие от статистического тестирования, сами тесты генерируются случайным образом по списку заданного набора специфицированных характеристик.

Техники, ориентированные на код (Code-based techniques)

Тесты, базирующиеся на блок-схеме (Control-flow-based criteria)
Набор тестов строится исходя из покрытия всех условий и решений блок-схемы. В какой-то степени напоминает тесты на основе конечного автомата. Отличие – в источнике набора тестов.
Максимальная отдача от тестов на основе блок-схемы получается когда тесты покрывают различные пути блок-схемы – по-сути, сценарии потоков работ (поведения) тестируемой системы. Адекватность таких тестов оценивается как процент покрытия всех возможных путей блок-схемы.
Тесты на основе потоков данных (Data-flow-based criteria)
В данных тестах отслеживается полный жизненный цикл величин (переменных) – с момента рождения (определения), на всем протяжении использования, вплоть до уничтожения (неопределенности). В реальной практике используются нестрогое тестирование такого вида, ориентированное, например, только на проверку задания начальных значений всех переменных или всех вхождений переменных в код, с точки зрения их использования.
Ссылочные модели для тестирования, ориентированного на код (Reference models for code-based testing – flowgraph, call graph)
Является не столько техникой тестирования, сколько контролем структуры программы, представленной в виде дерева вызовов (например, sequence-диаграммы, определенной в нотации UML и построенной на основе анализа кода).

Тестирование, ориентированное на дефекты (Fault-based techniques)

Как это ни странно звучит на уровне названия таких техник тестирования, они, действительно, ориентированы на ошибки. Точнее – на специфические категории ошибок.

Предположение ошибок (Error guessing)
Направлены на обнаружение наиболее вероятных ошибок, предсказываемых, например, в результате анализа рисков.
Тестирование мутаций (Mutation testing)
Мутация – небольшое изменение тестируемой программы, произошедшее за счет частных синтаксических изменений кода (в частности, рефакторинга). Соответствующие тесты запускаются для оригинального и всех “мутировавших” вариантов тестируемой программы.
SWEBOK фокусируется на возможности, с помощью тестов, определять отличия между мутантами и исходным вариантом кода. Если такое отличие установлено, мутанта “убивают”, а тест считается успешным. Обычно, данный подход фокусируется на синтаксических ошибках, на практике отслеживаемых современными средами разработки и, конечно, компиляторами.

MindMap:Testing in Production.

MindMap:Testing in Production.

Полезный MindMap- тут нечего добавить.
Вот оригинал http://www.ministryoftesting.com/2012/08/mindmap-testing-in-production/

AllPairs Algorithm

Pairwise testing. Part 2 - AllPairs Algorithm.

Вступление.

Прошлым постом мы разобрались что такое попарное тестирование и тестирование ортогональными массивами. Теперь пришел черед allpairs algorithm. Эта комбинаторная техника была специально создана для попарного тестирования. Суть ее состоит в выборе таких комбинаций переменных, чтобы существовали все возможные комбинации значений каждой пары переменных.
Примечание: настоятельно рекомендуется перед изучением allpairs algorithm прочитать прошлый пост -orthogonal array testing.

Подход

Будем разбирать Allpairs algorithm сразу на примерах.

Начнем фантазировать. Представим что у нас есть формочка, на которой:
 * Есть список - Может принимать значение от 0 до 9 включительно.
 * Есть поле ввода - может принимать целочисленные значения от 1 до 99 включительно.
 * Есть чекбокс1 - принимает значения on или off.
 * Есть чекбокс2 - принимает значения on или off.
Сколько всего возможных комбинаций мы имеем? 99*10*2*2 = 3,960 возможных, валидных комбинаций. Тут нам придется либо умереть собственной смертью в попытках протестировать все комбинации, либо каким то способом уменьшить количество нужных нам комбинаций. Allpairs algorithm как раз и есть такой комбинаторный способ.

Суть Allpairs algorithm заключается в том, что мы не будем тестировать на всех комбинациях значений для всех переменных, а только все комбинации значений каждой пары переменных.

Ну приступим. Как всегда, для начала, нам нужно определить какое количество входных параметров(переменных) у нас есть, и какие значения может принимать каждый входной параметр.

List	TextBox	Checkbox1	Checkbox2
0	1	on	on
1	2	off	off
2	3
3	4
4	...
5	96
6	97
7	98
8	99
9

Если можно упростить значения переменных, то обязательно это делаем. Например, поле ввода может принимать значения от 1 до 99. Понимая бизнес логику приложения мы можем разбить значения 1 до 99 на классы эквивалентности и использовать уже их как возможные значения для комбинаторики. Либо можем использовать технику граничных значений.

Как бы там ни было, в нашем сказочном примере, для простоты, уменьшим количество возможных значений до 3х - валидное целочисленое значение, невалидное целочисленое значение, символы.

Ну и давайте уменьшим количество возможных значений для списка до 2х - 0 и любое другое значение.

Теперь наши входные данные выглядят так:

List	TextBox	Checkbox1	Checkbox2
0	Valid int	on	on
any other	Invalid int	off	off
	Alpha chars

Магичесий момент. Поменяем порядок столбцов таблицы так, чтобы переменная с наибольшим количеством значений была первой, а с наименьшим количеством значений последней.

TextBox(3)

List(2)

Checkbox1(2)

Checkbox2(2)

Кажется пора начинать заполнять таблицу. Каждая строка таблицы будет представлять уникальный набор входных данных для теста. Внимательно, полностью сконцентрировавшись и отбросив все задние мысли смотрим сколько значений может принимать переменная второго столбца (список). Ага, 2 значения. Значит столько раз нужно вставить все значения первого столбца.

TextBox(3)	List(2)	Checkbox1(2)	Checkbox2(2)
Valid Integer
Valid Integer
.
Invalid Integer
Invalid Integer
.
Alpha chars
Alpha chars

Мы вставили 6 строк. 3 возможных значения поля ввода (а т.е. первого столбца) значения повторяются дважды. Так же мы пропустили по строке после каждого дубля значения - это  важно, эпический момент, окутанный загадкой - дальше это нам понадобится.

Заполняем второй столбец. Для каждого дубля значений столбца 1 мы заполняем оба значения столбца 2.

TextBox(3)	List(2)	Checkbox1(2)	Checkbox2(2)
Valid Integer	0
Valid Integer	other
.
Invalid Integer	0
Invalid Integer	other
.
Alpha chars	0
Alpha chars	other

Пока все хорошо, у нас вышли все возможные комбинации пар значений первой и второй переменной. Думаю стоит продолжить заполнять таблицу :). Третья переменная может принимать 2 значения - on и off. Для каждого дубля значений столбца 1 мы заполняем оба значения столбца 3.

TextBox(3)	List(2)	Checkbox1(2)	Checkbox2(2)
Valid Integer	0	on
Valid Integer	other	off
.
Invalid Integer	0	on
Invalid Integer	other	off
.
Alpha chars	0	on
Alpha chars	other	off

Проверяем. Есть ли все возможные комбинации значений между 1ым и 2ым столбцом? Есть. Есть все возможные комбинации значений между вторым и третьим столбцом? Нет, у нас нет комбинации {0,off} и {other, on}.

TextBox(3)	List(2)	Checkbox1(2)	Checkbox2(2)
Valid Integer	0	on
Valid Integer	other	off
.
Invalid Integer	0	off
Invalid Integer	other	on
.
Alpha chars	0	on
Alpha chars	other	off

О, вот теперь намного лучше. Теперь у нас есть и все возможные комбинации значений 1ой, 2ой и 3ей переменной. Давайте разбираться с 4ой переменной - чекбокс2. Чекбокс2 тоже может иметь 2 возможных значнеия. Нам нужно подставить в таблицу эти значения так, чтобы все возможные комбинации значений каждой пары переменных существовали. Пробуем.

TextBox(3)	List(2)	Checkbox1(2)	Checkbox2(2)
Valid Integer	0	on	Checked
Valid Integer	other	off	Unchecked
.
Invalid Integer	0	off	Checked
Invalid Integer	other	on	Unchecked
.
Alpha chars	0	on	Unchecked
Alpha chars	other	off	Checked

Проверяем. Есть все возможные комбинации первого и четвертого столбца? Есть. Есть все возможные комбинации второго и четвертого столбца? Есть. Неплохо. Есть все возможные комбинации третьего и четвертого столбца? Еcть. Отлично, мы справились в 6 тест кейсов, когда всего существует 24 возможных комбинации.

Но зачем мы оставили пустые строки? Для того чтобы это понять нам нужно усложнить пример. Добавим еще 2 чекбокса (2 бинарных входных параметра) - чекбокс3 и чекбокс4. Продолжим строить тестовые данные на основе allpairs algorithm. Добавляем значения для 5ого столбца.

TextBox(3)	List(2)	Checkbox1(2)	Checkbox2(2)	Checkbox3(2)	Checkbox4(2)
Valid Integer	0	on	Checked	Yes
Valid Integer	other	off	Unchecked	No
.
Invalid Integer	0	off	Checked	No
Invalid Integer	other	on	Unchecked	Yes
.
Alpha chars	0	on	Unchecked	No
Alpha chars	other	off	Checked	Yes

Проверяем свежезаполненый 5ый столбец по отношению к остальным столбцам поочереди:
 * к первому - все ок. Все комбинации значений есть.
 * к второму - все ок. Все комбинации значений есть.
 * к третьему - все ок. Все комбинации значений есть.
 * к четвертому - все ок. Все комбинации значений есть.

Что ж, заполним последнюю колонку значениями.

TextBox(3)	List(2)	Checkbox1(2)	Checkbox2(2)	Checkbox3(2)	Checkbox4(2)
Valid Integer	0	on	Checked	Yes	1
Valid Integer	other	off	Unchecked	No	2
.
Invalid Integer	0	off	Checked	No	2
Invalid Integer	other	on	Unchecked	Yes	1
.
Alpha chars	0	on	Unchecked	No	1
Alpha chars	other	off	Checked	Yes	2

Проверяем свежак - 5ый столбец по отношению к остальным столбцам по очереди:
 * к первому - все ок. Все комбинации значений есть.
 * к второму - все ок. Все комбинации значений есть.
 * к третьему - есть проблемы. У нас есть комбинации значений On/1 и Off/2, но нет {On, 2} и {Off, 1}.
 * к четвертой - все ок. Все комбинации значений есть.
 * к пятой - все ок. Все комбинации значений есть.

Вот тут нам и понадобятся наши загадочные пустые строки. Добавляем не хватающие комбинации 3его и 6ого столбцов.

TextBox(3)	List(2)	Checkbox1(2)	Checkbox2(2)	Checkbox3(2)	Checkbox4(2)
Valid Integer	0	on	Checked	Yes	1
Valid Integer	other	off	Unchecked	No	2
.
Invalid Integer	0	off	Checked	No	1
Invalid Integer	other	on	Unchecked	Yes	2
.
Alpha chars	0	on	Unchecked	No	2
Alpha chars	other	off	Checked	Yes	1

Остальные значения переменных для добавленных строк выберем любые, ибо все комбинации значений каждой пары у нас уже есть.

TextBox(3)	List(2)	Checkbox1(2)	Checkbox2(2)	Checkbox3(2)	Checkbox4(2)
Valid Integer	0	on	Checked	Yes	1
Valid Integer	other	off	Unchecked	No	2
Invalid Integer	other	on	checked	yes	2
Invalid Integer	0	off	Checked	No	1
Invalid Integer	other	on	Unchecked	Yes	2
invalid integer	other	off	unchecked	No	1
Alpha chars	0	on	Unchecked	No	2
Alpha chars	other	off	Checked	Yes	1

Всё готово, мы закончили. Итого 8 комбинаций вместо 96.

Заимствованно с http://w1zle.blogspot.ru

Orthogonal Arrays

Pairwise testing. Part 1 - Orthogonal Arrays

Вступление


Рассмотрим следующие ситуации:

 1. Сайт должен работать в 8 браузерах - Internet Explorer 6, 7, и 8, Netscape 6.0 и 7.0, Mozilla 2 и 3, и Opera 9; используя плагины - RealPlayer, MediaPlayer, без плагинов; на ОС - Windows  NT, 2003, XP, vista, 2008 и seven; на разных веб серверах - IIS, Apache, и WebLogic; запущенных на сервере с разными ОС - Windows 2003, 2008 и Linux.
  * 8 бразуеров
  * 3 плагина
  * 6 ОС клиента
  * 3 веб сервера
  * 3 ОС сервера
Итого: 1,296 возможных комбинаций.

 2. Банк создал новую систему обработки данных. У этого банка есть разные клиенты - очень важные клиенты, юр. лица и физ. лица; различные виды счетов - сберегательные, ипотечные кредиты, потребительские кредиты, и коммерческие кредиты; плюс отделения банка работают в разных штатах, с разной спецификой проведения фин. операций - Калифорния, Невада, Юта, Айдахо, Аризона и Нью-Мехико.
 * 4 типа клиентов
 * 5 типов аккаунтов
 * 6 штатов
Итого: 120 комбинаций.

 3. В ООП приложении, объект класса "А" может передать параметром объект класса "P", объекту класса "X". Классы B,C,и D унаследованы от класса A, и тоже могут передавать данные. Классы Q, R, S и T унаследованы от класса P и могут быть переданы как данные. Классы Y и Z унаследованы от класса X и могут получать данные.
 * 4 классов отправителя
 * 5 классов данных
 * 3 класса приемника.
Итого: 60 комбинаций.


Что общего у этих примеров? В каждом случае мы имеем большое количество комбинаций, которые необходимо протестировать, причем не тестировать какие то комбинации выглядит рискованно. Но количество комбинаций настолько велико, что скорее всего у нас не хватит ресурсов, чтобы спроектировать и пройти тест кейсы. Поэтому, учитывая наши ограниченные ресурсы, каким то магическим образом, мы должны отобрать только часть комбинаций. Pairwise testing и есть этот магический способ.

В чём заключается магия выбора комбинаций Pairwise testing? Не следует пытаться проверить все комбинации значений для всех переменных, а проверять комбинации пар значений переменных(пока наверно не сильно понятно, но это ничего :)). Эта техника существенно уменьшает количество комбинаций для тестирования.
Например:
 * Если приложение имеет 4 разных входных параметра, и каждый из этих параметров может принимать 3 различных значения, то количество комбинаций будет 3 в 4 степени, а т.е. 81 комбинация. Попарно (pairwise), можно покрыть все входные значения за 8 тест кейсов.
 * Если приложение имеет 13 разных входных параметров, и каждый из этих параметров может принимать 3 различных значения, то количество комбинаций будет 3 в 13 степени, а т.е. 1 594 323 комбинаций. Попарно, можно покрыть все входные значения за 15 тест кейсов.
 * Если приложение имеет 20 разных входных параметров, и каждый из этих параметров может принимать 10 различных значения, то количество комбинаций будет 20 в 10 степени. Попарно, можно покрыть все входные значения за 180 тест кейсов.

Несколько исследований о pairwise testing:
 * Исследование, опубликованное Brownlie of AT&T в отношении тестирования local-area network-based electronic mail system гласит, что применение pairwise testing обнаружило на 28% дефектов больше, чем их оригинальный план разработки и выполнения 1 500 тест кейсов (позже количество тест кейсов было сокращено до 1 000 из-за временных ограничений), и заняло на 50% меньше ресурсов.
 * Kuhn и Reilly проанализированы недостатки, записанные в базе данных браузера Mozilla. Они определили, что pairwise testing обнаружили бы 76% найденных ошибок.
 * Wallace и Kuhn опубликовали исследование, проведенное Национальным институтом стандартов и технологий над ошибками ПО в отозванных мед. устройствах, собиравшимися на протяжении 15 лет. Они пришли к выводу, что 98% дефектов могли быть обнаружены с помощью pairwise testing. Т.е., по этой статистике, 98% ошибок возникают при конфликте ПАР входных данных или неверной интерпретацией 1 входного параметра системой, что pairwise testing покрывает. Еще раз, ошибки источником которых является комбинация 3х конкретных входных параметров составляет 2%.

Почему pairwise testing так хорошо работает? Неизветсно. В любом случае, успех применения этой техники на многих проектах является отличной мотивацией для ее использования.

Pairwise testing основывается на orthogonal arrays или the Allpairs algorithm. В этом посте будем рассматривать pairwise testing на основе orthogonal arrays.



Orthogonal Arrays

Сколько комбинаций существует для пары значений "1" и "2"? {1,1}, {1,2}, {2,1} и {2,2}. Ортогональный массив - это 2х мерный массив, с таким интересным свойством - выберите любые 2 столбца массива и найдете в них все комбинации значений этих столбцов. Т.е. если мы возьмем 2 столбца из ортогонального массива, в которых могут быть значения только "1" или "2", то найдем следующие строки для этих столбцов - {1,1}, {1,2}, {2,1} и {2,2}.

Например, у нашего приложения 3 входных параметра, причем каждый бинарный (принимает значение "1" или "2"). Все возможные комбинации входных данных:

#строки	Переменная 1	Переменная 2	Переменная 3
1	1	1	1
2	2	1	1
3	1	2	1
4	1	1	2
5	2	2	1
6	1	2	2
7	2	1	2
8	2	2	2

А ортогональный массив для этих данных будет выглядеть так:

# строки	Переменная 1	Переменная 2	Переменная 3
1	1	1	1
2	1	2	2
3	2	1	2
4	2	2	1

Возьмем столбец 1 и 3, и посмотрим, есть ли в них все комбинации этих столбцов (значения {1,1}, {1,2}, {2,1} и {2,2}) - да, есть. Возьмем столбец 1 и 2, и посмотрим, есть ли в них все комбинации значений этих столбцов (опять же значения {1,1}, {1,2}, {2,1} и {2,2}) - да есть. Возьмем столбец 2 и 3, и посмотрим, есть ли есть ли в них все комбинации значений этих столбцов ({1,1}, {1,2}, {2,1} и {2,2}) - да есть. Это ортогональный массив. Записывается он в таком виде - L₄(2³), где L₄ означает, что ортогональный массив с 4 строками, а (2³) - это не степень, это означает, что у массива 3 столбца, в котором значения могут быть "1" или "2".

Давайте возьмем ортогональный массив побольше. Допустим у нас есть 5 входных данных, каждое может принимать значения "1", "2" или "3". Как много существует пар для значений"1", "2" и "3"? {1,1}, {1,2}, {1,3}, {2,1}, {2,2}, {2,3}, {3,1}, {3,2}, и {3,3}. Рассмотрим L₉(3⁵) ортогональный массив:

# строки	переменная 1	переменная 2	переменная 3	переменная 4	переменная5
1	1	1	1	1	1
2	1	2	3	3	1
3	1	3	2	3	2
4	1	2	2	1	3
5	1	3	1	2	3
6	1	1	3	2	2
7	2	2	2	2	2
8	2	3	1	1	2
9	2	1	3	1	3
10	2	3	3	2	1
11	2	1	2	3	1
12	2	2	1	3	3
13	3	3	3	3	3
14	3	1	2	2	3
15	3	2	1	2	1
16	3	1	1	3	2
17	3	2	3	1	2
18	3	3	2	1	1

Примечание: Всего возможных комбинаций в этом случае 243.
Можете проверить - взяв любые 2 столбца вы найдете в них все возможные значения пар значений - {1,1}, {1,2}, {1,3}, {2,1}, {2,2}, {2,3}, {3,1}, {3,2}, и {3,3}.

Вернемся к определению ортогональных массивов:
Ортогональный массив - это 2х мерный массив, с таким интересным свойством - выберите любые 2 столбца массива и найдете в них все комбинации значений этих столбцов.

Это определение не полное. Массив содержит не только все комбинации значений 2х столбцов. Если какая то пара значений  2х столбцов встречается несколько раз, то все возможные парные комбинации значений этих столбцов должны встретится столько же раз. Это происходит потому что ортогональный массив должен быть сбалансирован. Посмотрите на столбцы 3 и 5 - найдите комбинацию (3,2). Эта комбинация встречается в строках 6 и 17. Значит для этих столбцов, все возможные комбинации значений( а это {1,1}, {1,2}, {1,3}, {2,1}, {2,2}, {2,3}, {3,1}, {3,2}, и {3,3}) встретятся дважды.

В ортогональных массивах необязательно все столбцы должны иметь одинаковое количество значений. Существуют смешанные (mixed) ортогональные массивы. Следующий массив - смешанный ортогональный массив L₁₈(2¹3⁷). У него 2 столбца со значениями "1" и "2" и 7 столбцов со значениями "1", "2", "3".

# строки	1	2	3	4	5	6	7	8
1	1	1	1	1	1	1	1	1
2	1	1	2	2	2	2	2	2
3	1	1	3	3	3	3	3	3
4	1	2	1	1	2	2	3	3
5	1	2	2	2	3	3	1	1
6	1	2	3	3	1	1	2	2
7	1	3	1	2	1	3	2	3
8	1	3	2	3	2	1	3	1
9	1	3	3	1	3	2	1	2
10	2	1	1	3	3	2	2	1
11	2	1	2	1	1	3	3	2
12	2	1	3	2	2	1	1	3
13	2	2	1	2	3	1	3	2
14	2	2	2	3	1	2	1	3
15	2	2	3	1	2	3	2	1
16	2	3	1	3	2	3	1	2
17	2	3	2	1	3	1	2	3
18	2	3	3	2	1	2	3	1

Важно: не бойтесь, вам  не придется самостоятельно создавать ортогональные массивы, только если вы этого сами не захотите :). Есть гора тулзов, которые создадут вам ортогональные массивы для ваших нужд. Например веб тулза http://www.testersdesk.com/pairwse_testersdesk.html (требует регистрации для использования).

Использование ортогональных массивов

 1. Определите переменные (кол-во входных данных)
   Важно: необходимо выбирать входные данные, любые комбинации значений которых, могут логически существовать. Например, если нам нужно проверить на браузерах: IE и FF, и операционных системах Linux и Windows, то мы явно не сможем проверить работу сайта под линухом в IE (ну или это лишено логического смысла). В этом случае необходимо сделать 2 ортогональных массива с браузерами для линуха и windows.

 2. Определите количество значений, которое может принимать каждая переменная (каждый входнной данный :))
  Важно: К моменту определения количества значений вы уже должны применить всевозможные техники тест дизайна для уменьшения количества значений - классы эквивалентности, граничные значения и др. Например, если переменная может принимать значения от 1 до 100, то ортогональный массив, в котором 1 столбец может принимать 100 значений очень существенно разрастется, по сравнению с ортогональным массивом, где вы разбили 100 значений на классы эквивалентности и теперь эта переменная может принимать, скажем, 5 значений - 5 диапазонов классов эквивалентности.

 3. Определите ортогональный массив, у которого будет столбец для каждой переменной (каждый столбец ортогонального массива имеет столько же вариантов значений, сколько имеет ваша переменная).

 4. Спроецируйте (map) задачу тестирования на ортогональный массив.
   Важно: шаги 3 и 4 успешно делают различные утилиты, например как http://www.testersdesk.com/pairwse_testersdesk.html. Вам всего лишь нужно вбить в нее какие входные данные могут быть, например так:
Journey mode: Return trip, One way
Preferred time: Morning, Afternoon, Evening, Late night
Leaving from: Type1_City,Type2_City,Type3_City
Going to: Type1_City,Type2_City,Type3_City
Booking type: Economy, First class
Customer type: Registered, New
Adults: 1, 2, 3, 4, 5, 6
Children: 0, 1, 2, 3, 4
Все остальное утилита сделает сама и вам останется перейти к 5 шагу.

 5. Постройте тест кейсы.

Перейдем наконец к примеру.
Сайт должен работать в 8 браузерах - Internet Explorer 5.0, 5.5, и 6; Netscape 6.0, 6.1 и 7.0; Mozilla 1.1;  Opera 7; используя плагины - RealPlayer, MediaPlayer, без плагинов; на ОС - Windows 95, 98, ME, NT, 2000, и XP; на разных веб серверах - IIS, Apache, и WebLogic; запущенных на сервере с разными ОС - Windows NT, 2000, и Linux.

1. Определите переменные (кол-во входных данных)
  * бразуеры
  * плагины
  * ОС клиента
  * веб сервера
  * ОС сервера
2. Определите количество значений, которое может принимать каждая переменная
  * 8 бразуеров - Internet Explorer 5.0, 5.5, and 6.0, Netscape 6.0, 6.1, and 7.0, Mozilla 1.1, and Opera 7.
  * 3 плагина - RealPlayer, MediaPlayer, без плагинов.
  * 6 ОС клиента - Windows 95, 98, ME, NT, 2000, and XP.
  * 3 веб сервера - IIS, Apache, и WebLogic..
  * 3 ОС сервера - Windows NT, 2000, and Linux..
3. Определите ортогональный массив, у которого будет столбец для каждой переменной.
Какой размер нам нужен? Для начала, ортогональный массив должен быть с 5 столбцами, каждый столбец для каждой переменной. Первый столбец должен принимать значения от 1 до 8 - браузеры. Второй столбец должен принимать значения от 1 до 3 - плагины. Третий столбец должен принимать значения от 1 до 6 - ОС клиента. Четвертый и пятный столбцы должны принимать значения от 1 до 3 - веб сервера и ОС сервера.

Итого нам нужен массив 8¹6¹3³. К сожалению, такого ортогонального массива не существует. Но существует ортогональный массив 8²4³, который нам подходит. Да да, подходит. Вот смотрите. Мы заменили колонки 8¹ и 6¹ на 8², а 3³ заменили на 4³.

Вы наверное скажите - у нас же 3 разных плагина, 3 веб сервера, 3 ОС сервера, где мы возьмем каждой переменной по еще одному значению? Ответ прост. Когда сформируется ортогональный массив, мы не существующие (лишние) значения просто заменим на любые валидные для переменной. Удалить строки с несуществующими значениями мы не можем - таким образом мы уничтожим баланс пар в ортогональном массиве. Поэтому просто заменим лишнее значение переменной любым валидным значениям. Давайте смотреть на примере.

Вот наш ортогональный массив 8²4³:

# строки	1	2	3	4	5
1	1	1	1	1	1
2	1	4	3	4	4
3	1	4	2	4	4
4	1	1	4	1	1
5	1	3	5	3	3
6	1	2	7	2	2
7	1	2	6	2	2
8	1	3	8	3	3
9	3	4	1	3	3
10	3	1	3	2	2
11	3	1	2	2	2
12	3	4	4	3	3
13	3	2	5	1	1
14	3	3	7	4	4
15	3	3	6	4	4
16	3	2	8	1	1
17	2	3	1	2	1
18	2	2	3	3	4
19	2	2	2	3	4
20	2	3	4	2	1
21	2	1	5	4	3
22	2	4	7	1	2
23	2	4	6	1	2
24	2	1	8	4	3
25	4	2	1	4	3
26	4	3	3	1	2
27	4	3	2	1	2
28	4	2	4	4	3
29	4	4	5	2	1
30	4	1	7	3	4
31	4	1	6	3	4
32	4	4	8	2	1
33	5	2	1	4	2
34	5	3	3	1	3
35	5	3	2	1	3
36	5	2	4	4	2
37	5	4	5	2	4
38	5	1	7	3	1
39	5	1	6	3	1
40	5	4	8	2	4
41	7	3	1	2	4
42	7	2	3	3	1
43	7	2	2	3	1
44	7	3	4	2	4
45	7	1	5	4	2
46	7	4	7	1	3
47	7	4	6	1	3
48	7	1	8	4	2
49	6	4	1	3	2
50	6	1	3	2	3
51	6	1	2	2	3
52	6	4	4	3	2
53	6	2	5	1	4
54	6	3	7	4	1
55	6	3	6	4	1
56	6	2	8	1	4
57	8	1	1	1	4
58	8	4	3	4	1
59	8	4	2	4	1
60	8	1	4	1	4
61	8	3	5	3	2
62	8	2	7	2	3
63	8	2	6	2	3
64	8	3	8	3	2

Сформировали, пора переходит к четвёртому шагу.

 4. Спроецируйте задачу тестирования на ортогональный массив.
Значения браузера у нас проецируются на первый столбец ортогонального массива:
 1 = Internet Explorer 6
 2 = Internet Explorer 7
 3 = Internet Explorer 8
 4 = Netscape 6
 5 = Netscape 7
 6 = Mozilla 2
 7 = Mozilla 3
 8 = Opera 9

Заменим значения ортогонального массива на версии браузеров:

# строки	Browser	2	3	4	5
1	IE 5.0	1	1	1	1
2	IE 5.0	4	3	4	4
3	IE 5.0	4	2	4	4
4	IE 5.0	1	4	1	1
5	IE 5.0	3	5	3	3
6	IE 5.0	2	7	2	2
7	IE 5.0	2	6	2	2
8	IE 5.0	3	8	3	3
9	IE 6.0	4	1	3	3
10	IE 6.0	1	3	2	2
11	IE 6.0	1	2	2	2
12	IE 6.0	4	4	3	3
13	IE 6.0	2	5	1	1
14	IE 6.0	3	7	4	4
15	IE 6.0	3	6	4	4
16	IE 6.0	2	8	1	1
17	IE 5.5	3	1	2	1
18	IE 5.5	2	3	3	4
19	IE 5.5	2	2	3	4
20	IE 5.5	3	4	2	1
21	IE 5.5	1	5	4	3
22	IE 5.5	4	7	1	2
23	IE 5.5	4	6	1	2
24	IE 5.5	1	8	4	3
25	Net 6.0	2	1	4	3
26	Net 6.0	3	3	1	2
27	Net 6.0	3	2	1	2
28	Net 6.0	2	4	4	3
29	Net 6.0	4	5	2	1
30	Net 6.0	1	7	3	4
31	Net 6.0	1	6	3	4
32	Net 6.0	4	8	2	1
33	Net 6.1	2	1	4	2
34	Net 6.1	3	3	1	3
35	Net 6.1	3	2	1	3
36	Net 6.1	2	4	4	2
37	Net 6.1	4	5	2	4
38	Net 6.1	1	7	3	1
39	Net 6.1	1	6	3	1
40	Net 6.1	4	8	2	4
41	Moz 1.1	3	1	2	4
42	Moz 1.1	2	3	3	1
43	Moz 1.1	2	2	3	1
44	Moz 1.1	3	4	2	4
45	Moz 1.1	1	5	4	2
46	Moz 1.1	4	7	1	3
47	Moz 1.1	4	6	1	3
48	Moz 1.1	1	8	4	2
49	Net 7.0	4	1	3	2
50	Net 7.0	1	3	2	3
51	Net 7.0	1	2	2	3
52	Net 7.0	4	4	3	2
53	Net 7.0	2	5	1	4
54	Net 7.0	3	7	4	1
55	Net 7.0	3	6	4	1
56	Net 7.0	2	8	1	4
57	Opera 7	1	1	1	4
58	Opera 7	4	3	4	1
59	Opera 7	4	2	4	1
60	Opera 7	1	4	1	4
61	Opera 7	3	5	3	2
62	Opera 7	2	7	2	3
63	Opera 7	2	6	2	3
64	Opera 7	3	8	3	2

Таким же образом мы проецируем каждую переменную (входной параметр).

2ой столбец - плагины:
 1 = None
 2 = RealPlayer
 3 = MediaPlayer
 4 = 4. У нас нет 4ого значения плагинов. Так и оставяем "4"

3ий столбец - ОС клиента
 1 = Windows 95
 2 = Windows 98
 3 = Windows ME
 4 = Windows NT
 5 = Windows 2000
 6 = Windows XP
 7 = 7. У нас нет 7ого значения ОС клиента. Так и оставяем "7"
 8 = 8. У нас нет 8ого значения ОС клиента. Так и оставяем "8"

4ой столбец - веб серверы
 1 = IIS
 2 = Apache
 3 = WebLogic
 4 = 4. У нас нет 4ого значения веб серверов. Так и оставяем "4"

5ый столбец - ОС сервера:
 1 = Windows 2003
 2 = Windows 2008
 3 = Linux
 4 = 4. У нас нет 4ого значения ОС сервера. Так и оставяем "4"

Итого:

# строки	Browser	Plug-in	Client OS	Server	Server OS
1	IE 5.0	None	Win 95	IIS	Win NT
2	IE 5.0	4	Win ME	4	4
3	IE 5.0	4	Win 98	4	4
4	IE 5.0	None	Win NT	IIS	Win NT
5	IE 5.0	MediaPlayer	Win 2000	WebLogic	Linux
6	IE 5.0	RealPlayer	7	Apache	Win 2000
7	IE 5.0	RealPlayer	Win XP	Apache	Win 2000
8	IE 5.0	MediaPlayer	8	WebLogic	Linux
9	IE 6.0	4	Win 95	WebLogic	Linux
10	IE 6.0	None	Win ME	Apache	Win 2000
11	IE 6.0	None	Win 98	Apache	Win 2000
12	IE 6.0	4	Win NT	WebLogic	Linux
13	IE 6.0	RealPlayer	Win 2000	IIS	Win NT
14	IE 6.0	MediaPlayer	7	4	4
15	IE 6.0	MediaPlayer	Win XP	4	4
16	IE 6.0	RealPlayer	8	US	Win NT
17	IE 5.5	MediaPlayer	Win 95	Apache	Win NT
18	IE 5.5	RealPlayer	Win ME	WebLogic	4
19	IE 5.5	RealPlayer	Win 98	WebLogic	4
20	IE 5.5	MediaPlayer	Win NT	Apache	Win NT
21	IE 5.5	None	Win 2000	4	Linux
22	IE 5.5	4	7	IIS	Win 2000
23	IE 5.5	4	Win XP	IIS	Win 2000
24	IE 5.5	None	8	4	Linux
25	Net 6.0	RealPlayer	Win 95	4	Linux
26	Net 6.0	MediaPlayer	Win ME	IIS	Win 2000
27	Net 6.0	MediaPlayer	Win 98	IIS	Win 2000
28	Net 6.0	RealPlayer	Win NT	4	Linux
29	Net 6.0	4	Win 2000	Apache	Win NT
30	Net 6.0	None	7	WebLogic	4
31	Net 6.0	None	Win XP	WebLogic	4
32	Net 6.0	4	8	Apache	Win NT
33	Net 6.1	RealPlayer	Win 95	4	Win 2000
34	Net 6.1	MediaPlayer	Win ME	IIS	Linux
35	Net 6.1	MediaPlayer	Win 98	IIS	Linux
36	Net 6.1	RealPlayer	Win NT	4	Win 2000
37	Net 6.1	4	Win 2000	Apache	4
38	Net 6.1	None	7	WebLogic	Win NT
39	Net 6.1	None	Win XP	WebLogic	1 Win NT
40	Net 6.1	4	8	Apache	4
41	Moz 1.1	MediaPlayer	Win 95	Apache	4
42	Moz 1.1	RealPlayer	Win ME	WebLogic	Win NT
43	Moz 1.1	RealPlayer	Win 98	WebLogic	Win NT
44	Moz 1.1	MediaPlayer	Win NT	Apache	4
45	Moz 1.1	None	Win 2000	4	Win 2000
46	Moz 1.1	4	7	IIS	Linux
47	Moz 1.1	4	Win XP	IIS	Linux
48	Moz 1.1	None	8	4	Win 2000
49	Net 7.0	4	Win 95	WebLogic	Win 2000
50	Net 7.0	None	Win ME	Apache	Linux
51	Net 7.0	None	Win 98	Apache	Linux
52	Net 7.0	4	Win NT	WebLogic	Win 2000
53	Net 7.0	RealPlayer	Win 2000	IIS	4
54	Net 7.0	MediaPlayer	7	4	Win NT
55	Net 7.0	MediaPlayer	Win XP	4	Win NT
56	Net 7.0	RealPlayer	8	IIS	4
57	Opera 7	None	Win 95	IIS	4
58	Opera 7	4	Win ME	4	Win NT
59	Opera 7	4	Win 98	4	Win NT
60	Opera 7	None	Win NT	IIS	4
61	Opera 7	MediaPlayer	Win 2000	WebLogic	Win 2000
62	Opera 7	RealPlayer	7	Apache	Linux
63	Opera 7	RealPlayer	Win XP	Apache	Linux
64	Opera 7	MediaPlayer	8	WebLogic	Win 2000

Что делать с не назначеными значениями (4=4,7=7 и др.) му уже знаем - выберите им любые валидные значения для переменной и запишите в таблицу.

Вот и все, можно составлять тест кейсы.

Еще раз хочу обратить внимание - выбрать подходящий ортогональный массив и заполнить его помогут различные тулзы на подобие http://www.testersdesk.com/pairwse_testersdesk.html. Вам всего лиш нужно будет определить входные данные и количество значений входных данных.

Будем считать с pairwise testing на основе ортогональных массивов мы разобрались. Следующим постом пойдет повествование о pairwise testing на основе Allpairs Algorithm.

Заимствованно с http://w1zle.blogspot.ru