prop

package prop

Ordering

Alphabetic

Visibility

Public
All

Type Members

trait Configuration extends AnyRef
Trait providing methods and classes used to configure property checks provided by the the forAll methods of trait GeneratorDrivenPropertyChecks (for ScalaTest-style property checks) and the check methods of trait Checkers (for ScalaCheck-style property checks).
trait TableDrivenPropertyChecks extends Whenever with Tables
Trait containing methods that faciliate property checks against tables of data.
Trait containing methods that faciliate property checks against tables of data.
This trait contains one exists, forAll, and forEvery method for each TableForN class, TableFor1 through TableFor22, which allow properties to be checked against the rows of a table. It also contains a whenever method that can be used to indicate a property need only hold whenever some condition is true.
For an example of trait TableDrivenPropertyChecks in action, imagine you want to test this Fraction class:
```
class Fraction(n: Int, d: Int) {

  require(d != 0)
  require(d != Integer.MIN_VALUE)
  require(n != Integer.MIN_VALUE)

  val numer = if (d < 0) -1 * n else n
  val denom = d.abs

  override def toString = numer + " / " + denom
}
```
TableDrivenPropertyChecks allows you to create tables with between 1 and 22 columns and any number of rows. You create a table by passing tuples to one of the factory methods of object Table. Each tuple must have the same arity (number of members). The first tuple you pass must all be strings, because it defines names for the columns. Subsequent tuples define the data. After the initial tuple that contains string column names, all tuples must have the same type. For example, if the first tuple after the column names contains two Ints, all subsequent tuples must contain two Int (i.e., have type Tuple2[Int, Int]).
To test the behavior of Fraction, you could create a table of numerators and denominators to pass to the constructor of the Fraction class using one of the apply factory methods declared in Table, like this:
```
import org.scalatest.prop.TableDrivenPropertyChecks._

val fractions =
  Table(
    ("n", "d"),  // First tuple defines column names
    (  1,   2),  // Subsequent tuples define the data
    ( -1,   2),
    (  1,  -2),
    ( -1,  -2),
    (  3,   1),
    ( -3,   1),
    ( -3,   0),
    (  3,  -1),
    (  3,  Integer.MIN_VALUE),
    (Integer.MIN_VALUE, 3),
    ( -3,  -1)
  )
```
You could then check a property against each row of the table using a forAll method, like this:
```
import org.scalatest.Matchers._

forAll (fractions) { (n: Int, d: Int) =>

  whenever (d != 0 && d != Integer.MIN_VALUE
      && n != Integer.MIN_VALUE) {

    val f = new Fraction(n, d)

    if (n < 0 && d < 0 || n > 0 && d > 0)
      f.numer should be > 0
    else if (n != 0)
      f.numer should be < 0
    else
      f.numer should be === 0

    f.denom should be > 0
  }
}
```
Trait TableDrivenPropertyChecks provides 22 overloaded exists, forAll, and forEvery methods that allow you to check properties using the data provided by a table. Each exists, forAll, and forEvery method takes two parameter lists. The first parameter list is a table. The second parameter list is a function whose argument types and number matches that of the tuples in the table. For example, if the tuples in the table supplied to forAll each contain an Int, a String, and a List[Char], then the function supplied to forAll must take 3 parameters, an Int, a String, and a List[Char]. The forAll method will pass each row of data to the function, and generate a TableDrivenPropertyCheckFailedException if the function completes abruptly for any row of data with any exception that would normally cause a test to fail in ScalaTest other than DiscardedEvaluationException. A DiscardedEvaluationException, which is thrown by the whenever method (also defined in this trait) to indicate a condition required by the property function is not met by a row of passed data, will simply cause forAll to skip that row of data.
The full list of table methods are:
- exists - succeeds if the assertion holds true for at least one element
- forAll - succeeds if the assertion holds true for every element
- forEvery - same as forAll, but lists all failing elements if it fails (whereas forAll just reports the first failing element) and throws TestFailedException with the first failed check as the cause.
Testing stateful functions
One way to use a table with one column is to test subsequent return values of a stateful function. Imagine, for example, you had an object named FiboGen whose next method returned the next fibonacci number, where next means the next number in the series following the number previously returned by next. So the first time next was called, it would return 0. The next time it was called it would return 1. Then 1. Then 2. Then 3, and so on. FiboGen would need to maintain state, because it has to remember where it is in the series. In such a situation, you could create a TableFor1 (a table with one column, which you could alternatively think of as one row), in which each row represents the next value you expect.
```
val first14FiboNums =
  Table("n", 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233)
```
Then in your forAll simply call the function and compare it with the expected return value, like this:
```
forAll (first14FiboNums) { n =>
  FiboGen.next should equal (n)
}
```
Testing mutable objects
If you need to test a mutable object, one way you can use tables is to specify state transitions in a table. For example, imagine you wanted to test this mutable Counter class:
```
class Counter {
  private var c = 0
  def reset() { c = 0 }
  def click() { c += 1 }
  def enter(n: Int) { c = n }
  def count = c
}
```
A Counter keeps track of how many times its click method is called. The count starts out at zero and increments with each click invocation. You can also set the count to a specific value by calling enter and passing the value in. And the reset method returns the count back to zero. You could define the actions that initiate state transitions with case classes, like this:
```
abstract class Action
case object Start extends Action
case object Click extends Action
case class Enter(n: Int) extends Action
```
Given these actions, you could define a state-transition table like this:
```
val stateTransitions =
  Table(
    ("action", "expectedCount"),
    (Start,    0),
    (Click,    1),
    (Click,    2),
    (Click,    3),
    (Enter(5), 5),
    (Click,    6),
    (Enter(1), 1),
    (Click,    2),
    (Click,    3)
  )
```
To use this in a test, simply do a pattern match inside the function you pass to forAll. Make a pattern for each action, and have the body perform that action when there's a match. Then check that the actual value equals the expected value:
```
val counter = new Counter
forAll (stateTransitions) { (action, expectedCount) =>
  action match {
    case Start => counter.reset()
    case Click => counter.click()
    case Enter(n) => counter.enter(n)
  }
  counter.count should equal (expectedCount)
}
```
Testing invalid argument combinations
A table-driven property check can also be helpful to ensure that the proper exception is thrown when invalid data is passed to a method or constructor. For example, the Fraction constructor shown above should throw IllegalArgumentException if Integer.MIN_VALUE is passed for either the numerator or denominator, or zero is passed for the denominator. This yields the following five combinations of invalid data:

