Cours programmation réseau en C++

UDP – S’assurer du bon fonctionnement de son code

Bousk

Ce troisième article montre la mise en place de tests afin de vérifier le bon fonctionnement de notre bibliothèque réseau.

Commentez

- Titre : Cours programmation réseau en C++

- Auteur : Bousk

- Parution : 16 janvier 2018

- Mise à jour : 15 janvier 2019

- Public visé :

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2018 Cyrille (Bousk) Bousquet. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Tester son code

- II. Un projet de tests

- II-A. Quel framework de tests choisir ?

- II-B. Macros de test

- II-C. Programme de test

- III. Notre premier test : les fonctions utilitaires

- IV. Tester le gestionnaire d’acquittements

- V. Gestionnaire de versions

- V-A. Pourquoi utiliser un gestionnaire de versions ?

- V-B. Versions de support du cours

- VI. Conclusion

I - Tester son code

Dans un jeu multijoueur, la couche réseau est un élément critique puisque l’ensemble de l’application repose dessus. Bien que celle-ci soit intensément éprouvée lors du développement, il n’est pour autant pas réaliste de se contenter de ces tests, en particulier si l’on veut changer un fonctionnement interne. Afin d’assurer la pérennité de son comportement au reste de l’équipe, il convient que son fonctionnement atteigne toujours un niveau minimum de satisfaction et de qualité pour ne pas empêcher vos collègues de travailler pour cause de « problème réseau ». Aussi la mise en place de tests spécifiques à la bibliothèque réseau est un élément important, voire primordial à la réussite de cette dernière.

II - Un projet de tests

Afin de tester notre bibliothèque, il s’agira de créer un projet, une application minimale, qui l’utilise. Puisque la seule dépendance de la bibliothèque réseau est la std, une simple application console fera parfaitement l’affaire.

Je ne détaillerai pas ici comment créer un tel projet. Je présume que si vous êtes en train de lire cette série d’articles vous connaissez un minimum comment le langage fonctionne. À défaut, vous pouvez toujours vous référer à la section cours C++ de développez.com.

II-A - Quel framework de tests choisir ?

Il existe une multitude de frameworks de tests : CppUnit, Boost.Test, Unit++ pour n’en citer que quelques-uns. Et choisir l’un d’eux n’est pas chose aisée.

Aussi je ne vous pousserai pas à utiliser l’un ou l’autre, chacun est libre dans son choix.

Pour ma part, ne souhaitant pas m’encombrer d’une dépendance, je me contente de macros pour réaliser mes tests et afficher leur résultat et ce qui est testé.

II-B - Macros de test

Voici les quelques macros que j’utiliserai dans le cadre de cet article :

Tester.hpp

1. #pragma once

3. #include <iostream>

5. #define CHECK_SUCCESS(expr) do { std::cout << "[OK] " #expr << std::endl; } while(0)

6. #define CHECK_FAILURE(expr) do { std::cout << "[FAILURE] " #expr << std::endl; } while(0)

7. #define CHECK(expr) do { if (expr) { CHECK_SUCCESS(expr); } else { CHECK_FAILURE(expr); } } while(0)

Ceci est ma base de travail que j’étofferai au fur et à mesure que le besoin le nécessite.

II-C - Programme de test

Le programme de test sera très simplement une fonction main qui appelle chacun des tests réalisés.

Je procède ainsi :

- pour chaque classe ou namespace XX à tester, je crée une classe XX_Test, que je déclare amie de XX s’il s’agit d’une classe ;

- chaque classe XX_Test se trouve dans son propre fichier ;

- chaque classe XX_Test a une unique fonction public static void Test(); ;

- le fichier principal se charge d’inclure chaque test et d’exécuter cette fonction Test.

De nombreux tests ne nécessiteront pas de vérifier l’état interne des membres de la classe à tester - il s’agira plus de tests de comportement que de tests unitaires pour la majorité. L’amitié sera alors superflue dans l’absolu, mais en suivant ce modèle il est plus simple pour chacun de comprendre comment le tout fonctionne.

III - Notre premier test : les fonctions utilitaires

Commençons avec l’élément le plus bas niveau de notre bibliothèque actuellement puisqu’il ne possède qu’une dépendance à la std : les fonctions utilitaires de Utils.h.

Le but de cette série de tests est de vérifier que notre logique de détection d’un identifiant plus récent est correcte et nos champs de bits se comportent comme attendu.

Utils_Test.hpp

1. #pragma once

3. #include "Tester.hpp"

4. #include "Utils.hpp"

6. class Utils_Test

7. {

8. public:

9. static void Test();

10. };

12. void Utils_Test::Test()

