Comment tester le multi-paramètre de la formule

Je suis refactoring du code qui implémente une formule et je veux le faire en testant d'abord, pour améliorer mes tests de compétences, et de laisser le code couvert.

De ce morceau de code est une formule qui prend 3 paramètres et renvoie une valeur. J'ai aussi des tables de données avec les résultats attendus pour les différentes entrées, donc, en théorie, je pourrais juste taper un tas de tests, simplement en changeant les paramètres d'entrée et de vérification des résultats contre l'correspondant à la valeur attendue.

Mais j'ai pensé qu'il devrait y avoir une meilleure façon de le faire, et de regarder les docs que j'ai trouvé de la Valeur Paramétrée Tests.

Donc, avec ce que je sais maintenant comment créer automatiquement les tests pour les différentes entrées.
Mais comment puis-je obtenir le correspondant prévu suite à la comparer avec mon calculé?

La seule chose que je ai été en mesure de venir avec de statique dans la table de recherche et un membre statique dans le texte de montage qui est un indice de la table de recherche et est incrémenté à chaque exécution. Quelque chose comme ceci:

#include "gtest/gtest.h"

double MyFormula(double A, double B, double C)
{
    return A*B - C*C;   //Example. The real one is much more complex
}

class MyTest:public ::testing::TestWithParam<std::tr1::tuple<double, double, double>>
{
protected:

    MyTest(){ Index++; }
    virtual void SetUp()
    {
        m_C = std::tr1::get<0>(GetParam());
        m_A = std::tr1::get<1>(GetParam());
        m_B = std::tr1::get<2>(GetParam());
    }

    double m_A;
    double m_B;
    double m_C;

    static double ExpectedRes[];
    static int Index;

};

int MyTest::Index = -1;

double MyTest::ExpectedRes[] =
{
//              C = 1
//     B:   1     2     3     4     5     6     7     8     9    10
/*A =  1*/ 0.0,  1.0,  2.0,  3.0,  4.0,  5.0,  6.0,  7.0,  8.0,  9.0, 
/*A =  2*/ 1.0,  3.0,  5.0,  7.0,  9.0, 11.0, 13.0, 15.0, 17.0, 19.0, 
/*A =  3*/ 2.0,  5.0,  8.0, 11.0, 14.0, 17.0, 20.0, 23.0, 26.0, 29.0, 

//              C = 2
//     B:     1     2     3     4     5     6     7     8     9    10
/*A =  1*/  -3.0, -2.0, -1.0,  0.0,  1.0,  2.0,  3.0,  4.0,  5.0,  6.0, 
/*A =  2*/  -2.0,  0.0,  2.0,  4.0,  6.0,  8.0, 10.0, 12.0, 14.0, 16.0, 
/*A =  3*/  -1.0,  2.0,  5.0,  8.0, 11.0, 14.0, 17.0, 20.0, 23.0, 26.0, 
};

TEST_P(MyTest, TestFormula)
{
    double res = MyFormula(m_A, m_B, m_C);
    ASSERT_EQ(ExpectedRes[Index], res);
}

INSTANTIATE_TEST_CASE_P(TestWithParameters,  
                        MyTest,  
                        testing::Combine( testing::Range(1.0, 3.0), //C
                                          testing::Range(1.0, 4.0), //A 
                                          testing::Range(1.0, 11.0) //B
                                          ));  

Est-ce une bonne approche ou est-il une meilleure façon d'obtenir le bon résultat attendu pour chaque course?

OriginalL'auteur MikMik | 2012-01-23