ZoneCodeGenerator: Add tests for CommandFile statements that are getting interpreted

test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestAlignTest.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.CommandFile;
+using ZoneCodeGenerator.Parsing.CommandFile.Tests;
+using ZoneCodeGenerator.Parsing.Testing;
+
+namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Tests
+{
+    [TestClass]
+    public class TestAlignTest
+    {
+        private Mock<ICommandParserState> parserStateMock;
+
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            parserStateMock = new Mock<ICommandParserState>();
+
+            tokenOffset = 0;
+            tokens = new List<string>();
+            lexerMock = new Mock<ILexer>();
+
+            lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
+                .Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
+            lexerMock.Setup(lexer => lexer.NextToken())
+                .Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
+            lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
+                .Callback((int count) => tokenOffset += count);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsSimpleAlignStatement()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "set", "align", "test", ":", ":", "type", "16", ";"
+            });
+
+            var test = new TestAlign();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(8, test.ConsumedTokenCount);
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestAssetTest.cs

@@ -0,0 +1,176 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator;
+using ZoneCodeGenerator.Domain;
+using ZoneCodeGenerator.Domain.StructureInformation;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.CommandFile;
+using ZoneCodeGenerator.Parsing.CommandFile.Tests;
+using ZoneCodeGenerator.Parsing.Testing;
+using ZoneCodeGenerator.Persistence;
+
+namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Tests
+{
+    [TestClass]
+    public class TestAssetTest
+    {
+        private Mock<IReadOnlyDataRepository> repositoryMock;
+        private Mock<ICommandParserState> parserStateMock;
+
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            parserStateMock = new Mock<ICommandParserState>();
+
+            tokenOffset = 0;
+            tokens = new List<string>();
+            lexerMock = new Mock<ILexer>();
+            repositoryMock = new Mock<IReadOnlyDataRepository>();
+
+            parserStateMock.SetupGet(state => state.Repository)
+                .Returns(() => repositoryMock.Object);
+
+            lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
+                .Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
+            lexerMock.Setup(lexer => lexer.NextToken())
+                .Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
+            lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
+                .Callback((int count) => tokenOffset += count);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsSimpleAssetStatement()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asset", "test", ":", ":", "type", "TEST_TYPE_NUMBER", ";"
+            });
+
+            var test = new TestAsset();
+            var assetStruct = new DataTypeStruct("test", "type", 4);
+            var assetInformation = new StructureInformation(assetStruct);
+
+            var assetEnum = new DataTypeEnum("", "testEnum", DataTypeBaseType.INT);
+            var assetEnumEntry = new EnumMember("TEST_TYPE_NUMBER", 1337);
+            assetEnum.Members.Add(assetEnumEntry);
+
+            repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
+                .Returns(assetStruct);
+            repositoryMock.Setup(repository => repository.GetInformationFor(assetStruct))
+                .Returns(() => assetInformation);
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[]{assetEnum});
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(7, test.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureThrowsExceptionWhenTypeCannotBeFound()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asset", "test", ":", ":", "type", "TEST_TYPE_NUMBER", ";"
+            });
+
+            var test = new TestAsset();
+            var assetStruct = new DataTypeStruct("test", "type", 4);
+            var assetInformation = new StructureInformation(assetStruct);
+
+            var assetEnum = new DataTypeEnum("", "testEnum", DataTypeBaseType.INT);
+            var assetEnumEntry = new EnumMember("TEST_TYPE_NUMBER", 1337);
+            assetEnum.Members.Add(assetEnumEntry);
+
+            repositoryMock.Setup(repository => repository.GetInformationFor(It.IsAny<DataTypeWithMembers>()))
+                .Returns(() => assetInformation);
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[]{assetEnum});
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+        }
+
+        [TestMethod]
+        public void EnsureThrowsExceptionWhenNoInformationForAssetCanBeFound()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asset", "test", ":", ":", "type", "TEST_TYPE_NUMBER", ";"
+            });
+
+            var test = new TestAsset();
+            var assetStruct = new DataTypeStruct("test", "type", 4);
+
+            var assetEnum = new DataTypeEnum("", "testEnum", DataTypeBaseType.INT);
+            var assetEnumEntry = new EnumMember("TEST_TYPE_NUMBER", 1337);
+            assetEnum.Members.Add(assetEnumEntry);
+
+            repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
+                .Returns(assetStruct);
+            repositoryMock.Setup(repository => repository.GetInformationFor(assetStruct))
+                .Returns(() => null);
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[] { assetEnum });
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+        }
+
+        [TestMethod]
+        public void EnsureThrowsExceptionWhenEnumEntryCannotBeFound()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asset", "test", ":", ":", "type", "TEST_TYPE_NUMBER", ";"
+            });
+
+            var test = new TestAsset();
+            var assetStruct = new DataTypeStruct("test", "type", 4);
+            var assetInformation = new StructureInformation(assetStruct);
+
+            var assetEnum = new DataTypeEnum("", "testEnum", DataTypeBaseType.INT);
+            var assetEnumEntry = new EnumMember("NOT_THE_RIGHT_ENTRY", 420);
+            assetEnum.Members.Add(assetEnumEntry);
+
+            repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
+                .Returns(assetStruct);
+            repositoryMock.Setup(repository => repository.GetInformationFor(assetStruct))
+                .Returns(() => assetInformation);
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[]{assetEnum});
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+        }
+
+        [TestMethod]
+        public void EnsureThrowsExceptionWhenAssetIsNotADataTypeWithMembers()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asset", "test", ":", ":", "type", "TEST_TYPE_NUMBER", ";"
+            });
+
+            var test = new TestAsset();
+            var asset = new DataTypeEnum("test", "type", DataTypeBaseType.INT);
+            var assetStruct = new DataTypeStruct("test", "type", 4);
+            var assetInformation = new StructureInformation(assetStruct);
+
+            var assetEnum = new DataTypeEnum("", "testEnum", DataTypeBaseType.INT);
+            var assetEnumEntry = new EnumMember("TEST_TYPE_NUMBER", 1337);
+            assetEnum.Members.Add(assetEnumEntry);
+
+            repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
+                .Returns(asset);
+            repositoryMock.Setup(repository => repository.GetInformationFor(It.IsAny<DataTypeWithMembers>()))
+                .Returns(() => assetInformation);
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[] { assetEnum });
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestBlockTest.cs

