Comprendre et utiliser efficacement le Testeur de Stratégie MQL5

Introduction

En tant que programmeurs ou développeurs MQL5, nous avons besoin de bien comprendre et d'utiliser le Testeur de Stratégie pour obtenir des résultats efficaces. En utilisant cet outil précieux, nous pouvons obtenir des informations précieuses sur les performances des programmes MQL5 que nous avons créés, ce qui nous permettra d'obtenir de meilleurs résultats de trading. Nous constatons donc qu'il est nécessaire de bien comprendre des sujets importants avant d'effectuer nos tests, comme le traitement de tous les types d'erreurs, car il est tout à fait normal, en tant que développeurs, que nous fassions des erreurs qui se traduisent par des fautes. Un autre sujet que nous devons bien comprendre est le débogage qui nous permet d'exécuter nos programmes créés de manière interactive. Ensuite, nous arrivons à l'outil le plus important et le plus précieux qui est le Testeur de Stratégie pour tester et évaluer nos programmes créés avec les fonctionnalités les plus intéressantes de MetaTrader 5. Dans cet article, vous découvrirez les aspects les plus importants de l'utilisation du Testeur de Stratégie MQL5 à travers les sujets suivants :

• Erreurs
• Débogage
• Le Testeur de Stratégie
• Conclusion

Nous allons essayer de couvrir les points les plus populaires de ces sujets afin de bien comprendre ce que nous devons gérer en tant que programmeurs ou développeurs. Ce que je dois mentionner ici, c'est que lorsque nous traitons de ce sujet, il est normal que tous les lecteurs connaissent déjà le langage de programmation MQL5 et qu'ils sachent comment coder leurs programmes. Il s'agit d'un pré-requis que vous devez comprendre pour tirer le maximum de bénéfices de la lecture de cet article. Si vous souhaitez d'abord vous familiariser avec le langage, vous pouvez consulter la documentation de MQL5. Vous pouvez également lire mes autres articles sur l'apprentissage des bases de la programmation MQL5 et sur la création de systèmes de trading basés sur les indicateurs techniques les plus populaires. J'espère qu'ils vous seront utiles.

Erreurs

Dans cette rubrique, nous allons découvrir les erreurs que nous pouvons trouver lors de la création, de l'exécution et de l'exécution des programmes MQL5. Ce qui rend ce sujet très important à comprendre, c'est que MQL5 signalera ces erreurs correctement. Mais si nous ne savons pas ce que ces erreurs signifient ou à quelle étape de notre programme, nous prendrons beaucoup plus de temps pour les traiter ou les résoudre que si nous savons déjà ce qu'elles signifient.

Nous présenterons ce sujet en fonction de l'état d'avancement de notre travail sur le programme MQL5. Alors que nous écrivons notre code, il y a des erreurs et des avertissements qui peuvent être rencontrés, qui sont des erreurs de compilation et des avertissements. Nous pouvons également rencontrer des erreurs lors de l'exécution du programme MQL5, qui sont des erreurs d'exécution. Nous pouvons également rencontrer d'autres types d'erreurs lorsque notre programme MQL5 essaie de trader, qui sont des erreurs du serveur de trading. Nous couvrirons donc les types d'erreurs suivants :

• Erreurs de compilation et avertissements
• Erreurs d'exécution
• Erreurs du serveur de trading

Avant de couvrir ces erreurs, il y a une chose importante que vous devez savoir : l'endroit où les erreurs apparaissent. Dans l'IDE MQL5, il y a une fenêtre de Boîte à Outils dans la partie la plus basse. Si vous ne la trouvez pas par défaut, vous pouvez l'afficher par l'une des méthodes suivantes :

1- Cliquer sur Affichage ==> Boîte à Outils

2- Appuyer sur les touches Ctrl+T du clavier

3- Cliquer sur le bouton Boîte à outils de la boîte à outils principale

Un contenu similaire à l'image suivante sera alors affiché :

Erreurs de compilation et avertissements :

