using System;
using System.Collections.Generic;
using System.Text;
using UnitTestSharp;
using Sunweaver.Commands.Abstracts;
using Sunweaver.Commands;
using Sunweaver.VM;
using Sunweaver;
using Sunweaver.Parsing;
using Sunweaver.MetaTags;
using System.Linq;

namespace Sunweaver.UnitTesting.Parsing
{    
    public class ParserTests : TestFixture
    {
        public class TokenizeLineTests : TestFixture
        {
            public void Basic()
            {
                string line = "basic line of text";

                var tokens = Parser.TokenizeLine(line, 76);

                var expected = new Token[]
                {
                    new Token
                    {
                        line = 76,
                        column = 1,
                        token = "basic",
                    },

                    new Token
                    {
                        line = 76,
                        column = 7,
                        token = "line",
                    },

                    new Token
                    {
                        line = 76,
                        column = 12,
                        token = "of",
                    },

                    new Token
                    {
                        line = 76,
                        column = 15,
                        token = "text",
                    },
                };

                CheckEqual(expected, tokens);
            }

            public void Comment()
            {
                string line = "basic line of text'really long comment'even more comment";

                var tokens = Parser.TokenizeLine(line, 76);

                var expected = new Token[]
                {
                    new Token
                    {
                        line = 76,
                        column = 1,
                        token = "basic",
                    },

                    new Token
                    {
                        line = 76,
                        column = 7,
                        token = "line",
                    },

                    new Token
                    {
                        line = 76,
                        column = 12,
                        token = "of",
                    },

                    new Token
                    {
                        line = 76,
                        column = 15,
                        token = "text",
                    },
                };

                CheckEqual(expected, tokens);
            }

            public void CStyleComment()
            {
                string line = "basic line of text//really long comment//even more comment";

                var tokens = Parser.TokenizeLine(line, 76);

                var expected = new Token[]
                {
                    new Token
                    {
                        line = 76,
                        column = 1,
                        token = "basic",
                    },

                    new Token
                    {
                        line = 76,
                        column = 7,
                        token = "line",
                    },

                    new Token
                    {
                        line = 76,
                        column = 12,
                        token = "of",
                    },

                    new Token
                    {
                        line = 76,
                        column = 15,
                        token = "text",
                    },
                };

                CheckEqual(expected, tokens);
            }

            public void Empty()
            {
                string line = "";

                var tokens = Parser.TokenizeLine(line, 76);

                var expected = new Token[]
                {
                    
                };

                CheckEqual(expected, tokens);
            }

            public void EmptyWithComment()
            {
                string line = "    'Comment!";

                var tokens = Parser.TokenizeLine(line, 76);

                var expected = new Token[]
                {
                    
                };

                CheckEqual(expected, tokens);
            }

            public void TooManySpaces()
            {
                string line = "basic  line\t \tof  text";

                var tokens = Parser.TokenizeLine(line, 76);

                var expected = new Token[]
                {
                    new Token
                    {
                        line = 76,
                        column = 1,
                        token = "basic",
                    },

                    new Token
                    {
                        line = 76,
                        column = 8,
                        token = "line",
                    },

                    new Token
                    {
                        line = 76,
                        column = 15,
                        token = "of",
                    },

                    new Token
                    {
                        line = 76,
                        column = 19,
                        token = "text",
                    },
                };

                CheckEqual(expected, tokens);
            }
        }

        public class TryToParseAsMetaTagTests : UnitTestSharp.TestFixture
        {
            public void BasicConstantDef()
            {
                string line = "const six 6";

                var tokens = Parser.TokenizeLine(line, 1);

                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {

                };
                
                bool success = Parser.TryToParseAsMetaTag(tokens, dna, errors);
                MetaTag expected = new @const
                {
                    Label = "six",
                    Number = 6,
                };

                Check(success);
                CheckEqual(expected, dna.ConstantTags[0]);
                CheckEqual(expectedErrors, errors);
            }

            public void IncompleteConstant()
            {
                string line = "const six";

                var tokens = Parser.TokenizeLine(line, 1);

                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = tokens[0],
                    },
                };

                bool success = Parser.TryToParseAsMetaTag(tokens, dna, errors);
                
                Check(success);
                CheckEqual(0, dna.ConstantTags.Count);
                CheckEqual(expectedErrors, errors);
            }

