unit testing - tipos - ¿Qué es prueba positiva y prueba negativa en pruebas unitarias?

pruebas unitarias software

Question

Soy bastante nuevo en TDD. Veo que algunos doctores dicen sobre pruebas positivas, pruebas negativas, pruebas de límites, etc. ¿Puede alguien decirme la diferencia entre una prueba positiva y una prueba negativa? ¿Hay alguna referencia por ahí que diga sobre los diferentes tipos de pruebas? (No estoy buscando libros)

Answer 1

Prueba de unidad positiva frente a negativa

===============================================================
|      Positive Test Case      |      Negative Test Case      |
+==============================+==============================+
| test by valid/expected data  | test by invalid data         |
+------------------------------+------------------------------+
| check if the function does   | check if the function does   |
| that it should do            | not that it should not do    |
+------------------------------+------------------------------+
| examine general behaviors of | examine if the function      |
| the function                 | is fault proof (does not     |
|                              | crush/mis-response in bad    |
|                              | situations)                  |
===============================+===============================

_{Algunos ejemplos rápidos le ayudarán a comprender la diferencia con mayor claridad.}

Ejemplo

Función del candidato:

public boolean deleteFile(String filePath) {
    // try to delete the file; and
    // return true for success, false for failure
}

Casos de prueba positivos: como esta función espera una ruta de archivo, el caso de prueba positivo incluirá todas las rutas de archivo válidas posibles:

public void deleteFile_forAbsoluteFilePath_P() {
    String filePath = "D://Temp//file.txt";
    // create file, call deleteFile(), and check if really deleted
}

public void deleteFile_forRelativeFilePath_P() {
    String filePath = "file.txt";
    // create file, call deleteFile(), and check if really deleted
}

public void deleteFile_forNonExistingFilePath_P() {
    String filePath = "wHSyY#zP_04l.txt";
    // call deleteFile(), and check if false is returned
}

public void deleteFile_forSymlinkedFilePath_P() {
    String filePath = "D://Temp//symlink//dir//file.txt";
    // create file, create symlink, delete file, and
    // check if really deleted
}

public void deleteFile_forUndeletableFile_P() {
    String filePath = "file.bin";
    // create file, restrict delete permission, call deleteFile(), and
    // check if does not crash and returns false
}

Casos de prueba negativos: cualquier cosa que se pueda enviar a la función y no sea válida, estará en caso de prueba negativa:

public void deleteFile_forAlreadyDeletedFile_N() {
    String filePath = "file.bin";
    // create file, call deleteFile() twice, and
    // for second time check if does not crash and returns false
}

public void deleteFile_forDirectoryPath_N() {
    String dirPath = "D://Temp//dir";
    // create directory, call deleteFile(), and check if false is returned
}

public void deleteFile_forSymlinkedDirectoryPath_N() {
    String symlink = "D://Temp//symlink";
    // create symlink, call deleteFile(), and check if false is returned
}

public void deleteFile_forNullString_N() {
    String filePath = NULL;
    // call deleteFile(), and check if does not crash and returns false
}

public void deleteFile_forCorruptedFilePath_N() {
    String filePath = "D://Tem¡¿ÿ¿";
    // call deleteFile(), and check if does not crash and returns false
}

Unit-test también funciona como una documentación en vivo para su función. Por lo tanto, en lugar de presentar todos los argumentos posibles a la función, el caso de prueba negativo debe incluir solo las condiciones excepcionales esperadas .

Answer 2

Las pruebas negativas comprueban que el sistema no hace lo que no debería. Ejemplo: si solo un administrador puede aprobar una solicitud para una computadora portátil nueva, las pruebas negativas muestran que un usuario "regular" no puede aprobar esa solicitud.

Answer 3

Prueba positiva : prueba el sistema proporcionando los datos válidos.

Prueba negativa : prueba el sistema al proporcionar los datos no válidos.

Por ejemplo, una aplicación contiene un cuadro de texto y de acuerdo con los Requisitos del usuario, el cuadro de texto debe aceptar solo Cadenas. Al proporcionar solo Cadena como datos de entrada al cuadro de texto y para verificar si funciona correctamente o no, significa que la prueba es positiva. Si dar una entrada que no sea String significa que es una prueba negativa.

Las pruebas negativas mejoran la cobertura de pruebas de su aplicación. El uso conjunto de enfoques de prueba negativos y positivos le permite probar sus aplicaciones con cualquier posible información de entrada (tanto válida como no válida) y puede ayudarlo a hacer que su aplicación sea más estable y confiable.

Consulte este Glossary para diferentes tipos de pruebas.

Answer 4

En términos de pruebas unitarias, (que es el enfoque de TDD), el concepto se puede describir simplemente de la siguiente manera:

• Una prueba positiva verifica si una función / método se comporta como se espera con su entrada esperada.
• Una prueba negativa verifica si una función / método se comporta como se espera con una entrada incorrecta. (debería tener suficientes pruebas negativas para cubrir todas las definiciones posibles de "malo", idealmente ") Consulte esta pregunta para obtener más información.