A Test Driven Development Tutorial in C# 4.0

• Add the following below the TestCannonShootAngleIncorrect method

  [TestMethod]
  public void TestCannonShootVelocityGreaterThanSpeedOfLight()
  {
  var shot = cannon.Shoot(45, 300000001);
  Assert.IsFalse(shot.Item1);
  }

• So we run the tests and it will fail RED because the validation isn't complete in the Shoot method . We add the code needed into shoot method just under the validation code for the incorrect angle:

  if (velocity > 300000000)
  {
  return Tuple.Create(false, "Velocity of the cannon cannot travel faster than the speed of light");
  }

• Run the tests again and this time they all pass - GREEN
• Time to refactor, but this time lets use a new feature in VS2010 that allows us to determine the impact of a code change on the Test project.
• Select from the menu TEST->Windows->Test Impact View :
  
  
• The Test Impact View will appear on the right of your IDE and if you haven't used Test Impact View yet you will see:
  
  
• Click the Enable test impact data collection in the active test settings link and then select OK on the next dialog. You must do this for each solution you use test impact view.
• Build and Run CTRL-F5 all the tests and again they should all pass. Time to refactor.
• Now add a constant (readonly int) for the speed of light and then ensure the code in the shoot method refers to the constant ie:
  
  private readonly int MAXVELOCITY = 300000000;
  And
  if (velocity > MAXVELOCITY)
  {
  return Tuple.Create(false, "Velocity of the cannon cannot travel faster than the speed of light");
  }
• Now build the project and have a look at the Test Impact View:
  
  

• Target Distance is simply the distance of the Cannon to Target, and is created randomly by default but can be overridden;
• Max distance for target is 20000 meters;
• Base the algorithm for the calculation of the cannons trajectory upon the following C# code (distance and height is meters and velocity is meters per second):
  • distance = velocity * Math.Cos(angleInRadians) * time;
  • height = (velocity * Math.Sin(angleInRadians) * time) - (GRAVITY * Math.Pow(time, 2)) / 2;
• A hit occurs if the cannon is within 50m of the target;

• So lets add the tests:

  [TestMethod]
  public void TestCannonShootMiss()
  {
  cannon.SetTarget(4000);
  var shot = cannon.Shoot(45, 350);
  Assert.IsTrue(shot.Item2 == "Missed cannonball landed at 12621 meters");
  }
  [TestMethod]
  public void TestCannonShootHit()
  {
  cannon.SetTarget(12621);
  var shot = cannon.Shoot(45, 350);
  Assert.IsTrue(shot.Item2 == "Hit");
  }

• This will not compile so we can right click SetTarget and select Generate Method Stub.
• Run the tests and of course the last two tests fail
• We need to some changes to make it succeed, add this private variable and readonly int to the class:

  private int distanceOfTarget;
  private readonly double GRAVITY = 9.8;

• below the validation code replace
  
  return Tuple.Create(true, "Angle OK"); //Not going to do //the calculation just yet
  with:
  string message;
  bool hit;
  int distanceOfShot = CalculateDistanceOfCannonShot(angle, velocity);
  if (distanceOfShot == distanceOfTarget)
  {
  message = "Hit";
  hit = true;
  }
  else
  {
  message = String.Format("Missed cannonball landed at {0} meters", distanceOfShot);
  hit = false;
  }
  return Tuple.Create(hit, message);
• and then we create another method

  public int CalculateDistanceOfCannonShot(int angle, int velocity)
  {
  int time = 0;
  double height = 0;
  double distance = 0;
  double angleInRadians = (3.1415926536 / 180) * angle;
  while (height >= 0)
  {
  time++;
  distance = velocity * Math.Cos(angleInRadians) * time;
  height = (velocity * Math.Sin(angleInRadians) * time) - (GRAVITY * Math.Pow(time, 2)) / 2;
  }
  return (int)distance;
  }

• Now Compile and run the tests and they will fail - because we are throwing an exception in SetTarget so lets change SetTarget to :

  public void SetTarget(int distanceOfTarget)
  {
  this.distanceOfTarget = distanceOfTarget;
  }

• Run the tests again and now they all pass GREEN. Time to refactor.
• Lets add some code to the constructor of the cannon class to randomly set it

  private Cannon()
  {
  //by default we setup a random target
  Random r = new Random();
  SetTarget(r.Next(MAXDISTANCEOFTARGET));
  }

• and a constant for MAXDISTANCEOFTARGET

  private readonly int MAXDISTANCEOFTARGET = 20000;

• Make sure DistanceOfTarget is now a property:

  public int DistanceOfTarget
  {
  get { return distanceOfTarget; }
  set { distanceOfTarget = value; }
  }

• And now SetTarget can change to:

  public void SetTarget(int distanceOfTarget)
  {
  if (!distanceOfTarget.Between(0, MAXDISTANCEOFTARGET))
  {
  throw new ApplicationException(String.Format("Target distance must be between 1 and {0} meters", MAXDISTANCEOFTARGET));
  }
  this.distanceOfTarget = distanceOfTarget;
  }

• And we need to include the burst radius code in the Shoot method which will replace:

  if (distanceOfShot == distanceOfTarget)

• With

  if (distanceOfShot.WithinRange(this.distanceOfTarget, BURSTRADIUS))

