static void Basic()
        {
            StringTemplate stringTemplate = new StringTemplate("hello <data>");
            stringTemplate.Add("data", "world");

            Console.WriteLine(stringTemplate.Render());
        }

 //= null
 public static string Apply(string template, Dictionary<string, object> @params )
 {
     StringTemplate st = new StringTemplate(template);
     AddDefaultAttributes(st);
     if (@params != null) AddAttributes(st, @params);
     return st.ToString();
 }

        public StringTemplateView(StringTemplate template)
        {
            //null check
            if (template == null) throw new ArgumentNullException("template");

            //set template
            _template = template;
        }

 static void TestStringTemplate()
 {
     string text = "$entity.Account$您好！<br/> 请点击连接重置您的秘密<br><a href=\"$url$\">$url$</a>";
     StringTemplate st = new StringTemplate(text);
     st.SetAttribute("entity", new Demo() { Account = "fengpengbin" });
     st.SetAttribute("url", "http://www.aporeboy.com/vail");
     Console.WriteLine(st.ToString());
 }

        public string Populate(ParameterSet parameterSet)
        {
            var t = new StringTemplate()
            {
                Text = Text,
            };

            return t.Populate(parameterSet.Parameters);
        }

        public string Export(IList dbObjects, string templatePath)
        {
            StringTemplate template = new StringTemplate();

            var text = File.ReadAllText(templatePath);

            //remove all tabs - it used only to format template code, not output code
            template.Template = text.Replace("\t", "");

            template.SetAttribute("dbObjects", dbObjects);
            var output = template.ToString();

            return output;
        }

        public Template(string name)
        {
            var assembly = Assembly.GetCallingAssembly();
            var stream = assembly.GetManifestResourceStream(name);

            if (stream == null)
            {
                var candidates = string.Join(", ", assembly.GetManifestResourceNames());
                throw new FileNotFoundException(string.Format("cannot find embedded resource {0} in assembly {1}, candidate templates include [{2}]", name, assembly.GetName(), candidates));
            }

            var contents = new StreamReader(stream).ReadToEnd();
            template = new StringTemplate(contents);
        }

        public static string Generate(string input, Dictionary<string, object> data)
        {
            var template = new StringTemplate(input);

            foreach (var d in data)
                template.SetAttribute(d.Key, d.Value);

            string result = template.ToString();
            ;
            template.Reset();
            data.Clear();
            template = null;
            return result;
        }

        public void ListIterator_MultipleItems()
        {
            // Arrange
            var template = new StringTemplate("$user:{ u | <p>$u.FirstName$ is a super user? $u.IsSuperUser$. But his last name is $u.LastName$.</p>}$");
            var user = new { FirstName = "Ian", LastName = "Robinson", IsSuperUser = false };
            var userList = (new[] {user}).ToList();
            userList.Add(new { FirstName = "Gertrude", LastName = "Schmuckbucket", IsSuperUser = true});

            template.SetAttribute("user", userList);

            // Act
            var renderedText = template.ToString();

            // Assert
            Assert.AreEqual(renderedText, "<p>Ian is a super user? False. But his last name is Robinson.</p><p>Gertrude is a super user? True. But his last name is Schmuckbucket.</p>");
        }

        public void ListIterator_SingleItem()
        {
            // Arrange
            var template = new StringTemplate("$user:{ u | $u.FirstName$ is a super user? $u.IsSuperUser$. But his last name is $u.LastName$.}$");
            template.SetAttribute("user", new
                                              {
                                                  FirstName = "Ian",
                                                  LastName = "Robinson",
                                                  IsSuperUser = false
                                              });
            // Act
            var renderedText = template.ToString();

            // Assert
            Assert.AreEqual(renderedText, "Ian is a super user? False. But his last name is Robinson.");
        }

        public override StringTemplate GetParserCreationTemplate()
        {
            StringTemplate createParserST =
                new StringTemplate(
                    "        Profiler2 profiler = new Profiler2();\n" +
                    "        $parserName$ parser = new $parserName$(tokens,profiler);\n" +
                    "        profiler.setParser(parser);\n"
                    );

            if ( !Debug )
            {
                createParserST =
                    new StringTemplate(
                        "        $parserName$ parser = new $parserName$(tokens);\n"
                        );
            }

            return createParserST;
        }

        public void NestedProperties()
        {
            // Arrange
            IDictionary<string, object> ret = new Dictionary<string, object>();
            ret["elem1"] = true;
            ret["elem2"] = false;

            var nestedObj = new Dictionary<string, object>();
            nestedObj["nestedProp"] = 100;
            ret["elem3"] = nestedObj;

            var template = new StringTemplate("$elem1$ or $elem2$ and value: $elem3.nestedProp$") { Attributes = ret };

            // Act
            var renderedText = template.ToString();

            // Assert
            Assert.AreEqual(renderedText, "True or False and value: 100");
        }

 public static void AddAttributes(StringTemplate st, Dictionary<string, object> @params)
 {
     foreach(string key in @params.Keys) {
         object val = @params[key];
         if (val != null) {
             if (val is string && String.IsNullOrEmpty(val as string))
                 continue;
             /*
            if (val is ArrayList)
             {
                 //st.SetAttribute(key, (val as ArrayList).ToArray());
                 ArrayList al = val as ArrayList;
                 foreach (object o in al)
                     st.SetAttribute(key, o);
             }
             else
             */
                 st.SetAttribute(key, val);
         }
     }
 }

        public override StringTemplate GetLexerTestFileTemplate()
        {
            StringTemplate outputFileST = new StringTemplate(
                "import org.antlr.runtime.*;\n" +
                "import org.antlr.runtime.tree.*;\n" +
                "import org.antlr.runtime.debug.*;\n" +
                "\n" +
                "class Profiler2 extends Profiler {\n" +
                "    public void terminate() { ; }\n" +
                "}\n" +
                "public class Test {\n" +
                "    public static void main(String[] args) throws Exception {\n" +
                "        CharStream input = new ANTLRFileStream(args[0]);\n" +
                "        $lexerName$ lex = new $lexerName$(input);\n" +
                "        CommonTokenStream tokens = new CommonTokenStream(lex);\n" +
                "        System.out.println(tokens);\n" +
                "    }\n" +
                "}"
                );

            return outputFileST;
        }

        public void StringTemplatAddDuplicateSameValuesTest()
        {
            target = new StringTemplate(String.Empty);

            target.Add("test", "one");

            try
            {
                target.Add("test", "one");

                Assert.Fail("No exception thrown");
            }
            catch (ArgumentException exception)
            {
                Assert.AreEqual("Element has already been added.\r\nParameter name: element", exception.Message);
                Assert.AreEqual("element", exception.ParamName);
            }
            catch
            {
                Assert.Fail("ArgumentException not thrown");
            }
        }

        public override string ToString()
        {
            Tests = Enumerable
                .Range(0, TestCount)
                .Select(x => "test" + x)
                .Join(", ");

            InstructionCompleteCasesText = InstructionCompleteCases
                .Select(x => string.Format(
                    @"
                        {0}:
                                  begin
                                      {1}
                                  end
                        ",
                    x.Key,
                    x.Value))
                .JoinLines();

            var template = File.ReadAllText(PathHelper.GetExecutingPath(@"McuTestTemplate.v"));
            var t = new StringTemplate(template).PopulateObj(this);

            return t;
        }

        public override StringTemplate GetTreeTestFileTemplate()
        {
            StringTemplate outputFileST = new StringTemplate(
                "import org.antlr.runtime.*;\n" +
                "import org.antlr.runtime.tree.*;\n" +
                "import org.antlr.runtime.debug.*;\n" +
                "\n" +
                "class Profiler2 extends Profiler {\n" +
                "    public void terminate() { ; }\n" +
                "}\n" +
                "public class Test {\n" +
                "    public static void main(String[] args) throws Exception {\n" +
                "        CharStream input = new ANTLRFileStream(args[0]);\n" +
                "        $lexerName$ lex = new $lexerName$(input);\n" +
                "        TokenRewriteStream tokens = new TokenRewriteStream(lex);\n" +
                "        $createParser$\n" +
                "        $parserName$.$parserStartRuleName$_return r = parser.$parserStartRuleName$();\n" +
                "        $if(!treeParserStartRuleName)$\n" +
                "        if ( r.tree!=null ) {\n" +
                "            System.out.println(((Tree)r.tree).toStringTree());\n" +
                "            ((CommonTree)r.tree).sanityCheckParentAndChildIndexes();\n" +
                "		 }\n" +
                "        $else$\n" +
                "        CommonTreeNodeStream nodes = new CommonTreeNodeStream((Tree)r.tree);\n" +
                "        nodes.setTokenStream(tokens);\n" +
                "        $treeParserName$ walker = new $treeParserName$(nodes);\n" +
                "        walker.$treeParserStartRuleName$();\n" +
                "        $endif$\n" +
                "    }\n" +
                "}"
                );

            return outputFileST;
        }

 public virtual StringTemplate GetEmbeddedInstanceOf( StringTemplate enclosingInstance,
                                             string name )
 {
     //Console.Out.WriteLine( "surrounding group is " +
     //                   enclosingInstance.Group.Name +
     //                   " with native group " + enclosingInstance.NativeGroup.Name );
     StringTemplate st = null;
     // TODO: seems like this should go into lookupTemplate
     if ( name.StartsWith( "super." ) )
     {
         // for super.foo() refs, ensure that we look at the native
         // group for the embedded instance not the current evaluation
         // group (which is always pulled down to the original group
         // from which somebody did group.getInstanceOf("foo");
         st = enclosingInstance.NativeGroup.GetInstanceOf( enclosingInstance, name );
     }
     else
     {
         st = GetInstanceOf( enclosingInstance, name );
     }
     // make sure all embedded templates have the same group as enclosing
     // so that polymorphic refs will start looking at the original group
     st.Group = this;
     st.EnclosingInstance = enclosingInstance;
     return st;
 }

 public virtual void EmitTemplateStopDebugString( StringTemplate st,
                                         IStringTemplateWriter @out )
 {
     if ( _noDebugStartStopStrings == null ||
          !_noDebugStartStopStrings.Contains( st.Name ) )
     {
         string groupPrefix = "";
         if ( !st.Name.StartsWith( "if" ) && !st.Name.StartsWith( "else" ) )
         {
             if ( st.NativeGroup != null )
             {
                 groupPrefix = st.NativeGroup.Name + ".";
             }
             else
             {
                 groupPrefix = st.Group.Name + ".";
             }
         }
         @out.Write( "</" + groupPrefix + st.Name + ">" );
     }
 }

 /** <summary>Track all references to regions &lt;@foo>...&lt;@end> or &lt;@foo()>.</summary>  */
 public virtual StringTemplate DefineRegionTemplate( StringTemplate enclosingTemplate,
                                            string regionName,
                                            string template,
                                            RegionType type )
 {
     StringTemplate regionST =
         DefineRegionTemplate( enclosingTemplate.OutermostName,
                              regionName,
                              template,
                              type );
     enclosingTemplate.OutermostEnclosingInstance.AddRegionName( regionName );
     return regionST;
 }