Gestern habe ich mich mal auf die Suche nach einem Unit-Testing Framework für den Pocket PC, sprich für das .NET Compact Framework, gemacht.

Mein Hauptaugenmerk habe ich dabei darauf gelegt, dass die Unit-Tests auch wirklich am Pocket PC, also auf der tatsächlichen Zielplattform, ausführbar sind.

Leider unterstützen die aktuellen Versionen der beiden gängigsten Unit-Testing Frameworks für .NET NUnit und csUnit noch nicht die mobile Version des .NET Frameworks.
Laut der NUnit-Roadmap sollte die Unterstützung des Compact Frameworks allerdings eines der nächsten Features sein, bis es aber soweit ist wird wahrscheinlich noch einige Zeit vergehen.

Fündig bin ich allerdings kurz darauf in der Mobile Client Software Factory der Microsoft Patterns & Practices Gruppe geworden.
Diese haben für den Test ihrer Application-Blocks ein kleines Unit-Testing Framework namens CFUnitTester entwickelt, das das Ausführen der Unit-Tests direkt am Gerät ermöglicht.

Da die Dokumentation zum CFUnitTester recht spärlich ist habe ich mal ein kleines Beispiel erstellt und möchte nun mein erworbenes Wissen in Form eines kleinen Tutorials weitergeben.

Bei dem Beispiel handelt es sich um einen Unit-Test für einen kleinen "nicht generischen" Stack.

Also, dann beginnen wir mal mit dem Tutorial!

Zuerst downloaden wir einmal die Mobile Client Software Factory der Microsoft Patterns & Practices Gruppe und installieren diese.

Als nächstes starten wir das Visual Studio 2005 und erstellen ein neues Projekt, und zwar einfach eine "Visual Studio Blank Solution".

 

Anschließend legen wir der Ordnung halber mal einen Ordner "Source" für den Quellcode des Stacks an.

 

Danach fügen wir diesem Ordner ein neues Projekt hinzu, und zwar eine "Class Library" für einen Windows Mobile 5.0 Pocket PC.

 

Die automatisch erzeugte Klasse "Class1" benennen wir anschließend in "Stack" um.

 

Ist das erledigt, ersetzen wir den automatisch generierten Inhalt der Klasse "Stack" in der Datei "Stack.cs" durch den nachfolgenden Code.

 

