Descargar utest.h - Descargar el código fuente de utest.h

? Utest.h

Una solución simple de encabezado para pruebas unitarias para C/C ++.

Uso

¡Solo #include "utest.h" en tu código!

Las plataformas compatibles actuales son Linux, MacOS y Windows.

Los compiladores compatibles actuales son GCC, Clang, Cl.Exe de MSVC y Clang-Cl.exe.

También funciona con TCC pero con una advertencia: la última versión del compilador TCC (versión 0.9.27) carece de una función para que UTEST funcione. Asegúrese de usar un TCC que esté parcheado con la extensión del atributo del constructor. Las distribuciones recientes de Ubuntu y Debian Linux envían TCC con ese parche ya incluido. Si compila TCC usted mismo, usa la versión del tronco y funcionará como se esperaba.

Opciones de línea de comando

Utest.h admite algunas opciones de línea de comandos:

--help para emitir el mensaje de ayuda
--filter=<filter> filtrará los casos de prueba para ejecutarse (útil para volver a ejecutar un caso de prueba de ofensiva en particular).
--list-tests enumerarán Names TestNames, uno por línea. Los nombres de salida se pueden pasar a --filter .
--output=<output> emitirá un archivo XML XUnit con los resultados de la prueba (que Jenkins, Travis-Ci y Appveyor pueden analizar los resultados de la prueba).
--enable-mixed-units permitirá que la salida por prueba contenga unidades mixtas (S/MS/US/NS).
--random-order[=<seed>] aleatorizará el orden en que las pruebas se ejecutan. Si no se proporciona el argumento opcional, entonces se usa una semilla de arranque aleatoria.

Diseño

UTEST es una biblioteca de encabezado único para habilitar toda la diversión de las pruebas unitarias en C y C ++. La biblioteca ha sido diseñada para proporcionar una salida similar al marco Googletest Google:

 [==========] Running 1 test cases.
[ RUN      ] foo.bar
[       OK ] foo.bar (631ns)
[==========] 1 test cases ran.
[  PASSED  ] 1 tests.

Utest_main

En un archivo C o C ++, debe llamar al macro utest_main:

 UTEST_MAIN ()

Esto llamará a Utest.h, instanciará todos los casos de prueba y ejecutará el marco de prueba unitario.

Alternativamente, si desea escribir su propia principal y llamar a Utest.h, puede, en una llamada de archivo C o C ++:

 UTEST_STATE ();

Y luego, cuando esté listo para llamar al marco UTest.H, hacer:

 int main ( int argc , const char * const argv []) {
  // do your own thing
  return utest_main ( argc , argv );
}

Definir un caso de prueba

Para definir un caso de prueba para ejecutar, puede hacer lo siguiente;

 #include "utest.h"

UTEST ( foo , bar ) {
  ASSERT_TRUE ( 1 );
}

La macro UTEST toma dos parámetros, el primero es el conjunto al que pertenece el caso de prueba, el segundo es el nombre de la prueba. Esto permite que las pruebas se agrupen por conveniencia.

Definir un caso de prueba fijo

Una prueba de prueba fija es aquel en la que hay una estructura que se instancia que se puede compartir en múltiples casas de prueba.

 struct MyTestFixture {
  char c ;
  int i ;
  float f ;
};

UTEST_F_SETUP ( MyTestFixture ) {
  utest_fixture -> c = 'a' ;
  utest_fixture -> i = 42 ;
  utest_fixture -> f = 3.14f ;

  // we can even assert and expect in setup!
  ASSERT_EQ ( 42 , utest_fixture -> i );
  EXPECT_TRUE (true);
}

UTEST_F_TEARDOWN ( MyTestFixture ) {
  // and also assert and expect in teardown!
  ASSERT_EQ ( 13 , utest_fixture -> i );
}

UTEST_F ( MyTestFixture , a ) {
  utest_fixture -> i = 13 ;
  // teardown will succeed because i is 13...
}

UTEST_F ( MyTestFixture , b ) {
  utest_fixture -> i = 83 ;
  // teardown will fail because i is not 13!
}

Algunas cosas a tener en cuenta que se demostraron anteriormente:

