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
Vous devez vous connecter pour publier un commentaire.
Inclure le résultat attendu avec les entrées. Au lieu d'un triplet de valeurs d'entrée, de faire votre test de paramètre 4-tuple.
L'inconvénient est que vous ne serez pas en mesure de garder vos paramètres de test concis avec
testing::Combine
. Au lieu de cela, vous pouvez utilisertesting::Values
de définir chacun d'eux 4-tuple vous souhaitez tester. Vous pourriez frapper l'argument-limite de nombre pourValues
, de sorte que vous pouvez séparer votre instanciations, comme le fait de mettre toutes les C = 1 des affaires dans un seul et tous les C = 2 cas dans l'autre.Ou vous pouvez mettre toutes les valeurs dans un tableau séparé de votre instanciation et ensuite utiliser
testing::ValuesIn
:OriginalL'auteur Rob Kennedy
Voir codage en dur le résultat attendu est comme vous limiter à nouveau le pas de cas de test. Si vous souhaitez obtenir un ensemble complet de données modèle, je préfère vous suggérons de lire les entrées, les résultats attendus à partir d'un fichier plat/xml/xls fichier.
C'est très bien. Si vous ajoutez vos données de test au sein de votre classe de test, le problème sera, dans l'avenir si vous voulez tester un autre scénario, alors vous devez mettre à jour votre classe à nouveau. Mais si vous accédez à vos données de test à partir d'un fichier externe, alors votre cas de test de maintenabilité sera réduit. Parce que vous allez mettre à jour que les fichiers à plat pour ajouter un nouveau test de données. c'est tout. Pas besoin de construire votre classe, puis de nouveau de le déployer.
tu veux dire que les cas de test de maintenabilité sera augmenté, droite? L'effort nécessaire pour le maintenir sera réduit.
OriginalL'auteur Pritam Karmakar
Je n'ai pas beaucoup d'expérience avec les tests unitaires, mais en tant que mathématicien, je pense qu'il n'est pas un beaucoup plus que vous pourriez faire.
Si vous connaissez certains invariants de votre formule, vous pouvez les tester, mais je pense que ne n'a de sens que dans très peu de scénarios.
Comme un exemple, si vous voulez tester, si vous avez correctement mis en œuvre la fonction exponentielle naturelle, vous pourriez faire usage de la connaissance, qu'il est dérivé doit avoir la même valeur que la fonction elle-même. Vous pouvez ensuite calculer une approximation numérique de la dérivée pour un million de points et de voir si elles sont à proximité de la réelle valeur de la fonction.
OriginalL'auteur DanT