Import code from previous AssetBuilder version

test/ZoneCodeGeneratorTests/Parsing/Impl/LexerTest.cs

@@ -0,0 +1,353 @@
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ZoneCodeGenerator.Parsing.Impl;
+using ZoneCodeGeneratorTests.Parsing.Mock;
+
+namespace ZoneCodeGeneratorTests.Parsing.Impl
+{
+    [TestClass]
+    public class LexerTest
+    {
+        private IncludingParsingStreamTest headerStream;
+        private Lexer lexer;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            headerStream = new IncludingParsingStreamTest("file.h");
+            lexer = new Lexer(headerStream);
+        }
+
+        private void AssertTokenOutput(params string[] expectedTokens)
+        {
+            foreach (var token in expectedTokens)
+                Assert.AreEqual(token, lexer.NextToken());
+        }
+
+        [TestMethod]
+        public void EnsureCanSplitWords()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some random tokens",
+                "right here"
+            });
+            
+            AssertTokenOutput("Some", "random", "tokens", "right", "here");
+            Assert.IsTrue(lexer.IsEndOfStream);
+        }
+
+        [TestMethod]
+        public void EnsureCanSplitSpecialCharactersFromWords()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "word1;word2; word3 ; word4 ;word5",
+                "word1:word2: word3 : word4 :word5",
+                "word1{word2{ word3 { word4 {word5",
+                "word1}word2} word3 } word4 }word5",
+                "word1,word2, word3 , word4 ,word5",
+                "word1=word2= word3 = word4 =word5",
+                "word1(word2( word3 ( word4 (word5",
+                "word1)word2) word3 ) word4 )word5",
+                "word1*word2* word3 * word4 *word5",
+                "word1[word2[ word3 [ word4 [word5",
+                "word1]word2] word3 ] word4 ]word5",
+                "word1<word2< word3 < word4 <word5",
+                "word1>word2> word3 > word4 >word5",
+                "word1#word2# word3 # word4 #word5",
+                "word1&word2& word3 & word4 &word5",
+                "word1%word2% word3 % word4 %word5",
+                "word1\"word2\" word3 \" word4 \"word5",
+                "word1?word2? word3 ? word4 ?word5",
+                "word1!word2! word3 ! word4 !word5",
+                "word1+word2+ word3 + word4 +word5",
+                "word1-word2- word3 - word4 -word5",
+                "word1/word2/ word3 / word4 /word5",
+                "word1\\word2\\ word3 \\ word4 \\word5",
+            });
+            
+            AssertTokenOutput("word1", ";", "word2", ";", "word3", ";", "word4", ";", "word5");
+            AssertTokenOutput("word1", ":", "word2", ":", "word3", ":", "word4", ":", "word5");
+            AssertTokenOutput("word1", "{", "word2", "{", "word3", "{", "word4", "{", "word5");
+            AssertTokenOutput("word1", "}", "word2", "}", "word3", "}", "word4", "}", "word5");
+            AssertTokenOutput("word1", ",", "word2", ",", "word3", ",", "word4", ",", "word5");
+            AssertTokenOutput("word1", "=", "word2", "=", "word3", "=", "word4", "=", "word5");
+            AssertTokenOutput("word1", "(", "word2", "(", "word3", "(", "word4", "(", "word5");
+            AssertTokenOutput("word1", ")", "word2", ")", "word3", ")", "word4", ")", "word5");
+            AssertTokenOutput("word1", "*", "word2", "*", "word3", "*", "word4", "*", "word5");
+            AssertTokenOutput("word1", "[", "word2", "[", "word3", "[", "word4", "[", "word5");
+            AssertTokenOutput("word1", "]", "word2", "]", "word3", "]", "word4", "]", "word5");
+            AssertTokenOutput("word1", "<", "word2", "<", "word3", "<", "word4", "<", "word5");
+            AssertTokenOutput("word1", ">", "word2", ">", "word3", ">", "word4", ">", "word5");
+            AssertTokenOutput("word1", "#", "word2", "#", "word3", "#", "word4", "#", "word5");
+            AssertTokenOutput("word1", "&", "word2", "&", "word3", "&", "word4", "&", "word5");
+            AssertTokenOutput("word1", "%", "word2", "%", "word3", "%", "word4", "%", "word5");
+            AssertTokenOutput("word1", "\"", "word2", "\"", "word3", "\"", "word4", "\"", "word5");
+            AssertTokenOutput("word1", "?", "word2", "?", "word3", "?", "word4", "?", "word5");
+            AssertTokenOutput("word1", "!", "word2", "!", "word3", "!", "word4", "!", "word5");
+            AssertTokenOutput("word1", "+", "word2", "+", "word3", "+", "word4", "+", "word5");
+            AssertTokenOutput("word1", "-", "word2", "-", "word3", "-", "word4", "-", "word5");
+            AssertTokenOutput("word1", "/", "word2", "/", "word3", "/", "word4", "/", "word5");
+            AssertTokenOutput("word1", "\\", "word2", "\\", "word3", "\\", "word4", "\\", "word5");
+
+            Assert.IsTrue(lexer.IsEndOfStream);
+        }
+
+        [TestMethod]
+        public void EnsurePeekingDoesNotConsumeTokens()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some random tokens",
+                "right here"
+            });
+
+            Assert.AreEqual("Some", lexer.PeekToken());
+            Assert.AreEqual("tokens", lexer.PeekToken(2));
+            Assert.AreEqual("here", lexer.PeekToken(4));
+            Assert.AreEqual("right", lexer.PeekToken(3));
+
+
+            Assert.AreEqual("Some", lexer.NextToken());
+            Assert.AreEqual("right", lexer.PeekToken(2));
+
+            AssertTokenOutput("random", "tokens", "right");
+            
+            Assert.AreEqual("here", lexer.PeekToken());
+            Assert.AreEqual("here", lexer.PeekToken());
+            Assert.AreEqual("here", lexer.PeekToken());
+            
+            Assert.AreEqual("here", lexer.NextToken());
+
+            Assert.IsTrue(lexer.IsEndOfStream);
+        }
+
+        [TestMethod]
+        public void EnsurePeekingOutOfBoundsDoesNotCauseIssues()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some random tokens",
+                "right here"
+            });
+
+            Assert.AreEqual("", lexer.PeekToken(1337));
+            Assert.AreEqual("", lexer.PeekToken(5));
+            Assert.AreEqual("", lexer.PeekToken(-2));
+
+            AssertTokenOutput("Some", "random", "tokens", "right", "here");
+            Assert.IsTrue(lexer.IsEndOfStream);
+            
+            Assert.AreEqual("", lexer.PeekToken());
+            Assert.AreEqual("", lexer.PeekToken(2));
+        }
+
+        [TestMethod]
+        public void EnsureGettingNextTokenAfterStreamEndDoesNotCauseIssues()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some random tokens",
+                "right here"
+            });
+
+            AssertTokenOutput("Some", "random", "tokens", "right", "here");
+            Assert.IsTrue(lexer.IsEndOfStream);
+            
+            Assert.AreEqual("", lexer.NextToken());
+            Assert.AreEqual("", lexer.NextToken());
+        }
+
+        [TestMethod]
+        public void EnsureSkippingTokensWorksCorrectly()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some random tokens",
+                "right here"
+            });
+
+            AssertTokenOutput("Some", "random");
+            Assert.IsFalse(lexer.IsEndOfStream);
+
+            lexer.SkipTokens(2);
+            
+            AssertTokenOutput("here");
+            Assert.IsTrue(lexer.IsEndOfStream);
+        }
+
+        [TestMethod]
+        public void EnsureSkippingNoTokensWorksCorrectly()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some random tokens",
+                "right here"
+            });
+
+            AssertTokenOutput("Some", "random");
+            Assert.IsFalse(lexer.IsEndOfStream);
+
+            lexer.SkipTokens(0);
+            
+            AssertTokenOutput("tokens", "right", "here");
+            Assert.IsTrue(lexer.IsEndOfStream);
+        }
+
+        [TestMethod]
+        public void EnsureSkippingOutOfBoundsDoesNotCauseIssues()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some random tokens",
+                "right here"
+            });
+
+            AssertTokenOutput("Some", "random");
+            Assert.IsFalse(lexer.IsEndOfStream);
+
+            lexer.SkipTokens(-5);
+            
+            AssertTokenOutput("tokens", "right");
+
+            lexer.SkipTokens(1337);
+            Assert.IsTrue(lexer.IsEndOfStream);
+            AssertTokenOutput("");
+        }
+
+        [TestMethod]
+        public void EnsureSkippingAfterStreamEndDoesNotCauseIssues()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some random tokens",
+                "right here"
+            });
+            
+            AssertTokenOutput("Some", "random", "tokens", "right", "here");
+            Assert.IsTrue(lexer.IsEndOfStream);
+
+            lexer.SkipTokens(1);
+            lexer.SkipTokens(2);
+            
+            Assert.IsTrue(lexer.IsEndOfStream);
+        }
+
+        [TestMethod]
+        public void EnsureTheFilenameOfTheTokenIsCorrect()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some",
+                "random",
+                "tokens",
+                "right",
+                "here"
+            });
+            
+            Assert.AreEqual("file.h", lexer.CurrentFile);
+            AssertTokenOutput("Some");
+            Assert.AreEqual("file.h", lexer.CurrentFile);
+            headerStream.Filename = "file2.h";
+            AssertTokenOutput("random");
+            headerStream.Filename = "file3.h";
+            Assert.AreEqual("file3.h", lexer.CurrentFile);
+        }
+
+        [TestMethod]
+        public void EnsureFilenameOfTokenStaysConsistent()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some",
+                "random",
+                "tokens",
+                "right",
+                "here"
+            });
+            
+            Assert.AreEqual("file.h", lexer.CurrentFile);
+            Assert.AreEqual("Some", lexer.PeekToken());
+
+            headerStream.Filename = "file2.h";
+
+            Assert.AreEqual("file.h", lexer.CurrentFile);
+            Assert.AreEqual("Some", lexer.PeekToken());
+            Assert.AreEqual("file.h", lexer.CurrentFile);
+            
+            Assert.AreEqual("Some", lexer.NextToken());
+            
+            Assert.AreEqual("file2.h", lexer.CurrentFile);
+
+            AssertTokenOutput("random", "tokens", "right", "here");
+            Assert.IsTrue(lexer.IsEndOfStream);
+        }
+
+        [TestMethod]
+        public void EnsureTheLineOfTheTokenIsCorrect()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some",
+                "random",
+                "tokens",
+                "right",
+                "here"
+            });
+            
+            Assert.AreEqual(0, lexer.CurrentLine);
+            AssertTokenOutput("Some");
+            Assert.AreEqual(1, lexer.CurrentLine);
+            AssertTokenOutput("random");
+            Assert.AreEqual(2, lexer.CurrentLine);
+
+            lexer.SkipTokens(1);
+            Assert.AreEqual(3, lexer.CurrentLine);
+        }
+
+        [TestMethod]
+        public void EnsureLineOfTokenStaysConsistent()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "Some",
+                "random",
+                "tokens",
+                "right",
+                "here"
+            });
+
+            Assert.AreEqual(0, lexer.CurrentLine);
+            Assert.AreEqual("Some", lexer.PeekToken());
+            Assert.AreEqual("random", lexer.PeekToken(1));
+            
+            headerStream.Line = 3;
+            
+            Assert.AreEqual(0, lexer.CurrentLine);
+            Assert.AreEqual("Some", lexer.PeekToken());
+            Assert.AreEqual("Some", lexer.NextToken());
+            
+            Assert.AreEqual(1, lexer.CurrentLine);
+            Assert.AreEqual("random", lexer.PeekToken());
+            Assert.AreEqual("random", lexer.NextToken());
+            
+            Assert.AreEqual(3, lexer.CurrentLine);
+            Assert.AreEqual("right", lexer.PeekToken());
+            Assert.AreEqual("right", lexer.NextToken());
+        }
+
+        [TestMethod]
+        public void EnsureTreatsUnusedSpecialCharactersAsWordCharacters()
+        {
+            headerStream.Lines.AddRange(new List<string>
+            {
+                "$ome _random token$",
+                "right here"
+            });
+            
+            AssertTokenOutput("$ome", "_random", "token$", "right", "here");
+            Assert.IsTrue(lexer.IsEndOfStream);
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Impl/PreprocessorTest.cs

@@ -0,0 +1,242 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ZoneCodeGenerator.Parsing.C_Header;
+using ZoneCodeGenerator.Parsing.C_Header.Impl;
+using ZoneCodeGenerator.Utils;
+using ZoneCodeGeneratorTests.Parsing.Mock;
+
+namespace ZoneCodeGeneratorTests.Parsing.Impl
+{
+    [TestClass]
+    public class PreprocessorTest
+    {
+        private IncludingParsingStreamTest headerStreamTest;
+        private IHeaderParserState headerParserState;
+
+        private Preprocessor preprocessor;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            headerStreamTest = new IncludingParsingStreamTest("file.h");
+            headerParserState = new HeaderParserState();
+            preprocessor = new Preprocessor(headerStreamTest, headerParserState);
+        }
+
+        [TestMethod]
+        public void EnsureReturnsUnmodifiedText()
+        {
+            string[] stringsThatShouldNotBeModified =
+            {
+                "This is a normal string",
+                "There is nothing to be preprocessed!",
+                "0124124124 # 124124124",
+                "...",
+                "<?php><html>asdf</html>",
+                ""
+            };
+            headerStreamTest.Lines.AddRange(stringsThatShouldNotBeModified);
+
+            foreach (var stringThatShouldNotBeModified in stringsThatShouldNotBeModified)
+            {
+                Assert.AreEqual(stringThatShouldNotBeModified, preprocessor.ReadLine());
+            }
+        }
+
+        [TestMethod]
+        public void EnsureDoesRemoveLineComments()
+        {
+            var commentStrings = new Dictionary<string, string>()
+            {
+                {"// This is a comment at the beginning of the line", ""},
+                {"Text in front of a comment // Comment", "Text in front of a comment"},
+                {"/ / Not a comment", "/ / Not a comment"},
+                {"asdf /// Triple slash is a comment", "asdf"},
+                {"b2h3 /////////////// In fact after the first two slashes it should always be considered a comment", "b2h3"},
+            };
+            headerStreamTest.Lines.AddRange(commentStrings.Keys);
+
+            foreach (var (input, expectedResult) in commentStrings)
+            {
+                Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
+            }
+        }
+
+        [TestMethod]
+        public void EnsureDoesRemoveBlockComments()
+        {
+            var commentStrings = new Dictionary<string, string>()
+            {
+                {"/* This is a block comment */", ""},
+                {"Text in front of a comment /** Comment ***/", "Text in front of a comment"},
+                {"/ * Not a comment */", "/ * Not a comment */"},
+                {"Text in front of comment /* Comment */ Text after the comment", "Text in front of comment  Text after the comment"},
+                {"Hello/*Hell*/World", "HelloWorld"},
+            };
+            headerStreamTest.Lines.AddRange(commentStrings.Keys);
+
+            foreach (var (input, expectedResult) in commentStrings)
+            {
+                Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
+            }
+        }
+
+        [TestMethod]
+        public void EnsureBlockCommentsWorkOverMultipleLines()
+        {
+            var commentStrings = new Dictionary<string, string>()
+            {
+                {"The start of the comment /* Is now", "The start of the comment"},
+                {"Nothing to be seen here", ""},
+                {"* / /* Still nothing", ""},
+                {"The comment ends */ now", "now"},
+                {"This line should not cause any issues", "This line should not cause any issues"},
+            };
+            headerStreamTest.Lines.AddRange(commentStrings.Keys);
+
+            foreach (var (input, expectedResult) in commentStrings)
+            {
+                Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
+            }
+        }
+
+        [TestMethod]
+        public void EnsureDefinesArePlacedCorrectly()
+        {
+            var defineStrings = new Dictionary<string, string>()
+            {
+                {"#define World Hell", ""},
+                {"Hello World!", "Hello Hell!"},
+                {"World-wide Teamwork", "Hell-wide Teamwork"},
+                {"#define great pretty bad", ""},
+                {"Defines are great, right?", "Defines are pretty bad, right?"},
+                {"Great world", "Great world"}, // Capitalization should matter
+            };
+            headerStreamTest.Lines.AddRange(defineStrings.Keys);
+
+            foreach (var (input, expectedResult) in defineStrings)
+            {
+                Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
+            }
+        }
+
+        [TestMethod]
+        public void EnsureDefinesCanBeOverwritten()
+        {
+            var defineStrings = new Dictionary<string, string>()
+            {
+                {"#define World Hell", ""},
+                {"#define World Mars", ""},
+                {"Hello World!", "Hello Mars!"}
+            };
+            headerStreamTest.Lines.AddRange(defineStrings.Keys);
+
+            foreach (var (input, expectedResult) in defineStrings)
+            {
+                Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
+            }
+        }
+
+        [TestMethod]
+        public void EnsureEmptyDefinesResolveToEmpty()
+        {
+            var defineStrings = new Dictionary<string, string>()
+            {
+                {"#define World", ""},
+                {"Hello World!", "Hello !"}
+            };
+            headerStreamTest.Lines.AddRange(defineStrings.Keys);
+
+            foreach (var (input, expectedResult) in defineStrings)
+            {
+                Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
+            }
+        }
+
+        [TestMethod]
+        public void EnsureUndefRemovesDefines()
+        {
+            var defineStrings = new Dictionary<string, string>()
+            {
+                {"#define World Hell", ""},
+                {"Hello World!", "Hello Hell!"},
+                {"#undef World", ""},
+                {"Hello World 2!", "Hello World 2!"},
+                {"#define Hell Jupiter", ""},
+                {"#define Hell Mars", ""},
+                {"#undef Hell", ""},
+                {"Hell no", "Hell no"},
+            };
+            headerStreamTest.Lines.AddRange(defineStrings.Keys);
+
+            foreach (var (input, expectedResult) in defineStrings)
+            {
+                Assert.AreEqual(expectedResult, preprocessor.ReadLine().Trim());
+            }
+        }
+
+        [TestMethod]
+        public void EnsurePackIsParsedCorrectly()
+        {
+            var defaultPack = headerParserState.CurrentPack;
+
+            var packs = new List<Tuple<string, int>>
+            {
+                new Tuple<string, int>("Test", defaultPack),
+                new Tuple<string, int>("#pragma pack(push, 16)", 16),
+                new Tuple<string, int>("Test2", 16),
+                new Tuple<string, int>("#pragma pack(push, 64)", 64),
+                new Tuple<string, int>("Test3", 64),
+                new Tuple<string, int>("Test4", 64),
+                new Tuple<string, int>("#pragma pack(pop)", 16),
+                new Tuple<string, int>("Test5", 16),
+                new Tuple<string, int>("#pragma pack(pop)", defaultPack),
+                new Tuple<string, int>("Test6", defaultPack)
+            };
+            headerStreamTest.Lines.AddRange(packs.Select(tuple => tuple.Item1));
+            
+            foreach (var (input, expectedPack) in packs)
+            {
+                preprocessor.ReadLine();
+
+                Assert.AreEqual(expectedPack, headerParserState.CurrentPack);
+            }
+        }
+
+        [TestMethod]
+        public void EnsureIncludeChangesFileWhenUsingQuotationMarks()
+        {
+            headerStreamTest.Lines.AddRange(new []
+            {
+                "#include \"asdf.h\"",
+                "#include \"file/path/to/header.h\""
+            });
+            preprocessor.ReadLine();
+            Assert.AreEqual(1, headerStreamTest.IncludeCount);
+            Assert.AreEqual("asdf.h", headerStreamTest.LastInclude);
+            
+            preprocessor.ReadLine();
+            Assert.AreEqual(2, headerStreamTest.IncludeCount);
+            Assert.AreEqual("file/path/to/header.h", headerStreamTest.LastInclude);
+        }
+
+        [TestMethod]
+        public void EnsureIncludeChangesFileWhenUsingCarets()
+        {
+            headerStreamTest.Lines.AddRange(new []
+            {
+                "#include <asdf.h>",
+                "#include <file/path/to/header.h>"
+            });
+            preprocessor.ReadLine();
+            Assert.AreEqual(1, headerStreamTest.IncludeCount);
+            Assert.AreEqual("asdf.h", headerStreamTest.LastInclude);
+            
+            preprocessor.ReadLine();
+            Assert.AreEqual(2, headerStreamTest.IncludeCount);
+            Assert.AreEqual("file/path/to/header.h", headerStreamTest.LastInclude);
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Matching/Matchers/MatcherArrayTest.cs

@@ -0,0 +1,190 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.Matching;
+using ZoneCodeGenerator.Parsing.Matching.Matchers;
+
+namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
+{
+    [TestClass]
+    public class MatcherArrayTest
+    {
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+        private MatchingContext matchingContext;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            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);
+
+            matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
+        }
+
+        [TestMethod]
+        public void EnsureDecimalArraysAreRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "[", "15", "]"
+            });
+
+            var matcher = new MatcherArray();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(3, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureHexArraysAreRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "[", "0x20", "]"
+            });
+
+            var matcher = new MatcherArray();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(3, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureEnumValueArraysAreRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "[", "ENUM_VALUE", "]"
+            });
+
+            var matcher = new MatcherArray();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(3, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureFirstSquareBracketIsRequiredToBeRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "13", "]"
+            });
+
+            var matcher = new MatcherArray();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureSecondSquareBracketIsRequiredToBeRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "[", "13"
+            });
+
+            var matcher = new MatcherArray();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureSquareBracketsAreRequiredToBeRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "13"
+            });
+
+            var matcher = new MatcherArray();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureSquareBracketsNeedToBeInTheCorrectOrder()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "]", "13", "["
+            });
+
+            var matcher = new MatcherArray();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureNamedOutputIsDecimalNumberForDecimalInput()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "[", "13", "]"
+            });
+
+            var matcher = new MatcherArray().WithName("array_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(3, result.ConsumedTokenCount);
+            Assert.AreEqual("13", result["array_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureNamedOutputIsDecimalNumberForHexInput()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "[", "0x133", "]"
+            });
+
+            var matcher = new MatcherArray().WithName("array_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(3, result.ConsumedTokenCount);
+            Assert.AreEqual("307", result["array_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureNamedOutputIsStringForEnumValueInput()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "[", "HELLO_WORLD", "]"
+            });
+
+            var matcher = new MatcherArray().WithName("array_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(3, result.ConsumedTokenCount);
+            Assert.AreEqual("HELLO_WORLD", result["array_token"].ElementAtOrDefault(0));
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Matching/Matchers/MatcherGroupAndTest.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.Matching;
+using ZoneCodeGenerator.Parsing.Matching.Matchers;
+
+namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
+{
+    [TestClass]
+    public class MatcherGroupAndTest
+    {
+        private Mock<ILexer> lexerMock;
+        private MatchingContext matchingContext;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            lexerMock = new Mock<ILexer>();
+            matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
+        }
+
+        [TestMethod]
+        public void EnsureAllTestsSuccessfulMakesGroupSuccessful()
+        {
+            var groupAnd = new MatcherGroupAnd
+            (
+                new TestMatcher(true, 1),
+                new TestMatcher(true, 1),
+                new TestMatcher(true, 1),
+                new TestMatcher(true, 1)
+            );
+
+            var result = groupAnd.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(4, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureLastTestFailingLetsGroupFail()
+        {
+            var groupAnd = new MatcherGroupAnd
+            (
+                new TestMatcher(true, 4),
+                new TestMatcher(true, 2),
+                new TestMatcher(true, 1),
+                new TestMatcher(false, 0)
+            );
+
+            var result = groupAnd.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureFirstTestFailingLetsGroupFail()
+        {
+            var groupAnd = new MatcherGroupAnd
+            (
+                new TestMatcher(false, 0),
+                new TestMatcher(true, 1),
+                new TestMatcher(true, 1),
+                new TestMatcher(true, 1)
+            );
+
+            var result = groupAnd.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureTestsAreCalledWithCorrectTokenOffsets()
+        {
+            var testMatchers = new[]
+            {
+                new TestMatcher(true, 4),
+                new TestMatcher(true, 2),
+                new TestMatcher(true, 1),
+                new TestMatcher(false, 0),
+                new TestMatcher(true, 1)
+            };
+            var iTokenMatcherArray = (TokenMatcher[])testMatchers.Clone();
+            var groupAnd = new MatcherGroupAnd(iTokenMatcherArray);
+
+            var result = groupAnd.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+            
+            Assert.IsTrue(testMatchers[0].WasTested);
+            Assert.AreEqual(0, testMatchers[0].TestTokenOffset);
+            
+            Assert.IsTrue(testMatchers[1].WasTested);
+            Assert.AreEqual(4, testMatchers[1].TestTokenOffset);
+            
+            Assert.IsTrue(testMatchers[2].WasTested);
+            Assert.AreEqual(6, testMatchers[2].TestTokenOffset);
+            
+            Assert.IsTrue(testMatchers[3].WasTested);
+            Assert.AreEqual(7, testMatchers[3].TestTokenOffset);
+            
+            Assert.IsFalse(testMatchers[4].WasTested);
+        }
+
+        [TestMethod]
+        public void EnsureGroupWithNoTestsThrowsException()
+        {
+            MatcherGroupAnd matcherGroup = null;
+
+            Assert.ThrowsException<ArgumentException>(
+                () => matcherGroup = new MatcherGroupAnd()
+                );
+
+            Assert.IsNull(matcherGroup);
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Matching/Matchers/MatcherGroupLoopTest.cs

@@ -0,0 +1,186 @@
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.Matching;
+using ZoneCodeGenerator.Parsing.Matching.Matchers;
+
+namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
+{
+    [TestClass]
+    public class MatcherGroupLoopTest
+    {
+        private const string LoopToken = "loop_token";
+
+        private int testsUntilUnsuccessful;
+        private int timesTested;
+        private Mock<ILexer> lexerMock;
+        private Mock<TokenMatcher> tokenMatcherMock;
+        private MatchingContext matchingContext;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            timesTested = 0;
+            testsUntilUnsuccessful = 0;
+            lexerMock = new Mock<ILexer>();
+            tokenMatcherMock = new Mock<TokenMatcher>();
+
+            tokenMatcherMock.Setup(matcher => matcher.Test(It.IsAny<MatchingContext>(), It.IsAny<int>()))
+                .Returns(() =>
+                {
+                    timesTested++;
+
+                    if(testsUntilUnsuccessful == 0)
+                        return new TokenMatchingResult(false, 0);
+
+                    testsUntilUnsuccessful--;
+
+                    var matchResult = new TokenMatchingResult(true, 1);
+
+                    matchResult.AddNamedMatch(LoopToken, "test");
+
+                    return matchResult;
+                });
+
+            matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
+        }
+
+        [TestMethod]
+        public void EnsureZeroOneMultipleAcceptsNoSuccessfulTests()
+        {
+            testsUntilUnsuccessful = 0;
+            var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.ZeroOneMultiple, tokenMatcherMock.Object);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+            Assert.AreEqual(1, timesTested);
+        }
+
+        [TestMethod]
+        public void EnsureZeroOneMultipleAcceptsOneSuccessfulTest()
+        {
+            testsUntilUnsuccessful = 1;
+            var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.ZeroOneMultiple, tokenMatcherMock.Object);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+            Assert.AreEqual(2, timesTested);
+        }
+
+        [TestMethod]
+        public void EnsureZeroOneMultipleAcceptsMultipleSuccessfulTest()
+        {
+            testsUntilUnsuccessful = 5;
+            var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.ZeroOneMultiple, tokenMatcherMock.Object);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(5, result.ConsumedTokenCount);
+            Assert.AreEqual(6, timesTested);
+        }
+
+        [TestMethod]
+        public void EnsureOneMultipleRejectsNoSuccessfulTests()
+        {
+            testsUntilUnsuccessful = 0;
+            var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.OneMultiple, tokenMatcherMock.Object);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+            Assert.AreEqual(1, timesTested);
+        }
+
+        [TestMethod]
+        public void EnsureOneMultipleAcceptsOneSuccessfulTest()
+        {
+            testsUntilUnsuccessful = 1;
+            var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.OneMultiple, tokenMatcherMock.Object);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+            Assert.AreEqual(2, timesTested);
+        }
+
+        [TestMethod]
+        public void EnsureOneMultipleAcceptsMultipleSuccessfulTests()
+        {
+            testsUntilUnsuccessful = 3;
+            var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.OneMultiple, tokenMatcherMock.Object);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(3, result.ConsumedTokenCount);
+            Assert.AreEqual(4, timesTested);
+        }
+
+        [TestMethod]
+        public void EnsureMultipleRejectsNoSuccessfulTests()
+        {
+            testsUntilUnsuccessful = 0;
+            var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.Multiple, tokenMatcherMock.Object);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+            Assert.AreEqual(1, timesTested);
+        }
+
+        [TestMethod]
+        public void EnsureMultipleRejectsOneSuccessfulTest()
+        {
+            testsUntilUnsuccessful = 1;
+            var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.Multiple, tokenMatcherMock.Object);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+            Assert.AreEqual(2, timesTested);
+        }
+
+        [TestMethod]
+        public void EnsureMultipleAcceptsMultipleSuccessfulTests()
+        {
+            testsUntilUnsuccessful = 2;
+            var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.Multiple, tokenMatcherMock.Object);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(2, result.ConsumedTokenCount);
+            Assert.AreEqual(3, timesTested);
+        }
+
+        [TestMethod]
+        public void EnsureAllNamedMatchesAreIncluded()
+        {
+            testsUntilUnsuccessful = 10;
+            var matcherGroup = new MatcherGroupLoop(MatcherGroupLoop.LoopMode.Multiple, tokenMatcherMock.Object);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(10, result.ConsumedTokenCount);
+            Assert.AreEqual(11, timesTested);
+
+            var namedMatches = result[LoopToken];
+
+            Assert.AreEqual(10, namedMatches.Count);
+            
+            foreach(var namedMatch in namedMatches)
+                Assert.AreEqual("test", namedMatch);
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Matching/Matchers/MatcherGroupOptionalTest.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.Matching;
+using ZoneCodeGenerator.Parsing.Matching.Matchers;
+
+namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
+{
+    [TestClass]
+    public class MatcherGroupOptionalTest
+    {
+        private Mock<ILexer> lexerMock;
+        private MatchingContext matchingContext;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            lexerMock = new Mock<ILexer>();
+            matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
+        }
+
+        [TestMethod]
+        public void EnsureIsSuccessfulWhenMatcherIsSuccessful()
+        {
+            var matcherGroup = new MatcherGroupOptional(new TestMatcher(true, 5));
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(5, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureIsSuccessfulWhenMatcherIsUnsuccessful()
+        {
+            var matcherGroup = new MatcherGroupOptional(new TestMatcher(false, 0));
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Matching/Matchers/MatcherGroupOrTest.cs

@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.Matching;
+using ZoneCodeGenerator.Parsing.Matching.Matchers;
+
+namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
+{
+    [TestClass]
+    public class MatcherGroupOrTest
+    {
+        private Mock<ILexer> lexerMock;
+        private MatchingContext matchingContext;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            lexerMock = new Mock<ILexer>();
+            matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
+        }
+
+        [TestMethod]
+        public void EnsureAnyTestSuccessfulMakesGroupSuccessful()
+        {
+            var matcherGroup = new MatcherGroupOr
+            (
+                new TestMatcher(false, 0),
+                new TestMatcher(false, 0),
+                new TestMatcher(true, 3),
+                new TestMatcher(false, 0)
+            );
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(3, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureLastTestSuccessfulMakesGroupSuccessful()
+        {
+            var matcherGroup = new MatcherGroupOr
+            (
+                new TestMatcher(false, 0),
+                new TestMatcher(false, 0),
+                new TestMatcher(false, 0),
+                new TestMatcher(true, 4)
+            );
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(4, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureAllTestsSuccessfulMakesGroupSuccessful()
+        {
+            var matcherGroup = new MatcherGroupOr
+            (
+                new TestMatcher(true, 1),
+                new TestMatcher(true, 2),
+                new TestMatcher(true, 3),
+                new TestMatcher(true, 4)
+            );
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureNoTestsSuccessfulMakesGroupUnsuccessful()
+        {
+            var matcherGroup = new MatcherGroupOr
+            (
+                new TestMatcher(false, 0),
+                new TestMatcher(false, 0),
+                new TestMatcher(false, 0)
+            );
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureTestsAreCalledWithCorrectTokenOffsets()
+        {
+            var testMatchers = new[]
+            {
+                new TestMatcher(false, 0),
+                new TestMatcher(false, 0),
+                new TestMatcher(false, 0),
+                new TestMatcher(true, 4),
+                new TestMatcher(false, 0),
+            };
+            var iTokenMatcherArray = (TokenMatcher[])testMatchers.Clone();
+            var matcherGroup = new MatcherGroupOr(iTokenMatcherArray);
+
+            var result = matcherGroup.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(4, result.ConsumedTokenCount);
+            
+            Assert.IsTrue(testMatchers[0].WasTested);
+            Assert.AreEqual(0, testMatchers[0].TestTokenOffset);
+            
+            Assert.IsTrue(testMatchers[1].WasTested);
+            Assert.AreEqual(0, testMatchers[1].TestTokenOffset);
+            
+            Assert.IsTrue(testMatchers[2].WasTested);
+            Assert.AreEqual(0, testMatchers[2].TestTokenOffset);
+            
+            Assert.IsTrue(testMatchers[3].WasTested);
+            Assert.AreEqual(0, testMatchers[3].TestTokenOffset);
+            
+            Assert.IsFalse(testMatchers[4].WasTested);
+        }
+
+        [TestMethod]
+        public void EnsureGroupWithNoTestsThrowsException()
+        {
+            MatcherGroupOr matcherGroup = null;
+
+            Assert.ThrowsException<ArgumentException>(
+                () => matcherGroup = new MatcherGroupOr()
+            );
+
+            Assert.IsNull(matcherGroup);
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Matching/Matchers/MatcherLiteralTest.cs

@@ -0,0 +1,99 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.Matching;
+using ZoneCodeGenerator.Parsing.Matching.Matchers;
+
+namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
+{
+    [TestClass]
+    public class MatcherLiteralTest
+    {
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        private MatchingContext matchingContext;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            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);
+
+            matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
+        }
+
+        [TestMethod]
+        public void EnsureMatchingSameStringReturnsSuccessful()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "const"
+            });
+
+            var matcher = new MatcherLiteral("const");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureMatchingDifferentStringReturnsUnsuccessful()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "long"
+            });
+
+            var matcher = new MatcherLiteral("const");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureMatchingIsCaseSensitive()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "CONST"
+            });
+
+            var matcher = new MatcherLiteral("const");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureNamedMatchIsLiteralItself()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "const"
+            });
+
+            var matcher = new MatcherLiteral("const").WithName("test_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+            Assert.AreEqual("const", result["test_token"].ElementAtOrDefault(0));
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Matching/Matchers/MatcherNameTest.cs

@@ -0,0 +1,159 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.Matching;
+using ZoneCodeGenerator.Parsing.Matching.Matchers;
+
+namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
+{
+    [TestClass]
+    public class MatcherNameTest
+    {
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        private MatchingContext matchingContext;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            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);
+
+            matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
+        }
+
+        [TestMethod]
+        public void EnsureRecognizesNormalName()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "variable_name"
+            });
+
+            var matcher = new MatcherName();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureRecognizesUnderscoreAtTheBeginning()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "_variable_name"
+            });
+
+            var matcher = new MatcherName();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsDigit()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "v4ri4bl3_n4m3"
+            });
+
+            var matcher = new MatcherName();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureDoesNotAcceptDigitAtTheBeginning()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "5variable_name"
+            });
+
+            var matcher = new MatcherName();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureDoesNotAcceptCKeyword()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "float"
+            });
+
+            var matcher = new MatcherName();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureDoesNotAcceptSymbols()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "%$§"
+            });
+
+            var matcher = new MatcherName();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureDoesNotAcceptEmptyString()
+        {
+            tokens.AddRange(new List<string>
+            {
+                ""
+            });
+
+            var matcher = new MatcherName();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureNamedOutputIsMatchedName()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "variable_n4me"
+            });
+
+            var matcher = new MatcherName().WithName("name_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+            Assert.AreEqual("variable_n4me", result["name_token"].ElementAtOrDefault(0));
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Matching/Matchers/MatcherNumberTest.cs

@@ -0,0 +1,160 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.Matching;
+using ZoneCodeGenerator.Parsing.Matching.Matchers;
+
+namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
+{
+    [TestClass]
+    public class MatcherNumberTest
+    {
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        private MatchingContext matchingContext;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            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);
+
+            matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
+        }
+
+        [TestMethod]
+        public void EnsureDecimalNumbersAreRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "1337"
+            });
+
+            var matcher = new MatcherNumber();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureHexNumbersAreRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "0x1A4"
+            });
+
+            var matcher = new MatcherNumber();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureHexNumbersWithInvalidLettersAreInvalid()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "0xAFZF"
+            });
+
+            var matcher = new MatcherNumber();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureWordsAreInvalid()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "Hello"
+            });
+
+            var matcher = new MatcherNumber();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureSymbolsAreInvalid()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "%"
+            });
+
+            var matcher = new MatcherNumber();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureJustHexPrefixIsInvalid()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "0x"
+            });
+
+            var matcher = new MatcherNumber();
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureNamedOutputIsDecimalNumberForDecimalInput()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "420"
+            });
+
+            var matcher = new MatcherNumber().WithName("number_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+            Assert.AreEqual("420", result["number_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureNamedOutputIsDecimalNumberForHexInput()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "0x1a5"
+            });
+
+            var matcher = new MatcherNumber().WithName("number_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+            Assert.AreEqual("421", result["number_token"].ElementAtOrDefault(0));
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Matching/Matchers/MatcherTypenameTest.cs

@@ -0,0 +1,278 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using ZoneCodeGenerator.Parsing;
+using ZoneCodeGenerator.Parsing.Matching;
+using ZoneCodeGenerator.Parsing.Matching.Matchers;
+
+namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
+{
+    [TestClass]
+    public class MatcherTypenameTest
+    {
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        private MatchingContext matchingContext;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            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);
+
+            matchingContext = new MatchingContext(lexerMock.Object, new Dictionary<string, TokenMatcher>());
+        }
+
+        [TestMethod]
+        public void EnsureBaseTypeNamesAreRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "int"
+            });
+            
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+            Assert.AreEqual("int", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureNormalTypeNamesAreRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "GfxWorld"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+            Assert.AreEqual("GfxWorld", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureUnsignedTypeNamesAreRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "unsigned", "int"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(2, result.ConsumedTokenCount);
+            Assert.AreEqual("unsigned int", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureSignedTypeNamesAreRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "signed", "int"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(2, result.ConsumedTokenCount);
+            Assert.AreEqual("signed int", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureConstTypeNamesAreRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "const", "int"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(2, result.ConsumedTokenCount);
+            Assert.AreEqual("const int", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureDoubleLongIsRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "long", "long"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(2, result.ConsumedTokenCount);
+            Assert.AreEqual("long long", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureDoubleLongWithPrefixesIsRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "const", "unsigned", "long", "long"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(4, result.ConsumedTokenCount);
+            Assert.AreEqual("const unsigned long long", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureDoubleIntIsNotRecognized()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "int", "int"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+            Assert.AreEqual("int", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureNamespacesAreAllowed()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "std", ":", ":", "string"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(4, result.ConsumedTokenCount);
+            Assert.AreEqual("std::string", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsTypeNamesWithNumbersAndUnderscores()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "std", ":", ":", "int32_t"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(4, result.ConsumedTokenCount);
+            Assert.AreEqual("std::int32_t", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureShortNamespacesAreAllowed()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "a", ":", ":", "b"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(4, result.ConsumedTokenCount);
+            Assert.AreEqual("a::b", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureDoubleColonPrefixIsNotAllowed()
+        {
+            tokens.AddRange(new List<string>
+            {
+                ":", ":", "string"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+            Assert.That.IsZero(result["type_token"].Count);
+        }
+
+        [TestMethod]
+        public void EnsureSingleDoubleColonNamespacesDoNotMatch()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "std", ":", "string"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsTrue(result.Successful);
+            Assert.AreEqual(1, result.ConsumedTokenCount);
+            Assert.AreEqual("std", result["type_token"].ElementAtOrDefault(0));
+        }
+
+        [TestMethod]
+        public void EnsureSymbolsAreNotAllowed()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "%"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+            Assert.That.IsZero(result["type_token"].Count);
+        }
+
+        [TestMethod]
+        public void EnsureSymbolsWithUnsignedAreNotAllowed()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "unsigned", "%"
+            });
+
+            var matcher = new MatcherTypename().WithName("type_token");
+            var result = matcher.Test(matchingContext, 0);
+
+            Assert.IsFalse(result.Successful);
+            Assert.AreEqual(0, result.ConsumedTokenCount);
+            Assert.That.IsZero(result["type_token"].Count);
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Matching/Matchers/TestMatcher.cs

@@ -0,0 +1,41 @@
+using ZoneCodeGenerator.Parsing.Matching;
+
+namespace ZoneCodeGeneratorTests.Parsing.Matching.Matchers
+{
+    class TestMatcher : TokenMatcher
+    {
+        private readonly int tokenCount;
+        private readonly string tokenName;
+
+        public bool Successful { get; set; }
+        public int TestTokenOffset { get; private set; }
+        public bool WasTested { get; private set; }
+
+        public TestMatcher(bool successful, int tokenCount, string tokenName = "")
+        {
+            Successful = successful;
+            this.tokenCount = tokenCount;
+            this.tokenName = tokenName;
+            TestTokenOffset = 0;
+            WasTested = false;
+        }
+
+        protected override string GetIdentifier()
+        {
+            return "TestMatcher";
+        }
+
+        protected override TokenMatchingResult PerformTest(MatchingContext context, int tokenOffset)
+        {
+            var result = new TokenMatchingResult(Successful, Successful ? tokenCount : 0);
+
+            if(!string.IsNullOrEmpty(tokenName))
+                result.AddNamedMatch(tokenName, "test");
+
+            TestTokenOffset = tokenOffset;
+            WasTested = true;
+
+            return result;
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Mock/IncludingParsingStreamTest.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using ZoneCodeGenerator.Parsing;
+
+namespace ZoneCodeGeneratorTests.Parsing.Mock
+{
+    class IncludingParsingStreamTest : IIncludingParsingStream
+    {
+        public string Filename { get; set; }
+        public int Line { get; set; }
+        public List<string> Lines { get; }
+        public bool EndOfStream => Line >= Lines.Count;
+        public string LastInclude { get; private set; }
+        public int IncludeCount { get; private set; }
+
+        public IncludingParsingStreamTest(string filename)
+        {
+            Line = 0;
+            Filename = filename;
+            Lines = new List<string>();
+            LastInclude = "";
+            IncludeCount = 0;
+        }
+
+        public string ReadLine()
+        {
+            return EndOfStream ? "" : Lines[Line++];
+        }
+
+        public void IncludeFile(string filename)
+        {
+            LastInclude = filename;
+            IncludeCount++;
+        }
+
+        public void Close()
+        {
+            
+        }
+
+        public void Dispose()
+        {
+            Close();
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Testing/Tests/TestCloseBlockTest.cs

@@ -0,0 +1,161 @@
+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 TestCloseBlockTest
+    {
+        private Mock<IHeaderParserState> parserStateMock;
+        private Mock<Block> topBlock;
+        private Mock<INameAssignable> topBlockNameAssignable;
+
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            parserStateMock = new Mock<IHeaderParserState>();
+            topBlock = new Mock<Block>(parserStateMock.Object, BlockType.None);
+            topBlockNameAssignable = topBlock.As<INameAssignable>();
+
+            parserStateMock.SetupGet(state => state.CurrentBlock).Returns(() => topBlock.Object);
+
+            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 EnsureRecognizesSimpleCurlyBrackets()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "}", "struct", "test", "{"
+            });
+
+            var test = new TestCloseBlock(false);
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+
+            // Be sure there was no name assigned
+            topBlockNameAssignable.Verify(assignable => assignable.AssignName(It.IsAny<string>()), Times.Never());
+
+            // Be sure the top block was popped
+            parserStateMock.Verify(state => state.PopBlock());
+
+            Assert.AreEqual(1, test.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureRecognizesCurlyBracketsWithSemicolon()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "}", ";", "struct", "test", "{"
+            });
+
+            var test = new TestCloseBlock(true);
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+
+            // Be sure there was no name assigned
+            topBlockNameAssignable.Verify(assignable => assignable.AssignName(It.IsAny<string>()), Times.Never());
+
+            // Be sure the top block was popped
+            parserStateMock.Verify(state => state.PopBlock());
+
+            Assert.AreEqual(2, test.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureFailsWithoutSemicolonIfRequired()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "}", "struct", "test", "{"
+            });
+
+            var test = new TestCloseBlock(true);
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+
+            // Be sure there was no name assigned
+            topBlockNameAssignable.Verify(assignable => assignable.AssignName(It.IsAny<string>()), Times.Never());
+            
+            parserStateMock.Verify(state => state.PopBlock(), Times.Never());
+        }
+
+        [TestMethod]
+        public void EnsureAssignsName()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "}", "closing_name", ";", "struct", "test", "{"
+            });
+
+            var test = new TestCloseBlock(true);
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            
+            topBlockNameAssignable.Verify(assignable => assignable.AssignName("closing_name"));
+            topBlockNameAssignable.VerifyNoOtherCalls();
+
+            // Be sure the top block was popped
+            parserStateMock.Verify(state => state.PopBlock());
+
+            Assert.AreEqual(3, test.ConsumedTokenCount);
+        }
+
+        [TestMethod]
+        public void EnsureFailsIfCannotAssignName()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "}", "closing_name", ";", "struct", "test", "{"
+            });
+
+            // No INameAssignable interface implemented
+            topBlock = new Mock<Block>(parserStateMock.Object, BlockType.None);
+
+            var test = new TestCloseBlock(true);
+            
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            
+            parserStateMock.Verify(state => state.PopBlock(), Times.Never());
+        }
+
+        [TestMethod]
+        public void EnsureDoesNotMatchIfNoCurlyBracket()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "{", "}", "struct", "test", "{"
+            });
+
+            var test = new TestCloseBlock(false);
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            
+            parserStateMock.Verify(state => state.PopBlock(), Times.Never());
+
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Testing/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.Testing.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());
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Testing/Tests/TestEnumTest.cs

@@ -0,0 +1,394 @@
+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.Testing.Tests
+{
+    [TestClass]
+    public class TestEnumTest
+    {
+        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>();
+
+            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 EnsureAcceptsSimpleEnumOpening()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(3, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
+            parserStateMock.VerifyNoOtherCalls();
+
+            if (pushedBlock is BlockEnum blockEnum)
+            {
+                Assert.AreEqual("test_enum", blockEnum.Name);
+                Assert.IsFalse(blockEnum.IsTypedef);
+                Assert.AreEqual(DataTypeBaseType.INT, blockEnum.ParentType);
+            }
+            else
+                Assert.Fail("Pushed block is supposed to be an enum");
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsEnumAsTypedef()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "typedef", "enum", "test_enum", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(4, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
+            parserStateMock.VerifyNoOtherCalls();
+
+            if (pushedBlock is BlockEnum blockEnum)
+            {
+                Assert.AreEqual("test_enum", blockEnum.Name);
+                Assert.IsTrue(blockEnum.IsTypedef);
+                Assert.AreEqual(DataTypeBaseType.INT, blockEnum.ParentType);
+            }
+            else
+                Assert.Fail("Pushed block is supposed to be an enum");
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsEnumWithParentTypeSpecified()
+        {
+            parserStateMock.Setup(state => state.FindType("unsigned char")).Returns(DataTypeBaseType.UNSIGNED_CHAR);
+
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ":", "unsigned", "char", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(6, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
+
+            if (pushedBlock is BlockEnum blockEnum)
+            {
+                Assert.AreEqual("test_enum", blockEnum.Name);
+                Assert.IsFalse(blockEnum.IsTypedef);
+                Assert.AreEqual(DataTypeBaseType.UNSIGNED_CHAR, blockEnum.ParentType);
+            }
+            else
+                Assert.Fail("Pushed block is supposed to be an enum");
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsEnumWithParentTypeAsTypedef()
+        {
+            var typeDeclaration = new TypeDeclaration(DataTypeBaseType.SHORT, new List<ReferenceType>());
+            var typedef = new DataTypeTypedef("", "bla_blub", typeDeclaration);
+            parserStateMock.Setup(state => state.FindType("bla_blub")).Returns(typedef);
+
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ":", "bla_blub", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(5, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
+
+            if (pushedBlock is BlockEnum blockEnum)
+            {
+                Assert.AreEqual("test_enum", blockEnum.Name);
+                Assert.IsFalse(blockEnum.IsTypedef);
+                Assert.AreEqual(DataTypeBaseType.SHORT, blockEnum.ParentType);
+            }
+            else
+                Assert.Fail("Pushed block is supposed to be an enum");
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsEnumWithParentTypeAsTypedefWithNamespace()
+        {
+            var typeDeclaration = new TypeDeclaration(DataTypeBaseType.SHORT, new List<ReferenceType>());
+            var typedef = new DataTypeTypedef("std", "bla_blub", typeDeclaration);
+            parserStateMock.Setup(state => state.FindType("std::bla_blub")).Returns(typedef);
+
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ":", "std", ":", ":", "bla_blub", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(8, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
+
+            if (pushedBlock is BlockEnum blockEnum)
+            {
+                Assert.AreEqual("test_enum", blockEnum.Name);
+                Assert.IsFalse(blockEnum.IsTypedef);
+                Assert.AreEqual(DataTypeBaseType.SHORT, blockEnum.ParentType);
+            }
+            else
+                Assert.Fail("Pushed block is supposed to be an enum");
+        }
+
+        [TestMethod]
+        public void EnsureRejectsEnumWithInvalidParentType()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ":", "non_existant", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
+            parserStateMock.Verify(state => state.FindType("non_existant"), Times.Once());
+        }
+
+        [TestMethod]
+        public void EnsureRejectsEnumWithParentTypeAsTypedefWithArray()
+        {
+            var typeDeclaration = new TypeDeclaration(DataTypeBaseType.SHORT, new List<ReferenceType>
+            {
+                new ReferenceTypeArray(3)
+            });
+            var typedef = new DataTypeTypedef("", "bla_blub", typeDeclaration);
+            parserStateMock.Setup(state => state.FindType("bla_blub")).Returns(typedef);
+
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ":", "bla_blub", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
+            parserStateMock.Verify(state => state.FindType("bla_blub"), Times.Once());
+        }
+
+        [TestMethod]
+        public void EnsureRejectsEnumWithParentTypeAsTypedefWithPointerDepth()
+        {
+            var typeDeclaration = new TypeDeclaration(DataTypeBaseType.SHORT, new List<ReferenceType>
+            {
+                new ReferenceTypePointer()
+            });
+            var typedef = new DataTypeTypedef("", "bla_blub", typeDeclaration);
+            parserStateMock.Setup(state => state.FindType("bla_blub")).Returns(typedef);
+
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ":", "bla_blub", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
+            parserStateMock.Verify(state => state.FindType("bla_blub"), Times.Once());
+        }
+
+        [TestMethod]
+        public void EnsureRejectsEnumWithParentTypeNotBaseType()
+        {
+            var _struct = new DataTypeStruct("", "bla_blub", 4);
+            parserStateMock.Setup(state => state.FindType("bla_blub")).Returns(_struct);
+
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ":", "bla_blub", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
+            parserStateMock.Verify(state => state.FindType("bla_blub"), Times.Once());
+        }
+
+        [TestMethod]
+        public void EnsureRejectsEnumWithParentTypeTypedefNotBaseType()
+        {
+            var _struct = new DataTypeStruct("", "bla_blub", 4);
+            var typeDeclaration = new TypeDeclaration(_struct, new List<ReferenceType>());
+            var typedef = new DataTypeTypedef("", "bla_blub", typeDeclaration);
+            parserStateMock.Setup(state => state.FindType("bla_blub")).Returns(typedef);
+
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ":", "bla_blub", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.ThrowsException<TestFailedException>(() => test.PerformTest(parserStateMock.Object, lexerMock.Object));
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
+            parserStateMock.Verify(state => state.FindType("bla_blub"), Times.Once());
+        }
+
+        [TestMethod]
+        public void EnsureRejectsWhenKeywordIsWrong()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "notenum", "test_enum", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
+            parserStateMock.VerifyNoOtherCalls();
+        }
+
+        [TestMethod]
+        public void EnsureRejectsWhenNameIsWrong()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "enum", "3name", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
+            parserStateMock.VerifyNoOtherCalls();
+        }
+
+        [TestMethod]
+        public void EnsureRejectsWhenNoCurlyBrackets()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", "test", "test2"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
+            parserStateMock.VerifyNoOtherCalls();
+        }
+
+        [TestMethod]
+        public void EnsureRejectsWhenDoubleColonButNoType()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ":", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
+            parserStateMock.VerifyNoOtherCalls();
+        }
+
+        [TestMethod]
+        public void EnsureRejectsWhenDoubleColonAndTypeButNoBracket()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ":", "short", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Never());
+            parserStateMock.VerifyNoOtherCalls();
+        }
+
+        [TestMethod]
+        public void EnsureNameIsGeneratedIfNoneExisting()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "enum", "{", "test"
+            });
+
+            var test = new TestEnum();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(2, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.PushBlock(It.IsAny<Block>()), Times.Once());
+            parserStateMock.VerifyNoOtherCalls();
+
+            if (pushedBlock is BlockEnum blockEnum)
+            {
+                Assert.IsFalse(string.IsNullOrEmpty(blockEnum.Name));
+                Assert.IsFalse(blockEnum.IsTypedef);
+                Assert.AreEqual(DataTypeBaseType.INT, blockEnum.ParentType);
+            }
+            else
+                Assert.Fail("Pushed block is supposed to be an enum");
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Parsing/Testing/Tests/TestForwardDeclTest.cs

@@ -0,0 +1,121 @@
+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.Tests;
+using ZoneCodeGenerator.Parsing.Testing;
+
+namespace ZoneCodeGeneratorTests.Parsing.Testing.Tests
+{
+    [TestClass]
+    public class TestForwardDeclTest
+    {
+        private Mock<IHeaderParserState> parserStateMock;
+        private ForwardDeclaration addedForwardDeclaration;
+
+        private Mock<ILexer> lexerMock;
+        private int tokenOffset;
+        private List<string> tokens;
+
+        private Namespace currentNamespace;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            currentNamespace = new Namespace();
+            parserStateMock = new Mock<IHeaderParserState>();
+
+            parserStateMock.SetupGet(state => state.CurrentNamespace).Returns(() => currentNamespace);
+            parserStateMock.Setup(state => state.AddForwardDeclaration(It.IsAny<ForwardDeclaration>()))
+                .Callback((ForwardDeclaration forwardDeclaration) => addedForwardDeclaration = forwardDeclaration);
+
+            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 EnsureAcceptsForwardDeclarationForEnums()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "enum", "test_enum", ";"
+            });
+
+            var test = new TestForwardDecl();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(3, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.AddForwardDeclaration(It.IsAny<ForwardDeclaration>()), Times.Once());
+
+            Assert.AreEqual("", addedForwardDeclaration.Namespace);
+            Assert.AreEqual("test_enum", addedForwardDeclaration.Name);
+            Assert.AreEqual(DataTypeType.Enum, addedForwardDeclaration.Type);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsForwardDeclarationForStructs()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "struct", "test_struct", ";"
+            });
+
+            var test = new TestForwardDecl();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(3, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.AddForwardDeclaration(It.IsAny<ForwardDeclaration>()), Times.Once());
+
+            Assert.AreEqual("", addedForwardDeclaration.Namespace);
+            Assert.AreEqual("test_struct", addedForwardDeclaration.Name);
+            Assert.AreEqual(DataTypeType.Struct, addedForwardDeclaration.Type);
+        }
+
+        [TestMethod]
+        public void EnsureAcceptsForwardDeclarationForUnions()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "union", "test_union", ";"
+            });
+
+            var test = new TestForwardDecl();
+
+            Assert.AreEqual(TokenTestResult.Match, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(3, test.ConsumedTokenCount);
+
+            parserStateMock.Verify(state => state.AddForwardDeclaration(It.IsAny<ForwardDeclaration>()), Times.Once());
+
+            Assert.AreEqual("", addedForwardDeclaration.Namespace);
+            Assert.AreEqual("test_union", addedForwardDeclaration.Name);
+            Assert.AreEqual(DataTypeType.Union, addedForwardDeclaration.Type);
+        }
+
+        [TestMethod]
+        public void EnsureRejectsForwardDeclarationForNamespaces()
+        {
+            tokens.AddRange(new List<string>
+            {
+                "namespace", "test_union", ";"
+            });
+
+            var test = new TestForwardDecl();
+
+            Assert.AreEqual(TokenTestResult.NoMatch, test.PerformTest(parserStateMock.Object, lexerMock.Object));
+            Assert.AreEqual(0, test.ConsumedTokenCount);
+        }
+    }
+}

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();
+        }
+    }
+}