Das Dokument beschreibt die Automatisierung von Softwareentwicklungsprozessen mithilfe von Nant, einem Tool zum Erstellen von Skripten. Es bietet eine Einführung, Installationsanleitungen und ein Tutorial, das verschiedene Aspekte der Softwareentwicklung abdeckt, einschließlich Installation, Unit-Tests und API-Dokumentation. Zudem werden die Struktur des Beispielprojekts sowie die Konfiguration der Nant-Prozesse erläutert.

1. Automatisierung mit NANA
Documentation
Release 0.1
Steinam
26. 02. 2010

3. Inhaltsverzeichnis
1 Einführung 3
2 Installation der beteiligten Komponenten 5
2.1 Struktur des Beispielprojektes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Ordnerstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3 Erstellen der Konfiguration 11
3.1 Struktur der Konfigurationsatei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4 Indices and tables 13
i

4. ii

5. Automatisierung mit NANA Documentation, Release 0.1
Inhaltsverzeichnis:
Inhaltsverzeichnis 1

6. Automatisierung mit NANA Documentation, Release 0.1
2 Inhaltsverzeichnis

7. KAPITEL 1
Einführung
NANT (http://nant.sourceforge.net) ist ein Tool zum Erstellen von Skripten und ist damit ein wesentliches Element
der Automatisation der Softwareentwicklung. Mit Hilfe von NANT ist es möglich, die Abläufe der verschiedenen
Prozesse einer Softwareentwicklung unter einem Skript zusammenzufassen.
Ein Vorläufer von NANT ist das java-basierte ANT (http://ant.apache.org), von dem es wesentliche Konzepte über-
nommen hat. Das Microsoft-eigene Build-Tool msbuild (http://msbuild.microsoft.com) hat sich wiederun an NANT
orientiert und weitere Elemente hinzugefügt. Wer innerhalb der .NET-Plattform entwickelt, sollte sich daher mehr mit
MSBUILD als mit NANT beschäftigen.
Im folgenden Tutorial soll innerhalb von 5 Runden das Zusammenführen unterschiedlicher Aspekte der Softwareent-
wicklung dargestellt werden.
• Runde 1: Installation der entsprechenden Komponenten
• Runde 2: Löschen und Kompilieren des Quellcodes anhand verscheidener Variationen
• Runde 3: Ausführen von Unit-Tests
• Runde 4: Aufruf eines Installers
• Runde 5: Generieren einer API-Dokumentation
Das Tutorial setzt das .NET-Framework-SDK in der Version 4.0 voraus. Das .sln-File des Projektes ist mit der Version
11 definiert, welches die Verwendung von Visual Studio 2010 voraussetzt.
Die verwendeten Tools sind:
• NUNIT (http://www.nunit.org) zum Erstellen und Durchführen der Unit-Tests
• Doxygen (http://www.doxygen.org) zum Erstellen der API-Dokuemntation
• Innosetup (http://www.jrsoftware.org/isinfo.php) zum Erstellen des Installers
3

8. Automatisierung mit NANA Documentation, Release 0.1
4 Kapitel 1. Einführung

9. KAPITEL 2
Installation der beteiligten
Komponenten
NANT wird als einfache gepackte Datei zum Download angeboten und muss nicht weiter installiert werden. Die
ausführbare Datei befindet sich im Unterordner bin.
2.1 Struktur des Beispielprojektes
Beim Programm geht es um eine bereits in frühreren Zeiten verwendete selbstgeschriebene Stack-Klasse namens
Stapel, die mit Hilfe von UnitTests (StackTest) überprüft wird.
5

10. Automatisierung mit NANA Documentation, Release 0.1
Der Quellcode der entsprechenden Klassen sieht wie folgt aus:
using System;
using System.Collections;
namespace StackTest
{
/// <summary>
/// Description of Stapel.
/// </summary>
public class Stapel
{
bool emptyState = true;
//object myValue; tEST % GEHT SDO NICHT
ArrayList myValue = new ArrayList();
/// <summary>
/// Gibt an, ob der Stack leer ist oder nicht
6 Kapitel 2. Installation der beteiligten Komponenten

11. Automatisierung mit NANA Documentation, Release 0.1
/// </summary>
/// <returns>true für leer, false für voll</returns>
public bool isEmpty()
{
return emptyState;
}
/// <summary>
/// test 4 macht Halten eines Objektes notwendig
/// </summary>
/// <param name="value"></param>
public void push(object value)
{
myValue.Add(value);
emptyState = false;
}
/// <summary>
/// Wird durch den 4. test von void auf object geändert
/// </summary>
public object pop()
{
emptyState = true;
return myValue;
}
}
}
Die entsprechenden UnitTests befinden sich im Projekt StackTest und halten eine Referen auf die Klassenbibliothek
Stapel
using System;
using NUnit.Framework;
namespace StackTest
{
/// <summary>
/// Description of StapelTest.
/// </summary>
[TestFixture]
public class StapelTest
{
static Stapel myStack;
/// <summary>
/// Wird bei jedem Aufruf einer testmethode vorher
/// ausgeführt
/// </summary>
[SetUp]
public void Init()
{
myStack = new Stapel();
}
/// <summary>
/// Create a Stack and verify that
/// IsEmpty is true.
/// </summary>
2.1. Struktur des Beispielprojektes 7

12. Automatisierung mit NANA Documentation, Release 0.1
[Test]
public static void testOne()
{
Assert.IsTrue(myStack.isEmpty());
}
/// <summary>
/// Nach Hinzufügen eines Elementes muss
/// isEmpty false zurückgeben
/// </summary>
[Test]
public static void testTwo()
{
myStack.push("hello");
Assert.IsFalse(myStack.isEmpty());
}
/// <summary>
/// Hinzufügen - Wegnehmen --> isEmpty ergibt true
/// </summary>
[Test]
public static void testThree()
{
myStack.push("hello");
myStack.pop();
Assert.IsTrue(myStack.isEmpty());
}
/// <summary>
/// Hinzufügen von hello und holen von hello muss eine ObjektGleichheit ergeben
/// </summary>
[Test]
public static void testFour()
{
myStack.push("hello");
object x = myStack.pop();
Assert.AreEqual("hello", x);
}
/// <summary>
/// Hinzufügen und Wegnehmen mehrerer Elemente muss jeweils Objektgleichheit ergeben
/// </summary>
[Test]
public static void testFive()
{
string a = "hello";
string b = "mr.";
string c = "steinam";
myStack.push(a);
myStack.push(b);
myStack.push(c);
object z = myStack.pop();
8 Kapitel 2. Installation der beteiligten Komponenten

13. Automatisierung mit NANA Documentation, Release 0.1
Assert.AreEqual(c, z);
object y = myStack.pop();
Assert.AreEqual(b, y);
object x = myStack.pop();
Assert.AreEqual(a, x);
}
}
}
2.2 Ordnerstruktur
Die Struktur des Dateisystems ist wie folgt:
• C:nant_stack: Grundlegender Hauptordner
• C:nant_stackapi_doc: Nimmt die von doxygen generierte API-Dokumentation auf
• C:nant_stacksetup: Nimmt die Konfigurationsdatei von Innosetup sowie das Ergebnis des Innosetup-Comilers
(Setup.exe) setup.exe auf.
• C:nant_stacklogfiles: Nimmt die Logfiles auf
• C:nant_stacknant_086bin: Ausführbare Datei nant.exe
• C:nant_stackStapel: Quellcode der Stapel-Klasse
2.2. Ordnerstruktur 9

14. Automatisierung mit NANA Documentation, Release 0.1
• C:nant_stackStackTest: Quellcode der Testklassen
10 Kapitel 2. Installation der beteiligten Komponenten

15. KAPITEL 3
Erstellen der Konfiguration
NANT erwartet eine Beschreibung der aufzurufenden Prozesse in einer Konfigurationsdatei. Diese wird standardmäßig
default.build genannt. NANT sucht nach dem Aufruf im jeweils aktuellen Ordner nach dieser Datei. Andere Namen
kann man per Parameter an NANT übergeben
3.1 Struktur der Konfigurationsatei
Die Konfigurationsdatei wird mit Hilfe von XML-Tags beschrieben. Die grundlegende Struktur ist der sog. project -
Tag, der ein Projekt beschreibt.
Innerhalb dieser Struktur definieren sog. Target-Tags die einzelnen zu erledigenden Aufgaben.
Innerhalb der Target-Struktur werden dann die einzelnen Aufgaben durch sog. Tasks definiert.
Ein Beispiel für eine einfache Beschreibung könnte wie folgt aussehen:
<project name="Teacher" default="rebuild">
<target name="compileDebug">
<exec program="${devEnvPath}">
<arg value="c:/nant_stack/StackTest/StackTest.sln" />
<arg value="/build" />
<arg value="Debug" />
</exec>
</target>
<target name="rebuild" depends="compileDebug" />
</project>
</project>
11

16. Automatisierung mit NANA Documentation, Release 0.1
12 Kapitel 3. Erstellen der Konfiguration

17. KAPITEL 4
Indices and tables
• Index
• Module Index
• Search Page
13