Intégration de CppUnit dans Hudson – Part 1

De nombreux frameworks de tests existent sur le marché. Pour le langage C++, CppUnit est un framework de tests très puissant et très utilisé. L’exécution d’un test ou d’une suite de tests CppUnit ne produit pas des sorties standards comme les frameworks Java de la famille JUnit. Il se pose alors la question de son intégration au sein d’un serveur d’intégration continue comme Hudson.

Pré requis

La première étape consiste à préciser au framework CppUnit la production d’un fichier de résultat au format XML lors de l’exécution des tests.

1. #include <cppunit/BriefTestProgressListener.h>
2. #include <cppunit/CompilerOutputter.h>
3. #include <cppunit/extensions/TestFactoryRegistry.h>
4. #include <cppunit/TestResult.h>
5. #include <cppunit/TestResultCollector.h>
6. #include <cppunit/TestRunner.h>
7. #include <cppunit/XmlOutputter.h>
10. int main(int argc, char* argv[])
11. {
12. // Retrieve test path from command line first argument. Default to “” which resolve
13. // to the top level suite.
14. std::string testPath = (argc > 1) ? std::string(argv[1]) : std::string(“”);
16. // Create the event manager and test controller
17. CPPUNIT_NS::TestResult controller;
19. // Add a listener that collects test result
20. CPPUNIT_NS::TestResultCollector result;
21. controller.addListener( &result );
23. // Add a listener that print dots as test run.
24. CPPUNIT_NS::BriefTestProgressListener progress;
25. controller.addListener( &progress );
27. // Add the top suite to the test runner
28. CPPUNIT_NS::TestRunner runner;
29. runner.addTest( CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest() );
30. runner.run( controller );
32. // Print test in a compiler compatible format.
33. CPPUNIT_NS::CompilerOutputter outputter( &result, CPPUNIT_NS::stdCOut() );
34. outputter.write();
36. // Uncomment this for XML output
37. std::ofstream file( “cppunit-report.xml” );
38. CPPUNIT_NS::XmlOutputter xml( &result, file );
39. xml.write();
40. file.close();
42. return result.wasSuccessful() ? 0 : 1;
43. }

L’exécution des tests CppUnit produit un fichier dans un format XML propriétaire au framework

1. <?xml version=“1.0” encoding=‘ISO-8859-1’ standalone=‘yes’ ?>
2. <TestRun>
3. <FailedTests>
4. <FailedTest id=“3”>
5. <Name>MathTest::testSum</Name>
6. <FailureType>Assertion</FailureType>
7. <Location>
8. <File>mathTest.cpp</File>
9. <Line>56</Line>
10. </Location>
11. <Message>equality assertion failed
12. – Expected: 141496748
13. – Actual : 16777217
14. </Message>
15. </FailedTest>
16. </FailedTests>
17. <SuccessfulTests>
18. <Test id=“1”>
19. <Name>MathTest::testConstructor</Name>
20. </Test>
21. <Test id=“2”>
22. <Name>MathTest::testPush</Name>
23. </Test>
24. <Test id=“4”>
25. <Name>ExpressionTest::testConstructor</Name>
26. </Test>
27. <Test id=“5”>
28. <Name>ExpressionTest::testPush</Name>
29. </Test>
30. </SuccessfulTests>
31. <Statistics>
32. <Tests>5</Tests>
33. <FailuresTotal>1</FailuresTotal>
34. <Errors>0</Errors>
35. <Failures>1</Failures>
36. </Statistics>
37. </TestRun>

Conversion dans un format JUnit connu

La seconde étape va consister à transformer le format du fichier de sortie de CppUnit dans un format de fichier pouvant être exploité par les outils du marché comme Hudson. En effet, Hudson fournit une intégration native du résultat des tests JUnit.
Vous trouverez à cette adresse un exemple du format XSD d’un fichier JUnit.

Feuille de style de conversion

Pour obtenir ce format JUnit, une technique simple consiste à fournir une feuille de style XSL et à l’appliquer au fichier de sortie “cppunit-report.xml”. Ci-dessous, la feuille de style “cppunit-to-junit.xsl” pouvant réaliser le travail

