Prueba de múltiples conjuntos de datos con ScalaTest

Question

¿Existe alguna forma conveniente de ejecutar pruebas en múltiples conjuntos de datos, como en las pruebas parametrizadas de JUnit?

Answer 1

Hay una nueva función para probar múltiples conjuntos de datos que vienen en ScalaTest 1.5, que actualmente puede probar como una instantánea. Se libera en scala-tools.org: Identificación del

grupo: Identificación del org.scalatest artefacto: scalatest versión : 1.5-SNAPSHOT

Usted mezcla de (o importar los miembros de) TableDrivenPropertyChecks, entonces se puede defina tablas como esta:

val examples = 
    Table(
    ("a", "b", "c", "d"), 
    ( 1, 1, 1, 1), 
    ( 1, 1, 1, 1), 
    ( 1, 1, 1, 1), 
    ( 1, 1, 1, 1) 
) 

Usted pasa una lista de tuplas a la tabla. Cada tupla debe tener la misma aridad, en este caso cada tupla tiene arity 4 (4 miembros). La primera tupla es todas las cadenas, y estos definen nombres para las columnas. Las tuplas subsiguientes definen cada una una fila de datos. Puede poner cualquier tipo en la tupla, pero en general cada columna contendrá el mismo tipo. Aunque si quisieras, podrías tener columnas de tipo Cualquiera que pueda contener algo. Puede tener una tabla con 1 a 22 columnas. Si necesita más de 22 columnas (el tamaño máximo de tupla en Scala es actualmente 22), lo que podría hacer es usar un tipo compuesto en una o más columnas.

Una vez que tenga una mesa, se puede comprobar con forAll así:

forAll (examples) { (a, b, c, d) => 
    a + b + c + d should equal (4) 
} 

forAll toma dos listas de parámetros. La primera es una tabla y la segunda es una "función de propiedad", que expresa algo que debería ser cierto para cada fila de la tabla. porque todos tomarán cada fila de la tabla (omitiendo la fila del encabezado de los nombres de las columnas, por supuesto) y se asegurarán de que la propiedad se mantenga. Si no lo hace, recibirá un mensaje de error que indica qué fila de la tabla falló, cuáles fueron los valores de las columnas nombradas, etc.

Una tabla es una secuencia de las tuplas de datos, por lo que también puede usar es como una Seq. Por ejemplo, usted podría conseguir una Sec de la opción [Excepción] que indica qué filas fallaron así:

for ((a, b, c, d) <- examples) yield { 
    failureOf { a + b + c + d should equal (4) } 
} 

El Sec resultante contiene una opción para cada fila de datos de la tabla, que es una Ninguno si la propiedad pasó para esa fila, y Some [Exception] si la propiedad falló. La excepción en el Some contiene todos los detalles sobre el error.

Answer 2

Shared tests puede ser interesante para usted. Ellos le permiten definir un conjunto de pruebas como en este ejemplo de pila:

def nonEmptyStack(stack: Stack[Int], lastItemAdded: Int) { 
    "be non-empty" in { 
     assert(!stack.empty) 
    } 
    "return the top item on peek" in { 
     assert(stack.peek === lastItemAdded) 
    } 
    "not remove the top item on peek" in { 
     val size = stack.size 
     assert(stack.peek === lastItemAdded) 
     assert(stack.size === size) 
    } 
    "remove the top item on pop" in { 
     val size = stack.size 
     assert(stack.pop === lastItemAdded) 
     assert(stack.size === size - 1) 
    } 
    } 

y luego en la especificación actual se puede utilizar de esta manera:

behave like nonEmptyStack(stackWithOneItem, lastValuePushed) 

En otras palabras nonEmptyStack es parametrizada conjunto de pruebas que puede usar con diferentes conjuntos de datos que desea probar.

Answer 3

Otra posibilidad para la prueba basada en datos es utilizar la siguiente sintaxis:

class SampleTest extends FunSuite {  
    val input = List((1, 1), (4, 2), (9, 3)) 

    input.foreach{i => 
    test(s"Test of math.sqrt(${i._1})") { 
     assert(math.sqrt(i._1) === i._2) 
    } 
    } 
} 

Las pruebas realizadas por defecto a menos que se ejecutan en paralelo en build.sbt configura parallelExecution in Test := false.