Geekality » C# http://www.geekality.net With a hint of Social Ineptitude Tue, 27 Jul 2010 16:15:56 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 C#: How to send emails http://www.geekality.net/2010/05/16/c-how-to-send-emails/ http://www.geekality.net/2010/05/16/c-how-to-send-emails/#comments Sun, 16 May 2010 00:21:02 +0000 Torleif http://www.geekality.net/?p=991 Continue reading →]]> Sending a basic email message in a C# application is quite easy thanks to a class called SmptClient.

We simply need an address to send to, an address to send from, the message we want to send and the client:

var from = new MailAddress("me@example.com", "Me");
var to = new MailAddress("you@example.com", "You");

var message = new MailMessage(from, to)
{
    Subject = "Greetings!",
    Body = "How are you doing today?",
};

var client = new SmtpClient("smtp.example.com");

using (client)
{
    try
    {
        client.Send(message);
    }
    catch (SmtpException e)
    {
        Console.WriteLine(e.Message);
    }
}

That was pretty simple, wasn’t it? But what if we need to authenticate with our server? And what if we want to send our message in a more secure manner?

Authentication

You will quite often find that an SMTP server requires you to authenticate yourself before it will let you do anything. This is however very simple to do. All we need, is to provide our credentials to the client:

var client = new SmtpClient("smtp.example.com")
{
    Credentials = new NetworkCredential
    {
        UserName = "me@example.com",
        Password = "password",
    },
};

Now, when you try to send your message like before, it should be sent without problems :) But what if you want to send your email securely?

Using SSL to encrypt the connection

To send emails through an encrypted connection, all you have to do is to set the EnableSSL property of the SmtpClient to true:

var client = new SmtpClient("smtp.example.com")
{
    EnableSSL = true,
    Credentials = new NetworkCredential
    {
        UserName = "me@example.com",
        Password = "password",
    },
};

When you now try to send your email, it will use the Secure Socket Layer to encrypt the connection. Like me, you might run into a problem though; an AuthenticationException with the following message: The remote certificate is invalid according to the validation procedure.

Imperfect certificates

After reading about how these certificates work and some more digging around I found out that the certificate of the SMTP server I use is considered invalid for two reasons: Firstly it was not issued by a trusted Certification Authority (like VeriSign or Thawte), but by my host (Dreamhost) themselves. And finally there is a mismatch between the domain I’m connecting to (smtp.example.com) and the domain the certificate was issued to (mail.dreamhost.com).

Manual certificate validation

SSL has two purposes: security and authentication. And the security will actually work fine and all the traffic will be encrypted even if the authentication fails. In other words, as long as we can look at the certificate ourselves and be sure that we thrust it, we can go ahead and continue with our work.

To check the certificate ourselves we can provide a RemoteCertificateValidationCallback delegate to a class called the ServicePointManager.

ServicePointManager.ServerCertificateValidationCallback
    = OurCertificateValidation;

But how can we decide if we should trust the certificate or not? Well, I have found three ways that works nicely. Well, actually just two since the first way is to just cover your eyes and let anything pass.

Pretend validation

The following implementation is a way to simply say that I don’t care:

static bool OurCertificateValidation(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
    return true;
}

This is of course not very good… we should at least make some effort and check if the certificate is the one we should be getting. We can for example…

Check the certificate fingerprint

Certificates have something called a fingerprint and if we know the fingerprint of the certificate we should get, then we can compare it with the fingerprint of the one we actually got.

static bool OurCertificateValidation(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
    return certificate.GetCertHashString()
        == "6B8C79AB966D70277BA86E6F820859A2B5B8CCC0"; // SHA-1 fingerprint
}

If you don’t think this is enough, you can for example…

Check the whole certificate

If you can export the certificate to a file somehow, you can then later compare the certificate you get with the one you have stored and make sure they are equal.

static bool OurCertificateValidation(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
    var actualCertificate = X509Certificate.CreateFromCertFile("example.cert");
    return certificate.Equals(actualCertificate);
}

I got a hold of the certificate file by sticking the following snippet inside my validation delegate, ran my code once, and then changed it back to normal again:

static bool OurCertificateValidation(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
    using (var file = File.Create("example.cert"))
    {
        var cert = certificate.Export(X509ContentType.Cert);
        file.Write(cert, 0, cert.Length);
    }
    return false;
}

