Import code from previous AssetBuilder version

test/ZoneCodeGeneratorTests/AssertionExtensions.cs

@@ -0,0 +1,25 @@
+using System.Collections;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace ZoneCodeGeneratorTests
+{
+    public static class AssertionExtensions
+    {
+        public static void Contains(this Assert assert, object expected, ICollection collection)
+        {
+            if (collection.Cast<object>().Any(item => item == expected))
+            {
+                return;
+            }
+
+            throw new AssertFailedException();
+        }
+
+        public static void IsZero(this Assert assert, int number)
+        {
+            if(number != 0)
+                throw new AssertFailedException();
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Domain/NamespaceTest.cs

@@ -0,0 +1,95 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ZoneCodeGenerator.Domain;
+
+namespace ZoneCodeGeneratorTests.Domain
+{
+    [TestClass]
+    public class NamespaceTest
+    {
+        [TestMethod]
+        public void EnsureEmptyNamespaceResultIsCorrect()
+        {
+            var nameSpace = new Namespace();
+            
+            Assert.AreEqual("", nameSpace.GetName());
+        }
+
+        [TestMethod]
+        public void EnsureSingleNamespaceElementResultIsCorrect()
+        {
+            var nameSpace = new Namespace();
+
+            nameSpace.Push("NameTheSpace");
+            
+            Assert.AreEqual("NameTheSpace", nameSpace.GetName());
+        }
+
+        [TestMethod]
+        public void EnsureDoubleNamespaceElementResultIsCorrect()
+        {
+            var nameSpace = new Namespace();
+
+            nameSpace.Push("NameTheSpace");
+            nameSpace.Push("Please");
+            
+            Assert.AreEqual("NameTheSpace::Please", nameSpace.GetName());
+        }
+
+        [TestMethod]
+        public void EnsurePopRemovesNamespace()
+        {
+            var nameSpace = new Namespace();
+
+            nameSpace.Push("NameTheSpace");
+            nameSpace.Push("Please");
+            nameSpace.Push("Not");
+            
+            Assert.AreEqual("Not", nameSpace.Pop());
+            Assert.AreEqual("NameTheSpace::Please", nameSpace.GetName());
+        }
+
+        [TestMethod]
+        public void EnsureMultipleNamespaceElementsResultIsCorrect()
+        {
+            var nameSpace = new Namespace();
+
+            nameSpace.Push("NameTheSpace");
+            nameSpace.Push("Please");
+            nameSpace.Push("Just");
+            nameSpace.Push("Not");
+            nameSpace.Push("MySpace");
+            
+            Assert.AreEqual("NameTheSpace::Please::Just::Not::MySpace", nameSpace.GetName());
+        }
+
+        [TestMethod]
+        public void EnsureNamespaceCanBePoppedToEmpty()
+        {
+            var nameSpace = new Namespace();
+
+            nameSpace.Push("NameTheSpace");
+            nameSpace.Push("Please");
+
+            Assert.AreEqual("Please", nameSpace.Pop());
+            Assert.AreEqual("NameTheSpace", nameSpace.Pop());
+            
+            Assert.AreEqual("", nameSpace.GetName());
+        }
+
+        [TestMethod]
+        public void EnsureUsingPopTooOftenResultsInAnError()
+        {
+            var nameSpace = new Namespace();
+
+            nameSpace.Push("NameTheSpace");
+            nameSpace.Push("Please");
+
+            Assert.AreEqual("Please", nameSpace.Pop());
+            Assert.AreEqual("NameTheSpace", nameSpace.Pop());
+            Assert.ThrowsException<InvalidOperationException>(() => nameSpace.Pop());
+            
+            Assert.AreEqual("", nameSpace.GetName());
+        }
+    }
+}

test/ZoneCodeGeneratorTests/FieldInjector.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Reflection;
+
+namespace ZoneCodeGeneratorTests
+{
+    internal static class FieldInjector
+    {
+        public static bool InjectToField(object target, object toInject)
+        {
+            if(target == null || toInject == null)
+                throw new ArgumentException("Params must not be null");
+
+            var injectType = toInject.GetType();
+            var fields = target.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
+
+            foreach(var field in fields)
+            {
+                if (!field.FieldType.IsAssignableFrom(injectType)) continue;
+
+                field.SetValue(target, toInject);
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

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

test/ZoneCodeGeneratorTests/Persistence/InMemoryDataRepositoryTest.cs

@@ -0,0 +1,142 @@
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ZoneCodeGenerator.Domain;
+using ZoneCodeGenerator.Persistence;
+
+namespace ZoneCodeGeneratorTests.Persistence
+{
+    [TestClass]
+    public class InMemoryDataRepositoryTest
+    {
+        private IDataRepository dataRepository;
+
+        private DataTypeEnum enum1;
+        private DataTypeEnum enum2;
+
+        private DataTypeStruct struct1;
+        private DataTypeStruct struct2;
+
+        private DataTypeUnion union1;
+        private DataTypeUnion union2;
+
+        private DataTypeTypedef typedef1;
+        private DataTypeTypedef typedef2;
+
+        [TestInitialize]
+        public void PrepareSampleStorage()
+        {
+            dataRepository = new InMemoryDataRepository();
+
+            enum1 = new DataTypeEnum("namespace1", "enum1", DataTypeBaseType.INT);
+            enum2 = new DataTypeEnum("other_namespace", "enum2", DataTypeBaseType.SHORT);
+
+            struct1 = new DataTypeStruct("", "test_struct1", 4);
+            struct2 = new DataTypeStruct("space", "aBeautifulStruct", 2);
+            
+            union1 = new DataTypeUnion("", "u", 4);
+            union2 = new DataTypeUnion("namespacesareaverynice", "averylongunionnamewhowouldevercreateanamethislong", 16);
+
+            var typeDeclaration1 = new TypeDeclaration(DataTypeBaseType.BOOL, new List<ReferenceType>
+            {
+                new ReferenceTypeArray(4),
+                new ReferenceTypeArray(6)
+            });
+            typedef1 = new DataTypeTypedef("namespace1", "mytypedef", typeDeclaration1);
+            var typeDeclaration2 = new TypeDeclaration(struct1, new List<ReferenceType>
+            {
+                new ReferenceTypePointer()
+            });
+            typedef2 = new DataTypeTypedef("", "struct1_p", typeDeclaration2);
+
+            dataRepository.Add(enum1);
+            dataRepository.Add(enum2);
+            dataRepository.Add(struct1);
+            dataRepository.Add(struct2);
+            dataRepository.Add(union1);
+            dataRepository.Add(union2);
+            dataRepository.Add(typedef1);
+            dataRepository.Add(typedef2);
+        }
+
+        [TestMethod]
+        public void EnsureEnumsCanBeSavedAndRestored()
+        {
+            var allEnums = new List<DataTypeEnum>(dataRepository.GetAllEnums());
+
+            Assert.AreEqual(2, allEnums.Count);
+            
+            Assert.That.Contains(enum1, allEnums);
+            Assert.That.Contains(enum2, allEnums);
+        }
+
+        [TestMethod]
+        public void EnsureStructsCanBeSavedAndRestored()
+        {
+            var allEnums = new List<DataTypeStruct>(dataRepository.GetAllStructs());
+
+            Assert.AreEqual(2, allEnums.Count);
+            Assert.That.Contains(struct1, allEnums);
+            Assert.That.Contains(struct2, allEnums);
+        }
+
+        [TestMethod]
+        public void EnsureUnionsCanBeSavedAndRestored()
+        {
+            var allUnions = new List<DataTypeUnion>(dataRepository.GetAllUnions());
+
+            Assert.AreEqual(2, allUnions.Count);
+            Assert.That.Contains(union1, allUnions);
+            Assert.That.Contains(union2, allUnions);
+        }
+
+        [TestMethod]
+        public void EnsureTypedefsCanBeSavedAndRestored()
+        {
+            var allTypedefs = new List<DataTypeTypedef>(dataRepository.GetAllTypedefs());
+
+            Assert.AreEqual(2, allTypedefs.Count);
+            Assert.That.Contains(typedef1, allTypedefs);
+            Assert.That.Contains(typedef2, allTypedefs);
+        }
+
+        [TestMethod]
+        public void EnsureEnumsCanBeFoundByName()
+        {
+            var foundDataType1 = dataRepository.GetDataTypeByName("namespace1::enum1");
+            Assert.AreEqual(enum1, foundDataType1);
+            
+            var foundDataType2 = dataRepository.GetDataTypeByName("other_namespace::enum2");
+            Assert.AreEqual(enum2, foundDataType2);
+        }
+
+        [TestMethod]
+        public void EnsureStructsCanBeFoundByName()
+        {
+            var foundDataType1 = dataRepository.GetDataTypeByName("test_struct1");
+            Assert.AreEqual(struct1, foundDataType1);
+            
+            var foundDataType2 = dataRepository.GetDataTypeByName("space::aBeautifulStruct");
+            Assert.AreEqual(struct2, foundDataType2);
+        }
+
+        [TestMethod]
+        public void EnsureUnionsCanBeFoundByName()
+        {
+            var foundDataType1 = dataRepository.GetDataTypeByName("u");
+            Assert.AreEqual(union1, foundDataType1);
+            
+            var foundDataType2 = dataRepository.GetDataTypeByName("namespacesareaverynice::averylongunionnamewhowouldevercreateanamethislong");
+            Assert.AreEqual(union2, foundDataType2);
+        }
+
+        [TestMethod]
+        public void EnsureTypedefsCanBeFoundByName()
+        {
+            var foundDataType1 = dataRepository.GetDataTypeByName("namespace1::mytypedef");
+            Assert.AreEqual(typedef1, foundDataType1);
+            
+            var foundDataType2 = dataRepository.GetDataTypeByName("struct1_p");
+            Assert.AreEqual(typedef2, foundDataType2);
+        }
+    }
+}

test/ZoneCodeGeneratorTests/Properties/AssemblyInfo.cs

@@ -0,0 +1,19 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("ZoneCodeGeneratorTests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ZoneCodeGeneratorTests")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+[assembly: ComVisible(false)]
+
+[assembly: Guid("c29242db-84d0-4a37-ad3f-19b72b23c7e0")]
+
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

test/ZoneCodeGeneratorTests/ZoneCodeGeneratorTests.csproj

@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\..\packages\MSTest.TestAdapter.2.0.0\build\net45\MSTest.TestAdapter.props" Condition="Exists('..\..\packages\MSTest.TestAdapter.2.0.0\build\net45\MSTest.TestAdapter.props')" />
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{C29242DB-84D0-4A37-AD3F-19B72B23C7E0}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ZoneCodeGeneratorTests</RootNamespace>
+    <AssemblyName>ZoneCodeGeneratorTests</AssemblyName>
+    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">15.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages</ReferencePath>
+    <IsCodedUITest>False</IsCodedUITest>
+    <TestProjectType>UnitTest</TestProjectType>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Castle.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Castle.Core.4.4.0\lib\net45\Castle.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.TestPlatform.TestFramework, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\MSTest.TestFramework.2.0.0\lib\net45\Microsoft.VisualStudio.TestPlatform.TestFramework.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\MSTest.TestFramework.2.0.0\lib\net45\Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions.dll</HintPath>
+    </Reference>
+    <Reference Include="Moq, Version=4.13.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Moq.4.13.0\lib\net45\Moq.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Runtime.CompilerServices.Unsafe, Version=4.0.4.1, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\System.Runtime.CompilerServices.Unsafe.4.5.2\lib\netstandard2.0\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\System.Threading.Tasks.Extensions.4.5.3\lib\netstandard2.0\System.Threading.Tasks.Extensions.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AssertionExtensions.cs" />
+    <Compile Include="Domain\NamespaceTest.cs" />
+    <Compile Include="FieldInjector.cs" />
+    <Compile Include="Parsing\Impl\LexerTest.cs" />
+    <Compile Include="Parsing\Impl\PreprocessorTest.cs" />
+    <Compile Include="Parsing\Matching\Matchers\MatcherArrayTest.cs" />
+    <Compile Include="Parsing\Matching\Matchers\MatcherGroupAndTest.cs" />
+    <Compile Include="Parsing\Matching\Matchers\MatcherGroupLoopTest.cs" />
+    <Compile Include="Parsing\Matching\Matchers\MatcherGroupOptionalTest.cs" />
+    <Compile Include="Parsing\Matching\Matchers\MatcherGroupOrTest.cs" />
+    <Compile Include="Parsing\Matching\Matchers\MatcherLiteralTest.cs" />
+    <Compile Include="Parsing\Matching\Matchers\MatcherNameTest.cs" />
+    <Compile Include="Parsing\Matching\Matchers\MatcherNumberTest.cs" />
+    <Compile Include="Parsing\Matching\Matchers\MatcherTypenameTest.cs" />
+    <Compile Include="Parsing\Matching\Matchers\TestMatcher.cs" />
+    <Compile Include="Parsing\Mock\IncludingParsingStreamTest.cs" />
+    <Compile Include="Parsing\Testing\Tests\TestCloseBlockTest.cs" />
+    <Compile Include="Parsing\Testing\Tests\TestEnumMemberTest.cs" />
+    <Compile Include="Parsing\Testing\Tests\TestEnumTest.cs" />
+    <Compile Include="Parsing\Testing\Tests\TestForwardDeclTest.cs" />
+    <Compile Include="Parsing\Testing\Tests\TestNamespaceTest.cs" />
+    <Compile Include="Persistence\InMemoryDataRepositoryTest.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\ZoneCodeGenerator\ZoneCodeGenerator.csproj">
+      <Project>{d1c20c32-9cb8-44b8-9df7-f0cf8fb304d3}</Project>
+      <Name>ZoneCodeGenerator</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets" Condition="Exists('$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets')" />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\..\packages\MSTest.TestAdapter.2.0.0\build\net45\MSTest.TestAdapter.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\MSTest.TestAdapter.2.0.0\build\net45\MSTest.TestAdapter.props'))" />
+    <Error Condition="!Exists('..\..\packages\MSTest.TestAdapter.2.0.0\build\net45\MSTest.TestAdapter.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\MSTest.TestAdapter.2.0.0\build\net45\MSTest.TestAdapter.targets'))" />
+  </Target>
+  <Import Project="..\..\packages\MSTest.TestAdapter.2.0.0\build\net45\MSTest.TestAdapter.targets" Condition="Exists('..\..\packages\MSTest.TestAdapter.2.0.0\build\net45\MSTest.TestAdapter.targets')" />
+</Project>

test/ZoneCodeGeneratorTests/app.config

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Threading.Tasks.Extensions" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.2.0.1" newVersion="4.2.0.1" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>

test/ZoneCodeGeneratorTests/packages.config

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Castle.Core" version="4.4.0" targetFramework="net461" />
+  <package id="Moq" version="4.13.0" targetFramework="net461" />
+  <package id="MSTest.TestAdapter" version="2.0.0" targetFramework="net461" />
+  <package id="MSTest.TestFramework" version="2.0.0" targetFramework="net461" />
+  <package id="System.Runtime.CompilerServices.Unsafe" version="4.5.2" targetFramework="net461" />
+  <package id="System.Threading.Tasks.Extensions" version="4.5.3" targetFramework="net461" />
+</packages>