private void WriteHeaderFileContent(TextWriter writer, string suitePath) { Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream( NewTestSuiteTemplateResourcePath); StringTemplateGroup templateGroup = new StringTemplateGroup( new StreamReader(stream), typeof(AngleBracketTemplateLexer)); templateGroup.RegisterAttributeRenderer(typeof(string), new NewTestSuiteStringRenderer(suitePath)); StringTemplate template = templateGroup.GetInstanceOf("newSuiteFile"); // Initialize the options that will be passed into the template. Hashtable options = new Hashtable(); options["suiteName"] = suiteName; options["superclass"] = superclass; options["headerUnderTest"] = headerUnderTest.CanonicalName; options["createSetUp"] = createSetUp; options["createTearDown"] = createTearDown; template.SetAttribute("options", options); template.SetAttribute("testCases", new List <string>(stubNames)); template.Write(new AutoIndentWriter(writer)); }
protected virtual int WriteSubTemplate(StringTemplate self, IStringTemplateWriter @out, StringTemplate subtemplate) { /* To evaluate the IF chunk, make a new instance whose enclosingInstance * points at 'self' so get attribute works. Otherwise, enclosingInstance * points at the template used to make the precompiled code. We need a * new template instance every time we exec this chunk to get the new * "enclosing instance" pointer. */ StringTemplate s = subtemplate.GetInstanceOf(); s.EnclosingInstance = self; // make sure we evaluate in context of enclosing template's // group so polymorphism works. :) s.Group = self.Group; s.NativeGroup = self.NativeGroup; return(s.Write(@out)); }
/** <summary> * To write out the value of a condition expr, invoke the evaluator in eval.g * to walk the condition tree computing the boolean value. If result * is true, then write subtemplate. * </summary> */ public override int Write(StringTemplate self, IStringTemplateWriter @out) { if (AST == null || self == null || @out == null) { return(0); } //System.Console.Out.WriteLine( "evaluating conditional tree: " + AST.ToStringTree() ); #if !COMPILE_EXPRESSIONS ActionEvaluator eval = null; #endif int n = 0; try { bool testedTrue = false; // get conditional from tree and compute result #if COMPILE_EXPRESSIONS if (EvaluateCondition == null) { EvaluateCondition = GetEvaluator(this, AST.GetChild(0)); } bool includeSubtemplate = EvaluateCondition(self, @out); // eval and write out tree #else ITree cond = AST.GetChild(0); eval = new ActionEvaluator(self, this, @out, cond); // eval and write out trees bool includeSubtemplate = eval.ifCondition(); #endif //System.Console.Out.WriteLine( "subtemplate " + _subtemplate ); // IF if (includeSubtemplate) { n = WriteSubTemplate(self, @out, _subtemplate); testedTrue = true; } // ELSEIF else if (_elseIfSubtemplates != null && _elseIfSubtemplates.Count > 0) { for (int i = 0; i < _elseIfSubtemplates.Count; i++) { ElseIfClauseData elseIfClause = _elseIfSubtemplates[i]; #if COMPILE_EXPRESSIONS if (elseIfClause.EvaluateCondition == null) { elseIfClause.EvaluateCondition = GetEvaluator(this, elseIfClause.expr.AST); } includeSubtemplate = elseIfClause.EvaluateCondition(self, @out); #else eval = new ActionEvaluator(self, this, @out, elseIfClause.expr.AST); includeSubtemplate = eval.ifCondition(); #endif if (includeSubtemplate) { WriteSubTemplate(self, @out, elseIfClause.st); testedTrue = true; break; } } } // ELSE if (!testedTrue && _elseSubtemplate != null) { // evaluate ELSE clause if present and IF condition failed StringTemplate s = _elseSubtemplate.GetInstanceOf(); s.EnclosingInstance = self; s.Group = self.Group; s.NativeGroup = self.NativeGroup; n = s.Write(@out); } // cond==false and no else => Missing output not empty if (!testedTrue && _elseSubtemplate == null) { n = Missing; } } catch (RecognitionException re) { self.Error("can't evaluate tree: " + AST.ToStringTree(), re); } return(n); }
public void TestNewlineNormalizationInTemplateStringPC() { StringTemplate st = new StringTemplate( "Foo\r\n" + "Bar\n", typeof( AngleBracketTemplateLexer ) ); StringWriter sw = new StringWriter(); st.Write( new AutoIndentWriter( sw, "\r\n" ) ); // force \r\n as newline string result = sw.ToString(); string expecting = "Foo\r\nBar\r\n"; // expect \r\n in output Assert.AreEqual( expecting, result ); }
public void TestCharLiterals() { StringTemplate st = new StringTemplate( "Foo <\\r\\n><\\n><\\t> bar" + newline, typeof( AngleBracketTemplateLexer ) ); StringWriter sw = new StringWriter(); st.Write( new AutoIndentWriter( sw, "\n" ) ); // force \n as newline string result = sw.ToString(); string expecting = "Foo \n\n\t bar\n"; // expect \n in output Assert.AreEqual( expecting, result ); st = new StringTemplate( "Foo $\\n$$\\t$ bar" + newline ); sw = new StringWriter(); st.Write( new AutoIndentWriter( sw, "\n" ) ); // force \n as newline expecting = "Foo \n\t bar\n"; // expect \n in output result = sw.ToString(); Assert.AreEqual( expecting, result ); st = new StringTemplate( "Foo$\\ $bar$\\n$" ); sw = new StringWriter(); st.Write( new AutoIndentWriter( sw, "\n" ) ); // force \n as newline result = sw.ToString(); expecting = "Foo bar\n"; // force \n Assert.AreEqual( expecting, result ); }
public void TestNewlineNormalizationInAttribute() { StringTemplate st = new StringTemplate( "Foo\r\n" + "<name>\n", typeof( AngleBracketTemplateLexer ) ); st.SetAttribute( "name", "a\nb\r\nc" ); StringWriter sw = new StringWriter(); st.Write( new AutoIndentWriter( sw, "\n" ) ); // force \n as newline string result = sw.ToString(); string expecting = "Foo\na\nb\nc\n"; // expect \n in output Assert.AreEqual( expecting, result ); }
public void TestLineBreakNoWhiteSpaceDollar() { StringTemplate st = new StringTemplate( "Foo $\\\\$" + newline + "bar" + newline, typeof(DefaultTemplateLexer) ); StringWriter sw = new StringWriter(); st.Write(new AutoIndentWriter(sw, "\n")); // force \n as newline string result = sw.ToString(); string expecting = "Foo bar\n"; // expect \n in output Assert.AreEqual(expecting, result); }
public void TestLineBreak2() { StringTemplate st = new StringTemplate( "Foo <\\\\> " + newline + " \t bar" + newline, typeof(AngleBracketTemplateLexer) ); StringWriter sw = new StringWriter(); st.Write(new AutoIndentWriter(sw, "\n")); // force \n as newline string result = sw.ToString(); string expecting = "Foo bar\n"; // expect \n in output Assert.AreEqual(expecting, result); }
public void TestAlternativeWriter() { StringBuilder buf = new StringBuilder(); IStringTemplateWriter w = new AlternativeWriter( buf ); StringTemplateGroup group = new StringTemplateGroup( "test" ); group.DefineTemplate( "bold", "<b>$x$</b>" ); StringTemplate name = new StringTemplate( group, "$name:bold(x=name)$" ); name.SetAttribute( "name", "Terence" ); name.Write( w ); Assert.AreEqual( "<b>Terence</b>", buf.ToString() ); }
protected virtual int WriteTemplate(StringTemplate self, StringTemplate stToWrite, IStringTemplateWriter @out) { int n = 0; /* failsafe: perhaps enclosing instance not set * Or, it could be set to another context! This occurs * when you store a template instance as an attribute of more * than one template (like both a header file and C file when * generating C code). It must execute within the context of * the enclosing template. */ stToWrite.EnclosingInstance = self; // if self is found up the enclosing instance chain, then infinite recursion if (StringTemplate.LintMode && StringTemplate.IsRecursiveEnclosingInstance(stToWrite)) { // throw exception since sometimes eval keeps going even after I ignore this write of o. throw new InvalidOperationException("infinite recursion to " + stToWrite.GetTemplateDeclaratorString() + " referenced in " + stToWrite.EnclosingInstance.TemplateDeclaratorString + "; stack trace:" + Environment.NewLine + stToWrite.GetEnclosingInstanceStackTrace()); } else { // if we have a wrap string, then inform writer it might need to wrap if (_wrapString != null) { n = @out.WriteWrapSeparator(_wrapString); } // check if formatting needs to be applied to the stToWrite if (_formatString != null) { IAttributeRenderer renderer = self.GetAttributeRenderer(typeof(string)); if (renderer != null) { /* you pay a penalty for applying format option to a template * because the template must be written to a temp StringWriter so it can * be formatted before being written to the real output. */ StringWriter buf = new StringWriter(); IStringTemplateWriter sw = self.Group.GetStringTemplateWriter(buf); stToWrite.Write(sw); n = @out.Write(renderer.ToString(buf.ToString(), _formatString)); return n; } } n = stToWrite.Write(@out); } return n; }