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 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 Int
s, 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 elementforAll
- succeeds if the assertion holds true for every elementforEvery
- 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.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) }
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) }
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] }
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 Outcome
s 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) }
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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.
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 Outcome
s 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 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 that contains the whenever
clause that can be used in table- or generator-driven property checks.
Trait that contains the whenever
clause that can be used in table- or generator-driven property checks.
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.
Companion object for class TableFor1
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor1
to return another TableFor1
.
Companion object for class TableFor1
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor1
to return another TableFor1
.
Companion object for class TableFor10
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor10
to return another TableFor10
.
Companion object for class TableFor10
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor10
to return another TableFor10
.
Companion object for class TableFor11
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor11
to return another TableFor11
.
Companion object for class TableFor11
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor11
to return another TableFor11
.
Companion object for class TableFor12
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor12
to return another TableFor12
.
Companion object for class TableFor12
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor12
to return another TableFor12
.
Companion object for class TableFor13
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor13
to return another TableFor13
.
Companion object for class TableFor13
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor13
to return another TableFor13
.
Companion object for class TableFor14
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor14
to return another TableFor14
.
Companion object for class TableFor14
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor14
to return another TableFor14
.
Companion object for class TableFor15
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor15
to return another TableFor15
.
Companion object for class TableFor15
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor15
to return another TableFor15
.
Companion object for class TableFor16
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor16
to return another TableFor16
.
Companion object for class TableFor16
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor16
to return another TableFor16
.
Companion object for class TableFor17
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor17
to return another TableFor17
.
Companion object for class TableFor17
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor17
to return another TableFor17
.
Companion object for class TableFor18
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor18
to return another TableFor18
.
Companion object for class TableFor18
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor18
to return another TableFor18
.
Companion object for class TableFor19
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor19
to return another TableFor19
.
Companion object for class TableFor19
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor19
to return another TableFor19
.
Companion object for class TableFor2
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor2
to return another TableFor2
.
Companion object for class TableFor2
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor2
to return another TableFor2
.
Companion object for class TableFor20
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor20
to return another TableFor20
.
Companion object for class TableFor20
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor20
to return another TableFor20
.
Companion object for class TableFor21
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor21
to return another TableFor21
.
Companion object for class TableFor21
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor21
to return another TableFor21
.
Companion object for class TableFor22
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor22
to return another TableFor22
.
Companion object for class TableFor22
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor22
to return another TableFor22
.
Companion object for class TableFor3
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor3
to return another TableFor3
.
Companion object for class TableFor3
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor3
to return another TableFor3
.
Companion object for class TableFor4
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor4
to return another TableFor4
.
Companion object for class TableFor4
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor4
to return another TableFor4
.
Companion object for class TableFor5
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor5
to return another TableFor5
.
Companion object for class TableFor5
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor5
to return another TableFor5
.
Companion object for class TableFor6
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor6
to return another TableFor6
.
Companion object for class TableFor6
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor6
to return another TableFor6
.
Companion object for class TableFor7
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor7
to return another TableFor7
.
Companion object for class TableFor7
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor7
to return another TableFor7
.
Companion object for class TableFor8
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor8
to return another TableFor8
.
Companion object for class TableFor8
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor8
to return another TableFor8
.
Companion object for class TableFor9
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor9
to return another TableFor9
.
Companion object for class TableFor9
that provides an implicit canBuildFrom
method
that enables higher order functions defined on TableFor9
to return another TableFor9
.
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))
Trait providing methods and classes used to configure property checks provided by the the
forAll
methods of traitGeneratorDrivenPropertyChecks
(for ScalaTest-style property checks) and thecheck
methods of traitCheckers
(for ScalaCheck-style property checks).