n d

Integer.MIN_VALUE Integer.MIN_VALUE

a valid value Integer.MIN_VALUE

Integer.MIN_VALUE a valid value

Integer.MIN_VALUE zero

a valid value zero

You can express these combinations in a table:
```
val invalidCombos =
  Table(
    ("n",               "d"),
    (Integer.MIN_VALUE, Integer.MIN_VALUE),
    (1,                 Integer.MIN_VALUE),
    (Integer.MIN_VALUE, 1),
    (Integer.MIN_VALUE, 0),
    (1,                 0)
  )
```
Given this table, you could check that all invalid combinations produce IllegalArgumentException, like this:
```
forAll (invalidCombos) { (n: Int, d: Int) =>
  evaluating {
    new Fraction(n, d)
  } should produce [IllegalArgumentException]
}
```
class TableFor1[A] extends IndexedSeq[A] with IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]]
A table with 1 column.
A table with 1 column.
For an overview of using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of objects, where each object represents one row of the (one-column) table. This table also carries with it a heading tuple that gives a string name to the lone column of the table.
A handy way to create a TableFor1 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    "a",
      0,
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      8,
      9
  )
```
Because you supplied a list of non-tuple objects, the type you'll get back will be a TableFor1.
The table provides an apply method that takes a function with a parameter list that matches the type of the objects contained in this table. The apply method will invoke the function with the object in each row passed as the lone argument, in ascending order by index. (I.e., the zeroth object is checked first, then the object with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor1 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor1, passing in the property check function. Here's an example:
```
forAll (examples) { (a) =>
  a should equal (a * 1)
}
```
Because TableFor1 is a Seq[(A)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
One other way to use a TableFor1 is to test subsequent return values of a stateful function. Imagine, for example, you had an object named FiboGen whose next method returned the next fibonacci number, where next means the next number in the series following the number previously returned by next. So the first time next was called, it would return 0. The next time it was called it would return 1. Then 1. Then 2. Then 3, and so on. FiboGen would need to be stateful, because it has to remember where it is in the series. In such a situation, you could create a TableFor1 (a table with one column, which you could alternatively think of as one row), in which each row represents the next value you expect.
```
val first14FiboNums =
  Table("n", 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233)