@@ -0,0 +1,279 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Domain;
+using ZoneCodeGenerator.Domain.FastFileStructure;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.CommandFile;
+using ZoneCodeGenerator.Parsing.CommandFile.Tests;
+using ZoneCodeGenerator.Parsing.Testing;
+using ZoneCodeGenerator.Persistence;
+
+namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Tests
+{
+    [TestClass]
+    public class TestBlockTest
+    {
+        private Mock<IReadOnlyDataRepository> repositoryMock;
+        private Mock<ICommandParserState> parserStateMock;
+
+        private List<FastFileBlock> fastFileBlocks;
+
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            parserStateMock = new Mock<ICommandParserState>();
+
+            fastFileBlocks = new List<FastFileBlock>();
+
+            tokenOffset = 0;
+            tokens = new List<string>();
+            lexerMock = new Mock<ILexer>();
+            repositoryMock = new Mock<IReadOnlyDataRepository>();
+
+            parserStateMock.SetupGet(state => state.Repository)
+                .Returns(() => repositoryMock.Object);
+
+            lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
+                .Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
+            lexerMock.Setup(lexer => lexer.NextToken())
+                .Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
+            lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
+                .Callback((int count) => tokenOffset += count);
+
+            parserStateMock.SetupGet(state => state.FastFileBlocks)
+                .Returns(() => fastFileBlocks);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsSimpleTempBlockStatement()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "block", "temp", "SomeThing", ";"
+            });
+
+            var test = new TestBlock();
+
+            var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
+            var enumEntry1 = new EnumMember("whatever", 1);
+            var enumEntry2 = new EnumMember("SomeThing", 513);
+            assetTypeEnum.Members.Add(enumEntry1);
+            assetTypeEnum.Members.Add(enumEntry2);
+
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[] { assetTypeEnum });
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(4, test.ConsumedTokenCount);
+
+            Assert.AreEqual(1, fastFileBlocks.Count);
+
+            var block = fastFileBlocks[0];
+
+            Assert.AreEqual("SomeThing", block.Name);
+            Assert.AreEqual(513, block.Index);
+            Assert.AreEqual(FastFileBlock.Type.Temp, block.BlockType);
+            Assert.IsTrue(block.IsTemp);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsSimpleRuntimeBlockStatement()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "block", "runtime", "ASSET_TYPE_RUNTIME", ";"
+            });
+
+            var test = new TestBlock();
+
+            var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
+            var enumEntry1 = new EnumMember("whatever", 1);
+            var enumEntry2 = new EnumMember("ASSET_TYPE_RUNTIME", 11);
+            assetTypeEnum.Members.Add(enumEntry1);
+            assetTypeEnum.Members.Add(enumEntry2);
+
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[] { assetTypeEnum });
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(4, test.ConsumedTokenCount);
+
+            Assert.AreEqual(1, fastFileBlocks.Count);
+
+            var block = fastFileBlocks[0];
+
+            Assert.AreEqual("ASSET_TYPE_RUNTIME", block.Name);
+            Assert.AreEqual(11, block.Index);
+            Assert.AreEqual(FastFileBlock.Type.Runtime, block.BlockType);
+            Assert.IsTrue(block.IsRuntime);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsSimpleDelayBlockStatement()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "block", "delay", "ASSET_TYPE_DELAY", ";"
+            });
+
+            var test = new TestBlock();
+
+            var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
+            var enumEntry1 = new EnumMember("whatever", 1);
+            var enumEntry2 = new EnumMember("ASSET_TYPE_DELAY", 133);
+            assetTypeEnum.Members.Add(enumEntry1);
+            assetTypeEnum.Members.Add(enumEntry2);
+
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[] { assetTypeEnum });
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(4, test.ConsumedTokenCount);
+
+            Assert.AreEqual(1, fastFileBlocks.Count);
+
+            var block = fastFileBlocks[0];
+
+            Assert.AreEqual("ASSET_TYPE_DELAY", block.Name);
+            Assert.AreEqual(133, block.Index);
+            Assert.AreEqual(FastFileBlock.Type.Delay, block.BlockType);
+            Assert.IsTrue(block.IsDelay);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsSimpleNormalBlockStatement()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "block", "normal", "BLOCK_TYPE_LEET", ";"
+            });
+
+            var test = new TestBlock();
+
+            var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
+            var enumEntryBlaze = new EnumMember("BLOCK_TYPE_BLAZE", 420);
+            var enumEntryLeet = new EnumMember("BLOCK_TYPE_LEET", 1337);
+            assetTypeEnum.Members.Add(enumEntryBlaze);
+            assetTypeEnum.Members.Add(enumEntryLeet);
+
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[] { assetTypeEnum });
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(4, test.ConsumedTokenCount);
+
+            Assert.AreEqual(1, fastFileBlocks.Count);
+
+            var block = fastFileBlocks[0];
+
+            Assert.AreEqual("BLOCK_TYPE_LEET", block.Name);
+            Assert.AreEqual(1337, block.Index);
+            Assert.AreEqual(FastFileBlock.Type.Normal, block.BlockType);
+            Assert.IsTrue(block.IsNormal);
+        }
+
+        [TestMethod]
+        public void EnsureDoesNotExceptUnknownTypes()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "block", "unknowntype", "ASSET_TYPE_WHATEVER", ";"
+            });
+
+            var test = new TestBlock();
+
+            var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
+            var enumEntry1 = new EnumMember("whatever", 1);
+            var enumEntry2 = new EnumMember("ASSET_TYPE_WHATEVER", 2);
+            assetTypeEnum.Members.Add(enumEntry1);
+            assetTypeEnum.Members.Add(enumEntry2);
+
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[] { assetTypeEnum });
+
+            Assert.ThrowsException<TestFailedException>(
+                () => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+        }
+
+        [TestMethod]
+        public void EnsureDoesNotSetDefaultBlockWhenNotSpecified()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "block", "normal", "ASSET_TYPE_BLOCK", ";"
+            });
+
+            var test = new TestBlock();
+
+            var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
+            var enumEntry = new EnumMember("ASSET_TYPE_BLOCK", 5);
+            assetTypeEnum.Members.Add(enumEntry);
+
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[] { assetTypeEnum });
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(4, test.ConsumedTokenCount);
+
+            Assert.AreEqual(1, fastFileBlocks.Count);
+
+            var block = fastFileBlocks[0];
+            Assert.IsFalse(block.IsDefault);
+        }
+
+        [TestMethod]
+        public void EnsureDoesSetDefaultBlockWhenSpecified()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "block", "normal", "ASSET_TYPE_BLOCK", "default", ";"
+            });
+
+            var test = new TestBlock();
+
+            var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
+            var enumEntry = new EnumMember("ASSET_TYPE_BLOCK", 5);
+            assetTypeEnum.Members.Add(enumEntry);
+
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[] { assetTypeEnum });
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(5, test.ConsumedTokenCount);
+
+            Assert.AreEqual(1, fastFileBlocks.Count);
+
+            var block = fastFileBlocks[0];
+            Assert.IsTrue(block.IsDefault);
+        }
+
+        [TestMethod]
+        public void EnsureThrowsExceptionWhenEnumEntryCannotBeFound()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "block", "normal", "ASSET_TYPE_BLOCK", ";"
+            });
+
+            var test = new TestBlock();
+
+            var assetTypeEnum = new DataTypeEnum("", "AssetTypeEnum", DataTypeBaseType.INT);
+            var enumEntry1 = new EnumMember("whatever", 1);
+            var enumEntry2 = new EnumMember("ASSET_TYPE_SOMETHING_ELSE", 6);
+            assetTypeEnum.Members.Add(enumEntry1);
+            assetTypeEnum.Members.Add(enumEntry2);
+
+            repositoryMock.Setup(repository => repository.GetAllEnums())
+                .Returns(() => new[] { assetTypeEnum });
+
+            Assert.ThrowsException<TestFailedException>(
+                () => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestGameTest.cs

@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.CommandFile;
+using ZoneCodeGenerator.Parsing.CommandFile.Tests;
+using ZoneCodeGenerator.Parsing.Testing;
+using ZoneCodeGenerator.Persistence;
+
+namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Tests
+{
+    [TestClass]
+    public class TestGameTest
+    {
+        private Mock<IReadOnlyDataRepository> repositoryMock;
+        private Mock<ICommandParserState> parserStateMock;
+
+        private string game;
+
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            parserStateMock = new Mock<ICommandParserState>();
+
+            game = "";
+
+            tokenOffset = 0;
+            tokens = new List<string>();
+            lexerMock = new Mock<ILexer>();
+            repositoryMock = new Mock<IReadOnlyDataRepository>();
+
+            parserStateMock.SetupGet(state => state.Repository)
+                .Returns(() => repositoryMock.Object);
+
+            lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
+                .Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
+            lexerMock.Setup(lexer => lexer.NextToken())
+                .Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
+            lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
+                .Callback((int count) => tokenOffset += count);
+
+            parserStateMock.SetupGet(state => state.Game)
+                .Returns(() => game);
+            parserStateMock.SetupSet(state => state.Game = It.IsAny<string>())
+                .Callback((string s) => game = s);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsSimpleGameStatement()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "game", "asdf", ";"
+            });
+
+            var test = new TestGame();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(3, test.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureDoesNotAcceptMultipleGameStatements()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "game", "asdf", ";"
+            });
+
+            game = "alreadyAssignment";
+
+            var test = new TestGame();
+
+            Assert.ThrowsException<TestFailedException>(
+                () => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestUseTest.cs

@@ -0,0 +1,113 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Domain;
+using ZoneCodeGenerator.Domain.FastFileStructure;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.CommandFile;
+using ZoneCodeGenerator.Parsing.CommandFile.Tests;
+using ZoneCodeGenerator.Parsing.Testing;
+using ZoneCodeGenerator.Persistence;
+
+namespace ZoneCodeGeneratorTests.Parsing.CommandFile.Tests
+{
+    [TestClass]
+    public class TestUseTest
+    {
+        private Mock<IReadOnlyDataRepository> repositoryMock;
+        private Mock<ICommandParserState> parserStateMock;
+
+        private DataTypeWithMembers dataTypeWithMembers;
+
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            parserStateMock = new Mock<ICommandParserState>();
+
+            dataTypeWithMembers = null;
+
+            tokenOffset = 0;
+            tokens = new List<string>();
+            lexerMock = new Mock<ILexer>();
+            repositoryMock = new Mock<IReadOnlyDataRepository>();
+
+            parserStateMock.SetupGet(state => state.Repository)
+                .Returns(() => repositoryMock.Object);
+
+            lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny<int>()))
+                .Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset));
+            lexerMock.Setup(lexer => lexer.NextToken())
+                .Returns(() => tokens.ElementAtOrDefault(tokenOffset++));
+            lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny<int>()))
+                .Callback((int count) => tokenOffset += count);
+
+            parserStateMock.SetupGet(state => state.DataTypeInUse)
+                .Returns(() => dataTypeWithMembers);
+            parserStateMock.SetupSet(state => state.DataTypeInUse = It.IsAny<DataTypeWithMembers>())
+                .Callback((DataTypeWithMembers type) => dataTypeWithMembers = type);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsSimpleUseStatement()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "use", "test", ":", ":", "type", ";"
+            });
+
+            var test = new TestUse();
+
+            var assetTypeToUse = new DataTypeStruct("test", "type", 4);
+
+            repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
+                .Returns(() => assetTypeToUse);
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(6, test.ConsumedTokenCount);
+
+            Assert.AreEqual(assetTypeToUse, dataTypeWithMembers);
+        }
+
+        [TestMethod]
+        public void EnsureThrowsExceptionWhenTypeIsNotFound()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "use", "test", ":", ":", "type", ";"
+            });
+
+            var test = new TestUse();
+
+            Assert.ThrowsException<TestFailedException>(
+                () => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+        }
+
+        [TestMethod]
+        public void EnsureThrowsExceptionWhenTypeIsNotDataTypeWithMembers()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "use", "test", ":", ":", "type", ";"
+            });
+
+            var test = new TestUse();
+
+            var _enum = new DataTypeEnum("test", "type", DataTypeBaseType.INT);
+            var enumEntry1 = new EnumMember("ENTRY_ONE", 1);
+            var enumEntry2 = new EnumMember("ENTRY_TWO", 2);
+            _enum.Members.Add(enumEntry1);
+            _enum.Members.Add(enumEntry2);
+
+            repositoryMock.Setup(repository => repository.GetDataTypeByName("test::type"))
+                .Returns(() => _enum);
+
+            Assert.ThrowsException<TestFailedException>(
+                () => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+        }
+    }
+}