Tenemos esta nueva variable implícita dentro de nuestras macros: UTEST_FIXTURE. Este es un puntero a la estructura que decidió como su accesorio (así que MyTestFixture en el código anterior).
En lugar de especificar un conjunto de casos de prueba (como lo hacemos con la macro UTest), en su lugar especificamos el nombre de la estructura del accesorio que estamos usando.
Cada accesorio tiene que tener un macro UTEST_F_SETUP y UTEST_F_TEARDOWN , incluso si no hacen nada en el cuerpo.
Múltiples Casas de prueba (UTEST_F) pueden usar el mismo accesorio.
Puede usar Macros expects_* y afirmar_* dentro del cuerpo de las macros de configuración y desmontaje del accesorio.

Definir una prueba de prueba indexada

A veces desea usar el mismo accesorio y prueba repetidamente, pero tal vez cambiar sutilmente una variable dentro. Aquí es donde entran las casas de prueba indexadas.

 struct MyTestIndexedFixture {
  bool x ;
  bool y ;
};

UTEST_I_SETUP ( MyTestIndexedFixture ) {
  if ( utest_index < 30 ) {
    utest_fixture -> x = utest_index & 1 ;
    utest_fixture -> y = ( utest_index + 1 ) & 1 ;
  }
}

UTEST_I_TEARDOWN ( MyTestIndexedFixture ) {
  EXPECT_LE ( 0 , utest_index );
}

UTEST_I ( MyTestIndexedFixture , a , 2 ) {
  ASSERT_TRUE ( utest_fixture -> x | utest_fixture -> y );
}

UTEST_I ( MyTestIndexedFixture , b , 42 ) {
  // this will fail when the index is >= 30
  ASSERT_TRUE ( utest_fixture -> x | utest_fixture -> y );
}

Nota:

Utilizamos UTEST_I_* como prefijo para las funciones de configuración y desmontaje ahora.
Utilizamos UTEST_I para declarar las tareas de prueba.
Tenemos acceso a una nueva variable utest_index en nuestras funciones de configuración y desmontaje, que podemos usar para variar ligeramente nuestro accesorio.
Proporcionamos un número como el tercer parámetro de la macro UTEST_I: esta es la cantidad de veces que debemos ejecutar el caso de prueba para ese índice. Debe ser un literal.

Prueba de macros

Combinando lo que tiene Googletest, proporcionamos dos variantes de cada una de las condiciones de verificación de errores: afirma y espera. Si falla un afirmación, el caso de prueba cesará la ejecución, y Utest.h continuará con el próximo caso de prueba que se ejecutará. Si una esperanza falla, el resto del caso de prueba aún se ejecutará, lo que permite realizar más cheques.

Actualmente proporcionamos las siguientes macros que se utilizarán dentro de UTEST:

Afirmar_true (x)

Afirma que X evalúa a verdadero (por ejemplo, distinto de cero).

 UTEST ( foo , bar ) {
  int i = 1 ;
  ASSERT_TRUE ( i );  // pass!
  ASSERT_TRUE ( 42 ); // pass!
  ASSERT_TRUE ( 0 );  // fail!
}

ASSERT_FALSE (X)

Afirma que X se evalúa a falso (por ejemplo, cero).

 UTEST ( foo , bar ) {
  int i = 0 ;
  ASSERT_FALSE ( i ); // pass!
  ASSERT_FALSE ( 1 ); // fail!
}

Afirmar_eq (x, y)

Afirma que X e Y son iguales.

 UTEST ( foo , bar ) {
  int a = 42 ;
  int b = 42 ;
  ASSERT_EQ ( a , b );     // pass!
  ASSERT_EQ ( a , 42 );    // pass!
  ASSERT_EQ ( 42 , b );    // pass!
  ASSERT_EQ ( 42 , 42 );   // pass!
  ASSERT_EQ ( a , b + 1 ); // fail!
}

Afirmar_ne (x, y)

Afirma que X e Y no son iguales.

 UTEST ( foo , bar ) {
  int a = 42 ;
  int b = 13 ;
  ASSERT_NE ( a , b );   // pass!
  ASSERT_NE ( a , 27 );  // pass!
  ASSERT_NE ( 69 , b );  // pass!
  ASSERT_NE ( 42 , 13 ); // pass!
  ASSERT_NE ( a , 42 );  // fail!
}

Afirmar_lt (x, y)

Afirma que x es menor que y.

 UTEST ( foo , bar ) {
  int a = 13 ;
  int b = 42 ;
  ASSERT_LT ( a , b );   // pass!
  ASSERT_LT ( a , 27 );  // pass!
  ASSERT_LT ( 27 , b );  // pass!
  ASSERT_LT ( 13 , 42 ); // pass!
  ASSERT_LT ( b , a );   // fail!
}

Afirmar_le (x, y)