I also successfully exported it from Opera, which I use as an email client, by going to Preferences, Security, Manage Certificates, Approved and then export the one I want. This of course assumes you have have previously approved the certificate for use with Opera.

Wrap-up

That’s all for now! Found it kind of fun to get this working and thought I could share it in case someone else struggles with this. Please comment and let me know if I have misunderstood something or done a big blunder or something like that! I mostly just know that my code is working, so if you know more about how these security issues work and you know something you think i should know as well: Please share! I’d like to learn :)

Here is my final complete code:

using System;
using System.Net.Mail;
using System.Net;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.IO;
using System.Net.Security;

namespace Geekality.SecureEmail
{
    class Program
    {
        static bool OurCertificateValidation(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
        {
            var actualCertificate = X509Certificate.CreateFromCertFile("example.com.cert");

            return certificate.Equals(actualCertificate);
        }

        static void Main(string[] args)
        {
            // Register our own certificate validation
            ServicePointManager.ServerCertificateValidationCallback = OurCertificateValidation;

            // Message
            var from = new MailAddress("me@example.com", "Me");
            var to = new MailAddress("you@example.com", "Myself");

            var message = new MailMessage(from, to)
            {
                Subject = "Greetings!",
                Body = "How are you doing today?",
            };

            // Create client
            var client = new SmtpClient("smtp.example.com")
            {
                EnableSsl = true,
                Credentials = new NetworkCredential
                {
                    UserName = "me@example.com",
                    Password = "password",
                },
            };

            // Try to send
            using (client)
            {
                try
                {
                    client.Send(message);
                    Console.WriteLine("Message sent!");
                }
                catch (AuthenticationException e)
                {
                    Console.WriteLine(e.Message);
                }
                catch (SmtpException e)
                {
                    Console.WriteLine(e.Message);
                }
            }

            Console.ReadKey(true);
        }
    }
}
]]> http://www.geekality.net/2010/05/16/c-how-to-send-emails/feed/ 0 How to check for duplicates http://www.geekality.net/2010/01/19/how-to-check-for-duplicates/ http://www.geekality.net/2010/01/19/how-to-check-for-duplicates/#comments Tue, 19 Jan 2010 16:57:09 +0000 Torleif http://www.geekality.net/?p=884 Continue reading →]]> Say you have an IEnumerable<T> of some sort and you want to check if it contains any duplicates. How do you do that?

Terrible solution

I needed to do this a while ago and the first solution that hit me wasn’t exactly good. Linq has method called Distinct, which returns the distinct items in a sequence (weeds out duplicates). Using that to check if duplicates exists you can do something like this:

var hasDuplicates =
        subjects.Count() != subjects.Distinct().Count();

This is of course a really bad solution. So don’t use it! :P

Good solution

The much better solution is to use a HashSet<T>.

The HashSet<T> class provides high performance set operations. A set is a collection that contains no duplicate elements, and whose elements are in no particular order.

In addition to the fact that it cannot contain duplicate items, it also has a very nice add-method which returns false if the item is already in the set.

To check for duplicates using a hash set we can start out by assuming there is no duplicates and then add items to the hash set until we either run out of items, or we try to add an item that already exists. In the first case our assumption was right and in the second it turned out to be wrong.

var set = new HashSet<T>();

var hasDuplicates = false;

foreach (var s in subjects)
    if (!set.Add(s))
    {
        hasDuplicates = true;
        break;
    }

Good and handy solution

Since we don’t want to type in that stuff over and over again we want this snippet in a nice extension method. Code snippet coming up :)

using System.Collections.Generic;

namespace Geekality.Snippets
{
    public static class EnumerableExtensions
    {
        public static bool HasDuplicates<T>(this IEnumerable<T> subjects)
        {
            return HasDuplicates(subjects, EqualityComparer<T>.Default);
        }


        public static bool HasDuplicates<T>(this IEnumerable<T> subjects, IEqualityComparer<T> comparer)
        {
            if(subjects == null)
                throw new ArgumentNullException("subjects");

            if(comparer == null)
                throw new ArgumentNullException("comparer");

            var set = new HashSet<T>(comparer);

            foreach (var s in subjects)
                if (!set.Add(s))
                    return true;

            return false;
        }
    }
}

Simple and handy. You use it for example like this:

if(subjects.HasDuplicates())
{
    // Do something
}

Hope it can help someone, somewhere, below and/or over the rainbow :)

