#ifndef _TESTCASE__H
#define _TESTCASE__H

#include <vector>   //!< Container ür Funktionszeiger

#include "Test.h"

class TestCase;     //!< Vorwärtsdeklaration für typedef

typedef void (TestCase::*TESTFUNC)(); //!< Definition Testfunktion 

/**
 * TestCase.
 * Wird zum Gebrauch abgeleitet.
 *
 * Beispiel einer Testklasse.
 * Wird von TestCase abgeleitet
 * \code
 * class TestCase : public Test
 * {
 *    ...
 * \endcode
 * Weitere Schritte: Testfunktionen schreiben und
 * beispielsweise im Konstruktur hinzufügen.
 * @see Dokumentation TestCase::TestCase()
 * @author Prof. Ralf Mayer
 * @version 28.05.2005
 */
class TestCase : public Test
{
public:
  /** 
   * Konstruktor.
   * Anleitung zum Gebrauch: Klasse ableiten, dann Konstruktor
   * geeignet überschreiben:
   * \code
   * MyTestCase( char* name = 0 ) : TestCase( name )
   * {
   *   addTest( (TESTFUNC) &MyTestCase::test1 );
   *   addTest( (TESTFUNC) &MyTestCase::test2 );
   *   // alle weiteren Tests hinzufügen 
   *   // ...
   * } // Ende Konstruktor
   * \endcode
   * @param name [optional] char* Name der Testklasse
   */
  TestCase( char* name = 0);

  //! Destruktor
  virtual ~TestCase() {}

  /**
   * Ausführen aller Tests in der Testklasse.
   * Sobald ein Fehler auftritt, wird dieser ausgegeben und
   * der Einzeltest, also die einzelne Testfunktion beendet.
   */
  virtual void run();

  /**
   * Setup Methode.
   * Sollte immer von abgeleiter Testklasse überschreiben werden.
   * Wird zu Beginn jedes Tests aufgerufen, also zu Begin von run()
   */
  virtual void setUp() {}

  /**
   * Teardown Methode zum Aufräumen nach jedem Test.
   * Sollte immer von abgeleiter Testklasse überschreiben werden.
   * Wird am Ende jedes Tests aufgerufen, also zu Begin von run()
   */
  virtual void tearDown() {}

  /**
   * Hinzufügen von Testfunktionen in der Testklasse.
   * Bester Ort für diese Aufrufe ist der Konstruktor
   * der abgeleiteten Klasse, d.h. der Testklasse
   *
   * Bei Zeigern auf Elementfunktionen in C++ sind Besonderheiten
   * zu beachen. Rufen Sie diese Funktion stets in der folgenden
   * Form auf, wenn z.B. die Funktion test1 heisst,
   * und ihre Klasse MyTestCase:
   * \code
   * addTest( (TESTFUNC) &MyTestCase::test1 );
   * \endcode
   * Eine Testfunktion sollte immer wie folgt aufgebaut werden:
   * \code
   * void meinTest3()
   * {
   *   tN = "meinTest3";    // Hier Name der Testfunktion
   *   
   *   // Hier wird der Test vorbereitet, z.B
   *   float istWert = -2.5;    // z.B. Ergebnis einer Berechnung
   *   float erwartet = 2.5;    // Bekanntes, d.h. erwartetes Ergebnis
   *
   *   // Hier wird Ergebnis und Erwartungswert verglichen.
   *   //   Compiler schreibt in tL die aktuelle Zeilennummer (__LINE__)
   *   tL= __LINE__; assertEquals( istWert, erwartet );
   *      // sind beide Werte gleich, dann ist's o.k.
   *      //   wenn nicht wird Fehler mit Zeilennummer,
   *      //   Namen der Testklasse und dem Funktionsnamen
   *      //   angezeigt und dokumentiert.
   * }
   *
   * \endcode
   * Die Signatur einer Testfunktion darf nicht verändert werden
   * \code void meineTestfunktion() \endcode
   * @param f TESTFUNC
   * @todo Dokumentation hinzufügen
   */
  void addTest( TESTFUNC f );

  // all assertions
  /**
   * Vergleichsfunktion. Falls a != b wird Ausnahme 
   * geworfen und als Fehler dokumentiert.
   * @exception string. Enthält Fehler sowie Soll- und Ist-Wert
   * @param a int Soll(erwarteter) Wert
   * @param b int Ist, d.h Ergebniswert des Tests
   * @return void
   */
  void assertEquals( int a, int b);

