Estoy usando TDD y Google Test para un proyecto que involucra simulaciones numéricas. El estado de los datos se cambia dentro de un bucle en elmain función, pero hay requisitos que deben cumplirse después de cada cambio. Si se cumplen todos los requisitos para un caso de prueba, la prueba de aceptación fue aprobada:

while(simulation)
     modify simulation data
     FIRST_TEST()
     some other simulation operations
     SECOND_TEST()

losPrimer cebo indica que normalmente se llama a RUN_ALL_TESTS (). losGuia avanzada muestra cómo ejecutar sub-pruebas, porfiltrando pruebas desde RUN_ALL_TESTS. Sin embargo, me gustaría saber cómo invocar pruebas individualmente.

De lo contrario, tendría que escribir una nueva aplicación de prueba de aceptación cada vez que necesite una nueva prueba como FIRST_ y SECOND_ en el fragmento de pseudocódigo anterior.

Algunos antecedentes más: estoy usando el marco de trabajo de OpenFOAM para Computational Fluid Dynamics, por lo que estoy creando dispositivos globales fuera demain no es una opinión. La aplicación de simulación requiere un directorio y archivos de configuración para ejecutarse, y los objetos globales en main están correlacionados (se requieren entre sí para la inicialización). Un ejemplo de tal aplicación esOpenFOAM-2.2.x.

Notas Adicionales

Tomé la respuesta aceptada y la respuesta sobre cómo usar argc y argv como variables globales dentro de la prueba encontrada enotra pregunta sobre desbordamiento de pila y resumí esto en este pequeño modelo compilable, tal vez alguien lo encuentre útil:

#include <gtest/gtest.h>
#include <iostream>

class Type 
{
    int value_ = 0;
    int times_ = 1; 

    public: 

        Type(int x) : value_(x) {}; 

        void operator()(){
            if (times_ < 10) {
                ++times_; 
                value_ *= times_; 
            }
        }

        int value () const { return value_; } 
}; 

class mySeparatedTests : public ::testing::Test 
{
    protected:

      template<typename Type>
      void TEST_ONE(Type const &t)
      {
          ASSERT_TRUE((t.value() % 2) == 0); 
      }

      template<typename Type> 
      void TEST_TWO(Type const & t)
      {
          ASSERT_TRUE((t.value() - 5) > 0); 
      }
};

TEST_F(mySeparatedTests, testName)
{
    extern char** globalArgv; 
    char** argv = globalArgv;

    // Simulation parameters and objects requiring argc and argv for initialization. 
    int simulationEndTime;  

    *argv[1] >> simulationEndTime;  

    Type typeObject(*argv[2]); 

    TEST_ONE(typeObject); 

    // Simulation loop. 
    for (int i = 0; i < simulationEndTime; ++i)
    {
        typeObject(); 

        TEST_TWO(typeObject); 
    }
}

int globalArgc; 
char** globalArgv; 

int main(int argc, char **argv)
{
    ::testing::InitGoogleTest(&argc, argv);

    globalArgc = argc; 
    globalArgv = argv; 

    return RUN_ALL_TESTS(); 

    return 0; 
}

Este enfoque, como se describe en la respuesta aceptada, transmite el código de simulación demain en TEST_F, y usa elmySeparatedTests Funciones de clase para definir pruebas individuales, que luego pueden ser llamadas en cualquier lugar. Esto se compila con:

g++ -std=c++11 -l gtest main.cpp  -o main

Y las pruebas fallan / pasan dependiendo de los pares de parámetros analizados;

esto falla:

./main 1 1 

esto tiene éxito

./main 2 2 

Nota: Soy consciente de que está ocurriendo la conversión char / int; esto es sólo para mostrar cómo recoger args.