Iteracyjny test jednostkowy metody klasy

Stronę tą wyświetlono już: 1008 razy

Do celów przykładowych załóżmy, że dla pewnej klasy głównej, która steruje pewnym sygnałem konieczne jest opracowanie modelu jego sterowaniem. Model ten może istnieć w różnych postaciach testowych więc będzie wygodnie opracować klasę dziedziczącą po jednym interfejsie. Oto przykład takiej właśnie klasy:

Listing 1
  1. // Pierwsza klasa do przetestowania
  2. class IterableChangeDisplay : public IIterableChangeValueModelTesting{
  3. public:
  4. virtual void iterableChengeDisplay(uint32_t &start, uint32_t &end, uint8_t &wsp){
  5. if(wsp){
  6. start = std::ceil(qreal(end - start) / wsp) + start;
  7. }else{
  8. start = end;
  9. }
  10. }
  11. };
  12. // Druga klasa do przetestowania
  13. class IterableChangeDisplay2 : public IIterableChangeValueModelTesting{
  14. public:
  15. virtual void iterableChengeDisplay(uint32_t &start, uint32_t &end, uint8_t &wsp){
  16. if(wsp){
  17. start = (end - start) / wsp + start;
  18. }else{
  19. start = end;
  20. }
  21. }
  22. };

Jak widać klasy IterableChangeDisplay i IterableChangeDisplay2 dziedziczą po interfejsie IIterableChangeValueModelTesting, którego konstrukcja jest następująca:

Listing 2
  1. class IIterableChangeValueModelTesting : public IIterableChangeValueModel, ITesting{
  2. public:
  3. virtual void testing(enum testing_flags flag = testing_flags::DISPLAY_ALL, QHtmlObject* html = 0, std::unordered_map<QString, long> *parameters = 0){
  5. uint32_t start = 100;
  6. uint32_t end = 1000;
  7. uint8_t wsp = 100;
  9. QHtmlObject* body = 0;
  11. if(html){
  12. body = html->getElementsByName("body")[0];
  14. }
  16. if(body)
  17. body
  18. ->addHtmlChild(QHtmlObject::createH1("Testing class: " + QString(typeid(*this).name())));
  20. QString data = "=======================================================\nTesting class: " +
  21. QString(typeid(*this).name()) + "\n"
  22. "=======================================================\n\n";
  24. qDebug() << data;
  26. for(wsp = 0; wsp <= 100; wsp ++){
  27. start = 100;
  28. if(parameters){
  29. auto search = parameters->find("start");
  30. if(search != parameters->end()){
  31. start = search->second;
  32. }
  33. search = parameters->find("end");
  34. if(search != parameters->end()){
  35. end = search->second;
  36. }
  37. }
  39. if(body)
  40. body
  41. ->addHtmlChild(QHtmlObject::createH2("Testing for parameters:"))
  42. .addHtmlChild(QHtmlObject::createParagraph("start = " + QString::number(start)))
  43. .addHtmlChild(QHtmlObject::createParagraph("end = " + QString::number(end)))
  44. .addHtmlChild(QHtmlObject::createParagraph("wsp = " + QString::number(wsp)));
  47. data = "Testing for parameters:\n"
  48. "start = " + QString::number(start) + "\n"
  49. "end = " + QString::number(end) + "\n"
  50. "wsp = " + QString::number(wsp) + "\n";
  52. qDebug() << data;
  54. for(int i = 0; i < 1000; i++){
  56. iterableChengeDisplay(start, end, wsp);
  58. if(start == end){
  59. if(flag == testing_flags::DISPLAY_ALL){
  60. if(body)
  61. body
  62. ->addHtmlChild(
  63. QHtmlObject::createH3("Looks like algorythm works fine! End parameters for iteration: " + QString::number(i + 1) + ":")
  64. .addAttributes("class", "good")
  65. )
  66. .addHtmlChild(QHtmlObject::createParagraph("start = " + QString::number(start)))
  67. .addHtmlChild(QHtmlObject::createParagraph("end = " + QString::number(end)))
  68. .addHtmlChild(QHtmlObject::createParagraph("wsp = " + QString::number(wsp)));
  70. data = "Looks like algorythm works fine! End parameters:\n"
  71. "Parameters for iteration nr. " + QString::number(i + 1) + "\n"
  72. "start = " + QString::number(start) + "\n"
  73. "end = " + QString::number(end) + "\n"
  74. "wsp = " + QString::number(wsp) + "\n";
  76. qDebug() << data;
  78. }
  79. break ;
  80. }
  81. }
  83. if(start != end){
  84. if(body)
  85. body
  86. ->addHtmlChild(
  87. QHtmlObject::createH3("Looks like algorythm not works too good for 1000 iterations:")
  88. .addAttributes("class", "bad")
  89. )
  90. .addHtmlChild(QHtmlObject::createParagraph("start = " + QString::number(start)))
  91. .addHtmlChild(QHtmlObject::createParagraph("end = " + QString::number(end)))
  92. .addHtmlChild(QHtmlObject::createParagraph("wsp = " + QString::number(wsp)));
  94. data = "Looks like algorythm not works too good for 1000 iterations:\n"
  95. "start = " + QString::number(start) + "\n"
  96. "end = " + QString::number(end) + "\n"
  97. "wsp = " + QString::number(wsp) + "\n";
  99. qDebug() << data;
  101. }
  103. }
  104. }
  105. };

