Discussion :

[baring]

Bonsoir,

Je suis nouveau et je débute en programmation sur C++. J'aimerais savoir s'il est possible de tester juste une partie de son code pour voir s'il effectue bien ce qu'on lui demande. Je m'explique, par exemple, dans mon int main() je veux approcher le cosinus d'un nombre par un développement en série mais j'ai besoin de certaine fonctions annexes tel qu'une fonction factorielle entre autre et je voudrais juste tester cette fonction pour voir si elle est juste. Est-il possible de faire ça ? Parce que ça m'embête de devoir taper tout mon programme et seulement après la compilation de m'apercevoir que toutes mes fonctions sont mal codées...

Merci de votre aide

[Detenu-1_0-J_6_4]

Salut, je ne sais pas comment tu compiles ton code, mais à priori je dirais, utilise ton Debugger c'est très facile. si tu ne sais pas comment t'en servir, recherche sur le net Debugger de mon «IDE» IDE ici est pour l'outil de compilation que tu utilises. Bonne suite

[baring]

...

Merci de ton aide Dr_Frankenstein. Alors moi j'utilise geany et pour compiler je fais simplement F9 puis F5 pour exécuter le programme et ouvrir ma console. Donc si j'ai bien compris "debugger" ça permet d'identifier mes fautes de codage ? mais si la fonction que j'ai tapé est juste mais qu'elle ne fait pas ce que j'attend y a pas un moyen de la tester à part ?

[Detenu-1_0-J_6_4]

Le test avec le Test unitaire c'est une très bonne méthode dont il faut prendre l'habitude très tôt; mais ce que moi je conseillerai, c'est d'utiliser cette méthode que lorsqu'il s'agit de programme suffisamment costaud et difficilement debuggable. et puis le debuggeur aussi avec le temps d'aidera aussi à mieux connaître et à apprécier ton IDE

[Bktero]

Le test avec le Test unitaire c'est une très bonne méthode dont il faut prendre l'habitude très tôt; mais ce que moi je conseillerai, c'est d'utiliser cette méthode que lorsqu'il s'agit de programme suffisamment costaud et difficilement debuggable. et puis le debuggeur aussi avec le temps d'aidera aussi à mieux connaître et à apprécier ton IDE

Ces deux choses n'ont rien à voir.