```
Then in your forAll simply call the function and compare it with the expected return value, like this:
```
forAll (first14FiboNums) { n =>
  FiboGen.next should equal (n)
}
```
class TableFor10[A, B, C, D, E, F, G, H, I, J] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J)]]
A table with 10 columns.
A table with 10 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple10 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor10 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 10 members in each tuple, the type you'll get back will be a TableFor10.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor10 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor10, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j) =>
  a + b + c + d + e + f + g + h + i + j should equal (a * 10)
}
```
Because TableFor10 is a Seq[(A, B, C, D, E, F, G, H, I, J)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor11[A, B, C, D, E, F, G, H, I, J, K] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K)]]
A table with 11 columns.
A table with 11 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple11 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor11 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 11 members in each tuple, the type you'll get back will be a TableFor11.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor11 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor11, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k) =>
  a + b + c + d + e + f + g + h + i + j + k should equal (a * 11)
}
```
Because TableFor11 is a Seq[(A, B, C, D, E, F, G, H, I, J, K)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor12[A, B, C, D, E, F, G, H, I, J, K, L] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L)]]
A table with 12 columns.
A table with 12 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple12 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor12 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 12 members in each tuple, the type you'll get back will be a TableFor12.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor12 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor12, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l) =>
  a + b + c + d + e + f + g + h + i + j + k + l should equal (a * 12)
}
```
Because TableFor12 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L, M), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M)]]
A table with 13 columns.
A table with 13 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple13 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor13 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 13 members in each tuple, the type you'll get back will be a TableFor13.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor13 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor13, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m) =>
  a + b + c + d + e + f + g + h + i + j + k + l + m should equal (a * 13)
}
```
Because TableFor13 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L, M, N), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]]
A table with 14 columns.
A table with 14 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple14 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor14 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 14 members in each tuple, the type you'll get back will be a TableFor14.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor14 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor14, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n) =>
  a + b + c + d + e + f + g + h + i + j + k + l + m + n should equal (a * 14)
}
```
Because TableFor14 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]]
A table with 15 columns.
A table with 15 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple15 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor15 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 15 members in each tuple, the type you'll get back will be a TableFor15.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor15 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor15, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) =>
  a + b + c + d + e + f + g + h + i + j + k + l + m + n + o should equal (a * 15)
}
```
Because TableFor15 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]]
A table with 16 columns.
A table with 16 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple16 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor16 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 16 members in each tuple, the type you'll get back will be a TableFor16.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor16 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor16, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) =>
  a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p should equal (a * 16)
}
```
Because TableFor16 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]]
A table with 17 columns.
A table with 17 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple17 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor17 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 17 members in each tuple, the type you'll get back will be a TableFor17.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor17 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor17, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) =>
  a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q should equal (a * 17)
}
```
Because TableFor17 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]]
A table with 18 columns.
A table with 18 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple18 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor18 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 18 members in each tuple, the type you'll get back will be a TableFor18.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor18 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor18, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) =>
  a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r should equal (a * 18)
}
```
Because TableFor18 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]]
A table with 19 columns.
A table with 19 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple19 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor19 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 19 members in each tuple, the type you'll get back will be a TableFor19.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor19 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor19, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) =>
  a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r + s should equal (a * 19)
}
```
Because TableFor19 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor2[A, B] extends IndexedSeq[(A, B)] with IndexedSeqOps[(A, B), IndexedSeq, IndexedSeq[(A, B)]]
A table with 2 columns.
A table with 2 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple2 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor2 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b"),
 *     (  0,   0),
    (  1,   1),
    (  2,   2),
    (  3,   3),
    (  4,   4),
    (  5,   5),
    (  6,   6),
    (  7,   7),
    (  8,   8),
    (  9,   9)
  )
```
Because you supplied 2 members in each tuple, the type you'll get back will be a TableFor2.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor2 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor2, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b) =>
  a + b should equal (a * 2)
}
```
Because TableFor2 is a Seq[(A, B)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]]
A table with 20 columns.
A table with 20 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple20 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor20 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 20 members in each tuple, the type you'll get back will be a TableFor20.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor20 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor20, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) =>
  a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r + s + t should equal (a * 20)
}
```
Because TableFor20 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]]
A table with 21 columns.
A table with 21 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple21 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor21 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 21 members in each tuple, the type you'll get back will be a TableFor21.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor21 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor21, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) =>
  a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r + s + t + u should equal (a * 21)
}
```
Because TableFor21 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]]
A table with 22 columns.
A table with 22 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple22 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor22 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 22 members in each tuple, the type you'll get back will be a TableFor22.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor22 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor22, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) =>
  a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r + s + t + u + v should equal (a * 22)
}
```
Because TableFor22 is a Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor3[A, B, C] extends IndexedSeq[(A, B, C)] with IndexedSeqOps[(A, B, C), IndexedSeq, IndexedSeq[(A, B, C)]]
A table with 3 columns.
A table with 3 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple3 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor3 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c"),
 *     (  0,   0,   0),
    (  1,   1,   1),
    (  2,   2,   2),
    (  3,   3,   3),
    (  4,   4,   4),
    (  5,   5,   5),
    (  6,   6,   6),
    (  7,   7,   7),
    (  8,   8,   8),
    (  9,   9,   9)
  )
