source: spip-zone/_plugins_/_stable_/simpletest/inc/tests.php @ 24790

Last change on this file since 24790 was 24790, checked in by marcimat@…, 12 years ago

Correction d'un chdir parfois incorrect (?)...

Debut de classe pour tester des squelettes, mais comme simpleTest ne sait pas gérer les javascript dans son module 'browser', c'est assez limité finalement...

File size: 23.1 KB
Line 
1<?php
2
3include_spip('simpletest/autorun');
4include_spip('inc/autoriser');
5
6if (!autoriser('configurer')) 
7        die('Administrateur requis !');
8if ($_SERVER["REMOTE_ADDR"]!='127.0.0.1')
9        die('Admin local requis pour executer les tests !');
10
11/*
12 * il faut remettre le chdir pour les fonctions de spip
13 * comme chemin() ou include_spip()
14 * a l'interieur de la classe.
15 */
16define('_CHDIR', getcwd());
17define('_DEBUG_MAX_SQUELETTE_ERREURS', 100);
18
19/**
20 * Extension SpipTest
21 * pour donner le bon repertoire de travail
22 * et definir d'autres fonctions d'assertion
23 */
24class SpipTest extends UnitTestCase { 
25        var $options_recuperer_code = array();
26        var $adresse_dernier_fichier_pour_code = '';
27       
28        function SpipTest($name = false) {
29                chdir(_CHDIR);
30            if (!$name) {
31            $name = get_class($this);
32        }
33        $this->UnitTestCase($name);
34                // creer un repertoire pour les tests
35                // sert a la compilation
36                include_spip('inc/flock');
37                sous_repertoire(_DIR_CACHE, 'simpleTests');
38                define('_DIR_CODE',_DIR_CACHE . 'simpleTests/');
39    }
40       
41        /**
42         * Retourne l'adresse du site SPIP
43         */
44        function me(){
45                return $GLOBALS['meta']['url_site_spip'];
46        }
47       
48        /**
49         * Retourne une url pour tester une noisette
50         *
51         *
52         * @param string $noisette : noisette a tester
53         * @param array $params : tableau de params a transmettre
54         */
55        function generer_url_test($noisette, $params=array(), $var_mode_auto=true){
56                $appel = parametre_url(generer_url_public('simpletests'),'test',$noisette,'&');
57                foreach ($params as $p=>$v)
58                        $appel =  parametre_url($appel,$p,$v,'&');
59                if ($var_mode_auto) {
60                        if ($mode = $GLOBALS['var_mode'] AND in_array($mode, array('calcul','recalcul')))
61                                $appel =  parametre_url($appel,'var_mode',$mode,'&');
62                }
63                return $appel;
64        }
65       
66        /**
67         * Retourne une url pour tester une code
68         *
69         * Voir la fonction recuperer_fond pour les parametres
70         * @param string $code : code du squelette
71         * @param array $contexte : contexte de calcul du squelette
72         * @param array $opt : options ?
73         * @param string $connect : nom de la connexion a la bdd
74         *
75         * @return url d'appel
76         */     
77        function urlTestCode($code, $contexte=array(), $options = array(), $connect='') {
78                $infos = $this->recuperer_infos_code($code, $contexte, $options, $connect);
79                return $this->generer_url_test($infos['fond']);
80        }
81       
82        /**
83         * Determine si une chaine est de type NA (non applicable)
84         * @param string $chaine        Chaine a tester
85         * @return bool est-ce Non Applicable ?
86         */
87        function isNa($chaine) {
88                return substr(strtolower(trim($chaine)),0,2)=='na';
89        }
90       
91        /**
92         * Cree une exception si l'on est de type NA
93         * Retourne true si exception, false sinon.
94         *
95         * @param string $chaine        Chaine a tester
96         * @return bool         Est-ce Non Applicable ?
97         */
98        function exceptionSiNa($chaine) {
99                if ($this->isNa($chaine)) {
100                        throw new SpipNaException($chaine);
101                        return true;
102                }
103                return false;
104        }       
105       
106        /**
107         * Assertion qui verifie si le retour est la chaine 'ok' (casse indifferente)
108         *
109         * @param mixed $value valeur a tester si ok
110         * @param string $message : message pour une eventuelle erreur
111         * 
112         */
113        function assertOk($value, $message = "%s") {
114        $dumper = &new SimpleDumper();
115        $message = sprintf(
116                $message,
117                '[' . $dumper->describeValue($value) . '] should be string \'ok\'');
118                if ($this->exceptionSiNa($value)) {
119                        return false;
120                }
121        return $this->assertTrue((strtolower($value)=='ok'), $message);
122        }
123       
124        /**
125         * Assertion qui verifie que le retour n'est pas la chaine 'ok' (casse indifferente)
126         *
127         * @param mixed $value valeur a tester si pas ok
128         * @param string $message : message pour une eventuelle erreur
129         *
130         */
131        function assertNotOk($value, $message = "%s") {
132        $dumper = &new SimpleDumper();
133        $message = sprintf(
134                $message,
135                '[' . $dumper->describeValue($value) . '] shouldn\'t be string \'ok\'');
136        return $this->assertFalse((strtolower($value)=='ok'), $message);
137        }
138       
139        /**
140         * Assertion qui verifie si le retour ne vaut pas 'ok' (casse indifferente)
141         * la fonction appelle recuperer_code avec les arguments.
142         *
143         * L'appel
144         *              $this->assertNotOkCode('[(#CONFIG{pasla}|oui)ok]');
145         * est equivalent de :
146         *              $this->assertNotOk($this->recuperer_code('[(#CONFIG{pasla}|oui)ok]'));
147         *
148         * Voir la fonction recuperer_fond pour les parametres
149         * @param string $code : code du squelette
150         * @param array $contexte : contexte de calcul du squelette
151         * @param array $opt : options ?
152         * @param string $connect : nom de la connexion a la bdd
153         * @param string $message : message pour une eventuelle erreur
154         * 
155         * @return true/false
156         */
157        function assertNotOkCode($code, $contexte=array(), $options = array(), $connect='', $message = "%s") {
158                return $this->assertNotOk($this->recuperer_code($code, $contexte, $options, $connect), $message);
159        }
160       
161       
162        /**
163         * Assertion qui verifie si le retour vaut 'ok' (casse indifferente)
164         * la fonction appelle recuperer_code avec les arguments.
165         *
166         * L'appel
167         *              $this->assertOkCode('[(#CONFIG{pasla}|non)ok]');
168         * est equivalent de :
169         *              $this->assertOk($this->recuperer_code('[(#CONFIG{pasla}|non)ok]'));
170         *
171         * Voir la fonction recuperer_fond pour les parametres
172         * @param string $code : code du squelette
173         * @param array $contexte : contexte de calcul du squelette
174         * @param array $opt : options ?
175         * @param string $connect : nom de la connexion a la bdd
176         * @param string $message : message pour une eventuelle erreur
177         * 
178         * @return true/false
179         */
180        function assertOkCode($code, $contexte=array(), $options = array(), $connect='', $message = "%s") {
181                return $this->assertOk($this->recuperer_code($code, $contexte, $options, $connect), $message);
182        }
183       
184        /**
185         * Assertion qui verifie si le retour vaut $value
186         * la fonction appelle recuperer_code avec les arguments.
187         *
188         * L'appel
189         *              $this->assertEqualCode('ok','[(#CONFIG{pasla}|non)ok]');
190         * est equivalent de :
191         *              $this->assertEqual('ok',$this->recuperer_code('[(#CONFIG{pasla}|non)ok]'));
192         *
193         * Voir la fonction recuperer_fond pour les parametres
194         * @param string $value : chaine a comparer au resultat du code
195         * @param string $code : code du squelette
196         * @param array $contexte : contexte de calcul du squelette
197         * @param array $opt : options ?
198         * @param string $connect : nom de la connexion a la bdd
199         * @param string $message : message pour une eventuelle erreur
200         *
201         * @return true/false
202         */
203        function assertEqualCode($value, $code, $contexte=array(), $options = array(), $connect='', $message = "%s") {
204                return $this->assertEqual($value, $this->recuperer_code($code, $contexte, $options, $connect), $message);
205        }
206       
207       
208        /**
209         * Assertion qui verifie si le retour ne vaut pas $value
210         * la fonction appelle recuperer_code avec les arguments.
211         *
212         * L'appel
213         *              $this->assertEqualCode('ok','[(#CONFIG{pasla}|non)ok]');
214         * est equivalent de :
215         *              $this->assertEqual('ok',$this->recuperer_code('[(#CONFIG{pasla}|non)ok]'));
216         *
217         * Voir la fonction recuperer_fond pour les parametres
218         * @param string $value : chaine a comparer au resultat du code
219         * @param string $code : code du squelette
220         * @param array $contexte : contexte de calcul du squelette
221         * @param array $opt : options ?
222         * @param string $connect : nom de la connexion a la bdd
223         * @param string $message : message pour une eventuelle erreur
224         *
225         * @return true/false
226         */
227        function assertNotEqualCode($value, $code, $contexte=array(), $options = array(), $connect='', $message = "%s") {
228                return $this->assertNotEqual($value, $this->recuperer_code($code, $contexte, $options, $connect), $message);
229        }
230       
231        /**
232         * Assertion qui verifie si le retour verifie le pattern $pattern
233         * la fonction appelle recuperer_code avec les arguments.
234         *
235         * L'appel
236         *              $this->assertPatternCode('/^ok$/i','[(#CONFIG{pasla}|non)ok]');
237         * est equivalent de :
238         *              $this->assertPattern('/^ok$/i',$this->recuperer_code('[(#CONFIG{pasla}|non)ok]'));
239         *
240         * Voir la fonction recuperer_fond pour les parametres
241         * @param string $pattern : pattern a comparer au resultat du code
242         * @param string $code : code du squelette
243         * @param array $contexte : contexte de calcul du squelette
244         * @param array $opt : options ?
245         * @param string $connect : nom de la connexion a la bdd
246         * @param string $message : message pour une eventuelle erreur
247         *
248         * @return true/false
249         */
250        function assertPatternCode($pattern, $code, $contexte=array(), $options = array(), $connect='', $message = "%s") {
251                return $this->assertPattern($pattern, $this->recuperer_code($code, $contexte, $options, $connect), $message);
252        }
253       
254                       
255        /**
256         * recupere le resultat du calcul d'une compilation de code de squelette
257         * $coucou = $this->recuperer_code('[(#AUTORISER{ok}|oui)coucou]');
258         *
259         * Voir la fonction recuperer_fond pour les parametres
260         * @param string $code : code du squelette
261         * @param array $contexte : contexte de calcul du squelette
262         * @param array $opt : options ?
263         * @param string $connect : nom de la connexion a la bdd
264         *
265         * @return string/array : page compilee et calculee
266         */
267        function recuperer_code($code, $contexte=array(), $options = array(), $connect=''){
268                $opt = $this->options_recuperer_code;
269                if (isset($opt['avant_code']))
270                        $code = $opt['avant_code'] . $code;
271                if (isset($opt['apres_code']))
272                        $code .= $opt['apres_code'];
273               
274                $fond = _DIR_CODE . md5($code.serialize($opt));
275                $this->ecrire_fichier($fond . '.html', $code);
276               
277                if (isset($opt['fonctions']) and $opt['fonctions']) {
278                        // un fichier unique pour ces fonctions
279                        $func = _DIR_CODE . "func_" . md5($opt['fonctions']) . ".php";
280                        $this->ecrire_fichier($func, $this->php($opt['fonctions']));
281                        // une inclusion unique de ces fichiers
282                        $this->ecrire_fichier($fond.'_fonctions.php', $this->php("include_once('$func');"));
283                }
284                return recuperer_fond($fond, $contexte, $options, $connect);
285        }
286       
287       
288        /**
289         * Appele recuperer_fond avec l'option raw pour obtenir un tableau d'informations
290         * que l'on complete avec le nom du fond et les erreurs de compilations generees
291         */
292        function recuperer_infos_code($code, $contexte=array(), $options = array(), $connect=''){
293                $options['raw'] = true;
294                // vider les erreurs
295                $this->init_compilation_errors();
296                $infos = $this->recuperer_code($code, $contexte, $options, $connect);
297               
298                // ca ne devrait pas arriver
299                if (!is_array($infos)) return $infos;
300               
301                // on ajoute des infos supplementaires a celles retournees
302                $path = pathinfo($infos['source']);
303                $infos['fond'] = $path['dirname'].'/'.$path['filename']; // = $fond;
304                $infos['erreurs'] = $this->get_compilation_errors();
305                return $infos;
306        }
307       
308       
309       
310        /**
311         * S'utilise avec recuperer_code() :
312         *
313         * stocke des options :
314         * - fonctions : pour ajouter un fichier de fonction au squelette cree (on passe le contenu du fichier)
315         * - avant_code : pour inserer du contenu avant le code
316         * - apres_code : pour inserer du contenu apres le code
317         *
318         * @param array $options : param->valeur des options
319         * @param bool $merge  : les options se cumulent aux autres ? (ou viennent en remplacement)
320         * @return null;
321         */
322        function options_recuperer_code($options = array(), $merge=false) {
323                if ($merge) {
324                        $this->options_recuperer_code = array_merge($this->options_recuperer_code,$options);
325                } else {
326                        $this->options_recuperer_code = $options;
327                }
328        }
329
330        /**
331         * Recupere un array des erreurs de compilation
332         * @return array        Erreurs de compilations
333         */
334        function get_compilation_errors(){
335                $erreurs = $GLOBALS['tableau_des_erreurs'];
336                $GLOBALS['tableau_des_erreurs'] = array();
337                return $erreurs;
338        }
339       
340        /**
341         * Raz les erreurs de compilation
342         * @return null
343         */
344        function init_compilation_errors(){
345                // les erreurs s'ecrivent dans une jolie globale
346                $GLOBALS['tableau_des_erreurs'] = array();
347        }
348       
349        /**
350         * Retourne "<?php $code ?>"
351         * @param string $code  Code php
352         * @return string       Code php complet
353         */
354        function php($code){
355                return "<"."?php\n" . $code . "\n?".">";
356        }
357       
358        /**
359         * Ecrire un fichier a l'endroit indique
360         * Si le fichier existe, il n'est pas recree
361         * sauf en cas de var_mode=recalcul
362         *
363         * @param string $adresse       Adresse du fichier a ecrire
364         * @param string $contenu       Contenu du fichier
365         * @return null
366         */
367        function ecrire_fichier($adresse, $contenu){
368                if (!file_exists($adresse)
369                OR  $GLOBALS['var_mode']=='recalcul') {
370                        ecrire_fichier($adresse, $contenu);
371                }
372        }
373       
374}
375
376
377/**
378 * Gestion des exceptions
379 *
380 * Exception de type NA (Par exemple en generant des squelettes
381 *
382 */
383class SpipNaException extends Exception { 
384  // chaîne personnalisé représentant l'objet
385  public function __toString() {
386    return "{$this->message}\n";
387  }             
388}
389
390/**
391 * Gestion des exceptions
392 *
393 * Exceptions prevues dans les tests
394 *
395 */
396class SpipTestException extends Exception { 
397  // chaîne personnalisé représentant l'objet
398  public function __toString() {
399    return "{$this->message}\n";
400  }             
401}
402
403
404/**
405 * Extension de TestSuite
406 * pour donner le bon repertoire de travail
407 * et ajouter des fonctions specifiques a SPIP
408 */
409class SpipTestSuite extends TestSuite {
410        function SpipTestSuite($name = false){
411                chdir(_CHDIR);
412            if (!$name) {
413            $name = get_class($this);
414        }
415                $this->TestSuite($name);
416        }
417       
418        /**
419         * Ajoute tous les fichiers de tests
420         * d'un repertoire donne (ou du repertoire d'un fichier donne)
421         *
422         * @param string $dir : fichier ou repertoire qui sera scanne
423         * @param bool $recurs : inclure recursivement les dossiers ?
424         * @return null
425         */
426        function addDir($dir, $recurs = false){
427                if (is_file($dir))
428                        $dir = dirname($dir);
429                include_spip('inc/flock');
430                $a = preg_files($dir);
431                foreach ($a as $f) {
432                        $info = pathinfo($f);
433                        if (($info['extension']=='php') 
434                        AND !strpos($info['basename'], '_fonctions.php')
435                        AND !in_array($info['basename'], array(
436                                'lanceur_spip.php',
437                                'all_tests.php',
438                        ))) {
439                                $this->addFile($f);     
440                        }
441                }
442        }
443}
444
445
446
447/**
448 * Extension de HTMLReporter
449 * pour donner le bon repertoire de travail
450 * et ajouter des fonctions specifiques a SPIP
451 */
452class SpipHtmlReporter extends HtmlReporter {
453        var $_na;
454       
455        function SpipHtmlReporter($charset='UTF-8') {
456                chdir(_CHDIR);
457        $this->HtmlReporter($charset); 
458                $this->_na = 0;
459        }
460       
461        /**
462         * retourne un code css de deco
463         *
464         */
465        function _getCss() {
466                $css = parent::_getCss();
467                return $css . "\n.na{background-color: inherit; color: #fa0;}"
468                                        . "\n.complements{background-color: inherit; color: #999;}";
469        }
470       
471    /**
472     *    Paints the top of the web page setting the
473     *    title to the name of the starting test.
474     *    @param string $test_name      Name class of test.
475     *    @access public
476     */
477    function paintHeader($test_name) {
478                chdir(_CHDIR); // va savoir Charles... des fois il le perd en route ?
479                include_spip('inc/filtres_mini');
480        $this->sendNoCacheHeaders();
481        print "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">";
482        print "<html>\n<head>\n<title>$test_name</title>\n";
483        print "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=" .
484                $this->_character_set . "\">\n";
485        print "<style type=\"text/css\">\n";
486        print $this->_getCss() . "\n";
487        print "</style>\n";
488                print "<link rel='stylesheet' href='" . url_absolue(chemin('css/tests.css')) . "' type='text/css' />";
489        print "</head>\n<body>\n";
490               
491                print "<h1>Tests SPIP " . $this->version_spip() . "</h1>\n";
492        print "<h2>$test_name</h2>\n";
493        flush();       
494        }
495       
496    /**
497     *    Paints the end of the test with a summary of
498     *    the passes and failures.
499     *    @param string $test_name        Name class of test.
500     *    @access public
501     */
502    function paintFooter($test_name) {
503        $colour = ($this->getFailCount() + $this->getExceptionCount() > 0 ? "red" : ($this->getNaCount()>0 ? "#ffaa00" : "green"));
504               
505        print "<div style=\"";
506        print "padding: 8px; margin-top: 1em; background-color: $colour; color: white;";
507        print "\">";
508        print $this->getTestCaseProgress() . "/" . $this->getTestCaseCount();
509        print " test complete:\n";
510        print "<strong>" . $this->getPassCount() . "</strong> passes, ";
511        print "<strong>" . $this->getFailCount() . "</strong> fails, ";
512        print "<strong>" . $this->getExceptionCount() . "</strong> exceptions and ";
513        print "<strong>" . $this->getNaCount() . "</strong> non applicable.";
514        print "</div>\n";
515        print "</body>\n</html>\n";
516    }
517       
518        /**
519         * retourne le nombre de tests non applicables
520         * @return int  Nombre de tests non applicables
521         */
522        function getNaCount(){
523                return $this->_na;
524        }
525       
526    /**
527     *    Paints a PHP exception.
528     *    @param Exception $exception        Exception to display.
529     *    @access public
530     */
531    function paintException($exception) {
532                switch(get_class($exception)) {
533                        case 'SpipNaException':
534                                $this->paintNA($exception);
535                                break;
536                        case 'SpipTestException':
537                                $this->paintTestException($exception);
538                                break;
539                        default:
540                                parent::paintException($exception);
541                                break;
542                }
543    }
544       
545        /**
546         * Paints a Non Applicable Test
547         *
548     * @param Exception $exception    The actual exception thrown.
549     * @access public
550     */
551        function paintNa($exception) {
552                $this->_na++;
553               
554                print "<span class=\"na\">Non applicable</span>: ";
555                $breadcrumb = $this->getTestList();
556                array_shift($breadcrumb);
557                print implode(" -&gt; ", $breadcrumb);
558                $message = $exception->getMessage();
559                print " -&gt; <strong>" . $this->_htmlEntities($message) . "</strong><br />\n";                         
560        }
561       
562        /**
563         * Paints a Spip Test Exception
564         *
565     * @param Exception $exception    The actual exception thrown.
566     * @access public
567     */
568        function paintTestException($exception) {
569                $this->_exceptions++;
570               
571                print "<span class=\"fail\">Exception</span>: ";
572                $breadcrumb = $this->getTestList();
573                array_shift($breadcrumb);
574                print implode(" -&gt; ", $breadcrumb);
575                $message = $exception->getMessage();
576                print " -&gt; <strong>" . $this->_htmlEntities($message) . "</strong><br />\n";                         
577        }
578       
579       
580        function paintGroupStart($test_name, $size){
581                $test_name = str_replace(realpath(SpipTest::me()).'/','',$test_name);
582                parent::paintGroupStart($test_name, $size);
583                #echo "<ul><li><h3>$test_name</h3>\n";
584        }
585/*     
586        function paintGroupEnd($test_name){
587                parent::paintGroupEnd($test_name);
588                echo "</li></ul>\n";
589        }
590       
591        function paintCaseStart($test_name) {
592                parent::paintCaseStart($test_name);
593                echo "<ul><h3>$test_name</h3>\n";
594    }
595        function paintCaseEnd($test_name) {
596                parent::paintCaseEnd($test_name);
597                echo "</ul>\n";
598    }
599       
600        function paintMethodStart($test_name) {
601                parent::paintMethodStart($test_name);
602                echo "<li>$test_name</li>\n";
603    }
604        function paintMethodEnd($test_name) {
605                parent::paintMethodEnd($test_name);
606                parent::paintFooter($test_name);
607    }   
608*/             
609        /**
610         * Donne le nom de la version SPIP en cours
611         */
612        function version_spip() {
613                include_spip('inc/minipres');
614                $version = $GLOBALS['spip_version_affichee'];
615                if ($svn_revision = version_svn_courante(_DIR_RACINE)) {
616                        $version .= ' ' . (($svn_revision < 0) ? 'SVN ':'')
617                        . "[<a href='http://trac.rezo.net/trac/spip/changeset/"
618                        . abs($svn_revision) . "' onclick=\"window.open(this.href); return false;\">"
619                        . abs($svn_revision) . "</a>]";
620                }
621                return $version;
622        }
623}
624
625
626/**
627 * Extension de HTMLReporter
628 * pour donner le bon repertoire de travail
629 * et ajouter des fonctions specifiques a SPIP
630 */
631class SpipMiniHtmlReporter extends SpipHtmlReporter {
632        function SpipMiniHtmlReporter($charset='UTF-8') {
633                chdir(_CHDIR);
634        $this->SpipHtmlReporter($charset);
635        }
636       
637
638    /**
639     *    Paints the top of the web page setting the
640     *    title to the name of the starting test.
641     *    @param string $test_name      Name class of test.
642     *    @access public
643     */
644    function paintHeader($test_name) {
645                include_spip('inc/filtres_mini');
646        $this->sendNoCacheHeaders();
647        flush();       
648        }
649       
650       
651   /**
652     *    Paints the end of the test with a summary of
653     *    the passes and failures.
654     *    @param string $test_name        Name class of test.
655     *    @access public
656     */
657    function paintFooter($test_name) {
658        if ($this->getFailCount() + $this->getExceptionCount() == 0) {
659                        if ($this->getNaCount()) {
660                    print "OK <em>(".$this->getPassCount().")</em> but some NA <em>(".$this->getNaCount().")</em>\n";
661                        } else {
662                                print "OK <em>(".$this->getPassCount().")</em>\n";
663                        }
664        } else {
665            print "BOUM !!!\n";
666                        print "<span class='complements'>- Passes: " . $this->getPassCount() .
667                                        ", Failures: " . $this->getFailCount() .
668                                        ", Exceptions: " . $this->getExceptionCount() .
669                                        ", Non Applicable: " . $this->getNaCount() . "</span>\n";
670        }
671    }
672       
673       
674        /**
675         * Donne le nom de la version SPIP en cours
676         */
677        function version_spip() {
678                return SpipHtmlReporter::version_spip();
679        }
680       
681}
682
683/**
684 * Extension de TestReporter
685 * pour donner le bon repertoire de travail
686 * et ajouter des fonctions specifiques a SPIP
687 */
688class SpipTextReporter extends TextReporter {
689        function SpipTextReporter() {
690                chdir(_CHDIR);
691        $this->TextReporter(); 
692        }
693       
694   /**
695     *    Paints the end of the test with a summary of
696     *    the passes and failures.
697     *    @param string $test_name        Name class of test.
698     *    @access public
699     */
700    function paintFooter($test_name) {
701        if ($this->getFailCount() + $this->getExceptionCount() == 0) {
702                        if ($this->getNaCount()) {
703                    print "OK ($this->getPassCount()) but some NA ($this->getNaCount())\n";
704                        } else {
705                                print "OK ($this->getPassCount())\n";
706                        }
707        } else {
708            print "FAILURES!!!\n";
709                        print "Test cases run: " . $this->getTestCaseProgress() .
710                                        "/" . $this->getTestCaseCount() .
711                                        ", Passes: " . $this->getPassCount() .
712                                        ", Failures: " . $this->getFailCount() .
713                                        ", Exceptions: " . $this->getExceptionCount() .
714                                        ", Non Applicable: " . $this->getNaCount() . "\n";
715        }
716    }
717}
718
719
720class SqueletteTest{
721        var $title = "";
722        var $head = "";
723        var $body = "";
724       
725        /**
726         * Constructeur
727         * @param string $title         Donne un titre a la page
728         */
729        function SqueletteTest($title = ""){
730                $this->setTitle($title ? $title : "Squelette de test");
731        }
732       
733        /**
734         * Change le title
735         * @param string $title         Donne un titre a la page
736         * @return null
737         */
738        function setTitle($title){
739                $this->title = $title;
740        }
741       
742        /**
743         * Ajoute insert Head
744         * @return null
745         */
746        function addInsertHead(){
747                $this->head = "\n#INSERT_HEAD\n" . $this->head;
748        }
749       
750        /**
751         * Ajoute dans head
752         * @return null
753         */
754        function addToHead($content){
755                $this->head .= "\n" . $content;
756        }       
757       
758        /**
759         * Ajoute dans body
760         * @return null
761         */
762        function addToBody($content){
763                $this->body .= "\n" . $content;
764        }
765               
766        /**
767         * Retourne le code du squelette
768         */
769        function code(){
770                $code = '
771                        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
772                        <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="#LANG" lang="#LANG" dir="#LANG_DIR">
773                        <head>
774                        <title>'. $this->title . '</title>
775                        ' . $this->head . '
776                        </head>
777                        <body class="page_test">
778                        ' . $this->body . '
779                        </body>
780                        </html>         
781                ';
782                return $code;
783        }
784}
785
786
787
788
789// si provient de la base des tests de spip,
790// on affiche simplement un 'OK : ..."
791
792if (_request('mode') == 'test_general') {
793        SimpleTest::prefer(new SpipTextReporter());
794        SimpleTest::prefer(new SpipMiniHtmlReporter());
795} else {
796        SimpleTest::prefer(new SpipHtmlReporter());
797}
798
799?>
Note: See TracBrowser for help on using the repository browser.