Les tests unitaires valident du code (s'ils sont bien faits).

Le debuger est un outilo pour mieux comprendre l'exécution d'un code, souvent dans le but de comprendre pourquoi il ne fonctionne pas comme souhaité.

Que débogguer si tu n'as pas un programme de tests ? Le debuger peut justement servir à comprendre pourquoi tes tests unitaires sont en échec.

[Bousk]

Inutile de sortir l'artillerie lourde de tests unitaires dans un premier temps.
Perso je me content d'une simple macro pour commencer #define ASSERT(x) do { if (x) { std::cout<<"[OK]"<<#x<<std::endl; } else { std::cout<<"[FAILURE] " << #x <<std::endl; } } while(0)
Puis tu peux affiner autant que tu veux selon ce que tu tests (si je test que des égalités, cette seule macro me suffit)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#define ASSERT_OK(x, y, op) do { std::cout<<"[OK] "<< #x <<op<< #y << std::endl; } while(0)
#define ASSERT_KO(x, y, op) do { std::cout<<[FAILURE] " #x <<op<< #y << std::endl; } while(0)
#define ASSERT_EQUAL(x, y) do { const auto _x = (x); const auto _y = (y); if (_x == _y) { ASSERT_EQUAL_OK(x, y, "=="); } else { ASSERT_EQUAL_KO(x, y, "!="); } } while(0)
#define ASSERT_SUP(x, y) do { const auto _x = (x); const auto _y = (y); if (_x > _y) { ASSERT_EQUAL_OK(x, y, ">"); } else { ASSERT_EQUAL_KO(x, y, "<="); } } while(0)

Puis tu peux ajouter de la couleur, rouge en cas d'échec par exemple, etc...
https://stackoverflow.com/questions/...console-with-c

Tu peux aller très loin, d'où l'existence de frameworks de test entiers, à toi de voir ce que tu veux faire.

[Detenu-1_0-J_6_4]

Ces deux choses n'ont rien à voir.

Les tests unitaires valident du code (s'ils sont bien faits).

Le debuger est un outilo pour mieux comprendre l'exécution d'un code, souvent dans le but de comprendre pourquoi il ne fonctionne pas comme souhaité.

Que débogguer si tu n'as pas un programme de tests ? Le debuger peut justement servir à comprendre pourquoi tes tests unitaires sont en échec.

Jusqu'ici je n'ai déjà eu besoin de test unitaire qu'en Java à cause de son Garbage Collector qui me simplifie la tache, mais en C++ et C j'utilise couramment mon simple debugger pour comprendre effectivement bien comment tout se passe et du cout je peux me passer des tests unitaires. Mais attention je ne refute pas la puissance du test unitaire, je dis juste que le debugger peut avoir une autre utilisation que debugger

[Pyramidev]

Bonjour,

Voici un bout de code qui répond au besoin :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <iostream>
 
int factorielle(int param)
{
	// code
}
 
int puissance(int x, int y)
{
	// code
}
 
void tester_factorielle()
{
	if(factorielle(0) != 1)
		std::cout << __func__ << " : factorielle(0) aurait du valoir 1 mais vaut " << factorielle(0) << ".\n";
	if(factorielle(1) != 1)
		std::cout << __func__ << " : factorielle(1) aurait du valoir 1 mais vaut " << factorielle(1) << ".\n";
	if(factorielle(2) != 2)
		std::cout << __func__ << " : factorielle(2) aurait du valoir 2 mais vaut " << factorielle(2) << ".\n";
	if(factorielle(5) != 120)
		std::cout << __func__ << " : factorielle(5) aurait du valoir 120 mais vaut " << factorielle(5) << ".\n";
}
 
void tester_puissance()
{
	if(puissance(55, 0) != 1)
		std::cout << __func__ << " : puissance(55, 0) aurait du valoir 1 mais vaut " << puissance(55, 0) << ".\n";
	if(puissance(0, 55) != 0)
		std::cout << __func__ << " : puissance(0, 55) aurait du valoir 0 mais vaut " << puissance(0, 55) << ".\n";
	if(puissance(-2, 9) != -512)
		std::cout << __func__ << " : puissance(-2, 9) aurait du valoir -512 mais vaut " << puissance(-2, 9) << ".\n";
}
 
void lancer_les_tests_unitaires()
{
	std::cout << "Lancement des tests unitaires...\n";
	tester_factorielle();
	tester_puissance();
	std::cout << "Fin des tests.\n";
}
 
int main()
{
	lancer_les_tests_unitaires();
	return 0;
}

Écrire des tests pour vérifier le bon fonctionnement des morceaux du programme est une très bonne initiative.
De tels tests s'appellent des tests unitaires.
Quand on décide de modifier le code mais que l'on craint que, en faisant cela, on ajoute un bogue par étourderie, il suffit de lancer la batterie des tests unitaires. Si on a fait une bêtise, on le verra vite.
Tu remarqueras que je n'affiche que les tests qui échouent. C'est volontaire. Le jour où il y aura plusieurs centaines de tests unitaires, on ne voudra pas lire à chaque fois un gros paquet de texte pour vérifier si tout a bien réussi.

Cela dit, dans du code plus soigné mais plus technique, pour écrire des tests unitaires, on écrit un code moins lourd que celui que j'ai écrit. Par exemple, à la place de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
	if(factorielle(5) != 120)
		std::cout << __func__ << " : factorielle(5) aurait du valoir 120 mais vaut " << factorielle(5) << ".\n";

on écrirait plutôt un code du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

VERIFIER_VALEUR_REELLE_EGALE_VALEUR_ATTENDUE(factorielle(5), 120);

avec VERIFIER_VALEUR_REELLE_EGALE_VALEUR_ATTENDUE une macro-fonction qui fait le boulot de comparaison et de formatage du message d'erreur en cas d'inégalité.

Et dans du code encore meilleur, au lieu de réinventer la roue en bricolant des macro-fonctions comme VERIFIER_VALEUR_REELLE_EGALE_VALEUR_ATTENDUE, on utiliserait un framework de tests unitaires, comme Boost.Test.

Mais si tu débutes alors, les frameworks de tests unitaires, ce sera pour plus tard. En attendant, tu peux faire des tests unitaires avec du code un peu lourd mais accessible comme celui que j'ai écrit au début de mon message.

[baring]

...

Merci Pyramidev c'est exactement ça que je cherchais !

[foetus]

Comme l'a dit Pyramidev, faire un "script" est une solution rapide à coder.
Et tu as l'avantage de la ligne de commande: tu peux l'exécuter n'importe quand et rapidemment.

Après tu peux chercher des bibliothèques comme Google Test. Mais fais attention , c'est rempli de buzzword: dummy, fake, stub, mock, spy, ... (<- la différence est très subtile, et moi par exemple, j'ai déjà utilisé certains sans le savoir )

Ensuite je ne suis pas d'accord avec Pyramidev sur l'affichage d'un résultat . Un résultat doit dire si il a réussi ou échoué, quel est le but du test et avoir un compteur.
Donc un test comme ceci; par exemple, pour tester la validation d'une chaîne de caractères: (ma fonction validate_text_input doit prendre plus de paramètres, mais j'ai simplifié pour l'exemple)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
void test_validate_text_input() {
    int count = 1;
 
    std::printf("%02d - validate_text_input - test empty str : %s", count, (( validate_text_input("") )? "success": "fail"));
    ++count;
 
//  On inverse le retour pour savoir si la fonction a le bon comportement
    std::printf("%02d - validate_text_input - length str < min : %s", count, ((!validate_text_input("123"))? "success": "fail"));
    ++count;
 
    std::printf("%02d - validate_text_input - length str == min : %s", count, (( validate_text_input("12345") )? "success": "fail"));
    ++count;
 
//  On inverse le retour pour savoir si la fonction a le bon comportement
    std::printf("%02d - validate_text_input - length str > max : %s", count, ((!validate_text_input("123456789012345678901234567890123"))? "success": "fail"));
    ++count;
 
    std::printf("%02d - validate_text_input - length str == max : %s", count, (( validate_text_input("12345678901234567890123456789") )? "success": "fail"));
    ++count;
 
    std::printf("%02d - validate_text_input - no error, only alpha : %s", count, (( validate_text_input("1234567890") )? "success": "fail"));
    ++count;
 
    std::printf("%02d - validate_text_input - no error, ascii, lower case : %s", count, (( validate_text_input("abcdefghiklmnopqrstuvxyz") )? "success": "fail"));
    ++count;
 
    std::printf("%02d - validate_text_input - no error, ascii, upper case : %s", count, (( validate_text_input("ABCDEFGHIKLMNOPQRSTUVXYZ") )? "success": "fail"));
    ++count;
 
    std::printf("%02d - validate_text_input - no error, special char : %s", count, (( validate_text_input("082avbd/-*?@") )? "success": "fail"));
    ++count;
 
//  On inverse le retour pour savoir si la fonction a le bon comportement
    std::printf("%02d - validate_text_input - error pos 5 : %s", count, ((!validate_text_input("082a²vbd/-*?@"))? "success": "fail"));
    ++count;
 
// ...
}

Et le dernier point, il faut réussir autant que faire se peut que chaque résultat fasse moins de 80 caractères pour ne pas avoir de retour à ligne dans la console.
Et le must, l'alignement en colonnes (quelques espaces par ci par là) pour qu'en un coup d’œil voir les tests échoués plus facilement

[foetus]

Un résultat doit dire si il a réussi ou échoué, quel est le but du test et avoir un compteur.

J'ai oublié un truc important : pourquoi il échoue

Pour reprendre le test de ma fonction validate_text_input:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//  the simplified test
//  On inverse le retour pour savoir si la fonction a le bon comportement
//  std::printf("%02d - validate_text_input - error pos 5 : %s", count, ()? "success": "fail"));
// ++count;
 
//  the real test
    short pos;
    t_VALIDATION_ERROR error; // enum type
 
    if (!validate_text_input("082a²vbd/-*?@", error, pos)) {
        if (error == VALIDATION_ERROR_CHAR_AT) {
            if (pos == 5) {
                std::printf("%02d - validate_text_input - error pos 5 : success", count);
            } else {
                std::printf("%02d - validate_text_input - error pos 5 : fail (bad pos: %s)", count, pos);
            }
        } else {
            std::printf("%02d - validate_text_input - error pos 5 : fail (bad error: %s)", count, convert_error_to_str(error));
        }
    } else {
        std::printf("%02d - validate_text_input - error pos 5 : fail (error: success)", count);
    }
    +count;

[Bktero]

J'utilise Google Test et il est simple à mettre en oeuvre. La problématique décrite dans le premier message est exactement résolue par des tests unitaires. Il ne faut pas hésiter à en faire