From d1e097bbdfa3b2ffea7531aecf57fdfee8eda2c8 Mon Sep 17 00:00:00 2001 From: Jan Date: Wed, 30 Oct 2019 20:29:16 +0100 Subject: [PATCH] ZoneCodeGenerator: Add tests for CommandFile statements that are getting interpreted --- .../CommandFile/Tests/TestAlignTest.cs | 52 ++++ .../CommandFile/Tests/TestAssetTest.cs | 176 +++++++++++ .../CommandFile/Tests/TestBlockTest.cs | 279 ++++++++++++++++++ .../Parsing/CommandFile/Tests/TestGameTest.cs | 83 ++++++ .../Parsing/CommandFile/Tests/TestUseTest.cs | 113 +++++++ 5 files changed, 703 insertions(+) create mode 100644 test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestAlignTest.cs create mode 100644 test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestAssetTest.cs create mode 100644 test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestBlockTest.cs create mode 100644 test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestGameTest.cs create mode 100644 test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestUseTest.cs diff --git a/test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestAlignTest.cs b/test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestAlignTest.cs new file mode 100644 index 00000000..146a8ba3 --- /dev/null +++ b/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 parserStateMock; + + private Mock lexerMock; + private int tokenOffset; + private List tokens; + + [TestInitialize] + public void Setup() + { + parserStateMock = new Mock(); + + tokenOffset = 0; + tokens = new List(); + lexerMock = new Mock(); + + lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny())) + .Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset)); + lexerMock.Setup(lexer => lexer.NextToken()) + .Returns(() => tokens.ElementAtOrDefault(tokenOffset++)); + lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny())) + .Callback((int count) => tokenOffset += count); + } + + [TestMethod] + public void EnsureAcceptsSimpleAlignStatement() + { + tokens.AddRange(new List + { + "set", "align", "test", ":", ":", "type", "16", ";" + }); + + var test = new TestAlign(); + + Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object)); + Assert.AreEqual(8, test.ConsumedTokenCount); + } + } +} diff --git a/test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestAssetTest.cs b/test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestAssetTest.cs new file mode 100644 index 00000000..f250e304 --- /dev/null +++ b/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 repositoryMock; + private Mock parserStateMock; + + private Mock lexerMock; + private int tokenOffset; + private List tokens; + + [TestInitialize] + public void Setup() + { + parserStateMock = new Mock(); + + tokenOffset = 0; + tokens = new List(); + lexerMock = new Mock(); + repositoryMock = new Mock(); + + parserStateMock.SetupGet(state => state.Repository) + .Returns(() => repositoryMock.Object); + + lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny())) + .Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset)); + lexerMock.Setup(lexer => lexer.NextToken()) + .Returns(() => tokens.ElementAtOrDefault(tokenOffset++)); + lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny())) + .Callback((int count) => tokenOffset += count); + } + + [TestMethod] + public void EnsureAcceptsSimpleAssetStatement() + { + tokens.AddRange(new List + { + "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 + { + "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())) + .Returns(() => assetInformation); + repositoryMock.Setup(repository => repository.GetAllEnums()) + .Returns(() => new[]{assetEnum}); + + Assert.ThrowsException(() => test.PerformTest(parserStateMock.Object, lexerMock.Object)); + } + + [TestMethod] + public void EnsureThrowsExceptionWhenNoInformationForAssetCanBeFound() + { + tokens.AddRange(new List + { + "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(() => test.PerformTest(parserStateMock.Object, lexerMock.Object)); + } + + [TestMethod] + public void EnsureThrowsExceptionWhenEnumEntryCannotBeFound() + { + tokens.AddRange(new List + { + "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(() => test.PerformTest(parserStateMock.Object, lexerMock.Object)); + } + + [TestMethod] + public void EnsureThrowsExceptionWhenAssetIsNotADataTypeWithMembers() + { + tokens.AddRange(new List + { + "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())) + .Returns(() => assetInformation); + repositoryMock.Setup(repository => repository.GetAllEnums()) + .Returns(() => new[] { assetEnum }); + + Assert.ThrowsException(() => test.PerformTest(parserStateMock.Object, lexerMock.Object)); + } + } +} \ No newline at end of file diff --git a/test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestBlockTest.cs b/test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestBlockTest.cs new file mode 100644 index 00000000..8ddc6944 --- /dev/null +++ b/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 repositoryMock; + private Mock parserStateMock; + + private List fastFileBlocks; + + private Mock lexerMock; + private int tokenOffset; + private List tokens; + + [TestInitialize] + public void Setup() + { + parserStateMock = new Mock(); + + fastFileBlocks = new List(); + + tokenOffset = 0; + tokens = new List(); + lexerMock = new Mock(); + repositoryMock = new Mock(); + + parserStateMock.SetupGet(state => state.Repository) + .Returns(() => repositoryMock.Object); + + lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny())) + .Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset)); + lexerMock.Setup(lexer => lexer.NextToken()) + .Returns(() => tokens.ElementAtOrDefault(tokenOffset++)); + lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny())) + .Callback((int count) => tokenOffset += count); + + parserStateMock.SetupGet(state => state.FastFileBlocks) + .Returns(() => fastFileBlocks); + } + + [TestMethod] + public void EnsureAcceptsSimpleTempBlockStatement() + { + tokens.AddRange(new List + { + "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 + { + "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 + { + "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 + { + "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 + { + "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( + () => test.PerformTest(parserStateMock.Object, lexerMock.Object)); + } + + [TestMethod] + public void EnsureDoesNotSetDefaultBlockWhenNotSpecified() + { + tokens.AddRange(new List + { + "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 + { + "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 + { + "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( + () => test.PerformTest(parserStateMock.Object, lexerMock.Object)); + } + } +} \ No newline at end of file diff --git a/test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestGameTest.cs b/test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestGameTest.cs new file mode 100644 index 00000000..e8a9121e --- /dev/null +++ b/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 repositoryMock; + private Mock parserStateMock; + + private string game; + + private Mock lexerMock; + private int tokenOffset; + private List tokens; + + [TestInitialize] + public void Setup() + { + parserStateMock = new Mock(); + + game = ""; + + tokenOffset = 0; + tokens = new List(); + lexerMock = new Mock(); + repositoryMock = new Mock(); + + parserStateMock.SetupGet(state => state.Repository) + .Returns(() => repositoryMock.Object); + + lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny())) + .Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset)); + lexerMock.Setup(lexer => lexer.NextToken()) + .Returns(() => tokens.ElementAtOrDefault(tokenOffset++)); + lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny())) + .Callback((int count) => tokenOffset += count); + + parserStateMock.SetupGet(state => state.Game) + .Returns(() => game); + parserStateMock.SetupSet(state => state.Game = It.IsAny()) + .Callback((string s) => game = s); + } + + [TestMethod] + public void EnsureAcceptsSimpleGameStatement() + { + tokens.AddRange(new List + { + "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 + { + "game", "asdf", ";" + }); + + game = "alreadyAssignment"; + + var test = new TestGame(); + + Assert.ThrowsException( + () => test.PerformTest(parserStateMock.Object, lexerMock.Object)); + } + } +} \ No newline at end of file diff --git a/test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestUseTest.cs b/test/ZoneCodeGeneratorTests/Parsing/CommandFile/Tests/TestUseTest.cs new file mode 100644 index 00000000..04c8ac1b --- /dev/null +++ b/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 repositoryMock; + private Mock parserStateMock; + + private DataTypeWithMembers dataTypeWithMembers; + + private Mock lexerMock; + private int tokenOffset; + private List tokens; + + [TestInitialize] + public void Setup() + { + parserStateMock = new Mock(); + + dataTypeWithMembers = null; + + tokenOffset = 0; + tokens = new List(); + lexerMock = new Mock(); + repositoryMock = new Mock(); + + parserStateMock.SetupGet(state => state.Repository) + .Returns(() => repositoryMock.Object); + + lexerMock.Setup(lexer => lexer.PeekToken(It.IsAny())) + .Returns((int index) => tokens.ElementAtOrDefault(index + tokenOffset)); + lexerMock.Setup(lexer => lexer.NextToken()) + .Returns(() => tokens.ElementAtOrDefault(tokenOffset++)); + lexerMock.Setup(lexer => lexer.SkipTokens(It.IsAny())) + .Callback((int count) => tokenOffset += count); + + parserStateMock.SetupGet(state => state.DataTypeInUse) + .Returns(() => dataTypeWithMembers); + parserStateMock.SetupSet(state => state.DataTypeInUse = It.IsAny()) + .Callback((DataTypeWithMembers type) => dataTypeWithMembers = type); + } + + [TestMethod] + public void EnsureAcceptsSimpleUseStatement() + { + tokens.AddRange(new List + { + "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 + { + "use", "test", ":", ":", "type", ";" + }); + + var test = new TestUse(); + + Assert.ThrowsException( + () => test.PerformTest(parserStateMock.Object, lexerMock.Object)); + } + + [TestMethod] + public void EnsureThrowsExceptionWhenTypeIsNotDataTypeWithMembers() + { + tokens.AddRange(new List + { + "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( + () => test.PerformTest(parserStateMock.Object, lexerMock.Object)); + } + } +} \ No newline at end of file