```
Because you supplied 3 members in each tuple, the type you'll get back will be a TableFor3.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor3 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor3, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c) =>
  a + b + c should equal (a * 3)
}
```
Because TableFor3 is a Seq[(A, B, C)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor4[A, B, C, D] extends IndexedSeq[(A, B, C, D)] with IndexedSeqOps[(A, B, C, D), IndexedSeq, IndexedSeq[(A, B, C, D)]]
A table with 4 columns.
A table with 4 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple4 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor4 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d"),
 *     (  0,   0,   0,   0),
    (  1,   1,   1,   1),
    (  2,   2,   2,   2),
    (  3,   3,   3,   3),
    (  4,   4,   4,   4),
    (  5,   5,   5,   5),
    (  6,   6,   6,   6),
    (  7,   7,   7,   7),
    (  8,   8,   8,   8),
    (  9,   9,   9,   9)
  )
```
Because you supplied 4 members in each tuple, the type you'll get back will be a TableFor4.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor4 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor4, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d) =>
  a + b + c + d should equal (a * 4)
}
```
Because TableFor4 is a Seq[(A, B, C, D)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor5[A, B, C, D, E] extends IndexedSeq[(A, B, C, D, E)] with IndexedSeqOps[(A, B, C, D, E), IndexedSeq, IndexedSeq[(A, B, C, D, E)]]
A table with 5 columns.
A table with 5 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple5 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor5 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e"),
 *     (  0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9)
  )
