googletest - google test framework

GoogleTest: cómo omitir una prueba?

Question

Usando 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

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

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

Answer 2

Los docs para Google Test 1.7 suggest :

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

Answer 3

Para otro enfoque, puede ajustar 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 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 falta de) mediante la construcción de sockets falsos.

El único inconveniente es que la salida de la prueba y el número de pruebas cambiarán, lo que podría causar problemas con algo que controle 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 4

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 característica única 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 características utilizando comodines y escribiendo una lista, "MyLibrary.TestNetwork *" o "-MyLibrary.TestFileSystem *".

Answer 5

Si se necesita más de una prueba, omita

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

Answer 6

También puede ejecutar un subconjunto de pruebas , según la documentación:

Ejecutando un subconjunto de las pruebas

De forma predeterminada, un programa de prueba de Google ejecuta todas las pruebas que el usuario haya definido. A veces, desea ejecutar solo un subconjunto de las pruebas (por ejemplo, para la depuración o para 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 una '':'' - lista separada de patrones comodín (llamados patrones positivos) opcionalmente seguida de ''-'' y otra '':'' - lista de patrones separados (llamados 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 personaje) 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 bonita, pero funciona.

Answer 7

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, el tiempo de ejecución evaluado en main.cpp ANTES de iniciar las pruebas. Las pruebas que evalúan falso no se ejecutan. El macro es feo, pero parece que:

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