using System; using System.Collections; namespace DaSt.Collections { /// <summary> /// Represents a simple last-in-first-out (LIFO) non-generic /// collection of <see cref="System.Object">Objects</see>. /// </summary> /// <example> /// <code> /// using System; /// using System.Collections; /// /// public class StackSample /// { /// public static void PrintValues(IEnumerable collection, char separator) /// { /// foreach (Object obj in collection) /// { /// Console.Write("{0}{1}", separator, obj); /// } /// /// Console.WriteLine(); /// } /// /// static void Main(string[] args) /// { /// // Creates and initializes a new Stack. /// Stack stack = new Stack(); /// stack.Push("The"); /// stack.Push("quick"); /// stack.Push("brown"); /// stack.Push("fox"); /// /// // Displays the Stack. /// Console.Write("Stack values:"); /// PrintValues(stack, '\t'); /// /// // Removes an element from the Stack. /// Console.WriteLine("(Pop)\t\t{0}", stack.Pop()); /// /// // Displays the Stack. /// Console.Write("Stack values:"); /// PrintValues(stack, '\t'); /// /// // Removes another element from the Stack. /// Console.WriteLine("(Pop)\t\t{0}", stack.Pop()); /// /// // Displays the Stack. /// Console.Write("Stack values:"); /// PrintValues(stack, '\t'); /// /// // Views the first element in the Stack but does not remove it. /// Console.WriteLine("(Top)\t\t{0}", stack.Top()); /// /// // Displays the Stack. /// Console.Write("Stack values:"); /// PrintValues(stack, '\t'); /// } /// } /// /// /* /// This code produces the following output. /// /// Stack values: fox brown quick The /// (Pop) fox /// Stack values: brown quick The /// (Pop) brown /// Stack values: quick The /// (Top) quick /// Stack values: quick The /// */ /// </code> /// </example> public class Stack : IEnumerable { private ArrayList elements = new ArrayList(); /// <summary> /// Gets a value indicating whether the /// <see cref="TestDrivenStackSample.Stack">Stack</see> is empty. /// </summary> /// <value> /// <c>true</c>, if the <see cref="TestDrivenStackSample.Stack"> /// Stack</see> is empty; otherwise, <c>false</c>. /// </value> public bool IsEmpty { get { return (elements.Count == 0); } } /// <summary> /// Inserts an <see cref="System.Object">Object</see> at the top /// of the <see cref="TestDrivenStackSample.Stack">Stack</see>. /// </summary> /// <param name="element"> /// The <see cref="System.Object">Object</see> to push onto /// the <see cref="TestDrivenStackSample.Stack">Stack</see>. /// </param> public void Push(Object element) { elements.Insert(0, element); } /// <summary> /// Removes and returns the <see cref="System.Object">Object</see> at /// the top of the <see cref="TestDrivenStackSample.Stack">Stack</see>. /// </summary> /// <returns> /// The <see cref="System.Object">Object</see> removed from the top of /// the <see cref="TestDrivenStackSample.Stack">Stack</see>. /// </returns> /// <exception cref="System.InvalidOperationException"> /// Thrown when the <see cref="TestDrivenStackSample.Stack">Stack</see> /// is empty. /// </exception> public Object Pop() { Object top = Top(); elements.RemoveAt(0); return top; } /// <summary> /// Returns the <see cref="System.Object">Object</see> at the top of the /// <see cref="TestDrivenStackSample.Stack">Stack</see> without removing it. /// </summary> /// <returns> /// The <see cref="System.Object">Object</see> at the top of the /// <see cref="TestDrivenStackSample.Stack">Stack</see>. /// </returns> /// <exception cref="System.InvalidOperationException"> /// Thrown when the <see cref="TestDrivenStackSample.Stack">Stack</see> /// is empty. /// </exception> public Object Top() { if (IsEmpty) { throw new InvalidOperationException("Stack is Empty"); } return elements[0]; } /// <summary> /// Returns an <see cref="System.Collections.IEnumerator">IEnumerator /// </see> for the <see cref="TestDrivenStackSample.Stack">Stack</see>. /// </summary> /// <returns> /// An <see cref="System.Collections.IEnumerator">IEnumerator</see> /// for the <see cref="TestDrivenStackSample.Stack">Stack</see>. /// </returns> public IEnumerator GetEnumerator() { foreach (Object element in elements) { yield return element; } } } }

Anschließend legen wir uns wieder zwei Ordner an, um Platz für das Unit-Testing Framework CFUnitTester und den eigentlichen Unit-Test der Stack-Klasse zu schaffen.

 

Danach kopieren wir uns den CFUnitTester-Ordner aus dem Installationspfad der Mobile Client Software Factory in unseren Ordner mit der Beispielapplikation.

 

Nach dieser Aktion fügen wir die drei Projekte des CFUnitTester "GuiTestRunner", "TestRunner" und "UnitTesting" dem Ordner "CFUnitTester" hinzu.

 

 

Als nächstes erzeugen wir die eigentliche Test-Klasse für unseren Stack, indem wir dem Ordner "UnitTests" eine neue "Class Library" für einen Windows Mobile 5.0 Pocket PC hinzufügen.

 

Und wieder benennen wir anschließend die automatisch erzeugte Klasse "Class1" in "StackFixture" um.

 

Den automatisch generierten Inhalt der Klasse "StackFixture" in der Datei "StackFixture.cs" ersetzen wir wieder durch den nachfolgenden Code, der die einzelnen Test-Methoden beinhaltet.

 

using System; using DaSt.Collections; using Microsoft.Practices.Mobile.TestTools.UnitTesting; namespace DaSt.Collections.Tests { [TestClass] public class StackFixture { private Stack stack; [TestInitialize] public void Init() { stack = new Stack(); } [TestMethod] public void Empty() { Assert.IsTrue(stack.IsEmpty); } [TestMethod] public void PushOne() { stack.Push("first element"); Assert.IsFalse(stack.IsEmpty, "After Push, IsEmpty should be false."); } [TestMethod] public void Pop() { stack.Push("first element"); stack.Pop(); Assert.IsTrue(stack.IsEmpty, "After Push - Pop, IsEmpty should be true."); } [TestMethod] public void PushPopContentCheck() { int expected = 1234; stack.Push(expected); int actual = (int)stack.Pop(); Assert.Equals(expected, actual); } [TestMethod] public void PushPopMultipleElements() { string pushed1 = "1"; stack.Push(pushed1); string pushed2 = "2"; stack.Push(pushed2); string pushed3 = "3"; stack.Push(pushed3); string popped = (string)stack.Pop(); Assert.Equals(pushed3, popped); popped = (string)stack.Pop(); Assert.Equals(pushed2, popped); popped = (string)stack.Pop(); Assert.Equals(pushed1, popped); } [TestMethod] [ExpectedException(typeof(InvalidOperationException))] public void PopEmptyStack() { stack.Pop(); } [TestMethod] public void PushTop() { stack.Push("42"); stack.Top(); Assert.IsFalse(stack.IsEmpty); } [TestMethod] public void PushTopContentCheckOneElement() { string pushed = "42"; stack.Push(pushed); string topped = (string)stack.Top(); Assert.Equals(pushed, topped); } [TestMethod] public void PushTopContentCheckMultiples() { string pushed3 = "3"; stack.Push(pushed3); string pushed4 = "4"; stack.Push(pushed4); string pushed5 = "5"; stack.Push(pushed5); string topped = (string)stack.Top(); Assert.Equals(pushed5, topped); } [TestMethod] public void PushTopNoStackStateChange() { string pushed = "44"; stack.Push(pushed); for (int index = 0; index < 10; index++) { string topped = (string)stack.Top(); Assert.Equals(pushed, topped); } } [TestMethod] [ExpectedException(typeof(InvalidOperationException))] public void TopEmptyStack() { stack.Top(); } [TestMethod] public void PushNull() { stack.Push(null); Assert.IsFalse(stack.IsEmpty); } [TestMethod] public void PushNullCheckPop() { stack.Push(null); Assert.IsNull(stack.Pop()); Assert.IsTrue(stack.IsEmpty); } [TestMethod] public void PushNullCheckTop() { stack.Push(null); Assert.IsNull(stack.Top()); Assert.IsFalse(stack.IsEmpty); } } }

Damit die Test-Klasse "StackFixture" auch kompilierbar ist, müssen wir noch die fehlenden Referenzen hinzufügen.

 

 

Als nächstes müssen wir noch das Ausgabeverzeichnis des Projekts mit unseren Test-Klassen umstellen, da das Unit-Testing Framework CFUnitTester nur im aktuellen Verzeichnis seiner GUI-Applikation "GuiTestRunner" nach Test-Klassen sucht.

 

 

Damit alle benötigten Dateien auf das Zielgerät kopiert werden, müssen alle Projekte im "Configuration Manager" auf "Deploy" gesetzt werden.

 

Anschließend können alle Projekte mittels "Rebuild Solution" kompiliert werden.

 

Nun setzen wir noch das "GuiTestRunner" Projekt als "StartUp Project" und starten das ganz Ding im Emulator oder am Zielgerät.

 

Nachdem der Emulator gestartet ist, sollte auch schon kurz darauf die GuiTestRunner-Applikation des CFUnitTester-Frameworks erscheinen.

 

Die Tests können nun mittels "Select All" und "Run Selected..." gestartet werden. Nachdem alle Tests durchlaufen wurden, erscheint eine Übersicht mit den Ergebnissen der Tests.

 

So, das wärs eigentlich! Ist eigentlich nur noch zu erwähnen, dass das ganze auch unter dem Pocket PC 2003 Betriebssystem läuft, wie die beiden folgenden Screenshots zeigen.

 

Ach ja, das von mir erstellte Beispiel findet ihr natürlich auch online unter http://homepage.uibk.ac.at/~csaf3425/CFUnitTestSample.zip zum Downloaden!

Na dann, auf ein erfolgreiches "Testgetriebenes Entwickeln" am Pocket PC!

Posted on Thursday, September 21, 2006 6:33 AM Programmieren | Back to top