OOP Programmierung eines Prüfprogrammes

[DelphiManiac]

Hallo,

ich entwickle zurzeit ein Prüfprogramm für eine Hardware

- Relais testen
- LED's testen
- Kalibrieren von Ausgängen / Eingängen...

Ich wollte die nun, nach anfänglichen nicht OOP-konformen Implementierungen jetzt mal sauber konzipieren,
aber dafür brauche ich eure Hilfe.

So sieht es zurzeit aus:

Klasse:

Delphi-Quellcode:

 TPruefling

Implementiert alle Methoden um mit dem Prüfling zu kommunizieren.
Beispiel: Set_Relais_1(true); // Schalte Relais 1 vom Prüfling

Delphi-Quellcode:

  TTest = class(TObject)
  private
    FshouldStopp:Boolean;
  protected
    FPruefling:TPruefling;
    FPruefGeraet:TPruefGeraet;
    FUSB:TSchnittstelle;
    FProgressEvent:TProgressEvent;
    FPruefText:string;
    procedure SetProgressEvent( Event : TProgressEvent );
    procedure ShowProgressToGUI(PruefText:String;Fortschritt:Integer);    
  public
    constructor Create; virtual;
    destructor Destroy; override;
    function Execute:TTestResult; virtual;abstract;
    procedure StoppTest;
    property PruefText:String
      read FPruefText;
    property OnShowProgress:TProgressEvent
      read FProgressEvent write SetProgressEvent;
  end;

Oberklasse für einen Test

Delphi-Quellcode:

  TTestRelais = class(TTest)
  private
  public
    constructor Create; override;
    function Execute:TTestResult; override;
  end;

Spezielle Testklasse abgleitet von TTest

Delphi-Quellcode:

TControlTest = class(TObject)
private
  FTests:array of TTest;
  FactualTest: TTest;
  FTestObjList:TObjectList;
  FAnzahlTest:Integer;
  FStoppTesting:Boolean;
//  FKalibrierWerte:TKalibrierDaten;
  FOnShowTestName:TShowTestName;
  FOnProgressEvent:TProgressEvent;
    procedure setFonProgressEvent(const Value: TProgressEvent);
    procedure setOnShowTestName(const Value: TShowTestName);
  procedure ClearKalbrierwert;
    function getTests(TestNr:integer): TTest;
public
  PruefNummer:Word;
  constructor Create;
  destructor Destroy;override;
  procedure AddTest(const aTest:TTest);
  procedure ClearTest;
  function StarteTestAblauf:TTestResult;
  procedure StoppeTestAblauf;

  property OnShowTestName : TShowTestName
    read FOnShowTestName write setOnShowTestName;
  property OnShowFortschrittGesamt:TProgressEvent
    read FOnProgressEvent write setFonProgressEvent;
  property AnzahlTests : Integer
    read FAnzahlTest;
  property Tests[index:integer] : TTest
    read getTests;
end; // of TControlTest = class(TObject)

Also ich habe also im Prinzip eine GUI die die spezifischen Tests in die Controlklasse einfügt, diese Controlklasse übernimmt dann das Ausführen der Tests (arbeitet die Liste ab).

Jetzt ist das Problem, das ich immer habe, wenn ich solche losen Kopplungen mache, wie ich dann am Besten die Unteschiedlichkeit der Tests behandle.

Beispiel ich habe ein TestRelais Klasse, diese steuert nacheinander die Relais an und liest sich zurück ob das Relais geschaltet hat, nun will ich nach jedem Ansteueren das grafisch darstellen in meiner GUI....

Dann müsste ich wohl ein Callback realisieren, der in der Testklasse direkt aufgerufen wird, oder, da die TControlTestklasse ja da auch keinen Zugriff mehr hat (während der Ausführung eines einzelnen Tests), richtig, oder?


Vielen Dank schonmal für Anregungen...

Gruß
DM

[shmia]

Schau dir mal DUnit an.
Wenn deine Test vollständig automatisiert ablaufen sollen, dann kannst du im Prinzip DUnit komplett verwenden.
Ansonsten kannst du dir grössere Teile daraus kopieren oder vielleicht nur deinen eigenen TestRunner schreiben.

[DelphiManiac]

Ich habe DUnit schonmal grob überflogen,

aber du hast recht, ich kann mir da wahrscheinlich sehr viel abgucken. Deswegen werde ich jetzt erstmal die Sourcen durchstöbern und hoffen, das ich die Funktionsweise dahinter erkennen kann...

Vielen Dank

Gruß
DelphiManiac

[shmia]

Zitat:

Zitat von DelphiManiac

Deswegen werde ich jetzt erstmal die Sourcen durchstöbern und hoffen, das ich die Funktionsweise dahinter erkennen kann...

Die Sourcen sind OOP-technisch harter Stoff; wenn du alles verstehst, dann kannst du dich selbst schon als "OOP-Guru" bezeichnen. :cheers:

[DelphiManiac]

Ich will es ja nicht zu 100 % verstehen (das ist wohl auch nicht ohne Hilfe vom Entwicklerteam möglich)
:)

Aber das Grundgerüst will ich mir schonmal angucken um die Herangehensweise zu kapieren.

Ein UML Diagramm würde mir wahrscheinlich auf den ersten Blick mehr sagen, als 1000 Zeilen Quellcode, aber naja, da muss ich jetzt wohl durch :roll:

[DelphiManiac]

Aber hier gibts ja sogar UML und zwar in der Hilfe,... na dann geh ich erstmal daran...