Lorsque nous écrivons notre code pour un programme spécifique, nous pouvons faire une erreur, ce qui est tout à fait normal, en écrivant une syntaxe incorrecte ou en faisant des fautes de frappe, par exemple, ce qui entraîne des erreurs lors de la compilation du code. Dans cette partie, nous allons partager les erreurs les plus populaires et les plus courantes de ce type. La chose la plus importante à savoir est que le programme ne peut pas être compilé tant que les erreurs n'ont pas été éliminées ou résolues. Je vais présenter les erreurs les plus courantes auxquelles nous pouvons être confrontés dans le cadre de ce type d'erreurs :

Erreur « semicolon expected » (point-virgule attendu) :

Cette erreur se produit lorsqu'on oublie d'écrire un point-virgule à la fin de la ligne, lorsqu'il manque un point-virgule ou lorsqu'on oublie également un crochet à gauche. Nous devons utiliser ces symboles correctement pour éviter ce type d'erreur. Le code suivant est un exemple de cette erreur.

Mauvais code avec erreur :

int a=(2+1)

L'erreur sera la suivante :

Code correct sans erreur :

Le code suivant avec le point-virgule ajouté à la fin de la ligne de code est correct :

int a=(2+1);

Après avoir compilé le code, nous constatons que l'erreur est éliminée et que le code est compilé sans aucune erreur, comme dans le cas suivant :

Erreur « unexpected token » (symbole inattendu) :

Il s'agit d'un autre type de code auquel nous sommes souvent confrontés et qui s'explique par l'oubli d'une parenthèse droite dans la dernière ligne de code, ou par l'ajout d'une parenthèse gauche supplémentaire dans la ligne de code actuelle. Voici un exemple de ce type d'erreur :

Mauvais code avec erreur :