Wewnątrz interfejsu IIterableChangeValueModelTesting znajduje się jedynie metoda testing czysto wirtualna, która pozwala na przeprowadzenie testu działania algorytmu dla wartości:

  • wsp - zawierającej się w zakresie od 0 do 100;
  • start - ustawionej domyślnie na wartość 100;
  • end - ustawionej domyślnie na wartość 1000;
  • i - wewnętrznie określona liczba iteracji na 1000

Metoda testing tworzy plik .html z raportem o przebiegu testowania wyświetlając równocześnie te dane na ekranie. Jak widać interfejs ten dziedziczy po dwóch innych interfejsach: IIterableChangeValueModel - dostarcza czysto wirtualnej metody przeznaczonej do modyfikacji sygnału; ITesting - dostarcza czysto wirtualnej metody do testowania funkcji modyfikacji sygnału.

Listing 3
  1. class ITesting{
  2. public:
  3. virtual void testing(enum testing_flags flag = testing_flags::DISPLAY_ALL, QHtmlObject* html = 0, std::unordered_map<QString, long> *parameters = 0) = 0;
  5. virtual ~ITesting(){};
  6. };
  8. class IIterableChangeValueModel{
  9. public:
  10. virtual void iterableChengeDisplay(uint32_t &start, uint32_t &end, uint8_t &wsp) = 0;
  12. virtual ~IIterableChangeValueModel(){}
  13. };

Klasa QHtmlObject użyta jako parametr metody testing została napisana przeze mnie do generowania kodu HTML ponieważ na moje potrzeby wolę tworzyć plik raportu w bardziej przystępnej i sformatowanej formie. Pierwszy parametr wcześniej wspomnianej metody przyjmuje wartość jednej z dostępnych flag:

Listing 4
  1. enum testing_flags{
  2. DISPLAY_ERROR_ONLY,
  3. DISPLAY_ALL
  4. };

Klasa IterableChangeDisplay2 ma błąd wewnętrzny nie uwzględniający działania na liczbach całkowitych, natomiast klasa IterableChangeDisplay już takiego błędu jest pozbawiona. Oto kod wykorzystujący system testujący do obu tych klas:

Listing 5
  1. IterableChangeDisplay2 model2;
  2. IterableChangeDisplay model1;
  4. QFile file("test.html");
  6. file.open(QIODevice::WriteOnly);
  8. QTextStream textStream(&file);
  10. std::unordered_map<QString, long> parameters = {{"start", 0}, {"end", 500}};
  12. parameters.insert( std::make_pair<QString, long>("wsp", 100) );
  14. QHtmlPage html("Testing raport");
  16. html.addLocalStyle( ".bad{ color: red;} .good{ color: green; }");
  18. model2.testing(testing_flags::DISPLAY_ALL, &html, ¶meters);
  19. model1.testing(testing_flags::DISPLAY_ALL, &html, ¶meters);
  21. textStream << html;
  23. file.close();

Raport, jaki powyższy kod utworzy jest dość długi, ale dla celów poglądowych zamieszczam go tutaj. Jak wynika z tegoż raportu test dla obiektu klasy IterableChangeDisplay2 zakończył się powodzeniem jedynie w dwóch pierwszych przypadkach, a to dlatego, że nie uwzględniono operacji na liczbach całkowitych. Ten sam test dla obiektu klasy IterableChangeDisplay kończy się pomyślnie dla wszystkich testowanych wartości.

Diagram UML systemu testującego
Rys. 1
Diagram UML systemu testującego

Komentarze