public class ValueType<T> : IComparable, IComparable<ValueType<T>>, IEquatable<ValueType<T>>
 where T : IComparable<T>
{
 protected T Value { get; private set; }public ValueType(T value)
 {
  Value = value;
 }

 public override int GetHashCode()
 {
  return Value.GetHashCode();
 }

 public override string ToString()
 {
  return Value.ToString();
 }

 public override bool Equals(object obj)
 {
  return Equals(obj as ValueType<T>);
 }

 public bool Equals(ValueType<T> other)
 {
  return Compare(this, other) == 0;
 }

 public int CompareTo(object obj)
 {
  return CompareTo(this, obj as ValueType<T>);
 }

 public int CompareTo(ValueType<T> other)
 {
  return Compare(this, other);
 }

 static int Compare(ValueType<T> instance1, ValueType<T> instance2)
 {
  if (ReferenceEquals(instance1, instance2)) return 0;
  if (ReferenceEquals(instance1, null)) return -1;
  if (ReferenceEquals(instance2, null)) return 1;

  if (ReferenceEquals(instance1.Value, instance2.Value)) return 0;
  if (ReferenceEquals(instance1.Value, null)) return -1;
  if (ReferenceEquals(instance2.Value, null)) return 1;

  return instance1.Value.CompareTo(instance2.Value);
 }

 public static bool operator ==(ValueType<T> instance1, ValueType<T> instance2)
 {
  return Compare(instance1, instance2) == 0;
 }

 public static bool operator !=(ValueType<T> instance1, ValueType<T> instance2)
 {
  return !(instance1 == instance2);
 }

 public static bool operator <(ValueType<T> instance1, ValueType<T> instance2)
 {
   return Compare(instance1, instance2) < 0;
 }

 public static bool operator >(ValueType<T> instance1, ValueType<T> instance2)
 {
   return Compare(instance1, instance2) > 0;
 }
}

[Test] public void ShouldBeAbleToGetSeriesOfNumbers()
{
 // Arrange
 var series = 3.To(5);

 // Act
 var elements = series.Elements;

 // Assert
 var expected = new[] { 3, 4, 5 };
 CollectionAssert.AreEqual(expected, elements);
}

[Test] public void ShouldBeAbleToGetSeriesOfDays()
{
 // Arrange
 var now = DateTime.Now.Date;
 var twoDaysLater = now.AddDays(2);
 var series = now.To(twoDaysLater);

 // Act
 var elements = series.Elements;

 // Assert
 var expectedDays = new[] { now, now.AddDays(1), now.AddDays(2) };
 CollectionAssert.AreEqual(expectedDays, elements);
}

And here is the code that makes these tests pass:

public static class Series
{
 public static Series<int> To(this int from, int to)
 {
  return Create(from, to);
 }

 public static Series<DateTime> To(this DateTime from, DateTime to)
 {
  return Create(from, to);
 }

 public static Series<DateTime> Create(DateTime from, DateTime to)
 {
  return new Series<DateTime>(from.Date, to.Date, d => d.AddDays(1));
 }

 public static Series<DateTime> Create(DateTime from, int numberOfDays)
 {
  return Create(from.Date, from.Date.AddDays(numberOfDays));
 }

 public static Series<int> Create(int from, int to)
 {
  return new Series<int>(from, to, n => n + 1);
 }

 public static Series<int> Create(int from, int to, int stepSize)
 {
  return new Series<int>(from, to, n => n + stepSize);
 }
}

public class Series<T> : IEnumerable<T> where T : IComparable
{
 public T From { get; private set; }
 public T To { get; private set; }
 public Func<T, T> Step { get; private set; }

 public Series(T from, T to, Func<T, T> step)
 {
  From = from;
  To = to;
  Step = step;
 }

 public IEnumerable<T> Elements
 {
  get
  {
   var current = From;
   while (current.CompareTo(To) <= 0)
   {
    yield return current;
    current = Step(current);
   }
  }
 }

 public IEnumerator<T> GetEnumerator()
 {
  return Elements.GetEnumerator();
 }

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

Given()
{
 source = new[] { SourceElement };
 destination = new[] { DestinationElement };
}

When()
{
 source.AppendTo(ref destination);
}

ThenTheDestinationShouldStillHaveTheDestinationElement()
{
 Assert.AreEqual(DestinationElement, destination[0]);
}

ThenTheDestinationShouldHaveBeenExtendedWithTheSourceElement()
{
 Assert.AreEqual(SourceElement, destination[1]);
}

And here is the code which satisfies the requirements:

public static class Extensions
{
 public static void AppendTo<T>(this T[] sourceArray, ref T[] destinationArray)
 {
  var sourceLength = sourceArray.Length;
  var destinationLength = destinationArray.Length;
  var extendedLength = destinationLength + sourceLength;
  Array.Resize(ref destinationArray, extendedLength);
  Array.Copy(sourceArray, 0, destinationArray, destinationLength, sourceLength);
 }
}

Perhaps it’s time to start (or does it exist already, cause i can’t find it) an open-source project with extension methods.