            public void EmptyConstant()
            {
                string line = "const";

                var tokens = Parser.TokenizeLine(line, 1);

                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = tokens[0],
                    },
                };

                bool success = Parser.TryToParseAsMetaTag(tokens, dna, errors);

                Check(success);
                CheckEqual(0, dna.ConstantTags.Count);
                CheckEqual(expectedErrors, errors);
            }

            public void EmptyMacro()
            {
                string line = "macro";

                var tokens = Parser.TokenizeLine(line, 1);

                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = tokens[0],
                    },
                };

                bool success = Parser.TryToParseAsMetaTag(tokens, dna, errors);

                Check(success);
                CheckEqual(0, dna.MacroTags.Count);
                CheckEqual(expectedErrors, errors);
            }

            public void BasicObjectMacro()
            {
                string line = "macro six 3 2 mul";

                var tokens = Parser.TokenizeLine(line, 1);

                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {

                };

                bool success = Parser.TryToParseAsMetaTag(tokens, dna, errors);

                var expected = new macro
                {
                    CodeFragment = new Token[] {
                        new Token
                        {
                            token = "3",
                            line = 1,
                            column = 11,
                        },
                        new Token
                        {
                            token = "2",
                            line = 1,
                            column = 13,
                        },
                        new Token
                        {
                            token = "mul",
                            line = 1,
                            column = 15,
                        },
                    },
                    Label = "six",
                };

                Check(success);
                CheckEqual(expected, dna.MacroTags["six"]);
                CheckEqual(expectedErrors, errors);
            }

            public void MultiplyDefinedMacro_Identical()
            {
                string line = "macro six 3 2 mul";

                var tokens = Parser.TokenizeLine(line, 1);

                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {

                };

                Parser.TryToParseAsMetaTag(tokens, dna, errors);
                bool success = Parser.TryToParseAsMetaTag(tokens, dna, errors);

                var expected = new macro
                {
                    CodeFragment = new Token[] {
                        new Token
                        {
                            token = "3",
                            line = 1,
                            column = 11,
                        },
                        new Token
                        {
                            token = "2",
                            line = 1,
                            column = 13,
                        },
                        new Token
                        {
                            token = "mul",
                            line = 1,
                            column = 15,
                        },
                    },
                    Label = "six",
                };

                Check(success);
                CheckEqual(expected, dna.MacroTags["six"]);
                CheckEqual(0, errors.Count);
            }

            public void MultiplyDefinedMacro_Different()
            {
                string line1 = "macro six 3 2 mul";
                string line2 = "macro six 10";

                var tokens1 = Parser.TokenizeLine(line1, 1);
                var tokens2 = Parser.TokenizeLine(line2, 2);

                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {

                };

                Parser.TryToParseAsMetaTag(tokens1, dna, errors);
                bool success = Parser.TryToParseAsMetaTag(tokens2, dna, errors);

                var expected = new macro
                {
                    CodeFragment = new Token[] {
                        new Token
                        {
                            token = "3",
                            line = 1,
                            column = 11,
                        },
                        new Token
                        {
                            token = "2",
                            line = 1,
                            column = 13,
                        },
                        new Token
                        {
                            token = "mul",
                            line = 1,
                            column = 15,
                        },
                    },
                    Label = "six",
                };

                Check(success);
                CheckEqual(expected, dna.MacroTags["six"]);
                CheckEqual(1, errors.Count);
                CheckEqualRegex("defined more than once", errors[0].message);
            }

            public void EmptyObjectMacro()
            {
                string line = "macro six";

                var tokens = Parser.TokenizeLine(line, 1);

                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {

                };

                bool success = Parser.TryToParseAsMetaTag(tokens, dna, errors);

                Check(success);
                
                var expected = new macro
                {
                    CodeFragment = new Token[] { },
                    Label = "six",
                };

                CheckEqual(expected, dna.MacroTags["six"]);
                CheckEqual(expectedErrors, errors);
            }

            public void UnknownTag()
            {
                string line = "fakeTag add sub";

                var tokens = Parser.TokenizeLine(line, 1);

                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {

                };

                bool success = Parser.TryToParseAsMetaTag(tokens, dna, errors);

                CheckFalse(success);
                CheckEqual(expectedErrors, errors);
            }

            public void EmptyLine()
            {
                string line = "";

                var tokens = Parser.TokenizeLine(line, 1);

                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {

                };

                bool success = Parser.TryToParseAsMetaTag(tokens, dna, errors);

                CheckFalse(success);
                CheckEqual(expectedErrors, errors);
            }
        }

        public class TokenizeAndMetatagsTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                string dnatext = "const six 6\n six 7 add\n    mul div";

                int lineNumber;
                var returnMe = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {

                };

                var tokens = Parser.TokenizeAndMetatags(dnatext, returnMe, errors, out lineNumber);

                var expected = new Token[]
                {
                    new Token
                    {
                        line = 2,
                        column = 2,
                        token = "six",
                    },

                    new Token
                    {
                        line = 2,
                        column = 6,
                        token = "7",
                    },

                    new Token
                    {
                        line = 2,
                        column = 8,
                        token = "add",
                    },

                    new Token
                    {
                        line = 3,
                        column = 5,
                        token = "mul",
                    },

                    new Token
                    {
                        line = 3,
                        column = 9,
                        token = "div",
                    },
                };

                Check(returnMe.ConstantTags.Contains(new @const { Label = "six", Number = 6 }));
                CheckEqual(expected, tokens);
                CheckEqual(3, lineNumber);
                CheckEqual(expectedErrors, errors);
            }

            public void CarriageReturns()
            {
                string dnatext = "const six 6\r\n six 7 add\r\n    mul div";

                int lineNumber;
                var returnMe = new Chromosome();
                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {

                };

                var tokens = Parser.TokenizeAndMetatags(dnatext, returnMe, errors, out lineNumber);

                var expected = new Token[]
                {
                    new Token
                    {
                        line = 2,
                        column = 2,
                        token = "six",
                    },

                    new Token
                    {
                        line = 2,
                        column = 6,
                        token = "7",
                    },

                    new Token
                    {
                        line = 2,
                        column = 8,
                        token = "add",
                    },

                    new Token
                    {
                        line = 3,
                        column = 5,
                        token = "mul",
                    },

                    new Token
                    {
                        line = 3,
                        column = 9,
                        token = "div",
                    },
                };

                Check(returnMe.ConstantTags.Contains(new @const { Label = "six", Number = 6 }));
                CheckEqual(expected, tokens);
                CheckEqual(3, lineNumber);
                CheckEqual(expectedErrors, errors);
            }
        }

        public class ExtractCodulesTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var dnaText = "1 2 add";
                var dna = new Chromosome();

                var errors = new List<CompilationMessage>();
                var expectedErrors = new List<CompilationMessage>
                {

                };

                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = Parser.TokenizeLine(dnaText, 1).ToList(),
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqual(1, coduleDefinitions.Count);
                CheckEqual(expectedCoduleDefs, coduleDefinitions);
            }

            public void Embedded()
            {
                var dnaText = "{ 1 2 add }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        { 
                            new Token
                            {
                                column = 1,
                                line = 1,
                                token = "__anon0",
                            },
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                        coduleDefinitionToken = tokens[0],
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void DoubleEmbedded()
            {
                var dnaText = "{ { 1 2 add } call }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            new Token
                            {
                                token = "__anon0",
                                column = 1,
                                line = 1,
                            }
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        identifier = "__anon1",
                        tokens = tokens.GetRange(2, 3),
                        coduleDefinitionToken = tokens[1],
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens = new List<Token>
                        {
                            new Token
                            {
                                token = "__anon1",
                                column = 3,
                                line = 1,
                            },

                            tokens[6],
                        },
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void TripleEmbedded()
            {
                var dnaText = "{ { { 3 4 mul } 1 2 add } call }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = new List<Token>
                        {
                            tokens[1].CloneAndRename("__anon1"),
                            
                            tokens[11],
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[1],
                        identifier = "__anon1",
                        
                        tokens = new List<Token>
                        {
                            tokens[2].CloneAndRename("__anon2"),

                            tokens[7],
                            tokens[8],
                            tokens[9],
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[2],
                        identifier = "__anon2",
                        tokens = tokens.GetRange(3, 3),
                    },  
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void EndEmbedded()
            {
                var dnaText = "6 7 mul { 1 2 add }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0],
                            tokens[1],
                            tokens[2],
                            
                            new Token
                            {
                                column = tokens[3].column,
                                line = tokens[3].line,
                                token = "__anon0",
                            },
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[3],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(4, 3),
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void MidEmbedded()
            {
                var dnaText = "6 { 1 2 add } 7 mul";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0],

                            tokens[1].CloneAndRename("__anon0"),

                            tokens[6],
                            tokens[7],
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[1],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(2, 3),
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void Named()
            {
                var dnaText = "{inside 1 2 add }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("inside"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "inside",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void Named_Number()
            {
                var dnaText = "{69 1 2 add }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 69,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void Named_Number_Negative()
            {
                var dnaText = "{-1 1 2 add }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[0],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void Named_Number_TooLarge()
            {
                var dnaText = "{" + Chromosome.CoduleSlots + " -1 1 2 add }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 4),
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[0],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void PunctuationNamed()
            {
                var dnaText = "@{inside 1 2 add }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("@inside"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "inside",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void PunctuationAnonymous()
            {
                var dnaText = "@{ 1 2 add }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("@__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void NotEnoughEnds()
            {
                var dnaText = "{ { 1 2 add ";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[1],
                        identifier = "__anon1",
                        tokens = tokens.GetRange(2, 3),
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = new List<Token>
                        {
                            tokens[1].CloneAndRename("__anon1"),
                        },
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[1],
                    },

                    new CompilationMessage
                    {
                        token = tokens[0],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void TooManyEnds()
            {
                var dnaText = "1 2 add } }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = tokens.GetRange(0, 3),
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[3],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void TooManyBracesInOneToken()
            {
                var dnaText = "{{ 1 2 add }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[0],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void TooManyClosingBracesInOneToken()
            {
                var dnaText = "{ 1 2 add }}";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[4],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void MismatchedBracesInOneToken()
            {
                var dnaText = "{} 1 2 add }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[0],
                    },

                    new CompilationMessage
                    {
                        token = tokens[4],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void TailIndexRequest()
            {
                var dnaText = "{ 1 2 add }69";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 69,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void TailIndexRequest_Negative()
            {
                var dnaText = "{ 1 2 add }-69";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[4],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void TailIndexRequest_TooLarge()
            {
                var dnaText = "{ 1 2 add }" + Chromosome.CoduleSlots;
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[4],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void MatchedHeadTailIndexRequest()
            {
                var dnaText = "{69 1 2 add }69";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 69,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void MismatchedHeadTailIndexRequest()
            {
                var dnaText = "{69 1 2 add }70";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 69,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[4],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void BadTailSuffix()
            {
                var dnaText = "{ 1 2 add }stuff";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;                
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("__anon0"),
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon0",
                        tokens = tokens.GetRange(1, 3),
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = tokens[4],
                    },
                };

                CheckEqual(expectedErrors, errors);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void ImplicitCoduleCountStartAtNonZero()
            {
                var dnaText = "{ { 1 2 add } call }";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 66;
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            new Token
                            {
                                token = "__anon66",
                                column = 1,
                                line = 1,
                            }
                        },
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[1],
                        identifier = "__anon67",
                        tokens = tokens.GetRange(2, 3),
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = tokens[0],
                        identifier = "__anon66",
                        tokens = tokens = new List<Token>
                        {
                            tokens[1].CloneAndRename("__anon67"),
                            
                            tokens[6],
                        },
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void CoduleConstConflict()
            {
                var dnaText = "{val 1 2 add }20";
                var dna = new Chromosome();
                dna.PersonalConstants.Add("val", 10);

                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 20,
                        coduleDefinitionToken = tokens[0],
                        identifier = "val",
                        tokens = tokens.GetRange(1, 3),
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("val"),
                        },
                    },
                };

                CheckEqual(1, errors.Count);
                CheckEqualRegex("is a constant", errors[0].message);
                CheckEqual(2, coduleDefinitions.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void CoduleConstNoConflict()
            {
                var dnaText = "{val 1 2 add }20";
                var dna = new Chromosome();
                dna.PersonalConstants.Add("val", 20);

                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 20,
                        coduleDefinitionToken = tokens[0],
                        identifier = "val",
                        tokens = tokens.GetRange(1, 3),
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("val"),
                        },
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqual(2, coduleDefinitions.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }

            public void CoduleConstDesires()
            {
                var dnaText = "{val 1 2 add }";
                var dna = new Chromosome();
                dna.PersonalConstants.Add("val", 10);

                var errors = new List<CompilationMessage>();
                var tokens = Parser.TokenizeAndMetatags(dnaText, dna, errors);

                int implicitCoduleCount = 0;
                var coduleDefinitions = Parser.ExtractCodules(tokens, dna, errors, ref implicitCoduleCount);

                var expectedCoduleDefs = new CoduleDefinition[]
                {
                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 10,
                        coduleDefinitionToken = tokens[0],
                        identifier = "val",
                        tokens = tokens.GetRange(1, 3),
                    },

                    new CoduleDefinition
                    {
                        desiredCoduleIndex = 0,
                        identifier = Parser.EntryCoduleName,
                        tokens = new List<Token>
                        {
                            tokens[0].CloneAndRename("val"),
                        },
                    },
                };

                CheckEqual(0, errors.Count);
                CheckEqual(2, coduleDefinitions.Count);
                CheckEqualCommutative(expectedCoduleDefs, coduleDefinitions);
            }
        }

        public class CreateExplicitCoduleHandlesTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something",
                        desiredCoduleIndex = 10,
                    },
                };

                Parser.CreateExplicitCoduleHandles(errors, dna, codules);

                Check(dna.CoduleNames.ContainsKey("something"));
                CheckEqual(10, dna.CoduleNames["something"]);
                CheckEqual(0, errors.Count);
            }

            public void Implicit()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something",
                        desiredCoduleIndex = -1,
                    },
                };

                Parser.CreateExplicitCoduleHandles(errors, dna, codules);

                CheckEqual(0, dna.CoduleNames.Count);
                CheckEqual(1, dna.Codules.Count);
                CheckEqual(0, errors.Count);
            }

            public void Wants0()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something",
                        desiredCoduleIndex = 0,
                        coduleDefinitionToken = new Token
                        {
                            column = 7,
                            line = 10,
                            token = "{something",
                        },
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = codules[0].coduleDefinitionToken,
                    },
                };

                Parser.CreateExplicitCoduleHandles(errors, dna, codules);

                CheckEqual(0, dna.CoduleNames.Count);
                CheckEqual(1, dna.Codules.Count);
                CheckEqual(expectedErrors, errors);
            }

            public void MainCodule()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something",
                        desiredCoduleIndex = 0,
                        coduleDefinitionToken = null,
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    
                };

                Parser.CreateExplicitCoduleHandles(errors, dna, codules);

                CheckEqual(0, dna.CoduleNames.Count);
                CheckEqual(1, dna.Codules.Count);
                CheckEqual(expectedErrors, errors);
            }

            public void Conflict()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something1",
                        desiredCoduleIndex = 7,
                        coduleDefinitionToken = new Token
                        {
                            column = 7,
                            line = 10,
                            token = "{something1",
                        },
                    },

                    new CoduleDefinition
                    {
                        identifier = "something2",
                        desiredCoduleIndex = 7,
                        coduleDefinitionToken = new Token
                        {
                            column = 7,
                            line = 11,
                            token = "{something2",
                        },
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = codules[1].coduleDefinitionToken,
                    }
                };

                Parser.CreateExplicitCoduleHandles(errors, dna, codules);

                CheckEqual(1, dna.CoduleNames.Count);
                CheckEqual(2, dna.Codules.Count);
                CheckEqual(expectedErrors, errors);
            }

            public void Null()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something1",
                        desiredCoduleIndex = 7,
                        coduleDefinitionToken = new Token
                        {
                            column = 7,
                            line = 10,
                            token = "{something1",
                        },
                    },

                    null,
                };

                var expectedErrors = new CompilationMessage[]
                {
                    
                };

                Parser.CreateExplicitCoduleHandles(errors, dna, codules);

                CheckEqual(1, dna.CoduleNames.Count);
                CheckEqual(2, dna.Codules.Count);
                CheckEqual(expectedErrors, errors);
            }

            public void SameName()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something",
                        desiredCoduleIndex = 7,
                        coduleDefinitionToken = new Token
                        {
                            column = 7,
                            line = 10,
                            token = "{something",
                        },
                    },

                    new CoduleDefinition
                    {
                        identifier = "something",
                        desiredCoduleIndex = 7,
                        coduleDefinitionToken = new Token
                        {
                            column = 7,
                            line = 11,
                            token = "{something",
                        },
                    },
                };

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = codules[1].coduleDefinitionToken,
                    }
                };

                Parser.CreateExplicitCoduleHandles(errors, dna, codules);

                CheckEqual(1, dna.CoduleNames.Count);
                CheckEqual(2, dna.Codules.Count);
                CheckEqual(expectedErrors, errors);
            }
        }

        public class CreateImplicitCoduleHandlesTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something",
                        desiredCoduleIndex = -1,
                    },
                };

                Parser.CreateImplicitCoduleHandles(errors, dna, codules);

                Check(dna.CoduleNames.ContainsKey("something"));
                CheckEqual(1, dna.CoduleNames["something"]);
                CheckEqual(0, errors.Count);
            }

            public void Explicit()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something",
                        desiredCoduleIndex = 10,
                    },
                };

                Parser.CreateImplicitCoduleHandles(errors, dna, codules);

                var expectedErrors = new CompilationMessage[]
                {
                    
                };

                CheckEqual(0, dna.CoduleNames.Count);
                CheckEqual(1, dna.Codules.Count);
                CheckEqual(expectedErrors, errors);
            }

            public void Null()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var codules = new CoduleDefinition[] 
                {
                    null,
                };

                Parser.CreateImplicitCoduleHandles(errors, dna, codules);

                var expectedErrors = new CompilationMessage[]
                {
                    
                };

                CheckEqual(0, dna.CoduleNames.Count);
                CheckEqual(1, dna.Codules.Count);
                CheckEqual(expectedErrors, errors);
            }

            public void SameName()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var token = new Token
                {
                    column = 10,
                    line = 11,
                    token = "something",
                };

                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something",
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = token,
                    },
                };

                dna.CoduleNames.Add("something", 10);

                Parser.CreateImplicitCoduleHandles(errors, dna, codules);

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(1, dna.CoduleNames.Count);
                CheckEqual(1, dna.Codules.Count);
                CheckEqual(expectedErrors, errors);
            }

            public void NoMoreSlots()
            {
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var token = new Token
                {
                    column = 10,
                    line = 11,
                    token = "something",
                };

                for (Int16 i = 1; i < Chromosome.CoduleSlots; ++i)
                {
                    dna.Codules.Add(i, new Codule());
                }

                var codules = new CoduleDefinition[] 
                {
                    new CoduleDefinition
                    {
                        identifier = "something",
                        desiredCoduleIndex = -1,
                        coduleDefinitionToken = token,
                    },
                };

                Parser.CreateImplicitCoduleHandles(errors, dna, codules);

                var expectedErrors = new CompilationMessage[]
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(0, dna.CoduleNames.Count);
                CheckEqual(Chromosome.CoduleSlots, dna.Codules.Count);
                CheckEqual(expectedErrors, errors);
            }
        }

        public class ParseLabelTests : UnitTestSharp.TestFixture
        {
            public void Unknown()
            {
                IList<BasePair> codeFragment;
                var dna = new Chromosome();
                bool success = Parser.TryParseLabel("dummy", dna, out codeFragment);

                var expectedCodeFragment = new BasePair[]
                {

                };

                CheckFalse(success);
                CheckNull(codeFragment);
            }

            public void Sysvar()
            {
                DNASystem.Sysvars.Add("dummy", new DNASystem.SysvarDefinition
                {
                    Label = "dummy",
                    Memloc = 17,
                    MemlocLength = 1,
                });

                IList<BasePair> codeFragment;
                var dna = new Chromosome();
                bool success = Parser.TryParseLabel("dummy", dna, out codeFragment);

                var expectedCodeFragment = new BasePair[]
                {
                    new Label("dummy", 17)
                };

                Check(success);
                CheckEqual(expectedCodeFragment, codeFragment);

                DNASystem.Sysvars.Remove("dummy");
            }

            public void PersonalConstant()
            {
                IList<BasePair> codeFragment;
                var dna = new Chromosome();
                dna.PersonalConstants.Add("jimmy", 17);
                bool success = Parser.TryParseLabel("jimmy", dna, out codeFragment);

                var expectedCodeFragment = new BasePair[]
                {
                    new Label("jimmy", 17)
                };

                Check(success);
                CheckEqual(expectedCodeFragment, codeFragment);
            }

            public void NullDna()
            {
                IList<BasePair> codeFragment;
                bool success = Parser.TryParseLabel("dummy", null, out codeFragment);

                var expectedCodeFragment = new BasePair[]
                {

                };

                CheckFalse(success);
                CheckNull(codeFragment);
            }

            public void ObjectMacro()
            {
                IList<BasePair> codeFragment;
                var dna = new Chromosome();

                var expectedCodeFragment = new BasePair[]
                {
                    new add(), new sub(),
                };

                dna.ObjectMacros.Add("tommy", expectedCodeFragment);
                bool success = Parser.TryParseLabel("tommy", dna, out codeFragment);

                Check(success);
                CheckEqual(expectedCodeFragment, codeFragment);
            }

            public void CoduleName()
            {
                IList<BasePair> codeFragment;
                var dna = new Chromosome();

                dna.CoduleNames.Add("bobby", 17);
                dna.Codules.Add(17, new Codule { BasePairs = new List<BasePair> { new add(), new sub(), } });

                bool success = Parser.TryParseLabel("bobby", dna, out codeFragment);

                var expectedCodeFragment = new BasePair[]
                {
                    new Label("bobby", 17),
                };

                Check(success);
                CheckEqual(expectedCodeFragment, codeFragment);
            }

            public void Punctuation()
            {
                IList<BasePair> codeFragment;
                var dna = new Chromosome();

                dna.CoduleNames.Add("bobby", 17);
                dna.Codules.Add(17, new Codule { BasePairs = new List<BasePair> { new add(), new sub(), } });

                bool success = Parser.TryParseLabel('@', "bobby", dna, out codeFragment);

                var expectedCodeFragment = new BasePair[]
                {
                    new ExplicitCall("bobby", 17),
                };

                Check(success);
                CheckEqual(expectedCodeFragment, codeFragment);
            }

            public void ObjectMacrosHavePriority()
            {
                IList<BasePair> codeFragment;
                var dna = new Chromosome();

                DNASystem.Sysvars.Add("add", new DNASystem.SysvarDefinition
                {
                    MemlocLength = 1,
                    Memloc = 17,
                    Label = "add",
                });
                dna.PersonalConstants.Add("add", 18);
                dna.ObjectMacros.Add("add", new BasePair[] { new Constant(19), });
                dna.CoduleNames.Add("add", 20);
                dna.Codules.Add(20, new Codule());

                bool success = Parser.TryParseLabel("add", dna, out codeFragment);

                var expectedCodeFragment = new BasePair[]
                {
                    new Constant(19),
                };

                Check(success);
                CheckEqual(expectedCodeFragment, codeFragment);

                DNASystem.Sysvars.Remove("add");
            }

            public void PersonalConstantsHave2ndPriority()
            {
                IList<BasePair> codeFragment;
                var dna = new Chromosome();

                DNASystem.Sysvars.Add("add", new DNASystem.SysvarDefinition
                {
                    Label = "add",
                    Memloc = 17,
                    MemlocLength = 1,
                });
                dna.PersonalConstants.Add("add", 18);
                //dna.ObjectMacros.Add("add", new BasePair[] { new Constant(19), });
                dna.CoduleNames.Add("add", 20);
                dna.Codules.Add(20, new Codule());

                bool success = Parser.TryParseLabel("add", dna, out codeFragment);

                var expectedCodeFragment = new BasePair[]
                {
                    new Label("add", 18)
                };

                Check(success);
                CheckEqual(expectedCodeFragment, codeFragment);

                DNASystem.Sysvars.Remove("add");
            }

            public void CodulesHave3rdPriority()
            {
                IList<BasePair> codeFragment;
                var dna = new Chromosome();

                DNASystem.Sysvars.Add("add", new DNASystem.SysvarDefinition
                {
                    Label = "add",
                    Memloc = 17,
                    MemlocLength = 1,
                });
                //dna.PersonalConstants.Add("add", 18);
                //dna.ObjectMacros.Add("add", new BasePair[] { new Constant(19), });
                dna.CoduleNames.Add("add", 20);
                dna.Codules.Add(20, new Codule());

                bool success = Parser.TryParseLabel("add", dna, out codeFragment);

                var expectedCodeFragment = new BasePair[]
                {
                    new Label("add", 20)
                };

                Check(success);
                CheckEqual(expectedCodeFragment, codeFragment);

                DNASystem.Sysvars.Remove("add");
            }

            public void SysvarsHave4thPriority()
            {
                IList<BasePair> codeFragment;
                var dna = new Chromosome();

                DNASystem.Sysvars.Add("add", new DNASystem.SysvarDefinition
                {
                    Label = "add",
                    Memloc = 17,
                    MemlocLength = 1,
                });
                //dna.PersonalConstants.Add("add", 18);
                //dna.ObjectMacros.Add("add", new BasePair[] { new Constant(19), });
                //dna.CoduleNames.Add("add", 20);
                //dna.Codules.Add(20, new Codule());

                bool success = Parser.TryParseLabel("add", dna, out codeFragment);

                var expectedCodeFragment = new BasePair[]
                {
                    new Label("add", 17)
                };

                Check(success);
                CheckEqual(expectedCodeFragment, codeFragment);

                DNASystem.Sysvars.Remove("add");
            }

            public void CommandsHaveLastPriority()
            {
                IList<BasePair> codeFragment;
                var dna = new Chromosome();

                //DNASystem.Sysvars.Add("add", 17);
                //dna.PersonalConstants.Add("add", 18);
                //dna.ObjectMacros.Add("add", new BasePair[] { new Constant(19), });
                //dna.CoduleNames.Add("add", 20);
                //dna.Codules.Add(20, new Codule());

                bool success = Parser.TryParseLabel("add", dna, out codeFragment);

                CheckFalse(success);
                CheckNull(codeFragment);
            }
        }

        public class ParseTokenTests : UnitTestSharp.TestFixture
        {
            public void EmptyToken()
            {
                var token = new Token
                {
                    
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                CheckEqual(new BasePair[] { }, basePairs);
                CheckEqual(0, errors.Count);
            }

            public void Command()
            {
                var token = new Token
                {
                    token = "add",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                CheckEqual(new BasePair[] { new add(), }, basePairs);
                CheckEqual(0, errors.Count);
            }

            public void LonePunctuation()
            {
                var token = new Token
                {
                    token = "*",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(new BasePair[] { }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void UnknownPunctuation()
            {
                var token = new Token
                {
                    token = "$",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(new BasePair[] { }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void PunctuationNumber()
            {
                var token = new Token
                {
                    token = "@96",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    
                };

                CheckEqual(new BasePair[] { new ExplicitCall("96", 96), }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void PunctuationLabel()
            {
                var token = new Token
                {
                    token = "@scott",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                dna.PersonalConstants.Add("scott", 36);
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {

                };

                CheckEqual(new BasePair[] { new ExplicitCall("scott", 36), }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void Number()
            {
                var token = new Token
                {
                    token = "96",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {

                };

                CheckEqual(new BasePair[] { new Constant(96), }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void NegativeNumber()
            {
                var token = new Token
                {
                    token = "-96",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {

                };

                CheckEqual(new BasePair[] { new Constant(-96), }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void NumberWayTooLarge()
            {
                var token = new Token
                {
                    token = "9999999999",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(new BasePair[] { }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void NegativeNumberWayTooLarge()
            {
                var token = new Token
                {
                    token = "-9999999999",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(new BasePair[] { }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void NumberSlightlyTooLarge()
            {
                var token = new Token
                {
                    token = (Constant.MaxValue + 1).ToString(),
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(new BasePair[] { }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void NegativeNumberSlightlyTooLarge()
            {
                var token = new Token
                {
                    token = (Constant.MinValue - 1).ToString(),
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(new BasePair[] { }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void NumberJustWithinBounds()
            {
                var token = new Token
                {
                    token = Constant.MaxValue.ToString(),
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    
                };

                CheckEqual(new BasePair[] { new Constant(Constant.MaxValue) }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void NegativeNumberJustWithinBounds()
            {
                var token = new Token
                {
                    token = Constant.MinValue.ToString(),
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    
                };

                CheckEqual(new BasePair[] { new Constant(Constant.MinValue) }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void AllCommandsParse()
            {
                foreach (var command in DNASystem.Commands)
                {
                    var token = new Token
                    {
                        token = command.Key,
                    };

                    var errors = new List<CompilationMessage>();
                    var dna = new Chromosome();
                    var basePairs = Parser.ParseToken(token, dna, errors);

                    var expectedErrors = new List<CompilationMessage>
                    {

                    };

                    CheckEqual(expectedErrors, errors);
                    if (errors.Count == 0)
                    {
                        if (basePairs.Count != 1)
                        {
                            internals.RegisterFailedCheck(command.Key + " produced " + basePairs.Count + " basepairs.");
                        }
                        else
                        {
                            CheckEqual(command.Value, basePairs.First().GetType());
                        }
                    }
                    else
                    {
                        foreach (var error in errors)
                        {
                            internals.RegisterFailedCheck(command.Key + " failed: " + error.ToString());
                        }
                    }
                }
            }

            public void InvalidLabel()
            {
                var token = new Token
                {
                    token = "36A",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(new BasePair[] { }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void PunctuationOnUnknownLabel()
            {
                var token = new Token
                {
                    token = "@yourmom",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(new BasePair[] { }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void CompletelyUnknownToken()
            {
                var token = new Token
                {
                    token = "yourmom",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    new CompilationMessage
                    {
                        token = token,
                    },
                };

                CheckEqual(new BasePair[] { }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void PunctuationCommand_Single()
            {
                var token = new Token
                {
                    token = ">",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    
                };

                CheckEqual(new BasePair[] { new Greater() }, basePairs);
                CheckEqual(expectedErrors, errors);
            }

            public void PunctuationCommand_Double()
            {
                var token = new Token
                {
                    token = ">=",
                };

                var errors = new List<CompilationMessage>();
                var dna = new Chromosome();
                var basePairs = Parser.ParseToken(token, dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {

                };

                CheckEqual(new BasePair[] { new GreaterEqual() }, basePairs);
                CheckEqual(expectedErrors, errors);
            }
        }

        public class ParseCoduleTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var line = "36 *5 add";
                var dna = new Chromosome();
                var errors = new List<CompilationMessage>();
                var basePairs = Parser.ParseCodule(Parser.TokenizeLine(line, -1), dna, errors);

                var expectedErrors = new List<CompilationMessage>
                {
                    
                };

                CheckEqual(expectedErrors, errors);
                CheckEqual(new BasePair[] { new Constant(36), new ExplicitRef("5", 5), new add() }, basePairs);
            }
        }

        public class ParseCodulesTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var line1 = "36 *5 add";
                var line2 = "5 2 mul";

                var tokens1 = Parser.TokenizeLine(line1, 0);
                var tokens2 = Parser.TokenizeLine(line2, 0);

                var codules = new List<CoduleDefinition>
                {
                    new CoduleDefinition
                    {
                        tokens = tokens1.ToList(),
                        identifier = "A",
                    },

                    new CoduleDefinition
                    {
                        tokens = tokens2.ToList(),
                        identifier = "B",
                    },
                };

                var dna = new Chromosome();
                dna.CoduleNames.Add("A", 1);
                dna.CoduleNames.Add("B", 2);

                dna.Codules.Add(1, new Codule());
                dna.Codules.Add(2, new Codule());

                var errors = new List<CompilationMessage>();
                Parser.ParseCodules(dna, codules, errors);

                var expectedErrors = new List<CompilationMessage>()
                {

                };

                CheckEqual(expectedErrors, errors);
                CheckEqual(new BasePair[] {
                    new Constant(36),
                    new ExplicitRef("5", 5),
                    new add()
                }, dna.Codules[1].BasePairs);
                CheckEqual(new BasePair[] {
                    new Constant(5), 
                    new Constant(2),
                    new mul()
                }, dna.Codules[2].BasePairs);
            }

            public void HandlesNulls()
            {
                var line1 = "36 *5 add";
                var line2 = "5 2 mul";

                var tokens1 = Parser.TokenizeLine(line1, 0);
                var tokens2 = Parser.TokenizeLine(line2, 0);

                var codules = new List<CoduleDefinition>
                {
                    new CoduleDefinition
                    {
                        tokens = tokens1.ToList(),
                        identifier = "A",
                    },

                    null,

                    new CoduleDefinition
                    {
                        tokens = tokens2.ToList(),
                        identifier = "B",
                    },

                    null,
                };

                var dna = new Chromosome();
                dna.CoduleNames.Add("A", 1);
                dna.CoduleNames.Add("B", 2);

                dna.Codules.Add(1, new Codule());
                dna.Codules.Add(2, new Codule());

                var errors = new List<CompilationMessage>();
                Parser.ParseCodules(dna, codules, errors);

                var expectedErrors = new List<CompilationMessage>()
                {

                };

                CheckEqual(expectedErrors, errors);
                CheckEqual(new BasePair[] {
                    new Constant(36),
                    new ExplicitRef("5", 5),
                    new add()
                }, dna.Codules[1].BasePairs);
                CheckEqual(new BasePair[] { 
                    new Constant(5),
                    new Constant(2),
                    new mul()
                }, dna.Codules[2].BasePairs);
            }
        }

        public class ParseDNATests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var dna = "1 2 add ";
                var messages = new List<CompilationMessage>();
                Chromosome chrom = new Chromosome();
                Sunweaver.Parsing.Parser.ParseDNA(dna, ref chrom, out messages);

                var expectedChrom = new Chromosome(new Codule[]
                {
                    new Codule(new BasePair[]
                    {
                        new Constant(1),
                        new Constant(2),
                        new add(),
                    })
                });

                CheckEqual(expectedChrom, chrom);
                CheckEqual(new CompilationMessage[] { }, messages);
            }

            public void EmbeddedCodule()
            {
                var dna = "{ 1 2 add }";
                var messages = new List<CompilationMessage>();
                Chromosome chrom = new Chromosome();
                Sunweaver.Parsing.Parser.ParseDNA(dna, ref chrom, out messages);

                var expectedChrom = new Chromosome(new Codule[]
                {
                    new Codule(new BasePair[] { new Label("__anon0", 1) }),
                    new Codule(new BasePair[]
                    {
                        new Constant(1),
                        new Constant(2),
                        new add(),
                    })
                });
                expectedChrom.CoduleNames.Add("__anon0", 1);

                CheckEqual(expectedChrom, chrom);
                CheckEqual(new CompilationMessage[] { }, messages);
            }
        }
    }
}