```
Because you supplied 5 members in each tuple, the type you'll get back will be a TableFor5.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor5 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor5, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e) =>
  a + b + c + d + e should equal (a * 5)
}
```
Because TableFor5 is a Seq[(A, B, C, D, E)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor6[A, B, C, D, E, F] extends IndexedSeq[(A, B, C, D, E, F)] with IndexedSeqOps[(A, B, C, D, E, F), IndexedSeq, IndexedSeq[(A, B, C, D, E, F)]]
A table with 6 columns.
A table with 6 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple6 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor6 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f"),
 *     (  0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 6 members in each tuple, the type you'll get back will be a TableFor6.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor6 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor6, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f) =>
  a + b + c + d + e + f should equal (a * 6)
}
```
Because TableFor6 is a Seq[(A, B, C, D, E, F)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor7[A, B, C, D, E, F, G] extends IndexedSeq[(A, B, C, D, E, F, G)] with IndexedSeqOps[(A, B, C, D, E, F, G), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G)]]
A table with 7 columns.
A table with 7 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple7 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor7 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g"),
 *     (  0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 7 members in each tuple, the type you'll get back will be a TableFor7.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor7 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor7, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g) =>
  a + b + c + d + e + f + g should equal (a * 7)
}
```
Because TableFor7 is a Seq[(A, B, C, D, E, F, G)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor8[A, B, C, D, E, F, G, H] extends IndexedSeq[(A, B, C, D, E, F, G, H)] with IndexedSeqOps[(A, B, C, D, E, F, G, H), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H)]]
A table with 8 columns.
A table with 8 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple8 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor8 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 8 members in each tuple, the type you'll get back will be a TableFor8.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor8 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor8, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h) =>
  a + b + c + d + e + f + g + h should equal (a * 8)
}
```
Because TableFor8 is a Seq[(A, B, C, D, E, F, G, H)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
class TableFor9[A, B, C, D, E, F, G, H, I] extends IndexedSeq[(A, B, C, D, E, F, G, H, I)] with IndexedSeqOps[(A, B, C, D, E, F, G, H, I), IndexedSeq, IndexedSeq[(A, B, C, D, E, F, G, H, I)]]
A table with 9 columns.
A table with 9 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of Tuple9 objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.
A handy way to create a TableFor9 is via an apply factory method in the Table singleton object provided by the Tables trait. Here's an example:
```
val examples =
  Table(
    ("a", "b", "c", "d", "e", "f", "g", "h", "i"),
 *     (  0,   0,   0,   0,   0,   0,   0,   0,   0),
    (  1,   1,   1,   1,   1,   1,   1,   1,   1),
    (  2,   2,   2,   2,   2,   2,   2,   2,   2),
    (  3,   3,   3,   3,   3,   3,   3,   3,   3),
    (  4,   4,   4,   4,   4,   4,   4,   4,   4),
    (  5,   5,   5,   5,   5,   5,   5,   5,   5),
    (  6,   6,   6,   6,   6,   6,   6,   6,   6),
    (  7,   7,   7,   7,   7,   7,   7,   7,   7),
    (  8,   8,   8,   8,   8,   8,   8,   8,   8),
    (  9,   9,   9,   9,   9,   9,   9,   9,   9)
  )
```
Because you supplied 9 members in each tuple, the type you'll get back will be a TableFor9.
The table provides an apply method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. The apply method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and the apply method will complete abruptly with a TableDrivenPropertyCheckFailedException that wraps the exception thrown by the supplied property function.
The usual way you'd invoke the apply method that checks a property is via a forAll method provided by trait TableDrivenPropertyChecks. The forAll method takes a TableFor9 as its first argument, then in a curried argument list takes the property check function. It invokes apply on the TableFor9, passing in the property check function. Here's an example:
```
forAll (examples) { (a, b, c, d, e, f, g, h, i) =>
  a + b + c + d + e + f + g + h + i should equal (a * 9)
}
```
Because TableFor9 is a Seq[(A, B, C, D, E, F, G, H, I)], you can use it as a Seq. For example, here's how you could get a sequence of Outcomes for each row of the table, indicating whether a property check succeeded or failed on each row of the table:
```
for (row <- examples) yield {
  outcomeOf { row._1 should not equal (7) }
}
```
Note: the outcomeOf method, contained in the OutcomeOf trait, will execute the supplied code (a by-name parameter) and transform it to an Outcome. If no exception is thrown by the code, outcomeOf will result in a Succeeded, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail, outcomeOf will result in in a Failed instance containing that exception. For example, the previous for expression would give you:
```
Vector(Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded, Succeeded,
    Failed(org.scalatest.TestFailedException: 7 equaled 7), Succeeded, Succeeded)