Let me know what you think. I’m always open for improvements and feedback 8)

]]> http://www.geekality.net/2010/01/19/how-to-check-for-duplicates/feed/ 0 How to test asynchronous events http://www.geekality.net/2009/11/26/how-to-test-asynchronous-events/ http://www.geekality.net/2009/11/26/how-to-test-asynchronous-events/#comments Thu, 26 Nov 2009 18:59:59 +0000 Torleif http://www.geekality.net/?p=826 Continue reading →]]> The other day I had to test that an event was raised after some asynchronous work had been done. And since I currently am a total test newbie, this was a new thing for me. Say we have this simple shell of a class:

public class Worker
{
    public event EventHandler<EventArgs> Done;

    public void Start()
    {
       ...
    }
}

Let’s just assume it does some work, and is supposed to raise the Done event when it is… well… done.

Synchronous worker

If the Worker class works synchronously, it would be no problem at all to test it. For example:

[TestFixture]
public class WorkerTests
{
    [Test]
    public void Start_WhenFinished_DoneEventIsRaised()
    {
        var worker = new Worker();

        var eventWasRaised = false;
        worker.Done += (s, e) => eventWasRaised = true;

        worker.Start();

        Assert.That(eventWasRaised);
    }
}

We simply add an event handler which sets a boolean flag when called, start the worker and then check if the flag was set or not. Easy peasy.

Asynchronous worker

What now if the Start method just sends the work to a new thread and returns immediately? Our current test can not be trusted at all in that case. It might pass and it might fail. Most likely fail. All depending on if it managed to finish its work and raise the event before we check the flag. And that would be unlikely to happen. Highly unlikely.

So what do we do? We use a ManualResetEvent instead of the boolean flag:

[TestFixture]
public class WorkerTests
{
    [Test]
    public void Start_WhenFinished_DoneEventIsRaised()
    {
        var worker = new Worker();

        var eventWasRaised = new ManualResetEvent(false);
        worker.Done += (s, e) => eventWasRaised.Set();

        worker.Start();

        Assert.That(eventWasRaised.WaitOne(500));
    }
}

Instead of checking that a flag has been set, we check that the event handler gives us a signal within a certain period of time. If it doesn’t give us that signal we can assume that the event was never raised or that the work simply took longer than we expected. Either case could probably be of interest :)

Brilliant, simple and readable. Just how we like it 8)

Credits

I am still a total testing newbie at the moment and didn’t have a clue what to do, so after some failing google-fu I asked a question about it at StackOverflow. My solution is based on one of the answers I got there :)

]]> http://www.geekality.net/2009/11/26/how-to-test-asynchronous-events/feed/ 0 Generics and checking for null http://www.geekality.net/2009/11/13/generics-and-checking-for-null/ http://www.geekality.net/2009/11/13/generics-and-checking-for-null/#comments Fri, 13 Nov 2009 16:19:15 +0000 Torleif http://www.geekality.net/?p=788 Continue reading →]]> When writing C#, in Visual Studio, using generics… have you ever tried checking for null? I have always found that a bit of a hassle.

Say we have this method which returns the subject if it is not null, and the result of a createNew() function if it is null.

public static T NewIfNull<T>(this T subject, Func<T> createNew)
{
    if (subject == null)
        return createNew();
    return subject;
}

Not claiming this is a very useful method, but it was the simplest thing I could come up with :P Anyways, in Visual Studio you will now probably have a blue (is blue here at least) squiggly line under the equality operator. It states you are doing a Possible compare of value type with ‘null’, which of course is reasonable and correct. We could just ignore it and move on… but we don’t really like squiggly lines, do we? I sure don’t… so lets get rid of it.

Faulty solution

ReSharper suggests that I use default(T) instead of null, like this:

public static T NewIfNull<T>(T subject, Func<T> createNew)
{
    if (subject == default(T))
        return createNew();
    return subject;
}

Now, this won’t do at all. First of all, we don’t really want to check for default(T), we want to check for null. And second of all, we now have a long red squiggly line under the whole equality statement! It says that it Cannot apply operator ‘==’ to operands of type ‘T’ and ‘T’. That messages doesn’t really make much sense to me, to be honest, but I trust that it is true. Either way, we have to get rid of it.

Good solution

ReferenceEquals to the rescue! We can use that method, instead of the equality operator, and compare with null like we intended! :D

public static T NewIfNull<T>(T subject, Func<T> createNew)
{
    if (ReferenceEquals(subject, null))
        return createNew();
    return subject;
}