Afirma que x es menor o igual a y.

 UTEST ( foo , bar ) {
  int a = 13 ;
  int b = 42 ;
  ASSERT_LE ( a , b );   // pass!
  ASSERT_LE ( a , 27 );  // pass!
  ASSERT_LE ( a , 13 );  // pass!
  ASSERT_LE ( 27 , b );  // pass!
  ASSERT_LE ( 42 , b );  // pass!
  ASSERT_LE ( 13 , 13 ); // pass!
  ASSERT_LE ( 13 , 42 ); // pass!
  ASSERT_LE ( b , a );   // fail!
}

Afirmar_gt (x, y)

Afirma que x es mayor que y.

 UTEST ( foo , bar ) {
  int a = 42 ;
  int b = 13 ;
  ASSERT_GT ( a , b );   // pass!
  ASSERT_GT ( a , 27 );  // pass!
  ASSERT_GT ( 27 , b );  // pass!
  ASSERT_GT ( 42 , 13 ); // pass!
  ASSERT_GT ( b , a );   // fail!
}

Afirmar_ge (x, y)

Afirma que x es mayor o igual a y.

 UTEST ( foo , bar ) {
  int a = 42 ;
  int b = 13 ;
  ASSERT_GE ( a , b );   // pass!
  ASSERT_GE ( a , 27 );  // pass!
  ASSERT_GE ( a , 13 );  // pass!
  ASSERT_GE ( 27 , b );  // pass!
  ASSERT_GE ( 42 , b );  // pass!
  ASSERT_GE ( 13 , 13 ); // pass!
  ASSERT_GE ( 42 , 13 ); // pass!
  ASSERT_GE ( b , a );   // fail!
}

ASSERT_STREQ (X, Y)

Afirma que las cadenas x e y son iguales.

 UTEST ( foo , bar ) {
  char * a = "foo" ;
  char * b = "bar" ;
  ASSERT_STREQ ( a , a ); // pass!
  ASSERT_STREQ ( b , b ); // pass!
  ASSERT_STREQ ( a , b ); // fail!
}

ASSERT_STRNE (X, Y)

Afirma que las cadenas x e y no son iguales.

 UTEST ( foo , bar ) {
  char * a = "foo" ;
  char * b = "bar" ;
  ASSERT_STRNE ( a , b ); // pass!
  ASSERT_STRNE ( a , a ); // fail!
}

ASSERT_STRNEQ (X, Y)

Afirma que las cadenas x e y son iguales hasta la longitud de la cadena x.

 UTEST ( foo , bar ) {
  char * a = "foobar" ;
  char * b = "foo" ;
  ASSERT_STRNEQ ( a , a ); // pass!
  ASSERT_STRNEQ ( b , b ); // pass!
  ASSERT_STRNEQ ( a , b ); // pass!
}

ASSERT_STRNNE (X, Y)

Afirma que las cadenas x e y no son iguales hasta la longitud de la cadena x.

 UTEST ( foo , bar ) {
  char * a = "foobar" ;
  char * b = "bar" ;
  ASSERT_STRNNE ( a , b ); // pass!
  ASSERT_STRNNE ( a , a ); // fail!
}

ASDERT_NEAR (X, Y, Epsilon)

Afirma que los valores de punto flotante x e y están a la distancia de epsilon entre sí.

 UTEST ( foo , bar ) {
  float a = 42.0f ;
  float b = 42.01f ;
  ASSERT_NEAR ( a , b , 0.01f );  // pass!
  ASSERT_NEAR ( a , b , 0.001f ); // fail!
}

Afirmar_exception (x, excepcion_type)

Afirma que Exception_Type se lanzará cuando se ejecute el Código X.

 void foo ( int bar) {
  if (bar == 1 )
    throw std::range_error;
}

UTEST (foo, bar) {
  ASSERT_EXCEPTION ( foo ( 1 ), std::range_error); // pass!
  ASSERT_EXCEPTION ( foo ( 2 ), std::range_error); // fail!
  ASSERT_EXCEPTION ( foo ( 1 ), std:: exception );   // fail!
}

Expect_true (x)

Espera que X se evalúe como verdadero (es decir, no cero).

 UTEST ( foo , bar ) {
  int i = 1 ;
  EXPECT_TRUE ( i );  // pass!
  EXPECT_TRUE ( 42 ); // pass!
  EXPECT_TRUE ( 0 );  // fail!
}

Espere_false (x)

