Pascal Interpreter - wie automatisiert testen?

[arc]

Ich bin einem Compilerbau Tutorial gefolgt und habe es etwas erweitert, um mir einen kleinen Pascal Interpreter mit Lexer, Parser und Interpreter von Grund auf zu bauen. Der auszuführende Code liegt am Ende als abstrakter Syntaxbaum vor und wird rekursiv abgearbeitet.

Nun stehe ich vor der Problematik, wie ich meine kleine Sprache und ihren Interpreter sinnvoll und effizient auf Fehler prüfen kann. Ich habe bereits zu Unit Tests recherchiert und unter anderem diesen Beitrag entdeckt: http://www.uweraabe.de/Blog/2012/03/...tor-extension/

Aber so richtig scheint es nicht das zu sein, was mir an der Stelle weiterhilft. Ich habe mich etwas in anderen Projekten umgeschaut und habe z.B. in DWScript einen Test Ordner gefunden, der einfach die Ausgaben eines Skripts mit dem Erwartungsbild aus einer Textdatei vergleicht.

100_doors.pas

Delphi-Quellcode:

var doors : array [1..100] of Boolean;
var i, j : Integer;

for i:=1 to 100 do
   for j:=i to 100 do
      if (j mod i)=0 then
         doors[j] := not doors[j];

for i:=1 to 100 do
   if doors[i] then
      PrintLn('Door '+IntToStr(i)+' is open');

sollte folgendes ausgeben

100_doors.txt

Code:

Door 1 is open
Door 4 is open
Door 9 is open
Door 16 is open
Door 25 is open
Door 36 is open
Door 49 is open
Door 64 is open
Door 81 is open
Door 100 is open

Dann habe ich mal in http://dlang.org/spec/unittest.html gestöbert und die Variante gefunden, daß eine Test Unit direkt Code interpretieren läßt und mit einem Ergebis vergleicht ala:

Code:

assert(add(1, 1) == 2);

Damit könnte ich prüfen, ob mein Interpreter prinzipiell korrekt arbeitet. Wie prüfe ich aber bewußt auf Fehler? Wenn z.B. eine Zeichenkette nicht geschlossen wurde ala

Code:

WriteLn('Hallo Welt!);

In diesem Fall sollte der Interpreter (bzw. der Lexer) eine Meldung ausgeben, die ich in meinem Test entsprechend erwarten müßte. Wie setzt man soetwas sinnvoll um? Wie testet man eine eigene kleine Sprache? Bisher habe ich eine Testunit geschrieben, die möglichst viele Befehle in verschiedenen Kombinationen ausführt, aber das erscheint mir nicht optimal. Die Datei findet ihr im Anhang, ist allerdings nur in Teilen Delphi / FPC kompatibel.

Herzlichen Dank schonmal für alle Anregungen!

[Dejan Vu]

Dein Programm besteht aus Klassen.
Jede Klasse besteht aus Methoden.
Jede Methode soll etwas machen.

Schreibe Testcode, die die Methode mit bestimmten Parametern aufrufen und dann das Ergebnis mit dem zu erwartenden Ergebnis vergleichen. Beispiel:

Delphi-Quellcode:

Type
  TMyClass = Class
  public 
     function Add (a,b : Integer) : Integer;
  end;

Function TMyClass.Add(a,b : Integer) : Integer;
begin
  result := a+b;
end;
....

Type
  TMyClassFixture = class
  public
     Procedure AddTest;
  End;

Procedure TMyClassFixture.AddTest;
var 
  unitUnderTest : TMyClass;
  actual : Integer;

Begin
  unitUnderTest := TMyClass.Create;
  actual := unitUnderTest.Add(1,2);
  Assert.AreEqual (3,actual); // Weiß nicht, ob es AreEqual hier gibt
End;

Je kleiner und einfacher deine Klassen, desto einfacher die Unittests. Ein Unittest testet also genau eine Klasse, ohne Abhängigkeiten.

Nach den Unittests kommen die Integrations- oder Komponententests, d.h. Du testest das Zusammenspiel der Klassen.

Du kannst z.B. deinen Parser testen, indem Du für jedes syntaktische Element den erwarteten Syntaxbaum verifizierst. Der Lexer/Tokenizer wird ähnlich getestet, d.h. InputString und Erwartete Tokensequenz vergleichen mit der aktuellen Sequenz, d.h. der Ausgabe des Tokenizers usw.