view API/Factories/Requirement/UnitRequiresNUnitsForMUnitsRequirementFactoryTest.cs @ 208:c323770e61c2

Re #379: Fix validation of requirements to check for unit * Rename classes in tests to match API changes * Alter tests to match new API (all classes require at least one UnitType that they're relevant to now)
author IBBoard <dev@ibboard.co.uk>
date Wed, 22 Feb 2012 20:48:40 +0000
parents 43b571aa4124
children e173c5512067
line wrap: on
line source

// This file (UnitUnitRequiresNUnitsForMUnitsRequirementFactoryTest.cs) is a part of the IBBoard.WarFoundry.API.Tests project and is copyright 2011 IBBoard
// 
// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
using System;
using NUnit.Framework;
using IBBoard.WarFoundry.API.Objects.Mock;
using NUnit.Framework.SyntaxHelpers;
using IBBoard.WarFoundry.API.Objects;
using IBBoard.WarFoundry.API.Objects.Requirement;
using IBBoard.WarFoundry.API.Factories.Mock;

namespace IBBoard.WarFoundry.API.Factories.Requirement
{
	[TestFixture()]
	public class UnitRequiresNUnitsForMUnitsRequirementFactoryTest
	{
		private static Race race;
		private static string typeID1 = "unit1";
		private static string typeID2 = "unit2";
		private static string typeID3 = "unit3";
		private static UnitType unitType1;
		private static UnitType unitType2;
		private static UnitType unitType3;
		private static MockRaceFactory raceFactory = new MockRaceFactory();

		[TestFixtureSetUp()]
		public void Setup()
		{
			race = new MockRace();
			unitType1 = new UnitType(typeID1, "Unit 1", race);
			race.AddUnitType(unitType1);
			unitType2 = new UnitType(typeID2, "Unit 2", race);
			race.AddUnitType(unitType2);
			unitType3 = new UnitType(typeID3, "Unit 3", race);
			race.AddUnitType(unitType3);
		}

		[Test()]
		public void TestCreatesRequirement()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			Assert.That(factory.CreateRequirement(unitType2, typeID1, raceFactory), Is.Not.Null);
		}