13. {

14. CHECK(Bousk::Utils::IsSequenceNewer(1, 0));

15. CHECK(!Bousk::Utils::IsSequenceNewer(0, 1));

16. CHECK(!Bousk::Utils::IsSequenceNewer(0, 0));

17. CHECK(Bousk::Utils::IsSequenceNewer(0, std::numeric_limits<uint16_t>::max()));

19. CHECK(Bousk::Utils::SequenceDiff(0, 0) == 0);

20. CHECK(Bousk::Utils::SequenceDiff(1, 0) == 1);

21. CHECK(Bousk::Utils::SequenceDiff(0, std::numeric_limits<uint16_t>::max()) == 1);

23. uint64_t bitfield = 0;

24. CHECK(bitfield == 0);

25. Bousk::Utils::SetBit(bitfield, 0);

26. CHECK(Bousk::Utils::HasBit(bitfield, 0));

27. CHECK(bitfield == Bousk::Utils::Bit<uint64_t>::Right);

28. Bousk::Utils::UnsetBit(bitfield, 0);

29. CHECK(bitfield == 0);

30. Bousk::Utils::SetBit(bitfield, 5);

31. CHECK(Bousk::Utils::HasBit(bitfield, 5));

32. CHECK(bitfield == (Bousk::Utils::Bit<uint64_t>::Right << 5));

33. Bousk::Utils::UnsetBit(bitfield, 0);

34. CHECK(bitfield == (Bousk::Utils::Bit<uint64_t>::Right << 5));

35. Bousk::Utils::UnsetBit(bitfield, 5);

36. CHECK(bitfield == 0);

37. }

Il s’agit de vérifier que les identifiants sont correctement reconnus comme plus récents ainsi que le cas de la réinitialisation après la valeur maximale. Puis que nos fonctions de bits changent le bon bit sur notre champ de bits.

Il n’y a pas grand-chose à dire sur celui-ci, et peu de choses à tester réellement : ajoutez autant de cas à tester que vous le souhaitez jusqu’à être satisfait et convaincu que le tout fonctionne correctement.

IV - Tester le gestionnaire d’acquittements

Dans l’article précédent, nous avons implémenté notre premier élément de notre bibliothèque réseau : le gestionnaire d’acquittements d’identifiants.

Il est temps de s’assurer qu’il fonctionne correctement, en le testant.

AckHandler_Test.hpp

1. #pragma once

3. class AckHandler_Test

4. {

5. public:

6. static void Test();

7. };

Au niveau de l’implémentation du test, il s’agit de tester les comportements critiques et singularités imaginables.

Pour le gestionnaire d’acquittements en particulier, voici les points à tester spécifiquement :

- Que se passe-t-il si l’on reçoit un identifiant en double ?

- Que se passe-t-il si l’on reçoit un identifiant ancien non déjà acquitté ?

- Que se passe-t-il si l’on reçoit un identifiant plus ancien que le masque actuel ?

- Que se passe-t-il si l’on reçoit un identifiant qui annule l’ensemble du masque actuel ?

- Que se passe-t-il si l’on reçoit un identifiant qui annule plus que l’ensemble du masque ?

- Comment sont gérées les valeurs extrêmes du masque ?

Et bien sûr les actions plus classiques afin de vérifier que les nouveaux identifiants sont correctement reconnus en tant que tels, que le masque évolue correctement, etc.

AckHandler_Test.cpp

1. void AckHandler_Test::Test()

