ActorInfoTest fixup with new ActorInfo ctor

OpenRA.Game/GameRules/ActorInfo.cs

@@ -67,6 +67,13 @@ namespace OpenRA
 			}
 		}
 
+		public ActorInfo(string name, params ITraitInfo[] traitInfos)
+		{
+			Name = name;
+			foreach (var t in traitInfos)
+				Traits.Add(t);
+		}
+
 		static Dictionary<string, MiniYaml> GetParents(MiniYaml node, Dictionary<string, MiniYaml> allUnits)
 		{
 			return node.Nodes.Where(n => n.Key == "Inherits" || n.Key.StartsWith("Inherits@"))

OpenRA.Test/OpenRA.Game/ActorInfoTest.cs

@@ -18,48 +18,40 @@ using OpenRA.Traits;
 
 namespace OpenRA.Test
 {
+	interface IMock : ITraitInfo { }
+	class MockTraitInfo : ITraitInfo { public object Create(ActorInitializer init) { return null; } }
+	class MockInheritInfo : MockTraitInfo { }
+	class MockAInfo : MockInheritInfo, IMock { }
+	class MockBInfo : MockTraitInfo, Requires<MockAInfo>, Requires<IMock>, Requires<MockInheritInfo> { }
+	class MockCInfo : MockTraitInfo, Requires<MockBInfo> { }
+	class MockDInfo : MockTraitInfo, Requires<MockEInfo> { }
+	class MockEInfo : MockTraitInfo, Requires<MockFInfo> { }
+	class MockFInfo : MockTraitInfo, Requires<MockDInfo> { }
+
 	[TestFixture]
 	public class ActorInfoTest
 	{
-		ActorInfo actorInfo;
-		Dictionary<string, MiniYaml> allUnits;
-
-		interface IMock : ITraitInfo { }
-		class MockTrait : ITraitInfo { public object Create(ActorInitializer init) { return null; } }
-		class MockInherit : MockTrait { }
-		class MockA : MockInherit, IMock { }
-		class MockB : MockTrait, Requires<MockA>, Requires<IMock>, Requires<MockInherit> { }
-		class MockC : MockTrait, Requires<MockB> { }
-		class MockD : MockTrait, Requires<MockE> { }
-		class MockE : MockTrait, Requires<MockF> { }
-		class MockF : MockTrait, Requires<MockD> { }
-
 		[SetUp]
 		public void SetUp()
 		{
-			allUnits = new Dictionary<string, MiniYaml>();
-			actorInfo = new ActorInfo("", new MiniYaml(""), allUnits);
 		}
 
 		[TestCase(TestName = "Sort traits in order of dependency")]
 		public void TraitsInConstructOrderA()
 		{
-			actorInfo.Traits.Add(new MockC());
+			var actorInfo = new ActorInfo("test", new MockCInfo(), new MockBInfo(), new MockAInfo());
-			actorInfo.Traits.Add(new MockB());
-			actorInfo.Traits.Add(new MockA());
 
 			var i = new List<ITraitInfo>(actorInfo.TraitsInConstructOrder());
 
-			Assert.That(i[0], Is.InstanceOf<MockA>());
+			Assert.That(i[0], Is.InstanceOf<MockAInfo>());
-			Assert.That(i[1], Is.InstanceOf<MockB>());
+			Assert.That(i[1].GetType().Name, Is.EqualTo("MockBInfo"));
-			Assert.That(i[2], Is.InstanceOf<MockC>());
+			Assert.That(i[2].GetType().Name, Is.EqualTo("MockCInfo"));
 		}
 
 		[TestCase(TestName = "Exception reports missing dependencies")]
 		public void TraitsInConstructOrderB()
 		{
-			actorInfo.Traits.Add(new MockB());
+			var actorInfo = new ActorInfo("test", new MockBInfo(), new MockCInfo());
-			actorInfo.Traits.Add(new MockC());
 
 			try
 			{
@@ -79,9 +71,7 @@ namespace OpenRA.Test
 		[TestCase(TestName = "Exception reports cyclic dependencies")]
 		public void TraitsInConstructOrderC()
 		{
-			actorInfo.Traits.Add(new MockD());
+			var actorInfo = new ActorInfo("test", new MockDInfo(), new MockEInfo(), new MockFInfo());
-			actorInfo.Traits.Add(new MockE());
-			actorInfo.Traits.Add(new MockF());
 
 			try
 			{