That is kind of ugly though… And it is so much longer to type. And, most importantly, it kind of makes the code a bit unreadable… At least if you have a bunch of things you have to check for null, like I did today.

But fear not! Today I came up with a tiny, but brilliant extension method which makes things a lot better:

public static bool IsNull<T>(this T subject)
{
    return ReferenceEquals(subject, null);
}

public static T NewIfNull<T>(T subject, Func<T> createNew)
{
    if (subject.IsNull())
        return createNew();
    return subject;
}

Doesn’t that just look a lot cleaner? I think so :D

And yes, I know this isn’t really a big issue. And I realize you have probably all come up with something similar already. Yes, I am slow :P But hey, I figured it might be worth sharing this anyways, just in case you hadn’t thought about it before. I sure hadn’t! And I really do think that tiny snippet of code made a huge difference in code readability. And we all want that, don’t we? Yes, yes we do…

]]> http://www.geekality.net/2009/11/13/generics-and-checking-for-null/feed/ 0 Project Euler: Problem 25 http://www.geekality.net/2009/11/06/project-euler-problem-25/ http://www.geekality.net/2009/11/06/project-euler-problem-25/#comments Fri, 06 Nov 2009 22:51:56 +0000 Torleif http://www.geekality.net/?p=751 Continue reading →]]>

The Fibonacci sequence is defined by the recurrence relation:
F_n = F_{n-1} + F_{n-2}, where F_1 = 1 and F_2 = 1.

Hence the first 12 terms will be:

  • F_1=1
  • F_2=1
  • …
  • F_{11}=89
  • F_{12}=144

The 12th term, F_{12}, is the first term to contain three digits.

What is the first term in the Fibonacci sequence to contain 1000 digits?

Solution

We touched on the Fibonacci sequence a while ago in the second euler problem. This time, however, we are in a whole different league. That time we were supposed to sum up all even Fibonacci numbers below 4 million, which might sound like a lot, but not when we compare it to the number we are asked for this time! The last Fibonacci number below 4 million is 3524578. That would be 7 digits. The maximum value of the datatype I used in the generator I made for that (ulong) is 18446744073709551615. That would be 20 digits. Quite a distance left to a thousand!

So, once again we turn to our big integer class, IntX. And since we have that, a solution to this problem is actually pretty straight forward. We simply have to make a new generator that uses the IntX data type instead of tiny ulong (it’s all relative…).

