Générateur de code de test CER

L'interpréteur de jeu de règles CER ci-dessus autorise la référence aux noms de classe de règles et d'attribut via des chaînes.

Même si celui-ci permet une configuration dynamique complète des jeux de règles, dans le cadre du test, il peut s'avérer fastidieux d'avoir à utiliser des chaînes et des valeurs d'attribut de transtypage. Si vous faites une faute de frappe dans le nom d'une classe de règles ou d'un attribut, ou si utilisez le mauvais type de transtypage, votre code peut être compilé sans erreur mais vous rencontrerez des erreurs lors de l'exécution.

CER inclut un générateur de code capable de générer des classes d'encapsuleur Java pour vos classes de règles. Ces classes générées peuvent simplifier l'écriture de votre code de test et permettre au compilateur de détecter les problèmes qui se produiraient uniquement lors de l'exécution.

Nous allons à présent réécrire notre code pour exécuter le jeu de règles HelloWorldRuleSet :

Figure 1. Exécution de règles à l'aide des classes de règles de test générées par CER

package curam.creole.example;

import junit.framework.TestCase;
import curam.creole.execution.session.RecalculationsProhibited;
import curam.creole.execution.session.Session;
import curam.creole.execution.session.Session_Factory;
import
 curam.creole.execution.session.StronglyTypedRuleObjectFactory;
import curam.creole.ruleclass.HelloWorldRuleSet.impl.HelloWorld;
import
 curam.creole.ruleclass.HelloWorldRuleSet.impl.HelloWorld_Factory;
import curam.creole.storage.inmemory.InMemoryDataStorage;

public class TestHelloWorldCodeGen extends TestCase {

  /**
   * Exécute la classe en tant qu'application Java autonome.
   */
  public static void main(final String[] args) {

    final TestHelloWorldCodeGen testHelloWorld =
        new TestHelloWorldCodeGen();
    testHelloWorld.testUsingGeneratedTestClasses();

  }

  /**
   * Scénario de test simple, utilisant les classes de test générées par CER pour
   * les tests de typage fort et de simplicité de codification.
   */
  public void testUsingGeneratedTestClasses() {

    /* démarre une session à typage fort */
    final Session session =
        Session_Factory.getFactory().newInstance(
            new RecalculationsProhibited(),
            new InMemoryDataStorage(
                new StronglyTypedRuleObjectFactory()));

    /*
     * crée une instance d'objet de règle de la classe de règles obligatoire, à
     * l'aide de sa classe générée
     */
    final HelloWorld helloWorld =
        HelloWorld_Factory.getFactory().newInstance(session);

    /*
     * utilise l'accesseur généré pour obtenir l'attribut de règle
     * "greeting" (aucun transtypage nécessaire) et toute erreur dans le
     * nom d'attribut provoque une erreur de compilation
     */
    final String greeting = helloWorld.greeting().getValue();

    System.out.println(greeting);
    assertEquals("Hello, world!", greeting);
  }

}

Remarquez les comparaisons suivantes avec notre code TestHelloWorldInterpreted :

la session employée avec le générateur de code utilise StronglyTypedRuleObjectFactory, nommé ainsi car il traite les classes Java générées plutôt que les instances RuleObject dynamiques ;
le chargement du jeu de règles n'est pas obligatoire (d'où l'absence de méthode utilitaire) ;
la référence à la classe de règles HelloWorld s'effectue via une interface Java du même nom ; toute faute de frappe dans le nom sera détectée par le compilateur Java ;
de la même manière, la référence à l'attribut de règle greeting s'effectue via une méthode Java du même nom sur l'interface ;
aucun transtypage du type de retour n'est requis, car la méthode greeting retourne le type correct (String).

avertissement : Le code généré est uniquement destiné à être utilisé dans les environnements de test où il est simple de recompiler les changements apportés au code.

Le code généré n'est pas transférable entre les machines, car il contient des chemins d'accès absolus aux jeux de règles sur la machine locale.

En particulier, vous ne devez pas utiliser le code généré dans un environnement de production où les jeux de règles sont susceptibles de changer dynamiquement.