public void TokenStreamContructorTest()
        {
            String expected = "test";

            target = new TokenStream(expected);

            Assert.AreEqual(expected, target.Source);
        }
        public void TokenStreamContructorSourceNullTest()
        {
            try
            {
                target = new TokenStream(null);

                Assert.Fail("No exception thrown");
            }
            catch (ArgumentNullException exception)
            {
                Assert.AreEqual("source", exception.ParamName);
            }
            catch
            {
                Assert.Fail("ArgumentNullException not thrown");
            }
        }
        public String Render()
        {
            TokenStream tokenStream = new TokenStream(template);

            StringBuilder sb = new StringBuilder();

            foreach (Token token in tokenStream.Tokens)
            {
                if (token.TokenType == TokenType.Element)
                {
                    if (ElementData.ContainsKey(token.Value))
                    {
                        sb.Append(ElementData[token.Value].ToString());
                    }
                    else
                    {
                        sb.Append("<" + token.Value + ">");
                    }
                }
                else if (token.TokenType == TokenType.StringLiteral)
                {
                    sb.Append(token.Value);
                }
                else
                {
                    throw new ArgumentException(String.Format("Unknonw TokenType {0}", token.TokenType.ToString()));
                }
            }

            return sb.ToString();
        }
        public void TokenStreamOneTokenTest1()
        {
            target = new TokenStream("one two two");

            Assert.AreEqual(1, target.Tokens.Count);
        }
        public void TokenStreamOneElementStartTest()
        {
            target = new TokenStream("<test> two two");

            Assert.AreEqual(2, target.Tokens.Count);
        }
        public void TokenStreamOneElementMiddleTest()
        {
            target = new TokenStream("one <test> two");

            Assert.AreEqual(3, target.Tokens.Count);
        }
        public void TokenStreamOneElementEndTest()
        {
            target = new TokenStream("one two <test>");

            Assert.AreEqual(2, target.Tokens.Count);
        }
        public void TokenStreamNoTokensTest()
        {
            target = new TokenStream(String.Empty);

            Assert.AreEqual(0, target.Tokens.Count);
        }
 public void TestInit()
 {
     target = new TokenStream(String.Empty);
 }
 public void TestCleanup()
 {
     target = null;
 }
        public void TokenStreamTwoElementsTest()
        {
            target = new TokenStream("<one><two>test");

            Assert.AreEqual(3, target.Tokens.Count);
        }
        public void TokenStreamOneTokenTest2()
        {
            target = new TokenStream("<test>");

            Assert.AreEqual(1, target.Tokens.Count);
        }