  /**
   * Vergleichsfunktion. Falls a != b wird Ausnahme 
   * geworfen und als Fehler dokumentiert.
   * @exception string. Enthält Fehler sowie Soll- und Ist-Wert
   * @param a long Soll(erwarteter) Wert
   * @param b long Ist, d.h Ergebniswert des Tests
   * @return void
   */
  void assertEquals( long a, long b);

  /**
   * Vergleichsfunktion. Falls a != b wird Ausnahme 
   * geworfen und als Fehler dokumentiert.
   * @exception string. Enthält Fehler sowie Soll- und Ist-Wert
   * @param a float Soll(erwarteter) Wert
   * @param b float Ist, d.h Ergebniswert des Tests
   * @return void
   */
  void assertEquals( float a, float b );

  /**
   * Vergleichsfunktion. Falls a != b wird Ausnahme 
   * geworfen und als Fehler dokumentiert.
   * @exception string. Enthält Fehler sowie Soll- und Ist-Wert
   * @param a double Soll(erwarteter) Wert
   * @param b double Ist, d.h Ergebniswert des Tests
   * @return void
   */
  void assertEquals( double a, double b );

  /**
   * Vergleichsfunktion. Falls a und b nicht innerhalb der
   * vorgegebenen Genauigkeitsgrenze übereinstimmen, wird Ausnahme 
   * geworfen und als Fehler dokumentiert. 
   * Beachten sie auch mögliche Rundungsfehler bei der Berechnung.
   * @exception string. Enthält Fehler sowie Soll- und Ist-Wert und Grenze
   * @param a double Soll(erwarteter) Wert
   * @param b double Ist, d.h Ergebniswert des Tests
   * @param e double >= 0 vorgegebene Genauigkeitsgrenze 
   * @return void
   */
  void assertEquals( double a, double b, double e );

  /**
   * Vergleichsfunktion. Falls a != b wird Ausnahme 
   * geworfen und als Fehler dokumentiert.
   * @exception string. Enthält Fehler sowie Soll- und Ist-Wert
   * @param a bool Soll(erwarteter) Wert
   * @param b bool Ist, d.h Ergebniswert des Tests
   * @return void
   */
  void assertEquals( bool a, bool b);

  /**
   * Vergleichsfunktion für Zeiger!! Falls a != b wird Ausnahme 
   * geworfen und als Fehler dokumentiert.
   * @exception string. Enthält Fehler sowie Soll- und Ist-Wert
   * in hexadezimaler Darstellung
   * @param a void* Soll(erwarteter) Wert als Zeiger
   * @param b void* Istwert als Zeiger
   * @return void
   */
  void assertEquals( void* a, void* b );

  /**
   * Vergleichsfunktion nur für C-Strings! Falls a != b wird Ausnahme 
   * geworfen und als Fehler dokumentiert.
   * @exception string. Enthält Fehler sowie Soll- und Ist-Wert,
   * jeweils auf 48 Zeichen begrenzt.
   * @param a char* Soll(erwarteter) Wert
   * @param b char* Ist, d.h Ergebniswert des Tests
   * @return void
   */
  void assertEquals( char* a, char* b );

  /**
   * Vergleichsfunktion. Falls a != true (wahr) wird Ausnahme 
   * geworfen und als Fehler dokumentiert.
   * Hier kann z.B. eine logische Abfrage übergeben werden.
   * @exception string. Enthält Fehler sowie den übergebenen Wert
   * @param a bool Soll(erwarteter) Wert
   * @return void
   */
  void assertTrue( bool a );

  /**
   * Vergleichsfunktion. Falls a != false (falsch) wird Ausnahme 
   * geworfen und als Fehler dokumentiert.
   * Hier kann z.B. eine logische Abfrage übergeben werden.
   * @exception string. Enthält Fehler sowie den übergebenen Wert
   * @param a bool Soll(erwarteter) Wert
   * @return void
   */
  void assertFalse( bool a );

  /**
   * Wirft Meldung als Ausnahme. 
   * Kann besipielsweise benutzt werden um das Auslösen einer
   * Exception zu überprüfen.
   * @exception string. Enthält Meldung
   * @param msg char* Meldung
   * @return void
   */
  void assertMessage( char* msg );

protected:
  int testsRun;
  int testsFailed;
  int testsOK;
  int tL;           //!< Zeilen Nummer
  char* tN;         //!< Test Name
  char tcName[32];  //!< Name des Test Case

  //! Container für Funktionszeiger
  vector<TESTFUNC> vecFkt;
};

// No Code behind this line!
#endif