Espera que X se evalúe en falso (es decir, cero).

 UTEST ( foo , bar ) {
  int i = 0 ;
  EXPECT_FALSE ( i ); // pass!
  EXPECT_FALSE ( 1 ); // fail!
}

Espere_eq (x, y)

Espera que X e Y sean iguales.

 UTEST ( foo , bar ) {
  int a = 42 ;
  int b = 42 ;
  EXPECT_EQ ( a , b );     // pass!
  EXPECT_EQ ( a , 42 );    // pass!
  EXPECT_EQ ( 42 , b );    // pass!
  EXPECT_EQ ( 42 , 42 );   // pass!
  EXPECT_EQ ( a , b + 1 ); // fail!
}

Expect_ne (x, y)

Espera que X e Y no sean iguales.

 UTEST ( foo , bar ) {
  int a = 42 ;
  int b = 13 ;
  EXPECT_NE ( a , b );   // pass!
  EXPECT_NE ( a , 27 );  // pass!
  EXPECT_NE ( 69 , b );  // pass!
  EXPECT_NE ( 42 , 13 ); // pass!
  EXPECT_NE ( a , 42 );  // fail!
}

Expect_lt (x, y)

Espera que X sea menor que y.

 UTEST ( foo , bar ) {
  int a = 13 ;
  int b = 42 ;
  EXPECT_LT ( a , b );   // pass!
  EXPECT_LT ( a , 27 );  // pass!
  EXPECT_LT ( 27 , b );  // pass!
  EXPECT_LT ( 13 , 42 ); // pass!
  EXPECT_LT ( b , a );   // fail!
}

Expect_le (x, y)

Espera que X sea menor o igual a y.

 UTEST ( foo , bar ) {
  int a = 13 ;
  int b = 42 ;
  EXPECT_LE ( a , b );   // pass!
  EXPECT_LE ( a , 27 );  // pass!
  EXPECT_LE ( a , 13 );  // pass!
  EXPECT_LE ( 27 , b );  // pass!
  EXPECT_LE ( 42 , b );  // pass!
  EXPECT_LE ( 13 , 13 ); // pass!
  EXPECT_LE ( 13 , 42 ); // pass!
  EXPECT_LE ( b , a );   // fail!
}

Expect_gt (x, y)

Espera que X sea mayor que y.

 UTEST ( foo , bar ) {
  int a = 42 ;
  int b = 13 ;
  EXPECT_GT ( a , b );   // pass!
  EXPECT_GT ( a , 27 );  // pass!
  EXPECT_GT ( 27 , b );  // pass!
  EXPECT_GT ( 42 , 13 ); // pass!
  EXPECT_GT ( b , a );   // fail!
}

Expect_ge (x, y)

Espera que X sea mayor o igual a y.

 UTEST ( foo , bar ) {
  int a = 42 ;
  int b = 13 ;
  EXPECT_GE ( a , b );   // pass!
  EXPECT_GE ( a , 27 );  // pass!
  EXPECT_GE ( a , 13 );  // pass!
  EXPECT_GE ( 27 , b );  // pass!
  EXPECT_GE ( 42 , b );  // pass!
  EXPECT_GE ( 13 , 13 ); // pass!
  EXPECT_GE ( 42 , 13 ); // pass!
  EXPECT_GE ( b , a );   // fail!
}

Espere_streq (x, y)

Espera que las cadenas x e y sean iguales.

 UTEST ( foo , bar ) {
  char * a = "foo" ;
  char * b = "bar" ;
  EXPECT_STREQ ( a , a ); // pass!
  EXPECT_STREQ ( b , b ); // pass!
  EXPECT_STREQ ( a , b ); // fail!
}

Espere_strne (x, y)

Espera que las cadenas x e y no sean iguales.

 UTEST ( foo , bar ) {
  char * a = "foo" ;
  char * b = "bar" ;
  EXPECT_STRNE ( a , b ); // pass!
  EXPECT_STRNE ( a , a ); // fail!
}

Espere_strneq (x, y)

Espera que las cadenas x e y sean iguales hasta la longitud de la cadena x.

 UTEST ( foo , bar ) {
  char * a = "foobar" ;
  char * b = "foo" ;
  EXPECT_STRNEQ ( a , a ); // pass!
  EXPECT_STRNEQ ( b , b ); // pass!
  EXPECT_STRNEQ ( a , b ); // pass!
}

Espere_strnne (x, y)

