Import code from previous AssetBuilder version

2025-06-10 14:58:10 -05:00 · 2019-09-24 10:45:09 +02:00
parent 5609557516
commit 0d8432d4f7
919 changed files with 154412 additions and 26 deletions
--- a/test/ZoneCodeGeneratorTests/Parsing/Testing/Tests/TestNamespaceTest.cs
+++ b/test/ZoneCodeGeneratorTests/Parsing/Testing/Tests/TestNamespaceTest.cs
@ -0,0 +1,140 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+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.Testing.Tests
+{
+    [TestClass]
+    public class TestNamespaceTest
+    {
+        private Mock<IHeaderParserState> parserStateMock;
+        private Block pushedBlock;
+
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            parserStateMock = new Mock<IHeaderParserState>();
+            pushedBlock = null;
+
+            parserStateMock.Setup(state => state.PushBlock(It.IsAny<Block>()))
+                .Callback((Block block) => pushedBlock = block);
+
+            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 EnsureAcceptsNamespaceDeclaration()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "namespace", "some_namespace", "{"
+            });
+
+            var test = new TestNamespace();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(3, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()));
+            parserStateMock.VerifyNoOtherCalls();
+
+            if (pushedBlock is BlockNamespace namespaceBlock)
+            {
+                Assert.AreEqual("some_namespace", namespaceBlock.Name);
+            }
+            else
+                Assert.Fail("Pushed block is supposed to be a namespace");
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsNamespacesWithSpecialCharacters()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "namespace", "$omeW3irdN4m3sp4c3", "{"
+            });
+
+            var test = new TestNamespace();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(3, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()));
+            parserStateMock.VerifyNoOtherCalls();
+
+            if (pushedBlock is BlockNamespace namespaceBlock)
+            {
+                Assert.AreEqual("$omeW3irdN4m3sp4c3", namespaceBlock.Name);
+            }
+            else
+                Assert.Fail("Pushed block is supposed to be a namespace");
+        }
+
+        [TestMethod]
+        public void EnsureCanOnlyHaveOneNamespaceName()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "namespace", "namespace_name", "another_namespace_name", "{"
+            });
+
+            var test = new TestNamespace();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+            
+            parserStateMock.VerifyNoOtherCalls();
+        }
+
+        [TestMethod]
+        public void EnsureNeedsOpeningCurlyBrackets()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "namespace", "namespace_name", ""
+            });
+
+            var test = new TestNamespace();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+            
+            parserStateMock.VerifyNoOtherCalls();
+        }
+
+        [TestMethod]
+        public void EnsureRejectsNameWithDigitAsFirstCharacter()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "namespace", "1ns", "{"
+            });
+
+            var test = new TestNamespace();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+            
+            parserStateMock.VerifyNoOtherCalls();
+        }
+    }
+}