Un cas de test pour le module consecutive.so

Cet exemple illustre le cas où un module requiert un peu plus de code Scheme pour le tester This is an example if a module that requires a bit more Scheme code to test (le module consecutive.so force Tablix à programmer certains évènement dans des créneaux consécutifs d'une même journée -voir le manuel de référence des modules pour plus de détails).

Ce qui suit est le contenu du fichier de test consecutive-1.xml (vous pouvez le trouver dans le sous-répertoire ttf/tests/ de la distribution).

<!--
BEGIN TTF BLOCK
(define (tuple-loop i j ok)
        (if (< i j)
                (tuple-loop (+ i 1) j 
                        (and 
                                ok 
                                (time i (+ (get-time (- i 1)) 1))
                                (= 
                                        (quotient (get-time i) 10) 
                                        (quotient (get-time (- i 1)) 10)
                                )
                        )
                )
                ok
        )
        
)
(test-ttf
        (tuple-loop 2 6 #t)
)
END TTF BLOCK
-->
<ttm version="0.2.0">
        <modules>
                <module name="sametime.so" weight="60" mandatory="yes"/> 
                <module name="timeplace.so" weight="60" mandatory="yes"/>
                <module name="consecutive.so" weight="60" mandatory="yes"/>
        </modules>

        <resources>
                <constant>
                        <resourcetype type="teacher">
                                <resource name="a"/>
                        </resourcetype>
                        <resourcetype type="class">
                                <linear name="#" from="1" to="3"/>
                        </resourcetype>
                </constant>
                <variable>
                        <resourcetype type="room">
                                <linear name="#" from="1" to="40"/>
                        </resourcetype>
                        <resourcetype type="time">
                                <matrix width="10" height="10"/>
                        </resourcetype>
                </variable>
        </resources>

        <events>
                <event name="test" repeats="1">
                        <resource type="teacher" name="a"/>
                        <resource type="class" name="1"/>
                </event>
                <event name="test" repeats="5">
                        <resource type="teacher" name="a"/>
                        <resource type="class" name="2"/>
                        <restriction type="consecutive"/>
                </event>
                <event name="test" repeats="1">
                        <resource type="teacher" name="a"/>
                        <resource type="class" name="3"/>
                </event>
        </events>
</ttm>

Le module consecutive.so utilise une extension d'emploi du temps dans sa fonction d'ajustage. De ce fait, nous devons utiliser les modules sametime.so et timeplace.so dans le test, sinon le module consecutive.so ne fonctionnera pas correctement.

En regardant le contenu de ce fichier XML, vous remarquerez que les 5 évènements du milieu doivent être programmés dans des créneaux successifs. Ces évènements portent les identifiants de tuple de 1 à 5.

Le code Scheme consiste en une fonction récursive tuple-loop. La variable i contient l'identifiant de tuple que nous sommes en train de vérifier, j contient le prochain identifiant de tuple à vérifier +1, et ok contient la valeur finale à retourner (#t so les tuples ont été consécutifs, ou #f dans le cas contraire).

Si nous regardons la fonction tuple-loop en détail, nous remarquons que nous nous vérifions d'abord si tous les identifiants de tuple ont été vérifiés. Si c'est le cas, nous retournons la valeur de ok. Sinon, nous vérifions le tuple courant i et appelons tuple-loop avec l'identifiant de tuple incrémenté i et une valeur de retour ok actualisée.

La nouvelle valeur de retour ok vaut #t si tous les tuples précédents étaient consécutifs (l'ancienne valeur ok est #t), si le tuple courant est programmé le créneau suivant celui du tuple précédent, et que le tuple courant et le précédent sont programmés le même jour (voir la section sur les matrices).