Generador de códigos de prueba de CER

El intérprete de conjunto de reglas de CER anterior permite hacer referencia a nombres de atributo y clase de reglas a través de las series.

Mientras que esto permite la configuración totalmente dinámica de los conjuntos de reglas, para realizar pruebas puede ser engorroso tener que utilizar series y los valores de atributo de conversión. Si escribe incorrectamente un nombre de atributo o clase de regla o utiliza el tipo incorrecto de conversión, el código puede compilarse sin errores pero obtendrá errores en tiempo de ejecución.

CER se incluye con un generador de códigos que puede generar clases de derivador Java para las clases de regla. Estas clases generadas pueden simplificar la escritura del código de prueba y permitir que el compilador detecte problemas que, de lo contrario, sólo se producirían en el tiempo de ejecución.

Ahora vamos a volver a escribir el código para ejecutar HelloWorldRuleSet:

Figura 1. Ejecución de reglas con las clases de regla de pruebas generadas por 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 {

  /**
   * Ejecuta la clase como aplicación Java autónoma.
   */
  public static void main(final String[] args) {

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

  }

  /**
   * Un caso de prueba simple, utilizando las clases de prueba generadas por CER para
   * tipificación firme y facilidad de codificación de pruebas.
   */
  public void testUsingGeneratedTestClasses() {

    /* iniciar una sesión de tipificación firme */
    final Session session =
        Session_Factory.getFactory().newInstance(
            new RecalculationsProhibited(),
            new InMemoryDataStorage(
                new StronglyTypedRuleObjectFactory()));

    /*
     * crear una instancia de objeto de regla de la clase de regla necesaria,
     * utilizando la fábrica generada
     */
    final HelloWorld helloWorld =
        HelloWorld_Factory.getFactory().newInstance(session);

    /*
     * utilizar el descriptor de acceso generado para llegar al atributo de regla de saludo ("greeting")
     * - ninguna conversión es necesaria y cualquier error en el
     * nombre de atributo llevará a un error de compilación
     */
    final String greeting = helloWorld.greeting().getValue();

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

}

Observe las comparaciones siguientes con nuestro código TestHelloWorldInterpreted:

La sesión utilizada con el generador de códigos utiliza StronglyTypedRuleObjectFactory, que se denomina así porque trata con clases Java generadas en lugar de instancias RuleObject dinámicas;
la carga del conjunto de reglas no es necesario (por lo tanto ningún método de programa de utilidad);
la referencia a la clase de regla HelloWorld es a través de una interfaz Java con un nombre idéntico; el compilador Java detectará cualquier error tipográfico en el nombre;
de forma similar, la referencia al atributo de regla greeting es a través de un método Java con un nombre idéntico en la interfaz;
no se necesita ninguna conversión del tipo de retorno, porque el método greeting generado devuelve el tipo correcto (String).

aviso: El código generado sólo está pensado para utilizarse en entornos de prueba donde es un asunto sencillo para volver a compilar los cambios en el código.

El código generado no es portable entre máquinas, porque contiene vías de acceso absolutas a los conjuntos de reglas en la máquina local.

En concreto, no debe utilizar el código generado en cualquier entorno de producción donde los conjuntos de reglas pueden cambiar dinámicamente.