• and a couple of important changes here
  • We are using an extension method to provide a number of additional functions to ints.
  • To add an extension method we follow the following steps:
    • Add a class to the console project
    • Call it ExtensionMethods.cs
    • Enter the following code:

    using System;
    namespace System
    {
    public static class ExtensionMethods
    {
    public static bool Between(this int source, int min, int max)
    {
    return (source >= min && source <= max);
    }
    public static bool WithinRange(this int source, int target, int offset)
    {
    return (target.Between(source - offset, source + offset));
    }
    }
    }
    

  • We also need a BURSTRADIUS constant added to the class:

    private readonly int BURSTRADIUS = 50;

• insert this after the last test.

  [TestMethod]
  public void TestCannonCountShots()
  {
  cannon.SetTarget(12621);
  var shot = cannon.Shoot(45, 350);
  Assert.IsTrue(shot.Item2 == "Hit - 1 Shot(s)", "Number of shots:" + cannon.Shots);
  }
  
  This will not compile because Shots doesn't exist yet.

• Right click on the Shots property and select Generate->Property
• Run the tests again and you will see this fail so lets make some changes to Cannon including:
  • Change the property for Shots to:

    public int Shots
    {
    get
    {
    return shots;
    }
    }

  • Add a field to the class

    private int shots;

  • Initialise the variable in the constructor. It should now look like:

    private Cannon()
    {
    //by default we setup a random target
    Random r = new Random();
    SetTarget(r.Next((int)MAXDISTANCEOFTARGET));
    }

  • Increment the shot count in the shoot method - insert this after the validation for the speed of light:
    
    shots ++;
  • Change the message of the hit to:
    message = String.Format("Hit - {0} Shot(s)", shots);
• Run the tests again we see the following:
  
  

• Add the following to Cannon.cs:

  public void Reset()
  {
  shots = 0;
  }

• The way we can use this in our tests is by using a method that is being called before every test. Add the following method to CannonAttackTest

  [TestInitialize]
  public void ResetCannonObject()
  {
  cannon.Reset();
  }

• Let's change the original for test for the hit to:

  [TestMethod]
  public void TestCannonShootHit()
  {
  cannon.SetTarget(12621);
  var shot = cannon.Shoot(45, 350);
  Assert.IsTrue(shot.Item2 == "Hit - 1 Shot(s)");
  }

• Run the tests CTRL-F5. They will all pass:
  
  

• Set the CannonAttack console project as the startup project
• Add the following code to the CannonAttack.cs file

using System;
namespace CannonAttack
{
class CannonAttack
{
private static readonly int MaxNumberOfShots = 50;
static void Main(string[] args)
{
Console.WriteLine("Welcome to CannonAttack");
bool isStillPlaying = true;
while (isStillPlaying)
{
bool isAHit = false;
Cannon cannon = Cannon.GetInstance();
while (!isAHit && cannon.Shots < MaxNumberOfShots)
{
int angle;
int velocity;
Console.WriteLine(String.Format("Target is at {0} meters", cannon.DistanceOfTarget));
GetInputVariable(out angle, out velocity);
var shot = cannon.Shoot(angle, velocity);
isAHit = shot.Item1;
Console.WriteLine(shot.Item2);
}
isStillPlaying = GetIsPlayingAgain();
cannon.Reset();
}
Console.WriteLine("Thanks for playing Cannon Attack");
}
}
}

This is the core of the application and it should provide the main basis for the cannon attack application.

Below are the additional helper methods that are needed, so add them in underneath the main method:

private static bool GetIsPlayingAgain()
{
bool isPlayingAgain = false;
bool validAnswer = false;
while (!validAnswer)
{
Console.Write("Do you want to play again (y/n)?");
string playAgain = Console.ReadLine();
if (playAgain == "y" || playAgain == "Y")
{
isPlayingAgain = true;
validAnswer = true;
}
if (playAgain == "n" || playAgain == "N")
{
isPlayingAgain = false;
validAnswer = true;
}
}
return isPlayingAgain;
}
private static void GetInputVariable(out int angle, out int velocity)
{
string angleBuffer;
string velocityBuffer;
Console.Write(String.Format("Enter Angle ({0}-{1}):", Cannon.MINANGLE, Cannon.MAXANGLE));
angleBuffer = Console.ReadLine();
if (!int.TryParse(angleBuffer, out angle))
{
Console.WriteLine("Not a number, defaulting to 45");
angle = 45;
}
Console.Write("Enter Velocity (meters per second):");
velocityBuffer = Console.ReadLine();
if (!int.TryParse(velocityBuffer, out velocity))
{
Console.WriteLine("Not a number, defaulting to 100 meters per second");
velocity = 100;
}
}

Now you should be able to run the application and it should work displaying the output similar to what we defined on page 2 and should look like:

This is the End

That's it - your first TDD project is complete!!!. The next tutorial will introduce a number of new areas of functionality including:

• Multiplayer; and
• Mountains.

• Head First Design Patterns, Freeman and Freeman, O'Reilly, 2004.
• Effective C# 50 Specific Ways to improve your C#, Bill Wagner, Addison -Wesley,2005.
• Trajectory Calculation Code: http://forums.macrumors.com/showthread.php?t=180810
• http://www.mdsn.microsoft.com/