1. <?xml version=“1.0” encoding=“UTF-8”?>
2. <xsl:stylesheet version=“1.0” xmlns:xsl=“http://www.w3.org/1999/XSL/Transform&#8221;>
3. <xsl:output method=“xml” indent=“yes” />
5. <xsl:param name=“suitename” />
7. <xsl:template match=“/”>
8. <testsuite>
9. <xsl:attribute name=“errors”>
10. <xsl:value-of select=“TestRun/Statistics/Errors” />
11. </xsl:attribute>
12. <xsl:attribute name=“failures”>
13. <xsl:value-of select=“TestRun/Statistics/Failures” />
14. </xsl:attribute>
15. <xsl:attribute name=“tests”>
16. <xsl:value-of select=“TestRun/Statistics/Tests” />
17. </xsl:attribute>
18. <xsl:attribute name=“name”>
19. <xsl:value-of select=“$suitename” />
20. </xsl:attribute>
21. <xsl:apply-templates />
22. </testsuite>
23. </xsl:template>
25. <xsl:template match=“/TestRun/SuccessfulTests/Test”>
26. <testcase>
27. <xsl:attribute name=“classname”>
28. <xsl:value-of select=“substring-before(Name, ‘::’)” />
29. </xsl:attribute>
30. <xsl:attribute< /span> name=“name”>
31. <xsl:value-of select=“substring-after(Name, ‘::’)” />
32. </xsl:attribute>
33. <xsl:attribute name=“time”>0</xsl:attribute>
34. </testcase>
35. </xsl:template>
37. <xsl:template match=“/TestRun/FailedTests/FailedTest”>
38. <testcase>
39. <xsl:attribute name=“classname”>
40. <xsl:value-of select=“substring-before(Name, ‘::’)” />
41. </xsl:attribute>
42. <xsl:attribute name=“name”>
43. <xsl:value-of select=“substring-after(Name, ‘::’)” />
44. </xsl:attribute>
46. <xsl:attribute name=“time”>0</xsl:attribute>
48. <xsl:choose>
49. <xsl:when test=“FailureType=’Error'”>
50. <error>
51. <xsl:attribute name=“message”>
52. <xsl:value-of select=” normalize-space(Message)” />
53. </xsl:attribute>
54. <xsl:attribute name=“type”>
55. <xsl:value-of select=“FailureType” />
56. </xsl:attribute>
57. <xsl:value-of select=“Message” />
58. File:<xsl:value-of select=“Location/File” />
59. Line:<xsl:value-of select=“Location/Line” />
60. </error>
61. </xsl:when>
63. <xsl:otherwise>
64. <failure>
65. <xsl:attribute name=“message”>
66. <xsl:value-of select=” normalize-space(Message)” />
67. </xsl:attribute>
68. <xsl:attribute name=“type”>
69. <xsl:value-of select=“FailureType” />
70. </xsl:attribute>
71. <xsl:value-of select=“Message” />
72. File:<xsl:value-of select=“Location/File” />
73. Line:<xsl:value-of select=“Location/Line” />
74. </failure>
75. </xsl:otherwise>
76. </xsl:choose>
77. </testcase>
78. </xsl:template>
80. <xsl:template match=“text()|@*” />
81. </xsl:stylesheet>

La feuille de style prend en entrée le paramètre “suitename” correspondant au nom de la suite de tests CppUnit. En cas d’erreur, un testcase de type “failure” est généré. Comme CppUnit ne fournit pas le temps de d’exécution d’un test, nous spécifierons dans le fichier JUnit final, un temps de “0” pour chaque cas de test.

Application de la feuille de style

Pour appliquer cette feuille de style, il nous faut un moteur de transformation. Dans l’objectif d’avoir une chaîne d’intégration complète, il est nécessaire d’incorporer cette transformation dans le script de build utilisé. Dans les environnements C++, le builder SCons est très utilisé. Avec cet outil, le script de build est écrit en Python.
Voici le script de transformation en langage Python basé sur la librairie 4suite

1. #!/usr/bin/python
3. from Ft.Lib.Uri import OsPathToUri
4. from Ft.Xml import InputSource
5. from Ft.Xml.Xslt import Processor
6. import os.path
9. class XmlConverter:
10. def __init__(self, xml, xsl):
12. self.xmlFile = xml
13. self.xslFile = xsl
15. def toXML(self, htmlFile):
17. if (os.path.exists(self.xslFile) == False):
18. return False
19. if (os.path.exists(self.xmlFile) == False):
20. return False
21. styuri = OsPathToUri(self.xslFile)
22. srcuri = OsPathToUri(self.xmlFile)
23. STY = InputSource.DefaultFactory.fromUri(styuri)
24. SRC = InputSource.DefaultFactory.fromUri(srcuri)
25. proc = Processor.Processor()
26. proc.appendStylesheet(STY)
27. result = proc.run(SRC)
28. try:
29. fileResult = open(htmlFile,“w”)
30. fileResult.write(result)
31. fileResult.close()
32. except IOError:
33. return False
34. return True
36. if __name__ == “__main__”:
37. directory = “./”
38. xml = directory + “cppunit-report.xml”
39. xsl = directory + “cppunit-to-junit.xsl”
40. resultXML = directory + “junit-result.xml”
41. xmlC = XmlConverter(xml,xsl)
42. print xmlC.toXML(resultXML)

Dans le cas d’utilisation d’un builder Java comme par exemple Gradle, il est est appréciable d’utiliser la tache XSLT de Ant pour réaliser la transformation.

1. createTask(‘transformer’){
2. ant{
3. xslt( style:‘cppunit-to-junit.xsl’,
4. basedir:‘.’,
5. includes:‘cppunit-report.xml’,
6. destdir:‘out’,
7. extension:‘.xml’){
8. param(name:‘suitename’, expression:‘demo’)
9. }
10. }
11. }

Intégration dans Hudson

Par défaut (sans plugins supplémentaires), Hudson fournit une intégration JUnit. Dans l’interface de configuration du job Hudson, il suffit de spécifier l’emplacement du fichier résultat de JUnit.

Hudson va analyser le fichier de résultat JUnit et impacter le statut du build du job Hudson.

Résultat dans Hudson