Two-stage algorithms for covering array construction

Kaushik Sarkar, Charles Colbourn

Research output: Contribution to journalArticle

Abstract

Modern software systems often consist of many different components, each with a number of options. Although unit tests may reveal faulty options for individual components, functionally correct components may interact in unforeseen ways to cause a fault. Covering arrays are used to test for interactions among components systematically. A two-stage framework, providing a number of concrete algorithms, is developed for the efficient construction of covering arrays. In the first stage, a time and memory efficient randomized algorithm covers most of the interactions. In the second stage, a more sophisticated search covers the remainder in relatively few tests. In this way, the storage limitations of the sophisticated search algorithms are avoided; hence, the range of the number of components for which the algorithm can be applied is extended, without increasing the number of tests. Many of the framework instantiations can be tuned to optimize a memory-quality trade-off, so that fewer tests can be achieved using more memory.

Original languageEnglish (US)
Pages (from-to)475-505
Number of pages31
JournalJournal of Combinatorial Designs
Volume27
Issue number8
DOIs
StatePublished - Aug 1 2019

Fingerprint

Covering Array
Cover
Number of Components
Randomized Algorithms
Remainder
Interaction
Software System
Search Algorithm
Fault
Efficient Algorithms
Trade-offs
Optimise
Unit
Range of data

Keywords

  • conditional expectation
  • covering array
  • Lovász local lemma
  • randomized algorithm
  • two-stage algorithm

ASJC Scopus subject areas

  • Discrete Mathematics and Combinatorics

Cite this

Two-stage algorithms for covering array construction. / Sarkar, Kaushik; Colbourn, Charles.

In: Journal of Combinatorial Designs, Vol. 27, No. 8, 01.08.2019, p. 475-505.

Research output: Contribution to journalArticle

@article{2daf1d7658d2456e8371fef29cced948,
title = "Two-stage algorithms for covering array construction",
abstract = "Modern software systems often consist of many different components, each with a number of options. Although unit tests may reveal faulty options for individual components, functionally correct components may interact in unforeseen ways to cause a fault. Covering arrays are used to test for interactions among components systematically. A two-stage framework, providing a number of concrete algorithms, is developed for the efficient construction of covering arrays. In the first stage, a time and memory efficient randomized algorithm covers most of the interactions. In the second stage, a more sophisticated search covers the remainder in relatively few tests. In this way, the storage limitations of the sophisticated search algorithms are avoided; hence, the range of the number of components for which the algorithm can be applied is extended, without increasing the number of tests. Many of the framework instantiations can be tuned to optimize a memory-quality trade-off, so that fewer tests can be achieved using more memory.",
keywords = "conditional expectation, covering array, Lov{\'a}sz local lemma, randomized algorithm, two-stage algorithm",
author = "Kaushik Sarkar and Charles Colbourn",
year = "2019",
month = "8",
day = "1",
doi = "10.1002/jcd.21657",
language = "English (US)",
volume = "27",
pages = "475--505",
journal = "Journal of Combinatorial Designs",
issn = "1063-8539",
publisher = "John Wiley and Sons Inc.",
number = "8",

}

TY - JOUR

T1 - Two-stage algorithms for covering array construction

AU - Sarkar, Kaushik

AU - Colbourn, Charles

PY - 2019/8/1

Y1 - 2019/8/1

N2 - Modern software systems often consist of many different components, each with a number of options. Although unit tests may reveal faulty options for individual components, functionally correct components may interact in unforeseen ways to cause a fault. Covering arrays are used to test for interactions among components systematically. A two-stage framework, providing a number of concrete algorithms, is developed for the efficient construction of covering arrays. In the first stage, a time and memory efficient randomized algorithm covers most of the interactions. In the second stage, a more sophisticated search covers the remainder in relatively few tests. In this way, the storage limitations of the sophisticated search algorithms are avoided; hence, the range of the number of components for which the algorithm can be applied is extended, without increasing the number of tests. Many of the framework instantiations can be tuned to optimize a memory-quality trade-off, so that fewer tests can be achieved using more memory.

AB - Modern software systems often consist of many different components, each with a number of options. Although unit tests may reveal faulty options for individual components, functionally correct components may interact in unforeseen ways to cause a fault. Covering arrays are used to test for interactions among components systematically. A two-stage framework, providing a number of concrete algorithms, is developed for the efficient construction of covering arrays. In the first stage, a time and memory efficient randomized algorithm covers most of the interactions. In the second stage, a more sophisticated search covers the remainder in relatively few tests. In this way, the storage limitations of the sophisticated search algorithms are avoided; hence, the range of the number of components for which the algorithm can be applied is extended, without increasing the number of tests. Many of the framework instantiations can be tuned to optimize a memory-quality trade-off, so that fewer tests can be achieved using more memory.

KW - conditional expectation

KW - covering array

KW - Lovász local lemma

KW - randomized algorithm

KW - two-stage algorithm

UR - http://www.scopus.com/inward/record.url?scp=85066302534&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=85066302534&partnerID=8YFLogxK

U2 - 10.1002/jcd.21657

DO - 10.1002/jcd.21657

M3 - Article

VL - 27

SP - 475

EP - 505

JO - Journal of Combinatorial Designs

JF - Journal of Combinatorial Designs

SN - 1063-8539

IS - 8

ER -