 <Grid.Resources>
  <DataTemplate x:Key="CellTemplate">
   <views:CellView />
  </DataTemplate>
 </Grid.Resources>
 <ItemsControl 
   ItemTemplate="{StaticResource CellTemplate}" 
   ItemsSource="{Binding Cells}" />
</Grid>

Because each CellViewModel needs to know which cell they manage i used the following dirty hack:

public CellView() 
{
 Loaded += CellView_Loaded; 
}

void CellView_Loaded(object sender, RoutedEventArgs e) 
{
 DataContext = new CellViewModel(DataContext);
}

Later on that day i realised there was a much cleaner solution: Let the BoardViewModel expose a collection of ViewModels.CellViewModel instead of Model.Cell. What a relief that i don’t have to use the Loaded event hack

Passive View doesn’t work (well) with smart views so i decided to give M-V-VM another because i really wanted to leverage WPF’s rich support for databinding.

The key difference between M-V-VM and Passive View is, imho, the fact that the ViewModel is unaware of the View unlike Passive View where the Presenter knows about the (simple) View.

When we test a Presenter i notice that we end up writing interaction based tests (assertions on a mocked view) and when we test a ViewModel we end up writing state-based tests instead.

if (new HasReachedLevel(10).IsSatisfiedBy(player))
{
 view.DisplayMessage("Congratulations! You have reached level 10.");
}

Pretty good but did you notice that they changed the order of player and level in their (code) story? With the aid of an extension method we can express this requirement as:

if (player.Satisfies(new HasReachedLevel(10)))
{
 view.DisplayMessage("Congratulations! You have reached level 10.");
}

Here is the extension method that allows you to express the requirement in this way:

public static bool Satisfies<T>(this T candidate, ISpecification<T> specification)
{
 return specification.IsSatisfiedBy(candidate);
}

controlStateMachine = new ControlStateMachine<States>(this);

controlStateMachine.AfterEachStateChange()
 .Do(MakeRelevantButtonsVisible);

controlStateMachine.WhenStateChangesTo(States.RetrievingSubscriptionPeriod)
 .TheOnlyVisibleControlsAre(flowLayoutPanel1, datePicker1);

controlStateMachine.WhenStateChangesTo(States.RetrievingCustomerInformation)
 .MakeVisible(customerInput1)
 .Do(() => customerInput1.Dock = DockStyle.Fill);

controlStateMachine.WhenStateChangesTo(States.Ready)
 .MakeInvisible(customerInput1);

And here is another example:

wizardStateMachine = new WizardStateMachine<States>(controlStateMachine);

wizardStateMachine.InState(States.RetrievingSubscriptionPeriod)
 .OnCommand(WizardCommands.Next)
  .TransitionTo(States.RetrievingCustomerInformation);

wizardStateMachine.InState(States.RetrievingCustomerInformation)
 .OnCommand(WizardCommands.Back)
  .TransitionTo(States.RetrievingSubscriptionPeriod)
 .OnCommand(WizardCommands.Finish)
  .TransitionTo(States.Ready);

wizardStateMachine.InState(States.Ready)
 .OnCommand(WizardCommands.New)
  .Do(() => MessageBox.Show("Currently not supported"));

Stay tuned for future posts where i describe the problem space that have lead to this API.

[Fact] public void ShouldDisplayEditClickMessage()
{
 // Establish context
 MockRepository mockRepository = new MockRepository();
 IView view = mockRepository.StrictMock<IView>();
 Expect.Call(delegate { view.EditClick += null; }).IgnoreArguments();
 mockRepository.Replay(view);

 // Create sut
 Presenter sut = new Presenter(view);

 // Setup expectations
 mockRepository.BackToRecord(view, BackToRecordOptions.Expectations);
 Expect.Call(delegate { view.DisplayClickMessage("edit"); });
 mockRepository.ReplayAll();

 // Exercise
 RhinoMocksExtensions
  .GetEventRaiser(view, delegate(IView v) { v.EditClick += null; })
  .Raise(view, EventArgs.Empty);

 // Verify
 mockRepository.VerifyAll();
}

And now we add the feature that displays the message “save” whenever the user clicks on the save button:

[Fact] public void ShouldDisplaySaveClickMessage()
{
 // Establish context
 MockRepository mockRepository = new MockRepository();
 IView view = mockRepository.StrictMock<IView>();
 Expect.Call(delegate { view.EditClick += null; }).IgnoreArguments();
 Expect.Call(delegate { view.SaveClick += null; }).IgnoreArguments();
 mockRepository.Replay(view);

 // Create sut
 Presenter sut = new Presenter(view);

 // Setup expectations
 mockRepository.BackToRecord(view, BackToRecordOptions.Expectations);
 Expect.Call(delegate { view.DisplayClickMessage("save"); });
 mockRepository.ReplayAll();

 // Exercise
 RhinoMocksExtensions
  .GetEventRaiser(view, delegate(IView v) { v.SaveClick += null; })
  .Raise(view, EventArgs.Empty);

  // Verify
  mockRepository.VerifyAll();
 }
}

Although we implemented the feature correctly, and left the code of the first feature untouched, we notice that our ShouldDisplayEditClickMessage test fails because it is not expecting a subscription to the SaveClick event. Imho, this way of testing is a testing anti-pattern.

/// <summary>
/// Represents an element that changes over time. 
/// It consists out of effectivities of that element that are effective in different periods.
/// </summary>
public interface ITemporal<T>
{
 /// <summary>
 /// Modifies the element from the given date.
 /// </summary>
 /// <param name="element"></param>
 /// <param name="from"></param>
 /// <returns></returns>
 void Modify(T element, DateTime from);

 /// <summary>
 /// Gets the effectivity that is valid on the given date.
 /// </summary>
 /// <param name="validityDate">The validity date.</param>
 /// <returns></returns>
 IEffectivity<T> GetSnapshot(DateTime validityDate);

 /// <summary>
 /// Tries to get the effectivity that is valid on the given date.
 /// </summary>
 /// <param name="validityDate"></param>
 /// <param name="effectivity"></param>
 /// <returns></returns>
 bool TryGetSnapshot(DateTime validityDate, out IEffectivity<T> effectivity);
}

In the implementation i have added a constructor that accepts a DiscreteValuesGenerator<DateTime> which makes it possible to create Periods with a resolution of a day instead of seconds.