ZoneCodeGenerator: Move Test tests to correct folder and namespace corresponding to ZoneCodeGenerator

2025-06-10 14:58:10 -05:00 · 2019-10-29 12:53:37 +01:00
parent 7117eb4506
commit 7ab7447827
5 changed files with 5 additions and 5 deletions
--- a/test/ZoneCodeGeneratorTests/Parsing/C_Header/Tests/TestEnumMemberTest.cs
+++ b/test/ZoneCodeGeneratorTests/Parsing/C_Header/Tests/TestEnumMemberTest.cs
@ -0,0 +1,318 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Domain;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.C_Header;
+using ZoneCodeGenerator.Parsing.C_Header.Blocks;
+using ZoneCodeGenerator.Parsing.C_Header.Tests;
+using ZoneCodeGenerator.Parsing.Testing;
+
+namespace ZoneCodeGeneratorTests.Parsing.C_Header.Tests
+{
+    [TestClass]
+    public class TestEnumMemberTest
+    {
+        private Mock<IHeaderParserState> parserStateMock;
+        private Mock<BlockEnum> enumMock;
+        private EnumMember addedEnumMember;
+
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            parserStateMock = new Mock<IHeaderParserState>();
+            enumMock = new Mock<BlockEnum>(parserStateMock.Object, "testenum", DataTypeBaseType.INT, false);
+            addedEnumMember = null;
+
+            parserStateMock.SetupGet(state => state.CurrentBlock).Returns(() => enumMock.Object);
+            enumMock.Setup(_enum => _enum.AddMember(It.IsAny<EnumMember>()))
+                .Callback((EnumMember member) => addedEnumMember = member);
+
+            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 EnsureAcceptsSimpleEnumEntry()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asdf", ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(2, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
+
+            Assert.AreEqual("asdf", addedEnumMember.Name);
+            Assert.AreEqual(0L, addedEnumMember.Value);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsEntryWithSpecialCharacters()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "$ASgF123__", ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(2, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
+
+            Assert.AreEqual("$ASgF123__", addedEnumMember.Name);
+            Assert.AreEqual(0L, addedEnumMember.Value);
+        }
+
+        [TestMethod]
+        public void EnsureRejectsWithDigitInTheBeginning()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "123var", ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsEntryWithDecimalNumber()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "leet", "=", "1337", ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(4, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
+
+            Assert.AreEqual("leet", addedEnumMember.Name);
+            Assert.AreEqual(1337L, addedEnumMember.Value);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsEntryWithHexadecimalNumber()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "smoke", "=", "0x1a4", ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(4, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
+
+            Assert.AreEqual("smoke", addedEnumMember.Name);
+            Assert.AreEqual(420L, addedEnumMember.Value);
+        }
+
+        [TestMethod]
+        public void EnsureRejectsEntryWithoutName()
+        {
+            tokens.AddRange(new List<string>
+            {
+                ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
+        }
+
+        [TestMethod]
+        public void EnsureRejectsEntryWithoutNameButWithNumber()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "=", "0", ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
+        }
+
+        [TestMethod]
+        public void EnsurePicksNextNumberWhenNoneSpecified()
+        {
+            enumMock.Setup(_enum => _enum.GetNextEnumValue()).Returns(1337L);
+            tokens.AddRange(new List<string>
+            {
+                "asdf", ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(2, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
+
+            Assert.AreEqual("asdf", addedEnumMember.Name);
+            Assert.AreEqual(1337L, addedEnumMember.Value);
+        }
+
+        [TestMethod]
+        public void EnsureNeedsTerminator()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asdf", "nextentry"
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
+        }
+
+        [TestMethod]
+        public void EnsureNeedsTerminatorEvenWithValueSpecified()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asdf", "=", "0", "nextentry"
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsLastEntryWithoutComma()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asdf", "}"
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(1, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
+
+            Assert.AreEqual("asdf", addedEnumMember.Name);
+            Assert.AreEqual(0L, addedEnumMember.Value);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsLastEntryWithoutCommaWithValueSpecified()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asdf", "=", "1336", "}"
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(3, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
+
+            Assert.AreEqual("asdf", addedEnumMember.Name);
+            Assert.AreEqual(1336L, addedEnumMember.Value);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsOtherEnumValues()
+        {
+            var previousMember = new EnumMember("prev", 1335);
+
+            parserStateMock.Setup(state => state.FindEnumMember("prev")).Returns(previousMember);
+
+            tokens.AddRange(new List<string>
+            {
+                "asdf", "=", "prev", ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(4, test.ConsumedTokenCount);
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Once());
+
+            Assert.AreEqual("asdf", addedEnumMember.Name);
+            Assert.AreEqual(1335L, addedEnumMember.Value);
+        }
+
+        [TestMethod]
+        public void EnsureThrowsErrorIfPreviousEnumValueNotDeclared()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "asdf", "=", "prev", ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
+        }
+
+        [TestMethod]
+        public void EnsureThrowsErrorIfTopBlockIsNotEnum()
+        {
+            var blockMock = new Mock<Block>(parserStateMock.Object, BlockType.None);
+            parserStateMock.SetupGet(state => state.CurrentBlock).Returns(blockMock.Object);
+            tokens.AddRange(new List<string>
+            {
+                "asdf", "=", "0", ","
+            });
+
+            var test = new TestEnumMember();
+
+            Assert.ThrowsException<Exception>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+
+            enumMock.Verify(_enum => _enum.AddMember(It.IsAny<EnumMember>()), Times.Never());
+        }
+    }
+}