2. {

3. static constexpr uint64_t MASK_COMPLETE = std::numeric_limits<uint64_t>::max();

4. static constexpr uint64_t MASK_FIRST_ACKED = Bousk::Utils::Bit<uint64_t>::Right;

5. static constexpr uint64_t MASK_FIRST_MISSING = ~MASK_FIRST_ACKED;;

6. static constexpr uint64_t MASK_LAST_ACKED = (MASK_FIRST_ACKED << 63);    Bousk::UDP::AckHandler ackhandler;

7. CHECK(ackhandler.lastAck() == std::numeric_limits<uint16_t>::max());

8. CHECK(ackhandler.previousAcksMask() == MASK_COMPLETE);

9. CHECK(!ackhandler.isAcked(0));

10. CHECK(!ackhandler.isNewlyAcked(0));

11. CHECK(ackhandler.loss().empty());

12. //!< Réception de l’identifiant #0

13. ackhandler.update(0, MASK_COMPLETE, true);

14. CHECK(ackhandler.lastAck() == 0);

15. CHECK(ackhandler.previousAcksMask() == MASK_COMPLETE);

16. CHECK(ackhandler.isAcked(0));

17. CHECK(ackhandler.isNewlyAcked(0));

18. CHECK(ackhandler.getNewAcks().size() == 1);

19. CHECK(ackhandler.getNewAcks()[0] == 0);

20. CHECK(ackhandler.loss().empty());

21. //!< Réception de l’identifiant #2 avec identifiant #1 manquant (63e bit du masque à 0)

22. ackhandler.update(2, MASK_FIRST_MISSING, true);

23. CHECK(ackhandler.lastAck() == 2);

24. CHECK(ackhandler.previousAcksMask() == MASK_FIRST_MISSING);

25. CHECK(ackhandler.isAcked(2));

26. CHECK(ackhandler.isAcked(0));

27. CHECK(ackhandler.isNewlyAcked(2));

28. CHECK(!ackhandler.isNewlyAcked(0));

29. CHECK(ackhandler.loss().empty());

30. //!< Réception de l’identifiant #1

31. ackhandler.update(1, MASK_COMPLETE, true);

32. CHECK(ackhandler.lastAck() == 2);

33. CHECK(ackhandler.previousAcksMask() == MASK_COMPLETE);

34. CHECK(ackhandler.isAcked(1));

35. CHECK(ackhandler.isAcked(2));

36. CHECK(ackhandler.isAcked(0));

37. CHECK(ackhandler.isNewlyAcked(1));

38. CHECK(!ackhandler.isNewlyAcked(2));

39. CHECK(!ackhandler.isNewlyAcked(0));

40. CHECK(ackhandler.loss().empty());

41. //!< Réception de l’identifiant #66 avec masque vide : tous les identifiants [3,65] sont manquants, mais pas encore perdus

42. ackhandler.update(66, 0, true);

43. CHECK(ackhandler.lastAck() == 66);

44. CHECK(ackhandler.isNewlyAcked(66));

45. CHECK(ackhandler.previousAcksMask() == MASK_LAST_ACKED);

46. CHECK(ackhandler.loss().empty());

47. //!< Réception de l’identifiant #67 avec masque vide

48. ackhandler.update(67, 0, true);

49. CHECK(ackhandler.lastAck() == 67);

50. CHECK(ackhandler.isNewlyAcked(67));

51. CHECK(!ackhandler.isNewlyAcked(66));

52. CHECK(ackhandler.previousAcksMask() == MASK_FIRST_ACKED);

53. CHECK(ackhandler.loss().empty());

54. //!< Réception de l’identifiant #68, avec masque complet, l’identifiant #3 est maintenant perdu

55. ackhandler.update(68, MASK_COMPLETE, true);

56. CHECK(ackhandler.lastAck() == 68);

57. CHECK(ackhandler.isNewlyAcked(68));

58. CHECK(ackhandler.previousAcksMask() == MASK_COMPLETE);

59. {

60. auto loss = ackhandler.loss();

61. CHECK(loss.size() == 1);

62. CHECK(loss[0] == 3);

63. }

64. for (uint16_t i = 4; i < 66; ++i)

65. {

66. CHECK(ackhandler.isNewlyAcked(i));

67. }

68. //!< Réception d’un identifiant plus vieux que le masque

69. ackhandler.update(0, 0, true);

70. CHECK(ackhandler.lastAck() == 68);

71. CHECK(!ackhandler.isNewlyAcked(68));

72. CHECK(ackhandler.previousAcksMask() == MASK_COMPLETE);

73. //!< Saut de 65 identifiants, réception de #133 avec masque vide

74. ackhandler.update(133, 0, true);

75. CHECK(ackhandler.lastAck() == 133);

76. CHECK(ackhandler.previousAcksMask() == 0);

77. {

78. auto loss = ackhandler.loss();

79. CHECK(loss.size() == 1);

80. CHECK(loss[0] == 69);

81. }

82. //!< Réception de l’identifiant #132 avec masque complet

83. ackhandler.update(132, MASK_COMPLETE, true);

84. CHECK(ackhandler.lastAck() == 133);

85. CHECK(ackhandler.previousAcksMask() == MASK_COMPLETE);

86. CHECK(ackhandler.loss().empty());

87. //!< Saut de 100 identifiants avec masque complet, identifiants [134, 169] sont perdus

88. ackhandler.update(234, 0, true);

89. CHECK(ackhandler.lastAck() == 234);

90. CHECK(ackhandler.previousAcksMask() == 0);

91. {

92. auto loss = ackhandler.loss();

93. const auto firstLost = 134;

94. const auto lastLost = 169;

95. const auto totalLost = lastLost - firstLost + 1;

96. CHECK(loss.size() == totalLost);

97. for (auto i = 0; i < totalLost; ++i)

98. {

99. CHECK(loss[i] == firstLost + i);

100. }

101. }

102. ackhandler.update(234, MASK_COMPLETE, true);

103. ackhandler.update(236, MASK_COMPLETE, true);

104. //!< Saut de 65 identifiants avec masque vide

105. ackhandler.update(301, 0, true);

106. CHECK(ackhandler.lastAck() == 301);

107. CHECK(ackhandler.previousAcksMask() == 0);

108. CHECK(ackhandler.loss().empty());

109. CHECK(!ackhandler.isAcked(237));

110. //!< Acquittement de l’identifiant #237

111. ackhandler.update(237, MASK_COMPLETE, true);

112. CHECK(ackhandler.lastAck() == 301);

113. CHECK(ackhandler.previousAcksMask() == MASK_LAST_ACKED);

114. CHECK(ackhandler.loss().empty());

115. CHECK(ackhandler.isAcked(237));

116. CHECK(ackhandler.isNewlyAcked(237));

117. //!< Acquittement de tous les identifiants via masque complet et doublon de #301

118. ackhandler.update(301, MASK_COMPLETE, true);

119. CHECK(ackhandler.lastAck() == 301);

120. CHECK(ackhandler.previousAcksMask() == MASK_COMPLETE);

121. CHECK(ackhandler.loss().empty());

122. //!< Vérification de la transformation du masque en identifiants

123. ackhandler.update(303, MASK_COMPLETE, true);

124. auto newAcks = ackhandler.getNewAcks();

125. CHECK(newAcks.size() == 2);

126. CHECK(newAcks[0] == 302);

127. CHECK(newAcks[1] == 303);

128. }