public class LargeFibonacciSequence : IEnumerable<IntX>
{
    public IEnumerator<IntX> GetEnumerator()
    {
        var a = new IntX(0);
        var b = new IntX(1);

        while (true)
        {
            yield return a;

            var c = a + b;
            a = b;
            b = c;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

The straight forward solution should then be fairly obvious.

var n = 0;
var sequence = new LargeFibonacciSequence();

using (var e = sequence.GetEnumerator())
{
    while (e.MoveNext() && e.Current.ToString().Length < 1000)
        n++;
}

var answer = n;

That pretty much just moves through one Fibonacci number after the other, increasing n as it goes, until it reaches the first one that has 1000 or more digits.

Very brute-force, not very fast (takes around 500 ms) and not very interesting, but that’s pretty much it… ooor is it?

Take two!

Alright, while reading up on Fibonacci numbers I found some interesting mathematical formulas and such. I’m not going to come with an in-depth explanation or lots proofs here, but I will share the formulas that matters and go through how we use them. If you want the elaborate explanations you can find them where smarter people than I reign. For example at Wikipedia, or at this site. Anyways, here we go. Take cover if you fear math…

The Fibonacci sequence

The nth number in the Fibonacci sequence, F_n, is defined by the recurrence relation

F_n = F_{n-1} + F_{n-2}

with the seed values F_0=0 and F_1 = 1.

This recurrence, since it is linear, can be expressed by a closed-form solution known as the Binet’s formula:

Fib(n)=\dfrac{\varphi^n-(1-\varphi)^n}{\sqrt{5}}=\dfrac{\varphi^n-(\frac{-1}{\varphi})^n}{\sqrt{5}}
\varphi=\dfrac{1+\sqrt{5}}{2}\approx1.6180339887\ldots — (The Golden ratio)

Now, why 1-\varphi and \frac{-1}{\varphi} is considered the same, or even why that formula works or looks like that, I will leave as an exercise for the reader (Cause I have no idea :P Please share if you do…). But anyways, as an example, if you put 20 into that formula, you will get 6765 which is the 20th number in the Fibonacci sequence. Fantastic. We could now use that formula to make another brute-force solution to find the term we are after. But that wouldn’t make much sense and would be much much slower. So, we must move on further into this crazy land.

Before we move on to the next part, since we will be working with quite large values of n, we can simplify that expression a bit. That is because \frac{-1}{\varphi}^n will move pretty fast towards 0 as n increases. In other words, we can pretty much just skip that part and use the following formula instead:

Fib(n)=\dfrac{\varphi^n}{\sqrt{5}}

The length of a number

How do you calculate the length of a number? I actually had to do this in an earlier post and then I kind of cheated. I just converted the number into a string and just count the characters (In C#, string.Length). But, I recently discovered that there actually is a way you can do this mathematically! I had no idea… The key lays in the logarithm to base 10.

\log_{10}{n} (often written as just \log{n}) for any 1-digit number will give you 0.something. For any 2-digit number it gives you 1.something, and so on. So a formula for getting the length of any number:

Len(n)=\lfloor\log{n}\rfloor+1

In case you were wondering, those weird square brackets are called the floor function.

The length of a Fibonacci number

Now we are able to calculate the length of a certain Fibonacci number by using the following formula, which I for no good reason will call G:

G(n)=Len(Fib(n))=\lfloor\log{\dfrac{\varphi^n}{\sqrt{5}}}\rfloor+1

There is a problem here though. And the problem is \varphi^n. Why is it a problem? Because it get’s seriously large very quick. A value of around 500 actually makes my calculator overflow and just give me an error.

But fear not! There are a couple of formulas having to do with roots and logarithms that we can use to our advantage:

\sqrt{c}=\sqrt[2]{c}

\sqrt[b]{c}=c^{\frac{1}{b}}

\log_a{\dfrac{b}{c}}=\log_a{b}-\log_a{c}

\log_a{b^c}=c\log_a{b}

With those formulas we can handily rewrite our formula into one that is easier to handle:

G(n)=\lfloor\log{\dfrac{\varphi^n}{\sqrt{5}}}\rfloor+1

G(n)=\lfloor\log{\varphi^n}-\log{5^{\frac{1}{2}}}\rfloor+1

G(n)=\lfloor n\log{\varphi}-\dfrac{\log{5}}{2}\rfloor+1

Tadaa! Now we can push in 20 and get 4. And as we calculated earlier, the 20th Fibonacci number is 6769, which in fact is 4 digits long! Amazing…

The first Fibonacci number with 1000 digits

Now we are almost ready to solve our problem. The formula we have now works perfectly. The only problem is that it’s backwards! We are not looking for the length of a certain Fibonacci number, but rather what Fibonacci number has a certain length. In other words, we want n, not G(n). Luckily, using pretty basic algebra and some guessing, we can make a new formula that finds exactly what we are looking for. (My way of skipping the floor stuff and introducing a ceiling function in the end is purely based on guessing and observation. But it gives the correct answer :P Now, if you know the proper way of handling it, please let me know! )

G(n)=\lfloor n\log{\varphi}-\dfrac{\log{5}}{2}\rfloor+1

n\log{\varphi}=G(n)+\dfrac{\log{5}}{2}-1

n=\lceil\dfrac{G(n)+\dfrac{\log{5}}{2}-1}{\log\varphi}\rceil

Now we can just substitute G(n) with 1000, and calculate n, which should be the answer to this problem!

As usual, I will not put the actual answer here though ;)

This has been the longest blog post yet about these problems, I think, but I must say it was pretty fun to solve this one. I didn’t really get much at first, just saw that the formulas worked, but now that I have written about it and gone through it all step by step, it actually makes sense. Most of it anyways. If you know how to properly handle that floor and ceiling stuff, let me know :P

Anyways, that was it for now! Stay tuned for more good stuff like this :P

]]> http://www.geekality.net/2009/11/06/project-euler-problem-25/feed/ 1 Project Euler: Problem 16 http://www.geekality.net/2009/11/05/project-euler-problem-16/ http://www.geekality.net/2009/11/05/project-euler-problem-16/#comments Thu, 05 Nov 2009 16:46:16 +0000 Torleif http://www.geekality.net/?p=740 Continue reading →]]>

2^{15} = 32768 and the sum of its digits is
3 + 2 + 7 + 6 + 8 = 26.

What is the sum of the digits of the number 2^{1000}?

Solution

With the big integer type IntX (which I added to my project to solve an earlier problem) this one is pretty much as easy as you’d think.

var answer = IntX
        .Pow(2, 1000)
        .ToString()
        .Select(x => x - '0')
        .Sum();

It first does the calculation and then gets the string representation of the result. And in case you were wondering, that would be:

10715086071862673209484250490600018105614048117
05533607443750388370351051124936122493198378815
69585812759467291755314682518714528569231404359
84577574698574803934567774824230985421074605062
37114187795418215304647498358194126739876755916
55439460770629145711964776865421676604298316526
24386837205668069376

And as a comparison, here is the largest number that can be represented using built-in .net types. decimal.MaxValue.

79228162514264337593543950335

As you can see, the first number is kind of bigger than the second :P Aaaanyways, the next bit might be a bit cryptic. But fear not, it is actually quite simple:

  • A string is an array of characters.
  • All characters have a character code (a numeric value).
  • The character codes for the numeric characters (’0′, ’1′, and so on) comes after each other, which means that for example ’1′ has a character code value which is 1 larger than the character code of ’0′.
  • If we take a character code and subtracts it from itself, we get zero. (Thank you captain obvious…)
  • This means that if we subtract ’0′ from ’0′, we get 0. And if we subtract ’0′ from ’5′, we get 5. (Oh, right, clever!)

So, the last two lines in my code simply converts all the characters in the string into actual numbers and then sums them together. Which would get us the answer! Tadaa ^_^

How did you do? Have you found a more interesting solution? Please do share :)

]]> http://www.geekality.net/2009/11/05/project-euler-problem-16/feed/ 0 The Art of Unit Testing http://www.geekality.net/2009/11/03/the-art-of-unit-testing/ http://www.geekality.net/2009/11/03/the-art-of-unit-testing/#comments Tue, 03 Nov 2009 21:04:42 +0000 Torleif http://www.geekality.net/?p=722 Continue reading →]]> The Art of Unit Testing (Book cover)Have you gone through three years of computer science bachelor degree fun (or anything similar) and pretty much not heard a word about testing? Or have you heard from all your teachers that testing is extremely important, but never learned how to even write one? That has been the case for me. Testing is important, you all got to do it, it is very important, always test, do it a lot! Well, sure… but how do I do it? How do I write one of these tests?

The last book I finished is called The Art of Unit Testing, and I am so happy that I stumbled over that book. Spring 2009 I was at a developer conference called NDC 2009 (Norwegian Developer Conference) and it was really great. If you have the time, you should go to that website and have a look. You can watch most of the talks there online. Anyways, the second day I attended a series of talks about Test Driven Development with a great speaker called Roy Osherove. I learned a bunch and decided that TDD looks like something I should try to learn. However, I had a big problem. I didn’t even know how to write a test. And doing TDD without knowing how to write a test is kind of difficult… to say the least…

Anyways, this Roy Osherove person advertised that he had just finished a book about pretty much exactly that; writing unit tests. So, I decided to get myself a copy of it.

It was great! Seriously learned a lot. It covers the following subjects (yes, that would be the table of contents).

  1. The basics of unit testing
  2. A first unit test
  3. Using stubs to break dependencies
  4. Interaction testing using mock objects
  5. Isolation (mock object) frameworks
  6. Test hierarchies and organization
  7. The pillars of good tests
  8. Integrating unit testing into the organization
  9. Design and testability (Appendix A)
  10. Extra tools and frameworks (Appendix B)

It is only 283 pages long (including the appendixes) and a pretty quick and easy read. Which I like. I got sucked in, and it was finished fast. Probably should read it again some time :P But anyways: I previously did not even know how to write a single unit test in any language. Now I do :)

You can get it from for example Manning (who is the publisher) or from Amazon. I would probably get it from Amazon since they seem to have a 34% discount currently… Except I already have it, of course :P

If you want to learn how to do unit testing, I can recommend it with all my heart :)

Oh, by the way, when you buy this book, you even get a free eBook version of it! Which is totally brilliant, since then you can have the book and read it at home, but you can also for example put the eBook version on your netbook and read while travelling. Awesome all the way 8) Wish more publishers or authors (or whoever decides) were like that…

]]> http://www.geekality.net/2009/11/03/the-art-of-unit-testing/feed/ 3