```
This shows that all the property checks succeeded, except for the one at index 7.
trait Tables extends AnyRef
Trait containing the Table object, which offers one apply factory method for each TableForN class, TableFor1 through TableFor22.
Trait containing the Table object, which offers one apply factory method for each TableForN class, TableFor1 through TableFor22.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
trait Whenever extends AnyRef
Trait that contains the whenever clause that can be used in table- or generator-driven property checks.

`n`	`d`
`Integer.MIN_VALUE`	`Integer.MIN_VALUE`
a valid value	`Integer.MIN_VALUE`
`Integer.MIN_VALUE`	a valid value
`Integer.MIN_VALUE`	zero
a valid value	zero

Value Members

object Configuration extends Configuration
Companion object that facilitates the importing of Configuration members as an alternative to mixing it in.
Companion object that facilitates the importing of Configuration members as an alternative to mixing it in. One use case is to import Configuration members so you can use them in the Scala interpreter.
object TableDrivenPropertyChecks extends TableDrivenPropertyChecks
object TableFor1
Companion object for class TableFor1 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor1 to return another TableFor1.
object TableFor10
Companion object for class TableFor10 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor10 to return another TableFor10.
object TableFor11
Companion object for class TableFor11 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor11 to return another TableFor11.
object TableFor12
Companion object for class TableFor12 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor12 to return another TableFor12.
object TableFor13
Companion object for class TableFor13 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor13 to return another TableFor13.
object TableFor14
Companion object for class TableFor14 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor14 to return another TableFor14.
object TableFor15
Companion object for class TableFor15 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor15 to return another TableFor15.
object TableFor16
Companion object for class TableFor16 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor16 to return another TableFor16.
object TableFor17
Companion object for class TableFor17 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor17 to return another TableFor17.
object TableFor18
Companion object for class TableFor18 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor18 to return another TableFor18.
object TableFor19
Companion object for class TableFor19 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor19 to return another TableFor19.
object TableFor2
Companion object for class TableFor2 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor2 to return another TableFor2.
object TableFor20
Companion object for class TableFor20 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor20 to return another TableFor20.
object TableFor21
Companion object for class TableFor21 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor21 to return another TableFor21.
object TableFor22
Companion object for class TableFor22 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor22 to return another TableFor22.
object TableFor3
Companion object for class TableFor3 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor3 to return another TableFor3.
object TableFor4
Companion object for class TableFor4 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor4 to return another TableFor4.
object TableFor5
Companion object for class TableFor5 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor5 to return another TableFor5.
object TableFor6
Companion object for class TableFor6 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor6 to return another TableFor6.
object TableFor7
Companion object for class TableFor7 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor7 to return another TableFor7.
object TableFor8
Companion object for class TableFor8 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor8 to return another TableFor8.
object TableFor9
Companion object for class TableFor9 that provides an implicit canBuildFrom method that enables higher order functions defined on TableFor9 to return another TableFor9.

object Tables extends Tables

Companion object that facilitates the importing of Tables members as an alternative to mixing it in.

Companion object that facilitates the importing of Tables members as an alternative to mixing it in. One use case is to import Tables members so you can use them in the Scala interpreter:

Welcome to Scala version 2.8.0.final (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_22).
Type in expressions to have them evaluated.
Type :help for more information.

scala> import org.scalatest.prop.Tables._
import org.scalatest.prop.Tables._

scala> val examples =
  |   Table(
  |     ("a", "b"),
  |     (  1,   2),
  |     (  3,   4)
  |   )
examples: org.scalatest.prop.TableFor2[Int,Int] = TableFor2((1,2), (3,4))

Packages

prop

package prop

Type Members

Testing stateful functions

Testing mutable objects

Testing invalid argument combinations

Value Members

Ungrouped

Packages

prop

package prop

Type Members

Testing stateful functions

Testing mutable objects

Testing invalid argument combinations

Value Members

Ungrouped

prop