Ici encore, n’hésitez pas à ajouter autant de tests et cas que vous voulez afin de couvrir un maximum de scénarios.

V - Gestionnaire de versions

Un autre élément crucial lors de tout développement est d’avoir un gestionnaire de versions (ou SCM de l’anglais Source Control Management).

Il en existe plusieurs, chacun ayant ses avantages et inconvénients, tels que Subversion (SVN), Mercurial, Git, Perforce pour en citer quelques-uns des plus connus.

Pour avoir plus d’informations, je vous invite à vous rendre sur le forum dédié, lire des tutoriels ou FAQ correspondantes.

V-A - Pourquoi utiliser un gestionnaire de versions ?

Un gestionnaire de versions permettra de faire un suivi des modifications apportées à chaque fichier. L’utilisation de base permet également d’accompagner chaque modification d’un commentaire.

Ceci permet de créer un historique de chaque fichier, que l’on peut parcourir à tout instant pour voir l’évolution (d’une partie) d’un fichier permettant de tracer chaque modification dans le temps.

Surtout, en cas de problème majeur, il est possible de revenir à une version antérieure et fonctionnelle d’un fichier, assurant un état suffisant au reste de l’équipe en attendant de corriger le bogue – l’historique étant alors une aide précieuse afin de retrouver l’origine de l’erreur et comprendre son introduction.

V-B - Versions de support du cours

Le choix de l’un ou l’autre fait plus office de débat religieux qu’autre chose selon moi, aussi je n’entrerai pas dans plus de détails et vous laisse vous faire votre avis avec les ressources citées dans le paragraphe précédent. Personnellement pour l’écriture de ce cours, j’utilise Mercurial et vous pouvez retrouver le dépôt hébergé ici sur BitBucket. À la seule différence que le code hébergé sur BitBucket a des commentaires anglais puisque je compte le publier à terme.

Chaque chapitre est représenté par un tag de version : la V1.0 était la fin du chapitre 8 de TCP, et le précédent chapitre présentant le gestionnaire d’acquittements est la V1.0.2. Le chapitre actuel sera la V1.0.3. Le tag du chapitre sera désormais indiqué en fin de chaque article pour pouvoir s’y référer sur le dépôt.

VI - Conclusion

À titre d’exemple, ces tests m’ont permis de trouver trois erreurs lors de l’écriture du précédent article.

Idéalement, vous devriez exécuter ces tests à chaque fois que vous modifiez un fichier de votre bibliothèque réseau afin de vous assurer de ne rien casser dans les différentes implémentations.

Bien sûr ces tests ne sont pas figés et seront amenés à évoluer. Chaque fois que vous rencontrez un nouveau bogue, ou pensez à un nouveau scénario, ajoutez ses étapes de reproduction dans un test afin de vérifier que votre hypothèse est correcte, puis que votre correction fonctionne sans régresser quoi que ce soit d’autre.

Récupérez le code source sous le tag V1.0.3 dans le dépôt Mercurial à l’adresse suivante.

Article précédent

Article suivant

<< UDP – Gérer les pertes et duplications d’identifiants

UDP – Créer son protocole par-dessus UDP >>>