Archives par mot-clé : Test

Créer et exécuter des tests cases avec QTestLib

Publié dans C / C++ | Un commentaire
17 Mar 2025

Après avoir soliloqué sur l’architecture de tests Qt / C++ que j’aimerai obtenir, commençons par le commencement : créer un test avec QTestLib et l’exécuter. A vrai dire, cet article traine dans mes brouillons depuis au moins 2014, mais je me suis décidé à le publier. Les liens datent un peu, mais tout reste très fonctionnel.

Un mini rappel sur les tests unitaires :

  • Un test case par classe : ce test case testera les différentes fonctions de cette classe
    • dans des cas nominaux,
    • des cas d’erreurs,
    • voire des cas limites.
  • Tester le plus petit bloc possible : si la classe à tester utilise d’autres composants, on dit qu’elle a des « dépendances », il faut alors « mocker » ces dépendances (si possible) ou en tout cas les maîtriser au maximum. Ce sont les integration tests qui testeront plusieurs blocs ensemble.
Continuer la lecture →

Architecture de tests en C++ avec Qt

Publié dans C / C++ | Laisser un commentaire
27 Août 2014

Si vous êtes développeur, je pense que vous avez surement entendu parler des tests unitaires (unit test) et j’espère que vous êtes convaincu de leur utilité ! Tester unitairement un morceau de code, c’est vérifier que celui-ci fait ce que l’on souhaite dans de multiples situations. Ensuite, on peut passer sereinement aux tests d’intégration qui vont tester plusieurs morceaux de codes (ou d’applications) entre eux. On peut encore raffiner avec des tests de performances, tests système, etc, etc… Tout dépend jusqu’où on souhaite aller.

Si on est capable de lancer régulièrement l’exécution de nos tests unitaires, alors on est capable de dire que notre code continue de fonctionner comme voulu malgré les mises à jours ou les refactoring. Cela n’empêche pas les erreurs ni les bugs, car on ne peut pas tester tout notre code unitairement, ou cela peut lamentablement planter lors de l’intégration. Néanmoins, on sait qu’une base solide « fonctionne comme prévu », ce qui facilite grandement la correction d’une erreur.

Pour des myriades de raisons :
tester son code c’est génial !!!

Des études prouvent même qu’une bonne gestion des tests permet au final de gagner du temps. Si vous n’y croyez pas, je vous invite sérieusement à reconsidérer votre opinion.

Ce que j’ai déjà vu dans certains environnements et ce que j’aimerai reproduire dans mon environnement Qt / C++, se résume ainsi :

Continuer la lecture →

Attendre la fin d’un signal Qt de manière synchrone

Publié dans Snippet | Laisser un commentaire
20 Jan 2014

Ou comment attendre la fin d’une méthode asynchrone.

Snippet

/**
 * Wait synchronously for a Qt signal (+ timeout management)
 * May be useful for test purpose
 * Not recommended for production usage
 */

// -- Configure the waiting
// Signal to wait
QEventLoop loop;
QObject::connect(&anObject, SIGNAL(signalToWait()), &loop, SLOT(quit()));
// Timeout to avoid infite waiting
QTimer timer;
timer.setInterval(10*1000); //10s
timer.setSingleShot(true);
QObject::connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));

// -- Do stuff that should trigger the signal
// ...

// -- Start to wait
// What is done after "loop.exec()" is not executed until "loop.quit()" is called
timer.start();
loop.exec();
timer.stop(); // Just in case there is no timeout

// -- Other stuff
// ...

jUnit et les tests asynchrones

Publié dans Snippet | Laisser un commentaire
20 Jan 2014

Où comment tester des méthodes asynchrones (avec listaner ou callback) en Java, par exemple avec jUnit. En fait c’est un moyen rapide et relativement sûr (quoique non conseillé pour du vrai code) de rendre une méthode synchrone.

Snippet

public class AsynchronousTest
{
    /**
    * Asynchronous helper
    */
    private CountDownLatch lock = new CountDownLatch(1);
    /**
    * Received data from the asynchronous call
    */
    private Object receiveddata;

    @Test
    public void testAsynchronousCall() throws Exception {
        Object parameters = null;
        myAsynchronousCall(parameters, new MyCallback() {
                @Override
                public void onSuccess(Object data) {
                    receiveddata = data;
                    lock.countDown();
                }
            });

        boolean releaseBeforeTimeout = lock.await(2000, TimeUnit.MILLISECONDS);
        // Check timeout
        if (!releaseBeforeTimeout) {
            // Do stuff
            fail("Timeout");
        }

        assertNotNull(receiveddata);
        // Other tests
    }
}

Explications

L’idée de base est la suivante :

  • On initialise un CountDownLatch à 1, c’est-à-dire à un seul usage. Chaque appel à CountDownLatch::countDow() représente une utilisation.
  • On exécute la méthode asynchrone. La fin de cette méthode appelle CountDownLatch::countDow(). Mais avant d’en arriver là, pendant que la méthode s’exécute…
  • On regarde si le CountDownLatch est à 0 (dans le cas où la méthode asynchrone a déjà terminé) ou on attend qu’il passe à 0 (c’est-à-dire que la méthode asynchrone s’est terminée), ou on attend jusqu’à la fin d’un timeout (temps défini après lequel on considère que l’exécution de la méthode a échoué.

Injection de dépendances en C++

Publié dans C / C++ | Laisser un commentaire
30 Juil 2013

L’injection de dépendances, que l’on retrouve généralement sous le terme de dependency injection (DI pour les intimes) est un concept de programmation très simple.

Pistolet à injection

Pistolet à injection (de dépendances of course)

L’idée de base c’est de ne pas faire ça :

class Foo {
    private Bar bar;

    public Foo() {
        bar = new Bar();
    }
}

Mais ça :

class Foo {
    private IBar bar;

    public Foo(IBar bar) {
        this->bar = bar;
    }
}

Continuer la lecture →