int a=(2+1;

L'erreur est visible dans l'onglet Erreurs de la Boîte à Outils, comme suit :

Code correct sans erreur :

int a=(2+1);

Nous pouvons voir l'onglet Erreur avec toutes les erreurs après avoir corrigé le code en ajoutant la parenthèse droite :

Erreur « undeclared identifier » (identifiant non déclaré) :

Ce type d'erreur se produit lorsque nous utilisons une variable sans la déclarer au préalable. Nous devons déclarer toute nouvelle variable avant de l'utiliser ou de lui attribuer une valeur. Déclarer la variable en choisissant le type de données approprié de cette variable, comme un entier ou une chaîne de caractères par exemple. L'exemple suivant illustre ce type d'erreur en utilisant une nouvelle variable sans la déclarer.

Mauvais code avec erreur :

a=5;

Dans le code précédent, nous avons utilisé la variable a en lui affectant 5 sans la déclarer. L'erreur « identificateur non déclaré » sera donc levée lorsque nous compilerons ce code :

Comme nous pouvons le constater, la précision de la description de l'erreur peut être très utile, car elle ne se contente pas de signaler l'erreur, mais spécifie la variable "a" qui est à l'origine de cette erreur.

Code correct sans erreur :

int a=5;

Après avoir compilé ce code correct, nous ne trouverons plus l’erreur dans l’onglet Erreurs de la Boîte à Outils.

Erreur « unbalanced left parenthesis » (parenthèse gauche non trouvée ou non fermée) :

Ce type d'erreur se produit lorsque nous omettons la parenthèse droite ou que nous utilisons une parenthèse droite supplémentaire. Nous pouvons trouver cette erreur dans l'exemple suivant.

Mauvais code avec erreur :

   bool a=7;
   if (a=5
   a=5;

Dans le code précédent, nous constatons qu'en oubliant la parenthèse droite, l'erreur "unbalanced left parenthesis" s'ajoute à l'erreur de "some operator expected" comme dans l'image suivante

Code correct sans erreur :

   bool a=7;
   if (a=5)
   a=5;

Après avoir corrigé le code, nous constaterons qu'il a été compilé sans erreur.

Erreur « unexpected end of program » (fin de programme inattendue) :

Nous devons vérifier notre code pour voir ce qu'il faut ajouter ou nous assurer que chaque parenthèse ouvrante est accompagnée d'une parenthèse fermante pour résoudre cette erreur. Voici un exemple de ce code.

Mauvais code avec erreur :

void OnStart()
  {
   bool a=7;
   if (a=5)
   a=5;

En écrivant le code comme le bloc de code précédent en oubliant la parenthèse fermante après la dernière ligne (a=5) nous pouvons trouver l'erreur "unexpected end of program" en plus de l'erreur "unbalanced parentheses" comme dans l'image suivante

Code correct sans erreur :

void OnStart()
  {
   bool a=7;
   if (a=5)
   a=5;
   }

Après avoir corrigé le code en ajoutant la parenthèse fermante, nous constaterons que le code a été compilé sans erreur.

Erreur « expressions are not allowed on a global scope » (les expressions de portée globale ne sont pas autorisées) :

Cette erreur se produit lorsque nous oublions une parenthèse gauche dans un opérateur composé, ou lorsque nous écrivons une déclaration ou une expression en dehors du champ d'application d'une fonction spécifique, car nous ne devons utiliser que des expressions dans le champ d'application de la fonction. L'exemple suivant concerne ce type d'erreur.

Mauvais code avec erreur :

   int a=(7+5);
   if (a<7)
   
   a=7;
   }

Dans le code précédent, nous avons oublié l’accolade ouvrante ’}’ qui modifiait la portée. Nous avons donc l'erreur "Expressions are not allowed on a global scope". L'erreur suivante apparaît dans l'onglet Erreurs.

Code correct sans erreur :

   int a=(7+5);
   if (a<7)
   {
   a=7;
   }

Après avoir corrigé le code comme dans le bloc de code précédent, nous constaterons que le code a été compilé sans aucune erreur.

Erreur « wrong parameters count » (mauvais nombre de paramètres) :

Nous rencontrons ce type de code lorsque nous utilisons une fonction spécifique avec des paramètres spécifiques et que nous ne spécifions pas ces paramètres correctement en en spécifiant trop ou pas assez. Cette erreur apparaîtra lorsque nous utilisons une fonction prédéfinie ou une fonction que nous avons créée. Voici un exemple de cette erreur.

Mauvais code avec erreur :

Si nous avons créé une fonction "myVal" pour renvoyer une valeur entière comme étant le résultat de la somme de deux valeurs entières, cela signifie-t-il que nous avons deux paramètres dans cette fonction ? Lorsque nous appelons cette fonction en utilisant des paramètres différents de ces deux paramètres, nous obtiendrons ce type d'erreur, comme dans le code suivant

void OnStart()
  {
   int example=myVal(10);
  }
//+------------------------------------------------------------------+
int myVal(int a, int b)
  {
   return a+b;
  }

En compilant le code précédent, nous obtiendrons l'erreur suivante :

Code correct sans erreur :

Pour écrire ce code correctement, nous devons utiliser les paramètres spécifiés de cette fonction créée de la manière suivante

void OnStart()
  {
   int example=myVal(10,20);
  }
//+------------------------------------------------------------------+
int myVal(int a, int b)
  {
   return a+b;
  }

Après avoir compilé ce code correct, nous ne trouverons aucune erreur.

Erreur « Some operator expected » (opérateur attendu) :

Il s'agit d'un type d'erreur que l'on rencontre lorsqu’il manque un opérateur à un endroit précis, par oubli ou à cause d’un mauvais placement. Voici un exemple de ce type d'erreur.

Mauvais code avec erreur :

int a= 7 10;

Dans le code précédent, nous avons oublié un opérateur entre les deux nombres. C’est la raison pour laquelle nous obtiendrons l'erreur "some operator expected" comme dans l'image suivante :

Code correct sans erreur :

int a= 7+10;

Après avoir corrigé le code en ajoutant le ’+’, nous constaterons que le code sera compilé sans erreur.

Les erreurs mentionnées sont les erreurs les plus courantes dans ce type d'erreurs de compilation. Mais il est important de comprendre le messages affichés. Certaines entrées sont des avertissements de compilation. Nous devons également apprendre ce qu'ils sont, ils sont affichés à des fins d'information et ne sont pas des erreurs. L'exemple de code suivant montre que nous obtenons un avertissement dans l'onglet "Erreurs".

int a;

En compilant le code précédent, nous obtiendrons un avertissement concernant la variable "a" non utilisée, car nous avons déclaré une nouvelle variable "a", mais nous ne l'utilisons pas et ne lui attribuons pas de valeur. Voici l'image de l'avertissement :

Vous pouvez consulter les liens suivants vers la documentation pour voir tous les messages MQL5 :

• Erreurs de compilation
• Avertissements de compilations

Quelques conseils peuvent s'avérer très utiles pour traiter ces erreurs lorsqu'elles se produisent :

• Corrigez-les en commençant par la première, car cela peut résoudre toutes les autre erreurs (en fonction de la raison de cette erreur).
• Un double-clic sur la ligne d'erreur dans l'onglet Erreurs de la Boîte à Outils permet d'accéder à la ligne de code qui pose problème.

Nous avons maintenant appris les erreurs que nous pouvons rencontrer lors de la première étape de l'écriture du code du programme MQL5. Nous allons passer à la deuxième étape, qui concerne les erreurs qui se produisent lorsque nous exécutons le programme, c'est-à-dire les erreurs d'exécution.

Erreurs d'exécution

Comme nous l'avons mentionné précédemment, les erreurs d'exécution sont les types d'erreurs qui se produisent pendant l'exécution d'un programme MQL5. Ces erreurs n'empêcheront pas le code de se compiler sans erreur, mais il ne sera pas exécuté ou ne fonctionnera pas comme nous nous y attendons. Ces erreurs sont écrites dans le journal sous forme de messages avec la raison de l'erreur et la ligne de l'erreur dans le code source.

Exemples de ces erreurs :

Code d'erreur	Motif de l'erreur
4007	Mémoire insuffisante pour la relocalisation d'un tableau, ou tentative de modification de la taille d'un tableau statique.
4101	Mauvaise identifiant du graphique
4301	Symbole inconnu comme information de marché
4754	Ordre non trouvé
5120	Erreur interne de la base de données

Vous aurez remarqué que les codes d'erreur sont définis en MQL5. Chaque erreur d'exécution est donc facile à identifier. Vous obtiendrez ces codes en utilisant la fonction GetLastError() si vous ajoutez une méthode de gestion des erreurs à votre programme. Ces erreurs sont visibles dans l'onglet Journal pendant le test ou dans l'onglet Expert lors de l’exécution du programme . Toutes les erreurs d'exécution et leurs codes sont disponibles dans la documentation de MQL5 :

https://www.mql5.com/fr/docs/constants/errorswarnings/errorcodes

Je dois mentionner ici que le programme n'arrêtera pas l'exécution après une erreur d'exécution, sauf pour quelques erreurs critiques, comme un index en dehors du tableau par exemple.

Erreurs du serveur de trading

Ces types d'erreurs se produisent lors de l'exécution d'une transaction en utilisant la structure d'une demande de transaction MqlTradeRequest via la fonction OrderSend(). Ces erreurs sont aussi signalées dans l'onglet Journal lors du test ou dans l'onglet Expert lorsque le programme est attaché au graphique. Voici quelques exemples :

Code d'erreur	Motif de l'erreur
10006	Demande rejetée
10032	L'opération n'est autorisée que pour les comptes réels
10033	Le nombre d'ordres en attente a atteint la limite
10034	Le volume d'ordres et de positions pour le symbole a atteint la limite.
10041	La demande d'activation de l'ordre en attente est rejetée, l'ordre est annulé.

Tous les codes de ce type d'erreur sont disponibles dans la documentation MQL5 :

https://www.mql5.com/fr/docs/constants/errorswarnings/enum_trade_return_codes

Débogage

Dans cette rubrique, nous allons apprendre comment le débogage peut être utilisé à travers l'outil de débogage de MQL5. Il peut être utilisé pour exécuter notre programme avec des données historiques ou en direct. Nous pouvons le lancer en cliquant sur le démarrage/la reprise du débogage sur des données réelles ou historiques, comme le montre l'image suivante :

1- Démarrer/reprendre le débogage sur les données historiques

2- Démarrer/reprendre le débogage sur des données réelles

3- Pause du débogage

4- Arrêter le débogage

Une fois que nous avons appuyé sur le bouton de démarrage pour déboguer sur les données historiques, le programme sera exécuté sur les données historiques et ouvrira un graphique pour déboguer le programme. Ou si nous avons choisi le débogage sur les données réelles, le programme sera attaché au graphique sur les données réelles et à côté du programme, vous trouverez la mention « Débogage ».

Testeur de Stratégie

Dans cette partie, nous apprenons à connaître l'outil le plus important et le plus précieux de MetaTrader 5 qui est le Testeur de Stratégie avec de nouvelles fonctionnalités, meilleures que le testeur de MetaTrader 4 comme par exemple le test multi-devises. Pour ouvrir ce Testeur de Stratégie, nous pouvons utiliser l'une des méthodes suivantes :

1- Depuis le terminal de trading MetaTrader 5, appuyez sur Ctrl+R au clavier.

2- Depuis le menu Affichage ==> choisissez Testeur de Stratégie.

Ensuite, le Testeur de Stratégie sera disponible dans l'onglet Aperçu pour choisir ce dont vous avez besoin ou le type de test.

Nous choisirons simplement ce que nous devons tester dans l'onglet Aperçu. Une fois fait, l'onglet passera à l'onglet Paramètres avec des paramètres prédéfinis basés sur ce que vous avez choisi de tester.

• Signal : pour tester les Expert Advisors avec des signaux sans visualisation.
• Indicateur : pour tester un indicateur.
• Visualiser : pour activer le mode visualisation pendant les tests sur le graphique afin de voir comment le programme réagit aux données en fonction de ses instructions.
• Stress et retards : pour tester le stress et les retards, comme son nom l'indique clairement.
• Options d'optimisation (Complète, Génétique, En Avant).
• Analyse du marché : pour tester l'analyse du marché.
• Calculs mathématiques : pour tester les calculs mathématiques également.

Vous pouvez également consulter les résultats des tests précédents grâce à la dernière option Afficher les résultats précédents. Vous pouvez également rechercher un test précédent spécifique à l'aide de la fonction de recherche située sous les options de test.

Si nous passons à l'onglet "Paramètres", nous obtiendrons le même résultat qu'à l'étape suivante :

•   1- Expert : choisir le fichier du programme à tester.
•   2- IDE : pour ouvrir le code source du programme sélectionné.
  
•   3- pour enregistrer ou charger des paramètres spécifiques.
  
•   4- Symbole : choisir le ou les symboles à tester.
  
•   5- choisissez la période de temps du symbole sélectionné à tester.
  
•   6- pour les spécifications du symbole sélectionné.
  
•   7- Date : choisir la période à tester.
  
•   8- choisir la période de démarrage testée.
  
•   9- choisir la période de clôture testée.
  
•  10- Forward : c'est la sélection de la fraction nécessaire de la période d'optimisation qui sera mise de côté pour les tests prospectifs.
  
•  11- sélectionner ou commencer la date d’avance.
  
•  12- Délais, réglage pour obtenir des données proches de la réalité.
  
•  13- pour essayer de se rapprocher des données réelles et des exécutions réelles.
•  13/2- Modélisation : Pour sélectionner le modèle à tester à chaque tick ou autre.
  
•  14- cocher pour voir le profits en pips.
  
•  15- choisir le montant du dépôt pour commencer les tests.
  
•  16- choisir la devise du dépôt.
  
•  17- choisir l'effet de levier.
  
•  18- choisir si l'on veut une optimisation ou non, nous y reviendrons plus tard.
•  19- cocher si nous avons besoin de visualiser les transactions ou les exécutions pendant les tests.

L'onglet Entrées permet également de vérifier si le programme testé comporte des entrées qui peuvent être insérées ou modifiées par l'utilisateur.

Après avoir déterminé nos paramètres et appuyé sur le bouton Start, le programme sera testé et nous pouvons suivre ce test à travers le graphique qui apparaîtra si nous visualisons le test. Dans les onglets de ce graphique, nous pourrons voir les transactions exécutées si notre programme : Historique pour suivre les ordres fermés ou annulés, Opérations pour voir toutes les opérations, et Journal pour vérifier les messages imprimés du programme et d'autres. Nous pouvons également le contrôler à l'aide de l'onglet Graphique de la fenêtre du Testeur de Stratégie pour surveiller les performances du programme.

Une fois le test terminé, nous pouvons également vérifier l'onglet Backtest qui apparaîtra et qui contiendra toutes les statistiques et les informations relatives au test, comme dans l'exemple suivant

Selon le programme que vous allez tester, les données de cet onglet Backtest ressembleront ou seront différentes de celles de l'exemple précédent.

Il s'agit de l'optimisation qui comprend la sélection d'un large éventail de paramètres et d'entrées différents et la vérification de toutes les combinaisons possibles de ces entrées ou paramètres afin de vérifier et de tester les paramètres qui produiront les meilleurs résultats. Nous choisirons ici l'un des modèles d'optimisation dans l'onglet Vue d'ensemble et nous sélectionnerons les paramètres d'optimisation appropriés, comme dans les images suivantes

Les éléments les plus importants que nous devons vérifier et évaluer après les tests :

• Bénéfice Net (Net Profit) : Il est calculé en soustrayant la perte brute du bénéfice brut.
• Draw Down : il s'agit de la perte maximale que le compte subit pendant les transactions.
• Facteur de Profit (Profit Factor) : Il s'agit du rapport entre la marge brute et la perte brute.
• Rendement Attendu (Expected Payoff) : il s'agit du profit ou de la perte moyenne d'une transaction.
• Facteur de Récupération (Recovery Factor) : il mesure la capacité de la stratégie testée à se rétablir après avoir subi des pertes.  

Conclusion

Nous avons appris des choses essentielles sur l'un des outils les plus importants et les plus précieux que nous devons tous maîtriser lorsque nous développons un programme MQL5, à savoir le processus de test via le Testeur de Stratégie du terminal de trading MetaTrader 5. Et nous avons appris des choses connexes qui nous aideront à comprendre et à utiliser cet outil de manière efficace. Nous avons appris à connaître les erreurs auxquelles nous sommes confrontés lorsque nous développons des programmes MQL5, en fonction des types d'erreurs suivants :

• Erreurs de compilation et avertissements
• Erreurs d'exécution
• Erreurs du serveur de trading

Ensuite, nous avons appris comment déboguer avec le débogueur de l'IDE MQL5 et nous avons appris à utiliser le Testeur de Stratégie de MetaTrader 5 en apprenant ses différents modèles. Nous pouvons définir les paramètres du test en fonction du modèle, surveiller le processus de test à travers des onglets différents lors du test d’un programme MQL5. Et après le test, comment lire le rapport du test et identifier les éléments les plus importants à vérifier et à évaluer, et optimiser notre stratégie à travers le test pour obtenir le meilleur résultat du programme MQL5 testé.

J'espère que cet article et les informations qu'il contient vous seront utiles pour améliorer vos résultats en effectuant des tests efficaces et en créant vos programmes MQL5. Si vous avez trouvé cet article utile et que vous avez besoin de lire d'autres articles, vous pouvez consulter mes autres articles, par exemple comment créer des systèmes de trading basés sur les indicateurs techniques les plus populaires.