Espera que las cadenas x e y no sean iguales hasta la longitud de la cadena x.

 UTEST ( foo , bar ) {
  char * a = "foobar" ;
  char * b = "bar" ;
  EXPECT_STRNNE ( a , b ); // pass!
  EXPECT_STRNNE ( a , a ); // fail!
}

Expect_near (x, y, epsilon)

Espera que los valores de punto flotante x e y estén a la distancia de epsilon entre sí.

 UTEST ( foo , bar ) {
  float a = 42.0f ;
  float b = 42.01f ;
  EXPECT_NEAR ( a , b , 0.01f );  // pass!
  EXPECT_NEAR ( a , b , 0.001f ); // fail!
}

Espere_Exception (x, excepcion_type)

Espera que Exception_Type se arroje cuando se ejecute el Código X.

 void foo ( int bar) {
  if (bar == 1 )
    throw std::range_error;
}

UTEST (foo, bar) {
  EXPECT_EXCEPTION ( foo ( 1 ), std::range_error); // pass!
  EXPECT_EXCEPTION ( foo ( 2 ), std::range_error); // fail!
  EXPECT_EXCEPTION ( foo ( 1 ), std:: exception );   // fail!
}

Espere_exception_with_message (x, excepción_type, excepcion_message)

Espera que Exception_Type se arroje con Mensaje Exception_Message cuando se ejecute el código X.

 void foo ( int bar) {
  if (bar == 1 )
    throw std::range_error ( " bad bar " );
}

UTEST (foo, bar) {
  EXPECT_EXCEPTION_WITH_MESSAGE ( foo ( 1 ), std::range_error, " bad bar " ); // pass!
  EXPECT_EXCEPTION_WITH_MESSAGE ( foo ( 2 ), std::range_error, " bad bar2 " ); // fail!
  EXPECT_EXCEPTION_WITH_MESSAGE ( foo ( 1 ), std:: exception , " bad bar " );   // fail!
}

Utest_skip (msg)

Esta macro le permite marcar un caso de prueba como omitido, por ejemplo. que el caso de prueba no debe ser ejecutado. La prueba dejará de ejecutarse a medida que ejecute la macro, informa el msg como el motivo del omitido y marcará la prueba como 'omitido' . Estos se informarán al final de la ejecución antes de las fallas, y los casos de prueba omitidos no harán que el proceso salga con un código distinto de cero.

 UTEST ( foo , bar ) {
  UTEST_SKIP ( "Need to implement this test!" );
}

Prueba de macros con un mensaje personalizado

Además, para dar la posibilidad de tener mensajes personalizados en las pruebas de falla, todas las macros se pueden usar con un sufijo llamado "_msg", que recibe un parámetro adicional, que es la cadena con el mensaje personalizado para imprimir en caso de falla.

Por ejemplo:

 UTEST ( foo , bar ) {
  int i = 1 ;
  EXPECT_TRUE_MSG ( i , "custom message" );  // pass!
  EXPECT_TRUE_MSG ( 42 , "custom message" ); // pass!
  EXPECT_TRUE_MSG ( 0 , "custom message" );  // fail! (with the following output)
}

 test.cpp:42: Failure
  Expected : true
    Actual : false
   Message : custom message
[  FAILED  ] foo.bar (8086ns)

Tipos compatibles con cheques

La biblioteca admite afirmar en cualquier entero integrado, punto flotante o tipo de puntero.

Licencia

Este es un software gratuito y sin gravación lanzado en el dominio público.

Cualquier persona es libre de copiar, modificar, publicar, usar, compilar, vender o distribuir este software, ya sea en formulario de código fuente o como un binario compilado, para cualquier propósito, comercial o no comercial, y por cualquier medio.

En jurisdicciones que reconocen las leyes de derechos de autor, el autor o autores de este software dedican todos y cada uno de los intereses de los derechos de autor en el software al dominio público. Hacemos esta dedicación en beneficio del público en general y en detrimento de nuestros herederos y sucesores. Tenemos la intención de que esta dedicación sea un acto manifiesto de renuncia a perpetuidad de todos los derechos presentes y futuros de este software bajo la ley de derechos de autor.

El software se proporciona "tal cual", sin garantía de ningún tipo, expresa o implícita, incluidas, entre otros, las garantías de comerciabilidad, idoneidad para un propósito particular y no infracción. En ningún caso los autores serán responsables de ningún reclamo, daños u otra responsabilidad, ya sea en una acción de contrato, agravio o de otro modo, surgiendo, de o en relación con el software o el uso u otros tratos en el software.

Para obtener más información, consulte http://unlicense.org/

Expandir