GoogleTest: ¿Cómo omitir una prueba?

Question

Uso de Google Test 1.6 (Windows 7, Visual Studio C++). ¿Cómo puedo desactivar una prueba determinada? (también conocido como ¿cómo puedo evitar que se ejecute una prueba). ¿Hay algo que pueda hacer además de comentar toda la prueba?

Answer 1

El docs de Google Prueba 1.7 suggest:

"Si usted tiene una prueba rota que no se puede arreglar de inmediato, puede agregar el prefijo a su nombre DISABLED_ Esto puede excluirlo de la ejecución."

Ejemplos:

// Tests that Foo does Abc. 
TEST(FooTest, DISABLED_DoesAbc) { ... } 

class DISABLED_BarTest : public ::testing::Test { ... }; 

// Tests that Bar does Xyz. 
TEST_F(DISABLED_BarTest, DoesXyz) { ... } 

Answer 2

Puede también run a subset of tests, de acuerdo con la documentación:

Ejecución de un subconjunto de las pruebas

Por defecto, un programa de prueba de Google funciona todo pruebas que el usuario ha definido. A veces, desea ejecutar solo un subconjunto de las pruebas (por ejemplo, para la depuración o verificar rápidamente un cambio). Si establece la variable de entorno GTEST_FILTER o el indicador --gtest_filter en una cadena de filtro, Google Test solo ejecutará las pruebas cuyos nombres completos (en forma de TestCaseName.TestName) coinciden con el filtro.

El formato de un filtro es un ':' - lista separada de los patrones de comodín (llamado los patrones positivos) opcionalmente seguido por un '-' y otra ':' - lista de patrones separados (llamado los patrones negativos) . Una prueba coincide con el filtro si y solo si coincide con cualquiera de los patrones positivos , pero no coincide con ninguno de los patrones negativos.

Un patrón puede contener '*' (coincide con cualquier cadena) o '?' (coincide con cualquier carácter individual). Para mayor comodidad, el filtro '* -NegativePatterns' también se puede escribir como '-NegativePatterns'.

Por ejemplo:

./foo_test Has no flag, and thus runs all its tests. 
./foo_test --gtest_filter=* Also runs everything, due to the single match-everything * value. 
./foo_test --gtest_filter=FooTest.* Runs everything in test case FooTest. 
./foo_test --gtest_filter=*Null*:*Constructor* Runs any test whose full name contains either "Null" or "Constructor". 
./foo_test --gtest_filter=-*DeathTest.* Runs all non-death tests. 
./foo_test --gtest_filter=FooTest.*-FooTest.Bar Runs everything in test case FooTest except FooTest.Bar. 

No es la solución más bonito, pero funciona.

Answer 3

Si se necesitan más de una prueba se omiten

--gtest_filter=-TestName.*:TestName.*TestCase 

Answer 4

Por otro enfoque, se puede envolver en sus pruebas de función y el uso de los controles normales en tiempo de ejecución condicional sólo ejecutarlos si lo desea.

#include <gtest/gtest.h> 

const bool skip_some_test = true; 

bool some_test_was_run = false; 

void someTest() { 
    EXPECT_TRUE(!skip_some_test); 
    some_test_was_run = true; 
} 

TEST(BasicTest, Sanity) { 
    EXPECT_EQ(1, 1); 
    if(!skip_some_test) { 
     someTest(); 
     EXPECT_TRUE(some_test_was_run); 
    } 
} 

Esto es útil para mí, ya que estoy tratando de ejecutar algunas pruebas solo cuando un sistema es compatible con doble pila IPv6.

Técnicamente, las cosas de doble pila no deberían ser realmente una prueba de unidad, ya que depende del sistema. Pero realmente no puedo hacer ninguna prueba de integración hasta que haya probado que funcionan de todos modos y esto garantiza que no informará fallas cuando no sea culpa de los códigos.

En cuanto a la prueba, tengo objetos que simulan el soporte de un sistema para dualstack (o la falta de) construyendo sockets falsos.

El único inconveniente es que la salida de prueba y el número de pruebas cambiará, lo que podría causar problemas con algo que monitorea la cantidad de pruebas exitosas.

También puede usar ASSERT_ * en lugar de EQUAL_ *. Assert será sobre el resto de la prueba si falla. Evita que se descarguen muchas cosas redundantes en la consola.

Answer 5

Aquí es la expresión de incluir pruebas cuyos nombres tienen las cadenas foo1 o foo2 en ellos y no incluyen pruebas cuyos nombres tienen la Bar1 cuerdas o bar2 en ellos:

--gtest_filter=*foo1*:*foo2*-*bar1*:*bar2* 

Answer 6

prefiero hacerlo en código:

// Run a specific test only 
//testing::GTEST_FLAG(filter) = "MyLibrary.TestReading"; // I'm testing a new feature, run something quickly 

// Exclude a specific test 
testing::GTEST_FLAG(filter) = "-MyLibrary.TestWriting"; // The writing test is broken, so skip it 

puedo comentar ya sea a cabo ambas líneas a ejecutar todas las pruebas, elimine la primera línea para poner a prueba una sola característica que estoy investigando/trabajando, o elimine el comentario de segunda línea si una prueba se rompe pero quiero para probar todo lo demás.
También puede probar/excluir un conjunto de características utilizando comodines y escribiendo una lista, "MyLibrary.TestNetwork *" o "-MyLibrary.TestFileSystem *".

Answer 7

Tuve la misma necesidad de realizar pruebas condicionales, y descubrí una buena solución. Definí una macro TEST_C que funciona como una macro TEST_F, pero tiene un tercer parámetro, que es una expresión booleana, el tiempo de ejecución evaluado en main.cpp ANTES de iniciar las pruebas. Las pruebas que evalúan falso no se ejecutan. La macro es feo, pero que se vea como:

#pragma once 
extern std::map<std::string, std::function<bool()> >* m_conditionalTests; 
#define TEST_C(test_fixture, test_name, test_condition)\ 
class test_fixture##_##test_name##_ConditionClass\ 
{\ 
    public:\ 
    test_fixture##_##test_name##_ConditionClass()\ 
    {\ 
     std::string name = std::string(#test_fixture) + "." + std::string(#test_name);\ 
     if (m_conditionalTests==NULL) {\ 
      m_conditionalTests = new std::map<std::string, std::function<bool()> >();\ 
     }\ 
     m_conditionalTests->insert(std::make_pair(name, []()\ 
     {\ 
      DeviceInfo device = Connection::Instance()->GetDeviceInfo();\ 
      return test_condition;\ 
     }));\ 
    }\ 
} test_fixture##_##test_name##_ConditionInstance;\ 
TEST_F(test_fixture, test_name) 

Además, en su main.cpp, necesita este bucle para excluir las pruebas que evalúan falsa:

// identify tests that cannot run on this device 
std::string excludeTests; 
for (const auto& exclusion : *m_conditionalTests) 
{ 
    bool run = exclusion.second(); 
    if (!run) 
    { 
     excludeTests += ":" + exclusion.first; 
    } 
} 

// add the exclusion list to gtest 
std::string str = ::testing::GTEST_FLAG(filter); 
::testing::GTEST_FLAG(filter) = str + ":-" + excludeTests; 

// run all tests 
int result = RUN_ALL_TESTS();