I’ve had test-first religion for some time now, but deadlines have made me something of a lapsed tester. After finding a pretty bad-ass bug in my code, I got religion again, admitted I was a sinner, and went forward in Testing. I am redeeming myself by writing a few hundred unit tests of already existing code.

My preferred mock framework is Rhino Mocks. Now I’m all about the AAA (Arrange, Act, Assert) syntax. 99.9% of my tests (seriously, I’ve got over a thousand of them) are AAA. Most of my tests are unordered. I just want to test that something was called, and I don’t care what was called before or after it.

But you can’t do AAA syntax when you’re doing ordered tests. It hasn’t been a problem thus far, but I ran into a problem when I started testing objects that hooked up events in the constructor: So my code looked like this:

namespace RhinoMocksOrdredWithEvents {
    public interface IOrderedThing {
        void FirstThing();
        void SecondThing();
        void SomethingElse();
        event EventHandler<EventArgs> OnThingHappened;
    }

    public class MyTestClass {

        private IOrderedThing MyOrderedThing { get; set; }

        public MyTestClass(IOrderedThing orderedThing) {
            MyOrderedThing = orderedThing;
            MyOrderedThing.OnThingHappened += new EventHandler<EventArgs>(MyOrderedThing_OnThingHappened);
            MyOrderedThing.SomethingElse();
        }

        public void DoThingsInOrder() {

            MyOrderedThing.SomethingElse();

            MyOrderedThing.FirstThing();
            MyOrderedThing.SecondThing();
        }

        private void MyOrderedThing_OnThingHappened(object sender, EventArgs e) {
            return;
        }

    }
}

And here’s the test to make sure that FirstThing() and SecondThing() are called in order:

namespace RhinoMocksOrdredWithEvents {
    [TestClass]
    public class OrderedMockTests { 

        [TestMethod]
        public void TestThingsAreRunInOrder() {
            // Arrange
            MockRepository mocks = new MockRepository(); 

            IOrderedThing mockOrderedThing = mocks.DynamicMock<IOrderedThing>(); 

            MyTestClass classUnderTest = new MyTestClass(mockOrderedThing); 

            using (mocks.Record()) {
                using (mocks.Ordered()) {
                    mockOrderedThing.Expect(thing => thing.FirstThing());
                    mockOrderedThing.Expect(thing => thing.SecondThing());
                }
            } 

            mockOrderedThing.Replay(); 

            // Act
            classUnderTest.DoThingsInOrder(); 

            // Assert
            mockOrderedThing.VerifyAllExpectations();
        }
    }
} 

Be not fooled by my spurious use of the //Arange, //Act, and //Assert comments. This is most definitely not the AAA syntax.

So when I tried to run this test, I got the following error:


Test method
RhinoMocksOrdredWithEvents.OrderedMockTests.TestThingsAreRunInOrder
threw exception:
Rhino.Mocks.Exceptions.ExpectationViolationException:
IOrderedThing.add_OnThingHappened(System.EventHandler`1[System.EventArgs]);
Expected #1, Actual #0..


What what what!? I never told Rhino Mocks that I expected the event to be wired! And anyway, it is wired, right there in the constructor, see? Then I comment out the event hookup, and the test works! So off I sauntered to the Rhino Mocks mailing list all like, “Hey guys, I don’t mean to be all smug and stuff, but all y’all got a bug.”

Thankfully, Tim Barcz on the mailing list set me straight.

Yes, Virginia, you can do the AAA syntax in an ordered mock, and this is how you do it:

namespace RhinoMocksOrdredWithEvents {
    [TestClass]
    public class OrderedMockTests {

        [TestMethod]
        public void TestThingsAreRunInOrder() {
            // Arrange
            //MockRepository mocks = new MockRepository();

            IOrderedThing mockOrderedThing = MockRepository.GenerateMock<IOrderedThing>();

            MyTestClass classUnderTest = new MyTestClass(mockOrderedThing);

            mockOrderedThing.GetMockRepository().Ordered();

            mockOrderedThing.Expect(thing => thing.FirstThing());
            mockOrderedThing.Expect(thing => thing.SecondThing());

            // Act
            classUnderTest.DoThingsInOrder();

            // Assert
            mockOrderedThing.VerifyAllExpectations();

        }
    }
}

Which works no matter what strange stuff you want to do in the constructor.

Much thanks to Tim Barcz for setting me straight. Here is the original thread on the Rhino Mocks mailing list.

Geek Content Ahead. Feel Free to Ignore.

Today’s Praxis is on the Goldbach Conjecture which states that any even number greater than 2 can be expressed as the sum of two primes. The challenge is to write a program that will take in an even number, and spit out the two primes that can be added together to make it.

I realize my solution is extremely naive, but it’s the first time in a long time that I’ve actually worked on programming problems other than “get data from database a, transform it somehow, and put it in database b.” Also, for extra difficulty (and speed, although my algorithm is the real speed hangup in this case) I wrote it in C.

For the one or two people still reading, here is my extremely naive solution, cobbled together while watching West Side Story on TCM.

#include <stdio.h>
#include <stdlib.h>

void show_usage();
unsigned long *create_sieve_to_number(unsigned long number);

int main (int argc, const char * argv[]) {

    if (argc != 2) {
		show_usage();
		return -1;
	}

	unsigned long number = atol(argv[1]);

	if ((number % 2) != 0) {
		show_usage();
		return -1;
	}

	unsigned long *sieve = create_sieve_to_number(number);

	for (unsigned long i = 2; i < number; i++) {
		if (sieve[i] == 1) {
			for (unsigned long j = i; j < number; j++) {
				if (sieve[j] == 1) {
					if (i + j == number) {
						printf("Solution found: %d + %d\n", i, j);
						return 0;
					}
				}
			}
		}
	}

	printf("no solution found!  pick up your Fields Medal!\n");

	return 0;

}

void show_usage(void) {
	printf("usage: goldbach [even number]\n");
}

unsigned long *create_sieve_to_number(unsigned long number) {
	unsigned long *sieve;

	sieve = (unsigned long *)malloc(sizeof(unsigned long) * (number + 1));

	for (int i = 0; i < number; i++) {
		sieve[i] = 1;
	}

	for (unsigned long i = 2; i < number; i++) {
		if (sieve[i] == 1) {
			for (unsigned long j = i * i; j < number; j = j + i) {
				sieve[j] = 0;
			}
		}
	}

	return sieve;
}

Edit: See what happens when you’re watching TV when you’re doing your homework? The flags marking numbers as prime can be a bool (or even a bit) and most certainly does not have to be an unsigned long. Yay for massive, massive wastes of memory! (But hey, I was watching West Side Story…)