GoogleTest: ¿Cómo omitir una prueba?

Utilizando 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?

Los documentos de Google Test 1.7 sugieren :

"Si tiene una prueba rota que no puede corregir de inmediato, puede agregar el prefijo DISABLED_ a su nombre. Esto la excluirá 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) { ... }

También puede ejecutar un subconjunto de pruebas , de acuerdo con la documentación:

Ejecución de un subconjunto de pruebas

De forma predeterminada, un programa de prueba de Google ejecuta todas las pruebas que el usuario ha definido. A veces, desea ejecutar solo un subconjunto de las pruebas (por ejemplo, para depurar o verificar rápidamente un cambio). Si configura la variable de entorno GTEST_FILTER o la marca --gtest_filter en una cadena de filtro, Google Test solo ejecutará las pruebas cuyos nombres completos (en forma de TestCaseName.TestName) coincidan con el filtro.

El formato de un filtro es una ':' - lista separada de patrones comodín (llamados patrones positivos) seguida opcionalmente por un '-' y otro ':' - lista de patrones separados (llamados patrones negativos). Una prueba coincide con el filtro si y solo si coincide con alguno 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). Por conveniencia, 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 bonita, pero funciona.

Ahora puede usar la GTEST_SKIP()macro para omitir condicionalmente una prueba en tiempo de ejecución. Por ejemplo:

TEST(Foo, Bar)
{
    if (blah)
        GTEST_SKIP();

    ...
}

Tenga en cuenta que esta es una característica muy reciente, por lo que es posible que deba actualizar su biblioteca de GoogleTest para usarla.

Aquí está la expresión para incluir pruebas cuyos nombres tienen las cadenas foo1 o foo2 y excluir las pruebas cuyos nombres tienen las cadenas bar1 o bar2 en ellas:

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

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 ambas líneas para ejecutar todas las pruebas, descomentar la primera línea para probar una sola característica que estoy investigando / trabajando, o descomentar la segunda línea si una prueba está rota pero quiero probar todo lo demás.
También puede probar / excluir un conjunto de funciones utilizando comodines y escribiendo una lista, "MyLibrary.TestNetwork *" o "-MyLibrary.TestFileSystem *".

Si se necesita más de una prueba, omita

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

Para otro enfoque, puede envolver sus pruebas en una función y usar verificaciones condicionales normales en tiempo de ejecución para ejecutarlas solo 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 intento ejecutar algunas pruebas solo cuando un sistema admite IPv6 de doble pila.

Técnicamente, ese material de pila dual no debería ser una prueba unitaria, 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 la falla de los códigos.

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

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

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

Tenía la misma necesidad de 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, evaluado en tiempo de ejecución en main.cpp ANTES de que se inicien las pruebas. Las pruebas que evalúan falso no se ejecutan. La macro es fea, pero se ve así:

#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 ciclo para excluir las pruebas que evalúan falso:

// 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();