Buscando algo como JUnit @Before/@After en MUnit

Question

Estoy escribiendo una serie de casos de prueba en un solo archivo .mt que comparten procedimiento (s) de configuración común (y desmontaje). Esperaba ver algo como JUnit's @Before/@After, pero nada del paquete MUnit saltó a mí que eso lograría esto. Honestamente, la documentación del paquete MUnit es un poco mejor que la documentación de MUnit de Wolfram Workbench, pero tampoco está completa. Instructions on viewing the MUnit package.

Así que antes de reinventar la rueda, pensé que verificaría si me perdía algo en MUnit o si alguien tiene un patrón que funciona bien.

Así que basado en Leonid Shifrin inicial respuesta (que actualiza su respuesta mientras pongo esto juntos), esto es (era) donde estoy (era) en ...

TestPlus.mt

(* Mathematica Test File *) 

(* x is a global value *) 
x=0; 

SetUp[] := Module[{}, x=1;]; 
TearDown[] := Module[{}, x=0;]; 

(* test SetUp[] *) 
SetUp[];  
Test[x, 1, TestID->"SetUp-20120103-F2U9V6"] 

(* test TearDown[] *) 
TearDown[]; 
Test[x, 0, TestID->"TearDown-20120103-O4R6M7"] 

(* test plus --contrived tests-- *) 
SetUp[]; 
Test[x+0, 1, TestID->"Plus-20120103-S5D9X6"] 
TearDown[]; 

SetUp[]; 
Test[x+1, 2, TestID->"Plus-20120103-D7Q3E0"] 
TearDown[]; 

SetUp[]; 
Test[x+2, 3, TestID->"Plus-20120103-F0S4P9"] 
TearDown[]; 

Answer 1

MUnit archivos son archivos normales del paquete, y que son leídos y ejecutados secuencialmente - o al menos esto ha sido mi experiencia con ellos. Simplemente puede agregar líneas con su código común antes y después de sus pruebas, y se ejecutarán antes y después de todas las pruebas, respectivamente.

Si desea invocar sus procedimientos de instalación y desmontaje individualmente para cada prueba, puede agregar las líneas (llamadas) correspondientes justo antes y justo después de cada prueba. Puede que le resulte conveniente escribir un preprocesador, que cargaría sus pruebas como un paquete (por ejemplo, usando Import["Tests.tm","HeldExpressions"] - donde sus pruebas están en Tests.tm en este ejemplo), e insertando las líneas correspondientes y luego guardando un archivo nuevamente. Esto requerirá un poco de fluidez con las manipulaciones con código retenido, pero se puede recoger razonablemente rápidamente, y es muy conveniente si tiene muchas pruebas.

EDITAR

Como una alternativa más ligera, se puede definir atajos macro-similares. He aquí un ejemplo: el contenido del archivo de prueba

(* Mathematica Test File *) 

before[]:= (Print["Before Test: ",f[2]];f[x_]:=x^3); 
after[] := (ClearAll[f];Print["After Test: ",f[2]]); 

SetAttributes[withCodeAfter,HoldRest]; 
withCodeAfter[before_,after_]:=(after;before) 

SetAttributes[{wrapTest,wrapTest1},HoldAll] 
wrapTest[code_]:= withCodeAfter[before[];code,after[]] 
wrapTest1[code_]:=Block[{f},f[x_]:=x^3;code]; 

wrapTest@ 
Test[f[2], 
    8, 
    TestID -> "MyTest1" 
] 

wrapTest1@ 
Test[f[2], 
    8, 
    TestID -> "MyTest2" 
] 

Las funciones before y after imitan las funciones de su instalación/desmontaje. La función withCodeAfter es una macro auxiliar que ejecuta primero el código before y luego ejecuta el código after, pero como resultado devuelve el resultado de before. Las funciones wrapTest y wrapTest1 ilustran dos posibilidades: puede definir funciones separadas "antes" y "después" y emparejar su código con ellas, o puede usar Block y definir el macro "alrededor", que a veces puede ser más conveniente. Las pruebas funcionarán de cualquier manera. También puedes mezclar estos enfoques. En ambos casos, la cantidad de código repetitivo es mínima: solo agregue la línea wrapTest@ antes de cada prueba.

Answer 2

no puedo obtener el formato correcto en el comentario por lo que estoy haciendo esto como una respuesta ...

Bueno yo creo que tengo la diseccionado el código en su respuesta, que me haga saber si estoy correcto.

---

Define qué se evalúa antes y después de evaluar el "caso de prueba".Una nota al margen, está definiendo f en before, sin definir f en after.

(* Mathematica Test File *) 

before[]:= (Print["Before Test: ",f[2]];f[x_]:=x^3); 
after[] := (ClearAll[f];Print["After Test: ",f[2]]); 

---

Define la función withCodeAfter. Toma dos expresiones, la primera expresión, before, se evalúa cuando se pasa. La segunda expresión, after, se pasa sin evaluar y es la primera expresión que se evaluará dentro de withCodeAfter. La primera expresión evaluada, before, es devuelta por withCodeAfter.

SetAttributes[withCodeAfter,HoldRest]; 
withCodeAfter[before_,after_]:=(after;before) 

---

Define la función wrapTest. Se necesita una expresión, code, que se pasa sin evaluar. Esa expresión, code, es la segunda expresión de una expresión compuesta, before[];code, que se pasa como la primera expresión, before, a withCodeAfter. La expresión compuesta, before[];code, se evalúa cuando se pasa al withCodeAfter. El valor de la expresión evaluada, code, es devuelto por withCodeAfter después de la evaluación de after. El valor devuelto por withCodeAfter es devuelto por wrapTest.

SetAttributes[{wrapTest},HoldAll] 
wrapTest[code_]:= withCodeAfter[before[];code,after[]] 

---

¿Es el mismo que llamar wrapTest[Test[f[2], 8, TestID -> "MyTest1"]]

wrapTest@ 
Test[f[2], 8, TestID -> "MyTest1"]