http://de.accunit.access-codelib.net/index.php?title=Spezial:Beitr%C3%A4ge&feed=atom&target=KGunderAccUnit - Benutzerbeiträge [de]2024-03-28T10:09:14ZAus AccUnitMediaWiki 1.15.1http://de.accunit.access-codelib.net/GrundlagenGrundlagen2011-03-26T13:05:15Z<p>KGunder: </p>
<hr />
<div>[[en:Basics]]<br />
Eine Software zu testen bedeutet, festzustellen, ob die Software an sie gestellte Anforderungen auch erfüllt.<br />
<br />
Anforderungen in Umgangssprache sind jedoch nicht geeignet als Grundlage eines Tests. <br />
( "Naja, das Ding soll halt nicht abstürzen" oder "Wenn ich da vorne 100 eingebe, dann soll da hinten irgendwas rauskommen.. " )<br />
<br />
Zudem ist es nicht möglich komplexe Applikationen präzise zu beschreiben.<br />
<br />
Zum Testen von Software ist es also wichtig, die große Komplexität einer Applikation in kleine testbare Programmfragmente ( = Funktionen / Prozeduren) aufzuteilen.<br />
Diese Programmfragmente sollten dann EINE Aufgabe erledigen, so daß man dieses Programmfragment testet in dem man beschreibt:<br />
<br />
- welches Programmfragment ( Modul, Klasse, Funktion, Sub ) teste ich<br />
- welche Eingabewerte ( Vorbedingungen ) definiere ich<br />
- welche Ausgabewerte ( Nachbedingungen ) erwarte ich<br />
<br />
Unter Umständen wird es also nötig sein den bestehenden Programmcode zu überarbeiten und in kleine testbare Einheiten zu zerlegen.<br />
<br />
[[Der erste Test]]<br />
<br />
[[Der zweite und der dritte Test]]<br />
<br />
[[AccUnit-Attribute]]</div>KGunderhttp://de.accunit.access-codelib.net/Der_erste_TestDer erste Test2011-03-24T09:53:05Z<p>KGunder: </p>
<hr />
<div>[[en: The first Test]]<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
<source>Public Function Dez2Bin(ByVal TheValue As Long) As String</source><br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen", es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
<br />
[[Bild: AccUnit-Test1.jpg]]<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.<br />
<br />
AccUnit erzeugt die die Testklasse:<br />
<source><br />
Option Compare Text<br />
Option Explicit<br />
'AccUnit:TestClass<br />
'--------------------------------------------------------------------<br />
' AccUnit Infrastructure<br />
'--------------------------------------------------------------------<br />
Implements SimplyVBUnit.ITestFixture<br />
Implements AccUnit_Integration.ITestManagerBridge<br />
Private TestManager As AccUnit_Integration.TestManager<br />
Private Sub ITestManagerBridge_InitTestManager(ByVal NewTestManager As AccUnit_Integration.ITestManagerComInterface): Set TestManager = NewTestManager: End Sub<br />
Private Function ITestManagerBridge_GetTestManager() As AccUnit_Integration.ITestManagerComInterface: Set ITestManagerBridge_GetTestManager = TestManager: End Function<br />
Private Sub ITestFixture_AddTestCases(ByVal Tests As SimplyVBUnit.TestCaseCollector): TestManager.AddTestCases Tests: End Sub<br />
'--------------------------------------------------------------------<br />
' Tests<br />
'--------------------------------------------------------------------<br />
'<br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Err.Raise vbObjectError, "Dez2Bin_mitEingabe0_liefertdenString0", "Not implemented"<br />
' Act<br />
' Assert<br />
Assert.That 1, Iz.EqualTo(1)<br />
End Sub<br />
</source><br />
<br />
In dem Bereich 'AccUnit Infrastructure' werden ein paar Funktionen definiert die von der Testumgebung benötigt werden.<br />
Bitte nehmen Sie in diesem Bereich KEINE Änderungen vor.<br />
<br />
In unserer Testprozedur Dez2Bin_mitEingabe0_liefertdenString0 sehen Sie schon durch die Kommentare angedeutet, aus welchen Schritten ein Test bestehen sollte:<br />
<br />
- Arrange : Vorbereitungen zum Test - Variablen definieren - Vorgabewerte festlegen<br />
- Act: Die zu testende Funktion mit den Vorgabewerten aufrufen und das Ergebniss erhalten<br />
- Assert: Das erhaltene Ergebniss mit dem erwarteten Ergebniss vergleichen<br />
<br />
Ändern Sie also die Testprozedur ab:<br />
<source><br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Dim Eingabe As Long<br />
Dim Ergebniss As String<br />
Dim Erwartet As String<br />
<br />
Eingabe = 0<br />
Erwartet = "0"<br />
<br />
' Act<br />
Ergebniss = Dez2Bin(Eingabe)<br />
<br />
' Assert<br />
Assert.That Ergebniss, Iz.EqualTo(Erwartet)<br />
End Sub<br />
</source><br />
<br />
Den Test können Sie jetzt mit dem Kontextmenü der rechten Maustaste starten: "Aktiven Test ausführen".<br />
Es öffnet sich ein zusätzliches Fenster in denen Ihnen TestUnit das Ergebnis des Tests anzeigt:<br />
<br />
[[Bild: AccUnit-TestErgebnis1.jpg]]<br />
<br />
Mit einem Rechtsklick auf die Testbeschreibung können Sie das Detailfenster mit der ausführlichen Fehlerbeschreibung aufrufen. Der erste Fehler ist recht schnell zu erkennen: Wir liefern noch überhaupt kein Ergebnis zurück! Ändern wir als unsere Dez2Bin Funktion ab, damit ein korrektes Ergebnis geliefert wird:<br />
<br />
<source><br />
<br />
Public Function Dez2Bin(ByVal TheValue As Long) As String<br />
Dez2Bin = "0"<br />
End Function<br />
<br />
</source><br />
<br />
Einmal den Test wieder starten ( Entweder über das Kontextmenü oder über die Symbolleiste ) und voilá : alle Tests wurden erfolgreich durchgeführt, wir sind im Status "GRÜN"<br />
<br />
[[Bild: AccUnit-TestErgebnis2.jpg]]</div>KGunderhttp://de.accunit.access-codelib.net/Der_erste_TestDer erste Test2011-03-24T09:52:02Z<p>KGunder: </p>
<hr />
<div>[[en: The first Test]]<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
<source>Public Function Dez2Bin(ByVal TheValue As Long) As String</source><br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen". <br />
[[Bild: AccUnit-Test1.jpg]]<br />
<br />
es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.<br />
<br />
AccUnit erzeugt die die Testklasse:<br />
<source><br />
Option Compare Text<br />
Option Explicit<br />
'AccUnit:TestClass<br />
'--------------------------------------------------------------------<br />
' AccUnit Infrastructure<br />
'--------------------------------------------------------------------<br />
Implements SimplyVBUnit.ITestFixture<br />
Implements AccUnit_Integration.ITestManagerBridge<br />
Private TestManager As AccUnit_Integration.TestManager<br />
Private Sub ITestManagerBridge_InitTestManager(ByVal NewTestManager As AccUnit_Integration.ITestManagerComInterface): Set TestManager = NewTestManager: End Sub<br />
Private Function ITestManagerBridge_GetTestManager() As AccUnit_Integration.ITestManagerComInterface: Set ITestManagerBridge_GetTestManager = TestManager: End Function<br />
Private Sub ITestFixture_AddTestCases(ByVal Tests As SimplyVBUnit.TestCaseCollector): TestManager.AddTestCases Tests: End Sub<br />
'--------------------------------------------------------------------<br />
' Tests<br />
'--------------------------------------------------------------------<br />
'<br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Err.Raise vbObjectError, "Dez2Bin_mitEingabe0_liefertdenString0", "Not implemented"<br />
' Act<br />
' Assert<br />
Assert.That 1, Iz.EqualTo(1)<br />
End Sub<br />
</source><br />
<br />
In dem Bereich 'AccUnit Infrastructure' werden ein paar Funktionen definiert die von der Testumgebung benötigt werden.<br />
Bitte nehmen Sie in diesem Bereich KEINE Änderungen vor.<br />
<br />
In unserer Testprozedur Dez2Bin_mitEingabe0_liefertdenString0 sehen Sie schon durch die Kommentare angedeutet, aus welchen Schritten ein Test bestehen sollte:<br />
<br />
- Arrange : Vorbereitungen zum Test - Variablen definieren - Vorgabewerte festlegen<br />
- Act: Die zu testende Funktion mit den Vorgabewerten aufrufen und das Ergebniss erhalten<br />
- Assert: Das erhaltene Ergebniss mit dem erwarteten Ergebniss vergleichen<br />
<br />
Ändern Sie also die Testprozedur ab:<br />
<source><br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Dim Eingabe As Long<br />
Dim Ergebniss As String<br />
Dim Erwartet As String<br />
<br />
Eingabe = 0<br />
Erwartet = "0"<br />
<br />
' Act<br />
Ergebniss = Dez2Bin(Eingabe)<br />
<br />
' Assert<br />
Assert.That Ergebniss, Iz.EqualTo(Erwartet)<br />
End Sub<br />
</source><br />
<br />
Den Test können Sie jetzt mit dem Kontextmenü der rechten Maustaste starten: "Aktiven Test ausführen".<br />
Es öffnet sich ein zusätzliches Fenster in denen Ihnen TestUnit das Ergebnis des Tests anzeigt:<br />
<br />
[[Bild: AccUnit-TestErgebnis1.jpg]]<br />
<br />
Mit einem Rechtsklick auf die Testbeschreibung können Sie das Detailfenster mit der ausführlichen Fehlerbeschreibung aufrufen. Der erste Fehler ist recht schnell zu erkennen: Wir liefern noch überhaupt kein Ergebnis zurück! Ändern wir als unsere Dez2Bin Funktion ab, damit ein korrektes Ergebnis geliefert wird:<br />
<br />
<source><br />
<br />
Public Function Dez2Bin(ByVal TheValue As Long) As String<br />
Dez2Bin = "0"<br />
End Function<br />
<br />
</source><br />
<br />
Einmal den Test wieder starten ( Entweder über das Kontextmenü oder über die Symbolleiste ) und voilá : alle Tests wurden erfolgreich durchgeführt, wir sind im Status "GRÜN"<br />
<br />
[[Bild: AccUnit-TestErgebnis2.jpg]]</div>KGunderhttp://de.accunit.access-codelib.net/Der_erste_TestDer erste Test2011-03-24T09:51:25Z<p>KGunder: </p>
<hr />
<div>[[en: The first Test]]<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
<source>Public Function Dez2Bin(ByVal TheValue As Long) As String</source><br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen". <br />
[[Bild: AccUnit_Test1.jpg]]<br />
<br />
es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.<br />
<br />
AccUnit erzeugt die die Testklasse:<br />
<source><br />
Option Compare Text<br />
Option Explicit<br />
'AccUnit:TestClass<br />
'--------------------------------------------------------------------<br />
' AccUnit Infrastructure<br />
'--------------------------------------------------------------------<br />
Implements SimplyVBUnit.ITestFixture<br />
Implements AccUnit_Integration.ITestManagerBridge<br />
Private TestManager As AccUnit_Integration.TestManager<br />
Private Sub ITestManagerBridge_InitTestManager(ByVal NewTestManager As AccUnit_Integration.ITestManagerComInterface): Set TestManager = NewTestManager: End Sub<br />
Private Function ITestManagerBridge_GetTestManager() As AccUnit_Integration.ITestManagerComInterface: Set ITestManagerBridge_GetTestManager = TestManager: End Function<br />
Private Sub ITestFixture_AddTestCases(ByVal Tests As SimplyVBUnit.TestCaseCollector): TestManager.AddTestCases Tests: End Sub<br />
'--------------------------------------------------------------------<br />
' Tests<br />
'--------------------------------------------------------------------<br />
'<br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Err.Raise vbObjectError, "Dez2Bin_mitEingabe0_liefertdenString0", "Not implemented"<br />
' Act<br />
' Assert<br />
Assert.That 1, Iz.EqualTo(1)<br />
End Sub<br />
</source><br />
<br />
In dem Bereich 'AccUnit Infrastructure' werden ein paar Funktionen definiert die von der Testumgebung benötigt werden.<br />
Bitte nehmen Sie in diesem Bereich KEINE Änderungen vor.<br />
<br />
In unserer Testprozedur Dez2Bin_mitEingabe0_liefertdenString0 sehen Sie schon durch die Kommentare angedeutet, aus welchen Schritten ein Test bestehen sollte:<br />
<br />
- Arrange : Vorbereitungen zum Test - Variablen definieren - Vorgabewerte festlegen<br />
- Act: Die zu testende Funktion mit den Vorgabewerten aufrufen und das Ergebniss erhalten<br />
- Assert: Das erhaltene Ergebniss mit dem erwarteten Ergebniss vergleichen<br />
<br />
Ändern Sie also die Testprozedur ab:<br />
<source><br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Dim Eingabe As Long<br />
Dim Ergebniss As String<br />
Dim Erwartet As String<br />
<br />
Eingabe = 0<br />
Erwartet = "0"<br />
<br />
' Act<br />
Ergebniss = Dez2Bin(Eingabe)<br />
<br />
' Assert<br />
Assert.That Ergebniss, Iz.EqualTo(Erwartet)<br />
End Sub<br />
</source><br />
<br />
Den Test können Sie jetzt mit dem Kontextmenü der rechten Maustaste starten: "Aktiven Test ausführen".<br />
Es öffnet sich ein zusätzliches Fenster in denen Ihnen TestUnit das Ergebnis des Tests anzeigt:<br />
<br />
[[Bild: AccUnit-TestErgebnis1.jpg]]<br />
<br />
Mit einem Rechtsklick auf die Testbeschreibung können Sie das Detailfenster mit der ausführlichen Fehlerbeschreibung aufrufen. Der erste Fehler ist recht schnell zu erkennen: Wir liefern noch überhaupt kein Ergebnis zurück! Ändern wir als unsere Dez2Bin Funktion ab, damit ein korrektes Ergebnis geliefert wird:<br />
<br />
<source><br />
<br />
Public Function Dez2Bin(ByVal TheValue As Long) As String<br />
Dez2Bin = "0"<br />
End Function<br />
<br />
</source><br />
<br />
Einmal den Test wieder starten ( Entweder über das Kontextmenü oder über die Symbolleiste ) und voilá : alle Tests wurden erfolgreich durchgeführt, wir sind im Status "GRÜN"<br />
<br />
[[Bild: AccUnit-TestErgebnis2.jpg]]</div>KGunderhttp://de.accunit.access-codelib.net/InstallationInstallation2011-03-24T09:46:29Z<p>KGunder: </p>
<hr />
<div>__NOTOC__ [[en:Installation]]<br />
<br />
Für die Verwendung von AccUnit muss [[SimplyVBUnit|SimplyVBUnit 3.0]] installiert sein.<br />
SimplyVBUnit ist ein in Visual Basic 6 geschriebenes Testframework. <br />
Weitere Informationen zu VBUnit finden Sie auf <br />
der [http://sourceforge.net/projects/simplyvbunit/ Projektseite von SimplyVBUnit auf sourceforge].<br />
<br />
Laden Sie die Setup-Datei, die Sie ist unter ''[http://sourceforge.net/projects/simplyvbunit/files/ View all files]'' finden.<br />
<br />
AccUnit verursacht (derzeit noch) Probleme bei der Verwendung unter Access 2000.<br />
<br />
Danach können Sie von dieser Webseite das AccUnit Programm [http://accunit.access-codelib.net/download/AccUnitSetup.zip AccUnitSetup.zip] <br />
laden und die Installation mit ''Setup.exe'' starten.<br />
<br />
<br />
=== AccUnit als VBE-Add-In verwenden ===<br />
AccUnit installiert sich als VBE AddIn im Visual Basic Editor. <br />
Sie finden AccUnit einmal als Menüpunkt unter Extras->AccUnit <br />
und zweitens als zusätzlich Symbolleiste mit drei Symbolen.<br />
<br />
[[Bild:AccUnit-Menue.jpg]] <br />
<br />
<br />
[[Datei:AccUnit_AddIn_Commandbar_Beschreibung.png]]</div>KGunderhttp://de.accunit.access-codelib.net/InstallationInstallation2011-03-23T23:24:15Z<p>KGunder: /* AccUnit als VBE-Add-In verwenden */</p>
<hr />
<div>__NOTOC__ [[en:Installation]]<br />
<br />
Für die Verwendung von AccUnit muss [[SimplyVBUnit|SimplyVBUnit 3.0]] installiert sein.<br />
SimplyVBUnit ist ein in Visual Basic 6 geschriebenes Testframework. <br />
Weitere Informationen zu VBUnit finden Sie auf <br />
der [http://sourceforge.net/projects/simplyvbunit/ Projektseite von SimplyVBUnit auf sourceforge].<br />
<br />
Laden Sie die Setup-Datei, die Sie ist unter ''[http://sourceforge.net/projects/simplyvbunit/files/ View all files]'' finden.<br />
<br />
AccUnit verursacht (derzeit noch) Probleme bei der Verwendung unter Access 2000.<br />
<br />
Danach können Sie von dieser Webseite das AccUnit Programm [http://accunit.access-codelib.net/download/AccUnitSetup.zip AccUnitSetup.zip] <br />
laden und die Installation mit ''Setup.exe'' starten.<br />
<br />
<br />
=== AccUnit als VBE-Add-In verwenden ===<br />
AccUnit installiert sich als VBE AddIn im Visual Basic Editor. <br />
Sie finden AccUnit einmal als Menüpunkt unter Extras->AccUnit <br />
und zweitens als zusätzlich Symbolleiste mit vier Symbolen.<br />
<br />
[[Bild:AccUnit-Menue.jpg]] <br />
[[Datei:AccUnit_AddIn_Menu_Tools.png]]<br />
<br />
[[Bild:AccUnit-Symbole.jpg]]<br />
[[Datei:AccUnit_AddIn_Commandbar_Beschreibung.png]]</div>KGunderhttp://de.accunit.access-codelib.net/GrundlagenGrundlagen2011-02-28T16:21:42Z<p>KGunder: </p>
<hr />
<div>[[en:Basics]]<br />
Eine Software zu testen bedeutet, festzustellen, ob die Software an sie gestellte Anforderungen auch erfüllt.<br />
<br />
Anforderungen in Umgangssprache sind jedoch nicht geeignet als Grundlage eines Tests. <br />
( "Naja, das Ding soll halt nicht abstürzen" oder "Wenn ich da vorne 100 eingeben, dann soll da hinten irgendwas rauskommen.. " )<br />
<br />
Zudem ist es nicht möglich komplexe Applikationen präzise zu beschreiben.<br />
<br />
Zum Testen von Software ist es also wichtig, die große Komplexität einer Applikation in kleine testbare Programmstückchen aufzuteilen.<br />
Diese Programmstückchen sollten dann EINE Aufgabe erledigen, so daß man diese Programmstückchen testet in dem man beschreibt:<br />
<br />
- welches Programmstück ( Modul, Klasse, Funktion, Sub ) teste ich<br />
- welche Eingabewerte ( Vorbedingungen ) erhält das Programmstück<br />
- welche Ausgabewerte ( Nachbedingungen ) erwarte ich<br />
<br />
Unter Umständen wird es also nötig sein den bestehenden Programmcode zu überarbeiten und in kleine testbare Einheiten zu zerlegen.<br />
<br />
[[Der erste Test]]<br />
<br />
[[Der zweite und der dritte Test]]</div>KGunderhttp://de.accunit.access-codelib.net/Der_erste_TestDer erste Test2011-02-28T16:19:59Z<p>KGunder: </p>
<hr />
<div>[[en: The first Test]]<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
<source>Public Function Dez2Bin(ByVal TheValue As Long) As String</source><br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen". [[Bild: AccUnit_Test1.jpg]]<br />
<br />
es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.<br />
<br />
AccUnit erzeugt die die Testklasse:<br />
<source><br />
Option Compare Text<br />
Option Explicit<br />
'AccUnit:TestClass<br />
'--------------------------------------------------------------------<br />
' AccUnit Infrastructure<br />
'--------------------------------------------------------------------<br />
Implements SimplyVBUnit.ITestFixture<br />
Implements AccUnit_Integration.ITestManagerBridge<br />
Private TestManager As AccUnit_Integration.TestManager<br />
Private Sub ITestManagerBridge_InitTestManager(ByVal NewTestManager As AccUnit_Integration.ITestManagerComInterface): Set TestManager = NewTestManager: End Sub<br />
Private Function ITestManagerBridge_GetTestManager() As AccUnit_Integration.ITestManagerComInterface: Set ITestManagerBridge_GetTestManager = TestManager: End Function<br />
Private Sub ITestFixture_AddTestCases(ByVal Tests As SimplyVBUnit.TestCaseCollector): TestManager.AddTestCases Tests: End Sub<br />
'--------------------------------------------------------------------<br />
' Tests<br />
'--------------------------------------------------------------------<br />
'<br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Err.Raise vbObjectError, "Dez2Bin_mitEingabe0_liefertdenString0", "Not implemented"<br />
' Act<br />
' Assert<br />
Assert.That 1, Iz.EqualTo(1)<br />
End Sub<br />
</source><br />
<br />
In dem Bereich 'AccUnit Infrastructure' werden ein paar Funktionen definiert die von der Testumgebung benötigt werden.<br />
Bitte nehmen Sie in diesem Bereich KEINE Änderungen vor.<br />
<br />
In unserer Testprozedur Dez2Bin_mitEingabe0_liefertdenString0 sehen Sie schon durch die Kommentare angedeutet, aus welchen Schritten ein Test bestehen sollte:<br />
<br />
- Arrange : Vorbereitungen zum Test - Variablen definieren - Vorgabewerte festlegen<br />
- Act: Die zu testende Funktion mit den Vorgabewerten aufrufen und das Ergebniss erhalten<br />
- Assert: Das erhaltene Ergebniss mit dem erwarteten Ergebniss vergleichen<br />
<br />
Ändern Sie also die Testprozedur ab:<br />
<source><br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Dim Eingabe As Long<br />
Dim Ergebniss As String<br />
Dim Erwartet As String<br />
<br />
Eingabe = 0<br />
Erwartet = "0"<br />
<br />
' Act<br />
Ergebniss = Dez2Bin(Eingabe)<br />
<br />
' Assert<br />
Assert.That Ergebniss, Iz.EqualTo(Erwartet)<br />
End Sub<br />
</source><br />
<br />
Den Test können Sie jetzt mit dem Kontextmenü der rechten Maustaste starten: "Aktiven Test ausführen".<br />
Es öffnet sich ein zusätzliches Fenster in denen Ihnen TestUnit das Ergebnis des Tests anzeigt:<br />
<br />
[[Bild: AccUnit-TestErgebnis1.jpg]]<br />
<br />
Mit einem Rechtsklick auf die Testbeschreibung können Sie das Detailfenster mit der ausführlichen Fehlerbeschreibung aufrufen. Der erste Fehler ist recht schnell zu erkennen: Wir liefern noch überhaupt kein Ergebnis zurück! Ändern wir als unsere Dez2Bin Funktion ab, damit ein korrektes Ergebnis geliefert wird:<br />
<br />
<source><br />
<br />
Public Function Dez2Bin(ByVal TheValue As Long) As String<br />
Dez2Bin = "0"<br />
End Function<br />
<br />
</source><br />
<br />
Einmal den Test wieder starten ( Entweder über das Kontextmenü oder über die Symbolleiste ) und voilá : alle Tests wurden erfolgreich durchgeführt, wir sind im Status "GRÜN"<br />
<br />
[[Bild: AccUnit-TestErgebnis2.jpg]]</div>KGunderhttp://de.accunit.access-codelib.net/Der_erste_TestDer erste Test2011-02-28T16:17:35Z<p>KGunder: </p>
<hr />
<div>[[en: The first Test]]<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
<source>Public Function Dez2Bin(ByVal TheValue As Long) As String</source><br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen". [[Bild: AccUnit_Test1.jpg]]<br />
<br />
es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.<br />
<br />
AccUnit erzeugt die die Testklasse:<br />
<source><br />
Option Compare Text<br />
Option Explicit<br />
'AccUnit:TestClass<br />
'--------------------------------------------------------------------<br />
' AccUnit Infrastructure<br />
'--------------------------------------------------------------------<br />
Implements SimplyVBUnit.ITestFixture<br />
Implements AccUnit_Integration.ITestManagerBridge<br />
Private TestManager As AccUnit_Integration.TestManager<br />
Private Sub ITestManagerBridge_InitTestManager(ByVal NewTestManager As AccUnit_Integration.ITestManagerComInterface): Set TestManager = NewTestManager: End Sub<br />
Private Function ITestManagerBridge_GetTestManager() As AccUnit_Integration.ITestManagerComInterface: Set ITestManagerBridge_GetTestManager = TestManager: End Function<br />
Private Sub ITestFixture_AddTestCases(ByVal Tests As SimplyVBUnit.TestCaseCollector): TestManager.AddTestCases Tests: End Sub<br />
'--------------------------------------------------------------------<br />
' Tests<br />
'--------------------------------------------------------------------<br />
'<br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Err.Raise vbObjectError, "Dez2Bin_mitEingabe0_liefertdenString0", "Not implemented"<br />
' Act<br />
' Assert<br />
Assert.That 1, Iz.EqualTo(1)<br />
End Sub<br />
</source><br />
<br />
In dem Bereich 'AccUnit Infrastructure' werden ein paar Funktionen definiert die von der Testumgebung benötigt werden.<br />
Bitte nehmen Sie in diesem Bereich KEINE Änderungen vor.<br />
<br />
In unserer Testprozedur Dez2Bin_mitEingabe0_liefertdenString0 sehen Sie schon durch die Kommentare angedeutet, aus welchen Schritten ein Test bestehen sollte:<br />
<br />
- Arrange : Vorbereitungen zum Test - Variablen definieren - Vorgabewerte festlegen<br />
- Act: Die zu testende Funktion mit den Vorgabewerten aufrufen und das Ergebniss erhalten<br />
- Assert: Das erhaltene Ergebniss mit dem erwarteten Ergebniss vergleichen<br />
<br />
Ändern Sie also die Testprozedur ab:<br />
<source><br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Dim Eingabe As Long<br />
Dim Ergebniss As String<br />
Dim Erwartet As String<br />
<br />
Eingabe = 0<br />
Erwartet = "0"<br />
<br />
' Act<br />
Ergebniss = Dez2Bin(Eingabe)<br />
<br />
' Assert<br />
Assert.That Ergebniss, Iz.EqualTo(Erwartet)<br />
End Sub<br />
</source><br />
<br />
Den Test können Sie jetzt mit dem Kontextmenü der rechten Maustaste starten: "Aktiven Test ausführen".<br />
Es öffnet sich ein zusätzliches Fenster in denen Ihnen TestUnit das Ergebnis des Tests anzeigt:<br />
<br />
[[Bild: AccUnit-TestErgebnis1.jpg]]<br />
<br />
Mit einem Rechtsklick auf die Testbeschreibung können Sie das Detailfenster mit der ausführlichen Fehlerbeschreibung aufrufen. Der erste Fehler ist recht schnell zu erkennen: Wir liefern noch überhaupt kein Ergebnis zurück! Ändern wir als unsere Dez2Bin Funktion ab, damit ein korrektes Ergebnis geliefert wird:<br />
<br />
<source><br />
<br />
Public Function Dez2Bin(ByVal TheValue As Long) As String<br />
Dez2Bin = "0"<br />
End Function<br />
<br />
</source></div>KGunderhttp://de.accunit.access-codelib.net/Der_erste_TestDer erste Test2011-02-28T16:06:19Z<p>KGunder: </p>
<hr />
<div>[[en: The first Test]]<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
<source>Public Function Dez2Bin(ByVal TheValue As Long) As String</source><br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen". [[Bild: AccUnit_Test1.jpg]]<br />
<br />
es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.<br />
<br />
AccUnit erzeugt die die Testklasse:<br />
<source><br />
Option Compare Text<br />
Option Explicit<br />
'AccUnit:TestClass<br />
'--------------------------------------------------------------------<br />
' AccUnit Infrastructure<br />
'--------------------------------------------------------------------<br />
Implements SimplyVBUnit.ITestFixture<br />
Implements AccUnit_Integration.ITestManagerBridge<br />
Private TestManager As AccUnit_Integration.TestManager<br />
Private Sub ITestManagerBridge_InitTestManager(ByVal NewTestManager As AccUnit_Integration.ITestManagerComInterface): Set TestManager = NewTestManager: End Sub<br />
Private Function ITestManagerBridge_GetTestManager() As AccUnit_Integration.ITestManagerComInterface: Set ITestManagerBridge_GetTestManager = TestManager: End Function<br />
Private Sub ITestFixture_AddTestCases(ByVal Tests As SimplyVBUnit.TestCaseCollector): TestManager.AddTestCases Tests: End Sub<br />
'--------------------------------------------------------------------<br />
' Tests<br />
'--------------------------------------------------------------------<br />
'<br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Err.Raise vbObjectError, "Dez2Bin_mitEingabe0_liefertdenString0", "Not implemented"<br />
' Act<br />
' Assert<br />
Assert.That 1, Iz.EqualTo(1)<br />
End Sub<br />
</source><br />
<br />
In dem Bereich 'AccUnit Infrastructure' werden ein paar Funktionen definiert die von der Testumgebung benötigt werden.<br />
Bitte nehmen Sie in diesem Bereich KEINE Änderungen vor.<br />
<br />
In unserer Testprozedur Dez2Bin_mitEingabe0_liefertdenString0 sehen Sie schon durch die Kommentare angedeutet, aus welchen Schritten ein Test bestehen sollte:<br />
<br />
- Arrange : Vorbereitungen zum Test - Variablen definieren - Vorgabewerte festlegen<br />
- Act: Die zu testende Funktion mit den Vorgabewerten aufrufen und das Ergebniss erhalten<br />
- Assert: Das erhaltene Ergebniss mit dem erwarteten Ergebniss vergleichen<br />
<br />
Ändern wir also die Testprozedur also ab:<br />
<source><br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Dim Eingabe As Long<br />
Dim Ergebniss As String<br />
Dim Erwartet As String<br />
<br />
Eingabe = 0<br />
Erwartet = "0"<br />
<br />
' Act<br />
Ergebniss = Dez2Bin(Eingabe)<br />
<br />
' Assert<br />
Assert.That Ergebniss, Iz.EqualTo(Erwartet)<br />
End Sub<br />
</source></div>KGunderhttp://de.accunit.access-codelib.net/GrundlagenGrundlagen2011-02-28T15:58:02Z<p>KGunder: "Der erste Test" in eigene Seite verschoben</p>
<hr />
<div>[[en:Basics]]<br />
Eine Software zu testen bedeutet, festzustellen, ob die Software an sie gestellte Anforderungen auch erfüllt.<br />
<br />
Anforderungen in Umgangssprache sind jedoch nicht geeignet als Grundlage eines Tests. <br />
( "Naja, das Ding soll halt nicht abstürzen" oder "Wenn ich da vorne 100 eingeben, dann soll da hinten irgendwas rauskommen.. " )<br />
<br />
Zudem ist es nicht möglich komplexe Applikationen präzise zu beschreiben.<br />
<br />
Zum Testen von Software ist es also wichtig, die große Komplexität einer Applikation in kleine testbare Programmstückchen aufzuteilen.<br />
Diese Programmstückchen sollten dann EINE Aufgabe erledigen, so daß man diese Programmstückchen testet in dem man beschreibt:<br />
<br />
- welches Programmstück ( Modul, Klasse, Funktion, Sub ) teste ich<br />
- welche Eingabewerte ( Vorbedingungen ) erhält das Programmstück<br />
- welche Ausgabewerte ( Nachbedingungen ) erwarte ich<br />
<br />
Unter Umständen wird es also nötig sein den bestehenden Programmcode zu überarbeiten und in kleine testbare Einheiten zu zerlegen.<br />
<br />
[[Der erste Test]]</div>KGunderhttp://de.accunit.access-codelib.net/Der_erste_TestDer erste Test2011-02-28T15:44:09Z<p>KGunder: Die Seite wurde neu angelegt: „en: The first Test == Der erste Test == Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen: Es …“</p>
<hr />
<div>[[en: The first Test]]<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
<source>Public Function Dez2Bin(ByVal TheValue As Long) As String</source><br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen". [[Bild: AccUnit_Test1.jpg]]<br />
<br />
es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.<br />
<br />
AccUnit erzeugt die die Testklasse:<br />
<source><br />
Option Compare Text<br />
Option Explicit<br />
'AccUnit:TestClass<br />
'--------------------------------------------------------------------<br />
' AccUnit Infrastructure<br />
'--------------------------------------------------------------------<br />
Implements SimplyVBUnit.ITestFixture<br />
Implements AccUnit_Integration.ITestManagerBridge<br />
Private TestManager As AccUnit_Integration.TestManager<br />
Private Sub ITestManagerBridge_InitTestManager(ByVal NewTestManager As AccUnit_Integration.ITestManagerComInterface): Set TestManager = NewTestManager: End Sub<br />
Private Function ITestManagerBridge_GetTestManager() As AccUnit_Integration.ITestManagerComInterface: Set ITestManagerBridge_GetTestManager = TestManager: End Function<br />
Private Sub ITestFixture_AddTestCases(ByVal Tests As SimplyVBUnit.TestCaseCollector): TestManager.AddTestCases Tests: End Sub<br />
'--------------------------------------------------------------------<br />
' Tests<br />
'--------------------------------------------------------------------<br />
'<br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Err.Raise vbObjectError, "Dez2Bin_mitEingabe0_liefertdenString0", "Not implemented"<br />
' Act<br />
' Assert<br />
Assert.That 1, Iz.EqualTo(1)<br />
End Sub<br />
</source><br />
<br />
In dem Bereich 'AccUnit Infrastructure' werden ein paar Funktionen definiert die von der Testumgebung benötigt werden.<br />
Bitte nehmen Sie in diesem Bereich KEINE Änderungen vor.</div>KGunderhttp://de.accunit.access-codelib.net/GrundlagenGrundlagen2011-02-28T15:43:38Z<p>KGunder: </p>
<hr />
<div>[[en:Basics]]<br />
Eine Software zu testen bedeutet, festzustellen, ob die Software an sie gestellte Anforderungen auch erfüllt.<br />
<br />
Anforderungen in Umgangssprache sind jedoch nicht geeignet als Grundlage eines Tests. <br />
( "Naja, das Ding soll halt nicht abstürzen" oder "Wenn ich da vorne 100 eingeben, dann soll da hinten irgendwas rauskommen.. " )<br />
<br />
Zudem ist es nicht möglich komplexe Applikationen präzise zu beschreiben.<br />
<br />
Zum Testen von Software ist es also wichtig, die große Komplexität einer Applikation in kleine testbare Programmstückchen aufzuteilen.<br />
Diese Programmstückchen sollten dann EINE Aufgabe erledigen, so daß man diese Programmstückchen testet in dem man beschreibt:<br />
<br />
- welches Programmstück ( Modul, Klasse, Funktion, Sub ) teste ich<br />
- welche Eingabewerte ( Vorbedingungen ) erhält das Programmstück<br />
- welche Ausgabewerte ( Nachbedingungen ) erwarte ich<br />
<br />
Unter Umständen wird es also nötig sein den bestehenden Programmcode zu überarbeiten und in kleine testbare Einheiten zu zerlegen.<br />
<br />
[[Der erste Test]]<br />
<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
<source>Public Function Dez2Bin(ByVal TheValue As Long) As String</source><br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen". [[Bild: AccUnit_Test1.jpg]]<br />
<br />
es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.<br />
<br />
AccUnit erzeugt die die Testklasse:<br />
<source><br />
Option Compare Text<br />
Option Explicit<br />
'AccUnit:TestClass<br />
'--------------------------------------------------------------------<br />
' AccUnit Infrastructure<br />
'--------------------------------------------------------------------<br />
Implements SimplyVBUnit.ITestFixture<br />
Implements AccUnit_Integration.ITestManagerBridge<br />
Private TestManager As AccUnit_Integration.TestManager<br />
Private Sub ITestManagerBridge_InitTestManager(ByVal NewTestManager As AccUnit_Integration.ITestManagerComInterface): Set TestManager = NewTestManager: End Sub<br />
Private Function ITestManagerBridge_GetTestManager() As AccUnit_Integration.ITestManagerComInterface: Set ITestManagerBridge_GetTestManager = TestManager: End Function<br />
Private Sub ITestFixture_AddTestCases(ByVal Tests As SimplyVBUnit.TestCaseCollector): TestManager.AddTestCases Tests: End Sub<br />
'--------------------------------------------------------------------<br />
' Tests<br />
'--------------------------------------------------------------------<br />
'<br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Err.Raise vbObjectError, "Dez2Bin_mitEingabe0_liefertdenString0", "Not implemented"<br />
' Act<br />
' Assert<br />
Assert.That 1, Iz.EqualTo(1)<br />
End Sub<br />
</source><br />
<br />
In dem Bereich 'AccUnit Infrastructure' werden ein paar Funktionen definiert die von der Testumgebung benötigt werden.<br />
Bitte nehmen Sie in diesem Bereich KEINE Änderungen vor.</div>KGunderhttp://de.accunit.access-codelib.net/InstallationInstallation2011-02-28T15:42:43Z<p>KGunder: </p>
<hr />
<div>__NOTOC__ [[en:Installation]]<br />
<br />
Für die Verwendung von AccUnit muss [[SimplyVBUnit|SimplyVBUnit 3.0]] installiert sein.<br />
SimplyVBUnit ist ein in Visual Basic 6 geschriebenes Testframework. <br />
Weitere Informationen zu VBUnit finden Sie auf <br />
der [http://sourceforge.net/projects/simplyvbunit/ Projektseite von SimplyVBUnit auf sourceforge].<br />
<br />
Laden Sie die Setup-Datei, die Sie ist unter ''[http://sourceforge.net/projects/simplyvbunit/files/ View all files]'' finden.<br />
<br />
<br />
Danach können Sie von dieser Webseite das AccUnit Programm [http://accunit.access-codelib.net/download/AccUnitSetup.zip AccUnitSetup.zip] <br />
laden und die Installation mit ''Setup.exe'' starten.<br />
<br />
<br />
=== AccUnit als VBE-Add-In verwenden ===<br />
AccUnit installiert sich als VBE AddIn im Visual Basic Editor. <br />
Sie finden AccUnit einmal als Menüpunkt unter Extras->AccUnit <br />
und zweitens als zusätzlich Symbolleiste mit vier Symbolen.<br />
<br />
[[Bild:AccUnit-Menue.jpg]] <br />
<br />
[[Bild:AccUnit-Symbole.jpg]]</div>KGunderhttp://de.accunit.access-codelib.net/InstallationInstallation2011-02-28T15:41:47Z<p>KGunder: </p>
<hr />
<div>__NOTOC__ [[en:Installation]]<br />
<br />
Für die Verwendung von AccUnit muss [[SimplyVBUnit|SimplyVBUnit 3.0]] installiert sein.<br />
SimplyVBUnit ist ein in Visual Basic 6 geschriebenes Testframework. <br />
Weitere Informationen zu VBUnit finden Sie auf <br />
der [http://sourceforge.net/projects/simplyvbunit/ Projektseite von SimplyVBUnit auf sourceforge].<br />
<br />
Laden Sie die Setup-Datei, die Sie ist unter ''[http://sourceforge.net/projects/simplyvbunit/files/ View all files]'' finden.<br />
<br />
<br />
Danach können Sie von dieser Webseite das AccUnit Programm [http://accunit.access-codelib.net/download/AccUnitSetup.zip AccUnitSetup.zip] <br />
laden und die Installation mit ''Setup.exe'' starten.<br />
<br />
<br />
=== AccUnit als VBE-Add-In verwenden ===<br />
AccUnit installiert sich als VBE AddIn im Visual Basic Editor. <br />
Sie finden AccUnit einmal als Menüpunkt unter Extras->AccUnit <br />
und zweitens als zusätzlich Symbolleiste mit vier Symbolen.<br />
<br />
[[Bild:AccUnit-Menue.jpg]] [[Bild:AccUnit-Symbole.jpg]]</div>KGunderhttp://de.accunit.access-codelib.net/Nutzung_ohne_Add-InNutzung ohne Add-In2011-02-28T15:40:20Z<p>KGunder: Die Seite wurde neu angelegt: „ === Nutzung ohne Add-In === ''(wird nicht empfohlen)'' Die folgenden Punkte sind für die Bedienung per Add-In nicht erforderlich. ==== AccUnit-Unterstützung f…“</p>
<hr />
<div><br />
=== Nutzung ohne Add-In ===<br />
''(wird nicht empfohlen)''<br />
<br />
Die folgenden Punkte sind für die Bedienung per Add-In nicht erforderlich.<br />
==== AccUnit-Unterstützung für Debug-Fenster ====<br />
===== Konfiguration der Access-Anwendungen =====<br />
====== aktivieren ======<br />
Eingabe im Direktfenster: <code>CreateObject("AccUnit.Configurator").Init VBE.ActiveVBProject</code><br />
<br />
Ergebnis:<br />
* Verweise auf AccUnit und SimplyVBUnit werden gesetzt<br />
* Hilfsklasse ''TestSuiteStarter'' und das Modul ''_AccUnitObjects'' werden eingefügt<br />
<br />
====== entfernen ======<br />
Eingabe im Direktfenster: <code>CreateObject("AccUnit.Configurator").Remove VBE.ActiveVBProject</code></div>KGunderhttp://de.accunit.access-codelib.net/Erweiterte_FunktionenErweiterte Funktionen2011-02-28T15:39:43Z<p>KGunder: </p>
<hr />
<div>[[en:Advanced features]]<br />
[[Testen mit vbWatchdog|Testen mit aktiviertem vbWatchdog]]<br />
<br />
[[Nutzung ohne Add-In]]</div>KGunderhttp://de.accunit.access-codelib.net/GrundlagenGrundlagen2011-02-23T12:18:52Z<p>KGunder: /* Der erste Test */</p>
<hr />
<div>Eine Software zu testen bedeutet, festzustellen, ob die Software an sie gestellte Anforderungen auch erfüllt.<br />
<br />
Anforderungen in Umgangssprache sind jedoch nicht geeignet als Grundlage eines Tests. <br />
( "Naja, das Ding soll halt nicht abstürzen" oder "Wenn ich da vorne 100 eingeben, dann soll da hinten irgendwas rauskommen.. " )<br />
<br />
Zudem ist es nicht möglich komplexe Applikationen präzise zu beschreiben.<br />
<br />
Zum Testen von Software ist es also wichtig, die große Komplexität einer Applikation in kleine testbare Programmstückchen aufzuteilen.<br />
Diese Programmstückchen sollten dann EINE Aufgabe erledigen, so daß man diese Programmstückchen testet in dem man beschreibt:<br />
<br />
- welches Programmstück ( Modul, Klasse, Funktion, Sub ) teste ich<br />
- welche Eingabewerte ( Vorbedingungen ) erhält das Programmstück<br />
- welche Ausgabewerte ( Nachbedingungen ) erwarte ich<br />
<br />
Unter Umständen wird es also nötig sein den bestehenden Programmcode zu überarbeiten und in kleine testbare Einheiten zu zerlegen.<br />
<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
Public Function Dez2Bin(ByVal TheValue As Long) As String<br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen". [[Bild: AccUnit_Test1.jpg]]<br />
<br />
es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.<br />
<br />
AccUnit erzeugt die die Testklasse:<br />
Option Compare Text<br />
Option Explicit<br />
'AccUnit:TestClass<br />
'--------------------------------------------------------------------<br />
' AccUnit Infrastructure<br />
'--------------------------------------------------------------------<br />
Implements SimplyVBUnit.ITestFixture<br />
Implements AccUnit_Integration.ITestManagerBridge<br />
Private TestManager As AccUnit_Integration.TestManager<br />
Private Sub ITestManagerBridge_InitTestManager(ByVal NewTestManager As AccUnit_Integration.ITestManagerComInterface): Set TestManager = NewTestManager: End Sub<br />
Private Function ITestManagerBridge_GetTestManager() As AccUnit_Integration.ITestManagerComInterface: Set ITestManagerBridge_GetTestManager = TestManager: End Function<br />
Private Sub ITestFixture_AddTestCases(ByVal Tests As SimplyVBUnit.TestCaseCollector): TestManager.AddTestCases Tests: End Sub<br />
'--------------------------------------------------------------------<br />
' Tests<br />
'--------------------------------------------------------------------<br />
'<br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Err.Raise vbObjectError, "Dez2Bin_mitEingabe0_liefertdenString0", "Not implemented"<br />
' Act<br />
' Assert<br />
Assert.That 1, Iz.EqualTo(1)<br />
End Sub<br />
<br />
<br />
In dem Bereich 'AccUnit Infrastructure' werden ein paar Funktionen definiert die von der Testumgebung benötigt werden.<br />
Bitte nehmen Sie in diesem Bereich KEINE Änderungen vor.</div>KGunderhttp://de.accunit.access-codelib.net/GrundlagenGrundlagen2011-02-23T12:18:22Z<p>KGunder: /* Der erste Test */</p>
<hr />
<div>Eine Software zu testen bedeutet, festzustellen, ob die Software an sie gestellte Anforderungen auch erfüllt.<br />
<br />
Anforderungen in Umgangssprache sind jedoch nicht geeignet als Grundlage eines Tests. <br />
( "Naja, das Ding soll halt nicht abstürzen" oder "Wenn ich da vorne 100 eingeben, dann soll da hinten irgendwas rauskommen.. " )<br />
<br />
Zudem ist es nicht möglich komplexe Applikationen präzise zu beschreiben.<br />
<br />
Zum Testen von Software ist es also wichtig, die große Komplexität einer Applikation in kleine testbare Programmstückchen aufzuteilen.<br />
Diese Programmstückchen sollten dann EINE Aufgabe erledigen, so daß man diese Programmstückchen testet in dem man beschreibt:<br />
<br />
- welches Programmstück ( Modul, Klasse, Funktion, Sub ) teste ich<br />
- welche Eingabewerte ( Vorbedingungen ) erhält das Programmstück<br />
- welche Ausgabewerte ( Nachbedingungen ) erwarte ich<br />
<br />
Unter Umständen wird es also nötig sein den bestehenden Programmcode zu überarbeiten und in kleine testbare Einheiten zu zerlegen.<br />
<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
Public Function Dez2Bin(ByVal TheValue As Long) As String<br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen". [[Bild: AccUnit_Test1.jpg]]<br />
<br />
es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.<br />
<br />
AccUnit erzeugt die die Testklasse:<br />
Option Compare Text<br />
Option Explicit<br />
<br />
'AccUnit:TestClass<br />
<br />
'--------------------------------------------------------------------<br />
' AccUnit Infrastructure<br />
'--------------------------------------------------------------------<br />
<br />
Implements SimplyVBUnit.ITestFixture<br />
Implements AccUnit_Integration.ITestManagerBridge<br />
Private TestManager As AccUnit_Integration.TestManager<br />
Private Sub ITestManagerBridge_InitTestManager(ByVal NewTestManager As AccUnit_Integration.ITestManagerComInterface): Set TestManager = NewTestManager: End Sub<br />
Private Function ITestManagerBridge_GetTestManager() As AccUnit_Integration.ITestManagerComInterface: Set ITestManagerBridge_GetTestManager = TestManager: End Function<br />
Private Sub ITestFixture_AddTestCases(ByVal Tests As SimplyVBUnit.TestCaseCollector): TestManager.AddTestCases Tests: End Sub<br />
<br />
'--------------------------------------------------------------------<br />
' Tests<br />
'--------------------------------------------------------------------<br />
<br />
Public Sub Dez2Bin_mitEingabe0_liefertdenString0()<br />
' Arrange<br />
Err.Raise vbObjectError, "Dez2Bin_mitEingabe0_liefertdenString0", "Not implemented"<br />
' Act<br />
' Assert<br />
Assert.That 1, Iz.EqualTo(1)<br />
End Sub<br />
<br />
<br />
In dem Bereich 'AccUnit Infrastructure' werden ein paar Funktionen definiert die von der Testumgebung benötigt werden.<br />
Bitte nehmen Sie in diesem Bereich KEINE Änderungen vor.</div>KGunderhttp://de.accunit.access-codelib.net/GrundlagenGrundlagen2011-02-23T12:13:01Z<p>KGunder: </p>
<hr />
<div>Eine Software zu testen bedeutet, festzustellen, ob die Software an sie gestellte Anforderungen auch erfüllt.<br />
<br />
Anforderungen in Umgangssprache sind jedoch nicht geeignet als Grundlage eines Tests. <br />
( "Naja, das Ding soll halt nicht abstürzen" oder "Wenn ich da vorne 100 eingeben, dann soll da hinten irgendwas rauskommen.. " )<br />
<br />
Zudem ist es nicht möglich komplexe Applikationen präzise zu beschreiben.<br />
<br />
Zum Testen von Software ist es also wichtig, die große Komplexität einer Applikation in kleine testbare Programmstückchen aufzuteilen.<br />
Diese Programmstückchen sollten dann EINE Aufgabe erledigen, so daß man diese Programmstückchen testet in dem man beschreibt:<br />
<br />
- welches Programmstück ( Modul, Klasse, Funktion, Sub ) teste ich<br />
- welche Eingabewerte ( Vorbedingungen ) erhält das Programmstück<br />
- welche Ausgabewerte ( Nachbedingungen ) erwarte ich<br />
<br />
Unter Umständen wird es also nötig sein den bestehenden Programmcode zu überarbeiten und in kleine testbare Einheiten zu zerlegen.<br />
<br />
== Der erste Test ==<br />
<br />
Den ersten Test wollen wir natürlich nicht mit einem komplexen sondern mit einem ganz simplen Beispiel beginnen:<br />
Es soll eine Funktion erstellt werden, die zu einem Dezimal Wert die binäre Darstellung liefert.<br />
<br />
Ein entsprechende VBA Funktion könnte also so aussehen:<br />
Public Function Dez2Bin(ByVal TheValue As Long) As String<br />
<br />
Wie könnte also der erste Test lauten ?<br />
- Die Funktion Dez2Bin <br />
- liefert bei einer Eingabe des Dezimalwerts 0 <br />
- einen String mit der Ziffer "0"<br />
<br />
Erstellen Sie also ein neues Modul mit dem oben genannten Funktionsrumpf. Klicken Sie innerhalb dieser Funktion die rechte Maustaste und wählen Sie "Neue Testmethode einfügen". [[Bild: AccUnit_Test1.jpg]]<br />
<br />
es öffnet sich der Dialog zum Einfügen einer neue Testmethode:<br />
[[Bild: AccUnit-DialogEinfuegen.jpg]]<br />
<br />
AccUnit wird zu unserem Modul mit den zu testenden Funktionen eine neue Testklasse erstellen, in denen dann die Testmethoden untergebracht sind. Das Modul mit der Funktion Dez2Bin habe ich "Umrechungen" genannt. AccUnit schlägt als Name für die Testklasse "UmrechnungeTest" vor, den Sie so übernehmen sollten. Bei den zu testenden Methode ist schon unsere Funktion De2Bin ausgewählt, so daß wir nur noch den zu testenden Zustand und das erwartete Verhalten eintragen müssen.<br />
Als zu testender Zustand tragen wir ein: "mitEingabe0"<br />
und als erwartetes Verhalten: "liefertdenString0"<br />
AccUnit erzeugt aus diesen beiden Angaben den Namen der Testmethode. Achten Sie also darauf, daß Sie keine Leerzeichen, Anführungszeichen oder andere Sonderzeichen verwenden, die in Methodennamen nicht erlaubt sind.</div>KGunderhttp://de.accunit.access-codelib.net/GrundlagenGrundlagen2011-02-23T10:58:50Z<p>KGunder: Die Seite wurde neu angelegt: „Eine Software zu testen bedeutet, festzustellen, ob die Software an sie gestellte Anforderungen auch erfüllt. Anforderungen in Umgangssprache sind jedoch nicht g…“</p>
<hr />
<div>Eine Software zu testen bedeutet, festzustellen, ob die Software an sie gestellte Anforderungen auch erfüllt.<br />
Anforderungen in Umgangssprache sind jedoch nicht geeignet als Grundlage eines Tests. <br />
( "Naja, das Ding soll halt nicht abstürzen" oder "Wenn ich da vorne 100 eingeben, dann soll da hinten irgendwas rauskommen.. " )<br />
Zudem ist es nicht möglich komplexe Applikationen präzise zu beschreiben.<br />
<br />
Zum Testen von Software ist es also wichtig, die große Komplexität einer Applikation in kleine testbare Programmstückchen aufzuteilen.<br />
Diese Programmstückchen sollten dann EINE Aufgabe erledigen, so daß man diese Programmstückchen testet in dem man beschreibt:<br />
<br />
- welches Programmstück ( Modul, Klasse, Funktion, Sub ) teste ich<br />
- welche Eingabewerte ( Vorbedingungen ) erhält das Programmstück<br />
- welche Ausgabewerte ( Nachbedingungen ) erwarte ich</div>KGunderhttp://de.accunit.access-codelib.net/Erste_SchritteErste Schritte2011-02-23T08:57:25Z<p>KGunder: </p>
<hr />
<div>[[en:Getting started]]<br />
<br />
Der [http://de.wikipedia.org/wiki/Softwaretest Softwaretest] ist ein wichtiger Bestandteil der Softwareentwicklung.<br />
<br />
Während früher der Test am Ende der Softwareentwicklungszyklus als Abnahmebedingung verwendet wurde, so steht heute das Schreiben von Tests am Anfang der Programmiertätigkeiten ([http://en.wikipedia.org/wiki/Test-driven_development TDD] ).<br />
<br />
Viele Programmiersprachen bieten heute entsprechende Tools um Test automatisiert ausführen zu lassen.<br />
Die Programmiersprache [http://de.wikipedia.org/wiki/Visual_Basic_for_Applications VBA] enthält leider nur rudimentäre Funktionen um den Code zu testen (Debug.Print, Debug.Assert)<br />
<br />
AccUnit bietet jetzt zum ersten Mal die Möglichkeit auch unter Access automatisierte Tests zu verwenden. Es verwendet dazu ein in VB6 geschriebenes Zusatzmodul: SimplyVBUnit.<br />
<br />
Die folgenden Seiten sollen Euch helfen eure ersten Tests für Eure Applikation zu schreiben.</div>KGunderhttp://de.accunit.access-codelib.net/InstallationInstallation2011-02-23T08:54:35Z<p>KGunder: </p>
<hr />
<div>__NOTOC__ [[en:Installation]]<br />
<br />
Für die Verwendung von AccUnit muss [[SimplyVBUnit|SimplyVBUnit 3.0]] installiert sein.<br />
SimplyVBUnit ist ein in Visual Basic 6 geschriebenes Testframework. <br />
Weitere Informationen zu VBUnit finden Sie auf <br />
der [http://sourceforge.net/projects/simplyvbunit/ Projektseite von SimplyVBUnit auf sourceforge].<br />
<br />
Laden Sie die Setup-Datei, die Sie ist unter ''[http://sourceforge.net/projects/simplyvbunit/files/ View all files]'' finden.<br />
<br />
<br />
Danach können Sie von dieser Webseite das AccUnit Programm [http://accunit.access-codelib.net/download/AccUnitSetup.zip AccUnitSetup.zip] <br />
laden und die Installation mit ''Setup.exe'' starten.<br />
<br />
<br />
=== AccUnit als VBE-Add-In verwenden ===<br />
AccUnit installiert sich als VBE AddIn im Visual Basic Editor. <br />
Sie finden AccUnit einmal als Menüpunkt unter Extras->AccUnit <br />
und zweitens als zusätzlich Symbolleiste mit vier Symbolen.<br />
<br />
[[Bild:AccUnit-Menue.jpg]] [[Bild:AccUnit-Symbole.jpg]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Nutzung ohne Add-In ===<br />
''(wird nicht empfohlen)''<br />
<br />
Die folgenden Punkte sind für die Bedienung per Add-In nicht erforderlich.<br />
==== AccUnit-Unterstützung für Debug-Fenster ====<br />
===== Konfiguration der Access-Anwendungen =====<br />
====== aktivieren ======<br />
Eingabe im Direktfenster: <code>CreateObject("AccUnit.Configurator").Init VBE.ActiveVBProject</code><br />
<br />
Ergebnis:<br />
* Verweise auf AccUnit und SimplyVBUnit werden gesetzt<br />
* Hilfsklasse ''TestSuiteStarter'' und das Modul ''_AccUnitObjects'' werden eingefügt<br />
<br />
====== entfernen ======<br />
Eingabe im Direktfenster: <code>CreateObject("AccUnit.Configurator").Remove VBE.ActiveVBProject</code></div>KGunderhttp://de.accunit.access-codelib.net/InstallationInstallation2011-02-23T08:54:22Z<p>KGunder: </p>
<hr />
<div>__NOTOC__ [[en:Installation]]<br />
<br />
Für die Verwendung von AccUnit muss [[SimplyVBUnit|SimplyVBUnit 3.0]] installiert sein.<br />
SimplyVBUnit ist ein in Visual Basic 6 geschriebenes Testframework. <br />
Weitere Informationen zu VBUnit finden Sie auf <br />
der [http://sourceforge.net/projects/simplyvbunit/ Projektseite von SimplyVBUnit auf sourceforge].<br />
<br />
Laden Sie die Setup-Datei, die Sie ist unter ''[http://sourceforge.net/projects/simplyvbunit/files/ View all files]'' finden.<br />
<br />
<br />
Danach können Sie von dieser Webseite das AccUnit Programm [http://accunit.access-codelib.net/download/AccUnitSetup.zip AccUnitSetup.zip] <br />
laden und die Installation mit ''Setup.exe'' starten.<br />
<br />
<br />
=== AccUnit als VBE-Add-In verwenden ===<br />
AccUnit installiert sich als VBE AddIn im Visual Basic Editor. <br />
Sie finden AccUnit einmal als Menüpunkt unter Extras->AccUnit <br />
und zweitens als zusätzlich Symbolleiste mit vier Symbolen.<br />
<br />
[[Bild:AccUnit-Menue.jp]] [[Bild:AccUnit-Symbole.jpg]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Nutzung ohne Add-In ===<br />
''(wird nicht empfohlen)''<br />
<br />
Die folgenden Punkte sind für die Bedienung per Add-In nicht erforderlich.<br />
==== AccUnit-Unterstützung für Debug-Fenster ====<br />
===== Konfiguration der Access-Anwendungen =====<br />
====== aktivieren ======<br />
Eingabe im Direktfenster: <code>CreateObject("AccUnit.Configurator").Init VBE.ActiveVBProject</code><br />
<br />
Ergebnis:<br />
* Verweise auf AccUnit und SimplyVBUnit werden gesetzt<br />
* Hilfsklasse ''TestSuiteStarter'' und das Modul ''_AccUnitObjects'' werden eingefügt<br />
<br />
====== entfernen ======<br />
Eingabe im Direktfenster: <code>CreateObject("AccUnit.Configurator").Remove VBE.ActiveVBProject</code></div>KGunderhttp://de.accunit.access-codelib.net/InstallationInstallation2011-02-22T21:28:54Z<p>KGunder: </p>
<hr />
<div>__NOTOC__ [[en:Installation]]<br />
<br />
Für die Verwendung von AccUnit muss [[SimplyVBUnit|SimplyVBUnit 3.0]] installiert sein.<br />
<br />
Die Setup-Datei ist unter ''[http://sourceforge.net/projects/simplyvbunit/files/ View all files]'' der [http://sourceforge.net/projects/simplyvbunit/ Projektseite von SimplyVBUnit auf sourceforge] verfügbar.<br />
<br />
Download: [http://accunit.access-codelib.net/download/AccUnitSetup.zip AccUnitSetup.zip] <br />
Die Installation mit ''Setup.exe'' starten.<br />
<br />
<br />
=== AccUnit als VBE-Add-In verwenden ===<br />
Wenn Sie das VBE-Add-In nutzen, könnten Sie AccUnit über das Menü des VBA-Editor bedienen.<br />
<br />
<br />
<br />
<br />
<br />
=== Nutzung ohne Add-In ===<br />
''(wird nicht empfohlen)''<br />
<br />
Die folgenden Punkte sind für die Bedienung per Add-In nicht erforderlich.<br />
==== AccUnit-Unterstützung für Debug-Fenster ====<br />
===== Konfiguration der Access-Anwendungen =====<br />
====== aktivieren ======<br />
Eingabe im Direktfenster: <code>CreateObject("AccUnit.Configurator").Init VBE.ActiveVBProject</code><br />
<br />
Ergebnis:<br />
* Verweise auf AccUnit und SimplyVBUnit werden gesetzt<br />
* Hilfsklasse ''TestSuiteStarter'' und das Modul ''_AccUnitObjects'' werden eingefügt<br />
<br />
====== entfernen ======<br />
Eingabe im Direktfenster: <code>CreateObject("AccUnit.Configurator").Remove VBE.ActiveVBProject</code></div>KGunderhttp://de.accunit.access-codelib.net/Erste_SchritteErste Schritte2011-02-22T21:26:11Z<p>KGunder: </p>
<hr />
<div>[[en:Getting started]]<br />
<br />
Der [http://de.wikipedia.org/wiki/Softwaretest Softwaretest] ist ein wichtiger Bestandteil der Softwareentwicklung.<br />
<br />
Während früher der Test am Ende der Softwareentwicklungszyklus als Abnahmebedingung verwendet wurde, so steht heute das Schreiben von Tests am Anfang der Programmiertätigkeiten ([http://en.wikipedia.org/wiki/Test-driven_development TDD] ).<br />
<br />
Viele Programmiersprachen bieten heute entsprechende Tools um Test automatisiert ausführen zu lassen.<br />
Die Programmiersprache [http://de.wikipedia.org/wiki/Visual_Basic_for_Applications VBA] bietet leider nur rudimentäre Funktionen um den Code zu testen (Debug.Print, Debug.Assert)<br />
<br />
AccUnit bietet jetzt zum ersten Mal die Möglichkeit auch unter Access automatisierte Tests zu verwenden. Es verwendet dazu ein in VB6 geschriebenes Zusatzmodul: SimplyVBUnit.<br />
<br />
Die folgenden Seiten sollen Euch helfen eure ersten Tests für Eure Applikation zu schreiben.</div>KGunderhttp://de.accunit.access-codelib.net/Erste_SchritteErste Schritte2011-02-22T21:23:59Z<p>KGunder: </p>
<hr />
<div>[[en:Getting started]]<br />
<br />
Der [http://de.wikipedia.org/wiki/Softwaretest Softwaretest] ist ein wichtiger Bestandteil der Softwareentwicklung.<br />
<br />
Während früher der Test am Ende der Softwareentwicklungszyklus als Abnahmebedingung verwendet wurde, so steht heute das Schreiben von Tests am Anfang der Programmiertätigkeiten ([http://en.wikipedia.org/wiki/Test-driven_development TDD] ).<br />
<br />
Viele Programmiersprachen bieten heute entsprechende Tools um Test automatisiert ausführen zu lassen.<br />
Die Programmiersprache [http://de.wikipedia.org/wiki/Visual_Basic_for_Applications VBA] bietet leider nur rudimentäre Funktionen um den Code zu testen (Debug.Print, Debug.Assert)<br />
<br />
AccUnit bietet jetzt zum ersten Mal die Möglichkeit auch unter Access automatisierte Tests zu verwenden. Es verwendet dazu ein zusätzliche Modul: SimplyVBUnit<br />
<br />
Die folgenden Seiten sollen Euch helfen eure ersten Tests für Eure Applikation zu schreiben.</div>KGunderhttp://de.accunit.access-codelib.net/InstallationInstallation2011-02-22T21:21:47Z<p>KGunder: </p>
<hr />
<div>__NOTOC__ [[en:Installation]]<br />
<br />
Für die Verwendung von AccUnit muss [[SimplyVBUnit|SimplyVBUnit 3.0]] installiert sein.<br />
Die Setup-Datei ist unter ''[http://sourceforge.net/projects/simplyvbunit/files/ View all files]'' der [http://sourceforge.net/projects/simplyvbunit/ Projektseite von SimplyVBUnit auf sourceforge] verfügbar.<br />
<br />
Download: [http://accunit.access-codelib.net/download/AccUnitSetup.zip AccUnitSetup.zip] <br />
Die Installation mit ''Setup.exe'' starten.<br />
<br />
<br />
=== AccUnit als VBE-Add-In verwenden ===<br />
Wenn Sie das VBE-Add-In nutzen, könnten Sie AccUnit über das Menü des VBA-Editor bedienen.<br />
<br />
<br />
<br />
=== Nutzung ohne Add-In ===<br />
''(wird nicht empfohlen)''<br />
<br />
Die folgenden Punkte sind für die Bedienung per Add-In nicht erforderlich.<br />
==== AccUnit-Unterstützung für Debug-Fenster ====<br />
===== Konfiguration der Access-Anwendungen =====<br />
====== aktivieren ======<br />
Eingabe im Direktfenster: <code>CreateObject("AccUnit.Configurator").Init VBE.ActiveVBProject</code><br />
<br />
Ergebnis:<br />
* Verweise auf AccUnit und SimplyVBUnit werden gesetzt<br />
* Hilfsklasse ''TestSuiteStarter'' und das Modul ''_AccUnitObjects'' werden eingefügt<br />
<br />
====== entfernen ======<br />
Eingabe im Direktfenster: <code>CreateObject("AccUnit.Configurator").Remove VBE.ActiveVBProject</code></div>KGunderhttp://de.accunit.access-codelib.net/Erste_SchritteErste Schritte2011-02-22T21:20:26Z<p>KGunder: </p>
<hr />
<div>[[en:Getting started]]<br />
<br />
Der [http://de.wikipedia.org/wiki/Softwaretest Softwaretest] ist ein wichtiger Bestandteil der Softwareentwicklung.<br />
<br />
Während früher der Test am Ende der Softwareentwicklungszyklus als Abnahmebedingung verwendet wurde, so steht heute das Schreiben von Tests am Anfang der Programmiertätigkeiten ([http://en.wikipedia.org/wiki/Test-driven_development TDD] ).<br />
<br />
Viele Programmiersprachen bieten heute entsprechende Tools um Test automatisiert ausführen zu lassen.<br />
Die Programmiersprache [http://de.wikipedia.org/wiki/Visual_Basic_for_Applications VBA] bietet leider nur rudimentäre Funktionen um den Code zu testen (Debug.Print, Debug.Assert)<br />
<br />
AccUnit bietet jetzt zum ersten Mal die Möglichkeit auch unter Access automatisierte Tests zu verwenden. <br />
<br />
Die folgenden Seiten sollen Euch helfen eure ersten Tests für Eure Applikation zu schreiben.</div>KGunder