		[Test()]
		public void TestCreatesCorrectRequirement()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1);
			IRequirement req = factory.CreateRequirement(unitType, typeID1, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForTwoIDs()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1);
			expectedReq.AddUnitTypeRequirement(unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + "|" + typeID2, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForThreeIDs()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1);
			expectedReq.AddUnitTypeRequirement(unitType2);
			expectedReq.AddUnitTypeRequirement(unitType3);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + "|" + typeID2 + "|" + typeID3, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementWithNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, 2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ":2", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementWithTwoNumbers()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, 2, 3);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ":2;3", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForTwoIDsWithTwoNumbers()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, 2);
			expectedReq.AddUnitTypeRequirement(unitType2, 3);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ":2|" + typeID2 + ":3", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForTwoIDsWithOneNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, 2);
			expectedReq.AddUnitTypeRequirement(unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ":2|" + typeID2, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForTwoIDsWithOtherNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1);
			expectedReq.AddUnitTypeRequirement(unitType2, 3);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + "|" + typeID2 + ":3", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		[ExpectedException(typeof(InvalidRequirementException), ExpectedMessage="Invalid unit type 'fibble' for 'Requires N units for M units' requirement")]
		public void TestExceptionsForInvalidID()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			factory.CreateRequirement(unitType, "fibble", raceFactory);
		}

		[Test()]
		[ExpectedException(typeof(InvalidRequirementException), ExpectedMessage="Invalid allowed amount 'a' for unit types 'unit1' for 'Requires N units for M units' requirement")]
		public void TestExceptionsForInvalidNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			factory.CreateRequirement(unitType, typeID1 + ":a", raceFactory);
		}

		[Test()]
		[ExpectedException(typeof(InvalidRequirementException), ExpectedMessage="Invalid allowed amount 'a' for unit types 'unit1' for 'Requires N units for M units' requirement")]
		public void TestExceptionsForInvalidAllowedNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			factory.CreateRequirement(unitType, typeID1 + ":3;a", raceFactory);
		}

		[Test()]
		[ExpectedException(typeof(InvalidRequirementException), ExpectedMessage="Invalid minimum amount 'a' for unit types 'unit1' for 'Requires N units for M units' requirement")]
		public void TestExceptionsForInvalidMinimumNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			factory.CreateRequirement(unitType, typeID1 + ":a;3", raceFactory);
		}

		[Test()]
		public void TestCreatesCorrectAdditiveRequirement()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectTripleAdditiveRequirement()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, unitType2, unitType3);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ";" + typeID3, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectAdditiveRequirementForTwoIDs()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, unitType2);
			expectedReq.AddUnitTypeRequirement(unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + "|" + typeID2, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectAdditiveRequirementWithNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(2, unitType1, unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ":2", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectAdditiveRequirementWithTwoNumbers()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(2, 3, unitType1, unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ":2;3", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectAdditiveRequirementForTwoIDsWithTwoNumbers()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(2, unitType1, unitType2);
			expectedReq.AddUnitTypeRequirement(3, unitType2, unitType1);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ":2|" + typeID2 + ";" + typeID1 + ":3", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectAdditiveRequirementForTwoIDsWithOneNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(2, unitType1, unitType2);
			expectedReq.AddUnitTypeRequirement(unitType2, unitType1);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ":2|" + typeID2 + ";" + typeID1, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectAdditiveRequirementForTwoIDsWithOtherNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, unitType2);
			expectedReq.AddUnitTypeRequirement(3, unitType2, unitType1);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + "|" + typeID2 + ";" + typeID1 + ":3", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDAndOneAdditive()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, unitType2);
			expectedReq.AddUnitTypeRequirement(unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + "|" + typeID2, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDAndOneAdditiveInOtherOrder()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType2);
			expectedReq.AddUnitTypeRequirement(unitType1, unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID2 + "|" + typeID1 + ";" + typeID2, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDWithNumberAndOneAdditive()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, unitType2);
			expectedReq.AddUnitTypeRequirement(unitType2, 3);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + "|" + typeID2 + ":3", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDWithNumberAndOneAdditiveInOtherOrder()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType2, 3);
			expectedReq.AddUnitTypeRequirement(unitType1, unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID2 + ":3|" + typeID1 + ";" + typeID2, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDAndOneAdditiveWithNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(3, unitType1, unitType2);
			expectedReq.AddUnitTypeRequirement(unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ":3|" + typeID2, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDAndOneAdditiveWithNumberInOtherOrder()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType2);
			expectedReq.AddUnitTypeRequirement(3, unitType1, unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID2 + "|" + typeID1 + ";" + typeID2 + ":3", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDWithMinAndAllowedAndOneAdditive()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType1, unitType2);
			expectedReq.AddUnitTypeRequirement(3, 2, unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + "|" + typeID2 + ":3;2", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDWithMinAndAllowedAndOneAdditiveInOtherOrder()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(3, 2, unitType2);
			expectedReq.AddUnitTypeRequirement(unitType1, unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID2 + ":3;2|" + typeID1 + ";" + typeID2, raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDWithNumberAndOneAdditiveWithMinAndAllowed()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(3, 2, unitType1, unitType2);
			expectedReq.AddUnitTypeRequirement(unitType2, 3);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ":3;2|" + typeID2 + ":3", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDWithNumberAndOneAdditiveWithMinAndAllowedInOtherOrder()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType2, 3);
			expectedReq.AddUnitTypeRequirement(3, 2, unitType1, unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID2 + ":3|" + typeID1 + ";" + typeID2 + ":3;2", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDWithMinAndAllowedAndOneAdditiveWithNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(3, unitType1, unitType2);
			expectedReq.AddUnitTypeRequirement(unitType2, 3, 2);
			IRequirement req = factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ":3|" + typeID2 + ":3;2", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		public void TestCreatesCorrectRequirementForOneIDWithMinAndAllowedAndOneAdditiveWithNumberInOtherOrder()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			UnitRequiresNUnitsForMUnitsRequirement expectedReq = new UnitRequiresNUnitsForMUnitsRequirement(unitType);
			expectedReq.AddUnitTypeRequirement(unitType2, 3, 2);
			expectedReq.AddUnitTypeRequirement(3, unitType1, unitType2);
			IRequirement req = factory.CreateRequirement(unitType, typeID2 + ":3;2|" + typeID1 + ";" + typeID2 + ":3", raceFactory);
			Assert.That(req, Is.EqualTo(expectedReq));
		}

		[Test()]
		[ExpectedException(typeof(InvalidRequirementException), ExpectedMessage="Invalid unit type 'fibble' for 'Requires N units for M units' requirement")]
		public void TestExceptionsForAdditiveRequirementWithInvalidID()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			factory.CreateRequirement(unitType, "fibble;" + typeID1, raceFactory);
		}

		[Test()]
		[ExpectedException(typeof(InvalidRequirementException), ExpectedMessage="Invalid unit type 'fibble' for 'Requires N units for M units' requirement")]
		public void TestExceptionsForAdditiveRequirementWithOtherInvalidID()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			factory.CreateRequirement(unitType, typeID1 + ";fibble", raceFactory);
		}

		[Test()]
		[ExpectedException(typeof(InvalidRequirementException), ExpectedMessage="Invalid allowed amount 'a' for unit types 'unit1;unit2' for 'Requires N units for M units' requirement")]
		public void TestExceptionsForAdditiveRequirementWithInvalidNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ":a", raceFactory);
		}

		[Test()]
		[ExpectedException(typeof(InvalidRequirementException), ExpectedMessage="Invalid allowed amount 'a' for unit types 'unit1;unit2' for 'Requires N units for M units' requirement")]
		public void TestExceptionsForAdditiveRequirementWithInvalidAllowedNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ":3;a", raceFactory);
		}

		[Test()]
		[ExpectedException(typeof(InvalidRequirementException), ExpectedMessage="Invalid minimum amount 'a' for unit types 'unit1;unit2' for 'Requires N units for M units' requirement")]
		public void TestExceptionsForAdditiveRequirementWithInvalidMinimumNumber()
		{
			UnitRequiresNUnitsForMUnitsRequirementFactory factory = new UnitRequiresNUnitsForMUnitsRequirementFactory();
			UnitType unitType = new UnitType("testUnit", "Test Unit", race);
			factory.CreateRequirement(unitType, typeID1 + ";" + typeID2 + ":a;3", raceFactory);
		}
	}
}