public static IList <TestDescriptor> GetLoopTagsTests()
{
IList <TestDescriptor> lst = new List <TestDescriptor>();
// CYCLE TAG
lst.Add(new TestDescriptor("cycle01", "{% cycle a %}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.RenderingException))));
lst.Add(new TestDescriptor("cycle02", "{% cycle a,b,c as abc %}{% cycle abc %}", ContextObjects.empty, ContextObjects.p("ab")));
lst.Add(new TestDescriptor("cycle03", "{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}", ContextObjects.empty, ContextObjects.p("abc")));
lst.Add(new TestDescriptor("cycle04", "{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}", ContextObjects.empty, ContextObjects.p("abca")));
lst.Add(new TestDescriptor("cycle05", "{% cycle %}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.SyntaxException))));
lst.Add(new TestDescriptor("cycle06", "{% cycle a %}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.RenderingException))));
lst.Add(new TestDescriptor("cycle07", "{% cycle a,b,c as foo %}{% cycle bar %}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.RenderingException))));
lst.Add(new TestDescriptor("cycle08", "{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}", ContextObjects.empty, ContextObjects.p("abbbcc")));
lst.Add(new TestDescriptor("cycle09", "{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}", ContextObjects.p("test", ContextObjects.range(5)), ContextObjects.p("a0,b1,a2,b3,a4,")));
lst.Add(new TestDescriptor("cycle09-1", "{% for i in test %}{% cycle a,b %}{{ i.0 }};{{i.1}},{% endfor %}", ContextObjects.p("test", ContextObjects.square(5, 2)), ContextObjects.p("a0-0;0-1,b1-0;1-1,a2-0;2-1,b3-0;3-1,a4-0;4-1,")));
lst.Add(new TestDescriptor("cycle09-2", "{% for i, j in test %}{% cycle a,b %}{{ i }};{{j}},{% endfor %}", ContextObjects.p("test", ContextObjects.square(5, 2)), ContextObjects.p("a0-0;0-1,b1-0;1-1,a2-0;2-1,b3-0;3-1,a4-0;4-1,")));
lst.Add(new TestDescriptor("cycle09-3", "{% for i,j in test %}{% cycle a,b %}{{ i }};{{j}},{% endfor %}", ContextObjects.p("test", ContextObjects.square(5, 2)), ContextObjects.p("a0-0;0-1,b1-0;1-1,a2-0;2-1,b3-0;3-1,a4-0;4-1,")));
//// New format,
lst.Add(new TestDescriptor("cycle10-1", "{% cycle 'a' 'b' 'c' as abc %}", ContextObjects.empty, ContextObjects.p("a")));
lst.Add(new TestDescriptor("cycle10", "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}", ContextObjects.empty, ContextObjects.p("ab")));
lst.Add(new TestDescriptor("cycle11", "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}", ContextObjects.empty, ContextObjects.p("abc")));
lst.Add(new TestDescriptor("cycle12", "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}", ContextObjects.empty, ContextObjects.p("abca")));
lst.Add(new TestDescriptor("cycle13", "{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}", ContextObjects.p("test", ContextObjects.range(5)), ContextObjects.p("a0,b1,a2,b3,a4,")));
lst.Add(new TestDescriptor("cycle14", "{% cycle one two as foo %}{% cycle foo %}", ContextObjects.p("one", "1", "two", "2"), ContextObjects.p("12")));
lst.Add(new TestDescriptor("cycle13", "{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}", ContextObjects.p("test", ContextObjects.range(5), "aye", "a", "bee", "b"), ContextObjects.p("a0,b1,a2,b3,a4,")));
// for tag
lst.Add(new TestDescriptor("for 01", "{% for i in test %}{% cycle aye bee %}{{ i }}hide this{% empty %}show this{% endfor %}", ContextObjects.p("test", null, "aye", "a", "bee", "b"), ContextObjects.p("show this")));
lst.Add(new TestDescriptor("for 02", "{% for i in test %}{{ forloop.counter }},{% endfor %}", ContextObjects.p("test", ContextObjects.range(5)), ContextObjects.p("1,2,3,4,5,")));
lst.Add(new TestDescriptor("for 03", "{% for i in test %}{{ forloop.revcounter0 }},{% endfor %}", ContextObjects.p("test", ContextObjects.range(5)), ContextObjects.p("4,3,2,1,0,")));
lst.Add(new TestDescriptor("for 04", "{% for athlete in athleteList %}{{ athlete.name }},{% endfor %}", ContextObjects.p("athleteList", new AthleteList()), ContextObjects.p("Michael Jordan,Magic Johnson,")));
lst.Add(new TestDescriptor("for 05", "{% for FirstName, LastName in athleteList %}{{ FirstName }} {{ LastName }},{% endfor %}", ContextObjects.p("athleteList", new AthleteList()), ContextObjects.p("Michael Jordan,Magic Johnson,")));
lst.Add(new TestDescriptor("for 06", "{% for FirstName, LastName in athleteList %}{{ FirstName }} {{ LastName }},{% endfor %}",
ContextObjects.p("athleteList", new string[][] { new string[] { "Michael", "Jordan" }, new string[] { "Magic", "Johnson" } }),
ContextObjects.p("Michael Jordan,Magic Johnson,")));
lst.Add(new TestDescriptor("for 07", "{% for athlete in athleteList reversed %}{{ athlete.name }},{% endfor %}", ContextObjects.p("athleteList", new AthleteList()), ContextObjects.p("Magic Johnson,Michael Jordan,")));
lst.Add(new TestDescriptor("for 08", "{% for FirstName, LastName in athleteList %}{% if forloop.last %}{{ FirstName }} {{ LastName }}{% endif %}{% endfor %}",
ContextObjects.p("athleteList", new string[][] { new string[] { "Michael", "Jordan" }, new string[] { "Magic", "Johnson" } }),
ContextObjects.p("Magic Johnson")));
lst.Add(new TestDescriptor("for 09", "{% for i in test %}run {{ forloop.counter }}:{% for j in test%}i={{forloop.parentloop.counter}},j={{forloop.counter}};{% endfor %}{% endfor %}",
ContextObjects.p("test", ContextObjects.range(2)),
ContextObjects.p("run 1:i=1,j=1;i=1,j=2;run 2:i=2,j=1;i=2,j=2;")));
// ifchanged tag
lst.Add(new TestDescriptor("ifchanged 01", "{% for i in test %}{% ifchanged %}nothing changed{%else%}same {% endifchanged %}{{ forloop.counter }},{% endfor %}", ContextObjects.p("test", ContextObjects.range(5)), ContextObjects.p("nothing changed1,same 2,same 3,same 4,same 5,")));
lst.Add(new TestDescriptor("ifchanged 02", "{% for i in test %}{% ifchanged a %}nothing changed{% endifchanged %}{{ forloop.counter }},{% endfor %}", ContextObjects.p("test", ContextObjects.range(5)), ContextObjects.p("nothing changed1,2,3,4,5,")));
lst.Add(new TestDescriptor("ifchanged 03", "{% for i in test %}{% ifchanged %}counter = {{ forloop.counter }}{% else %} hide this {% endifchanged %}{{ forloop.counter }},{% endfor %}", ContextObjects.p("test", ContextObjects.range(5)), ContextObjects.p("counter = 11,counter = 22,counter = 33,counter = 44,counter = 55,")));
lst.Add(new TestDescriptor("ifchanged 04", "{% for i in test %}{% ifchanged i %}counter = {{ forloop.counter }}{% endifchanged %}{{ forloop.counter }},{% endfor %}", ContextObjects.p("test", ContextObjects.range(5)), ContextObjects.p("counter = 11,counter = 22,counter = 33,counter = 44,counter = 55,")));
return(lst);
}
public IList <TestDescriptor> GetReproducedIssues()
{
IList <TestDescriptor> lst = new List <TestDescriptor>();
List <string> lstIssue219bisBig = GetAHrefs(5000);
lst.Add(new TestDescriptor("issue219-bisBig",
lstIssue219bisBig[0],
ContextObjects.p(
"root", "http://www.hill30.com",
"revision", ContextObjects.dictStr("DrugCategoryId", 12,
"ScriptRevisionId", 123,
"DrugId", 1234,
"EntryPointId", 12345,
"ScriptRevisionType", 123456)), ContextObjects.p(lstIssue219bisBig[1])));
List <string> lstIssue219 = GetAHrefs(40);
lst.Add(new TestDescriptor("issue219",
lstIssue219[0],
ContextObjects.p(
"root", "http://www.hill30.com",
"revision", ContextObjects.dictStr("DrugCategoryId", 12,
"ScriptRevisionId", 123,
"DrugId", 1234,
"EntryPointId", 12345,
"ScriptRevisionType", 123456)),
ContextObjects.p(lstIssue219[1])));
List <string> lstIssue219Bis = GetAHrefs(4);
lst.Add(new TestDescriptor("issue219-bis",
lstIssue219Bis[0],
ContextObjects.p(
"root", "http://www.hill30.com",
"revision", ContextObjects.dictStr("DrugCategoryId", 12,
"ScriptRevisionId", 123,
"DrugId", 1234,
"EntryPointId", 12345,
"ScriptRevisionType", 123456)), ContextObjects.p(lstIssue219Bis[1])));
return(lst);
}
public static IList <TestDescriptor> GetIfTagTests()
{
IList <TestDescriptor> lst = new List <TestDescriptor>();
// ### SMART IF TAG ################################################################
lst.Add(new TestDescriptor("if-tag < 01", "{% if foo < bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", 1, "bar", 2), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag < 02", "{% if foo < bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", 1, "bar", 1), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag < 03", "{% if foo < bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", 2, "bar", 1), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag < 04", "{% if foo > bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", 1, "bar", 2), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag < 05", "{% if foo == bar %}yes{%else %}no{% endif %}", ContextObjects.p("foo", 1, "bar", 2), ContextObjects.p("no")));
// AND and OR raised a TemplateSyntaxError in django 1.1 but we can use OR and AND in one expression since django 1.2
lst.Add(new TestDescriptor("if-tag-orand", "{% if foo or bar and baz %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-andor", "{% if foo and bar or baz %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "baz", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-andand", "{% if foo and bar and baz %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true, "baz", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag->and", "{% if foo > bar and baz %}yes{% else %}no{% endif %}", ContextObjects.p("foo", 3, "bar", 2, "baz", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag->and<", "{% if foo > bar and baz < bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", 3, "bar", 2, "baz", 1), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not-or-and01", "{% if foo or not bar and baz %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false, "baz", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not-or-and02", "{% if foo or not bar and baz %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false, "baz", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not-or-and03", "{% if foo or not bar and baz %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true, "baz", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not-or-and04", "{% if foo or not bar and baz %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false, "baz", false), ContextObjects.p("no")));
// ### IF TAG ################################################################
lst.Add(new TestDescriptor("if-tag01", "{% if foo %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag02", "{% if foo %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag02-1", "{% if foo %}yes{% else %}no{% endif %}", ContextObjects.p("foo", null), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag03", "{% if foo %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("no")));
// AND
lst.Add(new TestDescriptor("if-tag-and01", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-and02", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and03", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and04", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and05", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and06", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and07", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and08", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("bar", true), ContextObjects.p("no")));
// OR
lst.Add(new TestDescriptor("if-tag-or01", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-or02", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-or03", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-or04", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-or05", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-or06", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-or07", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-or08", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("bar", true), ContextObjects.p("yes")));
// TODO, multiple ORs
// NOT
lst.Add(new TestDescriptor("if-tag-not01", "{% if not foo %}no{% else %}yes{% endif %}", ContextObjects.p("foo", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not02", "{% if not %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not03", "{% if not %}yes{% else %}no{% endif %}", ContextObjects.p("not", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not04", "{% if not not %}no{% else %}yes{% endif %}", ContextObjects.p("not", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not05", "{% if not not %}no{% else %}yes{% endif %}", ContextObjects.p(), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not06", "{% if foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not07", "{% if foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not08", "{% if foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not09", "{% if foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not10", "{% if foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not11", "{% if not foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not12", "{% if not foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not13", "{% if not foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not14", "{% if not foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not15", "{% if not foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not16", "{% if foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not17", "{% if foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not18", "{% if foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not19", "{% if foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not20", "{% if foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not21", "{% if not foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not22", "{% if not foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not23", "{% if not foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not24", "{% if not foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not25", "{% if not foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not26", "{% if not foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not27", "{% if not foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not28", "{% if not foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not29", "{% if not foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not30", "{% if not foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not31", "{% if not foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not32", "{% if not foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not33", "{% if not foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not34", "{% if not foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not35", "{% if not foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-error01", "{% if foo and %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p(typeof(Interfaces.SyntaxException))));
lst.Add(new TestDescriptor("if-tag-error02", "{% if foo or %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p(typeof(Interfaces.SyntaxException))));
lst.Add(new TestDescriptor("if-tag-error03", "{% if not foo and %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p(typeof(Interfaces.SyntaxException))));
lst.Add(new TestDescriptor("if-tag-error04", "{% if not foo or %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p(typeof(Interfaces.SyntaxException))));
lst.Add(new TestDescriptor("if-tag-error05", "{% if not foo %}yes{% else %}no", ContextObjects.p("foo", true), ContextObjects.p(typeof(Interfaces.SyntaxException))));
// IFEqual TAG
lst.Add(new TestDescriptor("ifequal-tag-01", "{% ifequal foo bar %}yes{% else %}no{% endifequal %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("ifequal-tag-02", "{% ifequal foo bar %}yes{% else %}no{% endifequal %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("ifequal-tag-03", "{% ifnotequal foo bar %}yes{% else %}no{% endifnotequal %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("ifequal-tag-04", "{% ifnotequal foo bar %}yes{% else %}no{% endifnotequal %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("ifequal-tag-05", "{% ifequal foo \"true\" %}yes{% else %}no{% endifequal %}", ContextObjects.p("foo", "true"), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("ifequal-tag-06", "{% ifequal foo bar %}yes{% else %}no{% endifequal %}", ContextObjects.p("foo", "true", "bar", false), ContextObjects.p("no")));
return(lst);
}
public static IList <TestDescriptor> GetBasicTests()
{
IList <TestDescriptor> lst = new List <TestDescriptor>();
//*
// Plain text should go through the template parser untouched
lst.Add(new TestDescriptor("basic-syntax01", "something cool", null, ContextObjects.p("something cool")));
// Variables should be replaced with their value in the current context
lst.Add(new TestDescriptor("basic-syntax02", "{{ headline }}", ContextObjects.p("headline", "Success"), ContextObjects.p("Success"), "headline"));
Guid guid = Guid.NewGuid();
lst.Add(new TestDescriptor("basic-syntax02", "{{ headline }}", ContextObjects.p("headline", guid), ContextObjects.p(guid.ToString()), "headline"));
// More than one replacement variable is allowed in a template
lst.Add(new TestDescriptor("basic-syntax03", "{{ first }} --- {{ second }}", ContextObjects.p("first", 1, "second", 2),
ContextObjects.p("1 --- 2"), "first", "second"));
int?p2 = null;
lst.Add(new TestDescriptor("basic-syntax03-1", "{{ first }} --- {{ second }}", ContextObjects.p("first", null, "second", p2), ContextObjects.p(" --- ")));
// Fail silently when a variable is not found in the current context
lst.Add(new TestDescriptor("basic-syntax04", "as{{ missing }}df", ContextObjects.empty, ContextObjects.p("asdf", "asINVALIDdf")));
// A variable may not contain more than one word
lst.Add(new TestDescriptor("basic-syntax06", "{{ multi word variable }}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.SyntaxException))));
// A variable may has to have a reference variable first
lst.Add(new TestDescriptor("basic-syntax06-1", "{{ |filter }}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.SyntaxException))));
// Raise TemplateSyntaxError for ContextObjects.empty variable tags
lst.Add(new TestDescriptor("basic-syntax07", "{{ }}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.SyntaxException))));
lst.Add(new TestDescriptor("basic-syntax08", "{{ }}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.SyntaxException))));
// Attribute syntax allows a template to call an object's attribute
lst.Add(new TestDescriptor("basic-syntax09", "{{ var.method }}", ContextObjects.p("var", new ContextObjects.SomeClass()), ContextObjects.p("SomeClass.method")));
// Multiple levels of attribute access are allowed
lst.Add(new TestDescriptor("basic-syntax10", "{{ var.otherclass.method }}", ContextObjects.p("var", new ContextObjects.SomeClass()),
ContextObjects.p("OtherClass.method"), "var.otherclass.method"));
// Multiple levels of attribute access are allowed
lst.Add(new TestDescriptor("basic-syntax10-l", "{{ var.classList.0.method }} {% for oc in var.classList %}{{forloop.counter}} = {{oc.method}};{%endfor%}", ContextObjects.p("var", new ContextObjects.SomeClass()),
ContextObjects.p("Instance 1 1 = Instance 1;2 = Instance 2;"), "var.otherclass.method"));
// Fail silently when a variable's attribute isn't found
lst.Add(new TestDescriptor("basic-syntax11", "{{ var.blech }}", ContextObjects.p("var", new ContextObjects.SomeClass()), ContextObjects.p("", "INVALID")));
// Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
//lst.Add(new TestDescriptor("basic-syntax12", "{{ var.__dict__ }}", ContextObjects.p("var", new ContextObjects.SomeClass()), ContextObjects.p(typeof(SyntaxException))));
// Raise TemplateSyntaxError when trying to access a variable containing an illegal character
lst.Add(new TestDescriptor("basic-syntax13", "{{ va>r }}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.SyntaxException))));
lst.Add(new TestDescriptor("basic-syntax14", "{{ (var.r) }}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.SyntaxException))));
lst.Add(new TestDescriptor("basic-syntax15", "{{ sp%am }}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.SyntaxException))));
lst.Add(new TestDescriptor("basic-syntax16", "{{ eggs! }}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.SyntaxException))));
lst.Add(new TestDescriptor("basic-syntax17", "{{ moo? }}", ContextObjects.empty, ContextObjects.p(typeof(Interfaces.SyntaxException))));
var d = new Dictionary <string, string>();
d.Add("bar", "baz");
// Attribute syntax allows a template to call a dictionary key's value
lst.Add(new TestDescriptor("basic-syntax18", "{{ foo.bar }}", ContextObjects.p("foo", d), ContextObjects.p("baz")));
// Fail silently when a variable's dictionary key isn't found
lst.Add(new TestDescriptor("basic-syntax19", "{{ foo.spam }}", ContextObjects.p("foo", d), ContextObjects.p("", "INVALID")));
// Fail silently when accessing a non-simple method
lst.Add(new TestDescriptor("basic-syntax20", "{{ var.method2 }}", ContextObjects.p("var", new ContextObjects.SomeClass()), ContextObjects.p("", "INVALID")));
// Don't get confused when parsing something that is almost, but not
// quite, a template tag.
lst.Add(new TestDescriptor("basic-syntax21", "a {{ moo %} b", ContextObjects.empty, ContextObjects.p("a {{ moo %} b")));
lst.Add(new TestDescriptor("basic-syntax22", "{{ moo //}", ContextObjects.empty, ContextObjects.p("{{ moo //}")));
// Will try to treat "moo //} {{ cow" as the variable. Not ideal, but
// costly to work around, so this triggers an error.
lst.Add(new TestDescriptor("basic-syntax23", "{{ moo //} {{ cow }}", ContextObjects.p("cow", "cow"), ContextObjects.p(typeof(Interfaces.SyntaxException))));
// Embedded newlines make it not-a-tag.
lst.Add(new TestDescriptor("basic-syntax24", "{{ moo\n }}", ContextObjects.empty, ContextObjects.p("{{ moo\n }}")));
// Literal strings are permitted inside variables, mostly for i18n
// purposes.
lst.Add(new TestDescriptor("basic-syntax25", "{{ \"fred\" }}", ContextObjects.empty, ContextObjects.p("fred")));
lst.Add(new TestDescriptor("basic-syntax25-sq1", "{{ '\"fred\"' }}", ContextObjects.empty, ContextObjects.p("\"fred\"")));
// No unescape for double-quote inside a single quoted string
lst.Add(new TestDescriptor("basic-syntax25-sq2", "{{ 'fr\"ed' }}", ContextObjects.empty, ContextObjects.p("fr\"ed")));
lst.Add(new TestDescriptor("basic-syntax26", "{% autoescape off %}{{ \"\\\"fred\\\"\" }}{% endautoescape %}", ContextObjects.empty, ContextObjects.p("\"fred\"")));
lst.Add(new TestDescriptor("basic-syntax27", "{{ _(\"\\\"fred\\\"\") }}", ContextObjects.empty, ContextObjects.p("\"fred\"")));
// List-index syntax allows a template to access a certain item of a subscriptable object.
lst.Add(new TestDescriptor("list-index01", "{{ var.1 }}", ContextObjects.p("var", ContextObjects.list("first item", "second item")), ContextObjects.p("second item")));
// Fail silently when the list index is out of range.
lst.Add(new TestDescriptor("list-index02", "{{ var.5 }}", ContextObjects.p("var", ContextObjects.list("first item", "second item")), ContextObjects.p("", "INVALID")));
// Fail silently when the variable is not a subscriptable object.
lst.Add(new TestDescriptor("list-index03", "{{ var.1 }}", ContextObjects.p("var", new ContextObjects.SomeClass()), ContextObjects.p("", "INVALID")));
// Fail silently when variable is a dict without the specified key.
lst.Add(new TestDescriptor("list-index04", "{{ var.1 }}", ContextObjects.p("var", ContextObjects.dict()), ContextObjects.p("", "INVALID")));
// Dictionary lookup wins out when dict's key is a string.
lst.Add(new TestDescriptor("list-index05", "{{ var.1 }}", ContextObjects.p("var", ContextObjects.dict("1", "hello")), ContextObjects.p("hello")));
// But list-index lookup wins out when dict's key is an int, which
// behind the scenes is really a dictionary lookup (for a dict)
// after converting the key to an int.
lst.Add(new TestDescriptor("list-index06", "{{ var.1 }}", ContextObjects.p("var", ContextObjects.dict(1, "hello")), ContextObjects.p("hello")));
// Dictionary lookup wins out when there is a string and int version of the key.
lst.Add(new TestDescriptor("list-index07", "{{ var.1 }}", ContextObjects.p("var", ContextObjects.dict("1", "hello", 1, "world")), ContextObjects.p("hello")));
return(lst);
}
public IList <TestDescriptor> GetMiscellaneousTagsTests()
{
IList <TestDescriptor> lst = new List <TestDescriptor>();
// autoescape tag
lst.Add(new TestDescriptor("autoescape-tag", "before <{{ lt }} {% autoescape off %}inside <{{ lt }}{{ gt }}>{% endautoescape %} after {{ gt }}>", ContextObjects.p("lt", "<", "gt", ">"), ContextObjects.p("before << inside <<>> after >>")));
// ### COMMENT TAG ################################################################
lst.Add(new TestDescriptor("comment-tag", "before {% comment %}hide this: {% invalid tag %} {% endcomment %} after", ContextObjects.empty, ContextObjects.p("before after")));
// DEBUG TAG
lst.Add(new TestDescriptor("debug", "{% debug %}", ContextObjects.p("v2", null, "v3", "vee3"),
ContextObjects.p("System.Collections.Generic.Dictionary`2[System.String,System.Object]\r\n---- NDjango Context ----\r\nSettings:\r\nautoescape = True\r\nVariables:\r\nv2 = NULL\r\nv3 = \"vee3\"\r\n")));
// FIRSTOF TAG
lst.Add(new TestDescriptor("firstof01", "{% firstof v1 v2 v3 \"fallback\" %}", ContextObjects.empty, ContextObjects.p("fallback")));
lst.Add(new TestDescriptor("firstof02", "{% firstof v1 v2 v3 \"fallback\" %}", ContextObjects.p("v2", "vee2", "v3", "vee3"), ContextObjects.p("vee2")));
lst.Add(new TestDescriptor("firstof03", "{% firstof v1 v2 v3 \"fallback\" %}", ContextObjects.p("v2", null, "v3", "vee3"), ContextObjects.p("vee3")));
// NOW TAG
lst.Add(new TestDescriptor("now 01", "{% now \"D,d F Y G:i:s O\" %}", ContextObjects.empty, () => new object[] { DateTime.Now.ToString("ddd,dd MMMM yyyy %H:mm:ss zzz") }));
lst.Add(new TestDescriptor("now 02", "{% now \"D,d F Y G:i:\\s O\" %}", ContextObjects.empty, () => new object[] { DateTime.Now.ToString("ddd,dd MMMM yyyy %H:mm:\\s zzz") }));
lst.Add(new TestDescriptor("date filter 01", "{{ now|date:\"D,d F Y G:i:s O\" }}", ContextObjects.p("now", DateTime.Now), ContextObjects.p(DateTime.Now.ToString("ddd,dd MMMM yyyy %H:mm:ss zzz"))));
lst.Add(new TestDescriptor("date filter 02", "{{ now|date:\"D,d F Y G:i:\\s O\" }}", ContextObjects.p("now", DateTime.Now), ContextObjects.p(DateTime.Now.ToString("ddd,dd MMMM yyyy %H:mm:\\s zzz"))));
lst.Add(new TestDescriptor("date filter 03", "{{ now|date:\"D,d F Y G:i:\\s O\" }}", ContextObjects.p("now", null), ContextObjects.p(DateTime.MinValue.ToString("ddd,dd MMMM yyyy %H:mm:\\s zzz"))));
// BLOCK TAG
lst.Add(new TestDescriptor("block 01", "some html out{% block something %} some html in{% endblock %} more html out", null, ContextObjects.p("some html out some html in more html out")));
// EXTENDS TAG
lst.Add(new TestDescriptor("extends 01", "{% extends \"t1\" %} skip1--{% block b1 %}the replacement{% endblock %}--skip2", null, ContextObjects.p("insert1--the replacement--insert2")));
lst.Add(new TestDescriptor("extends 01-bis", "{% extends 't1' %} skip1--{% block b1 %}the replacement{% endblock %}--skip2", null, ContextObjects.p("insert1--the replacement--insert2")));
lst.Add(new TestDescriptor("extends 02", "{% extends \"t21\" %} skip1--{% block b1 %}the replacement1{% endblock %}{% block b2 %} the replacement2{% endblock %}--skip2", null, ContextObjects.p("insert1--the replacement1 the replacement2--insert2")));
lst.Add(new TestDescriptor("extends 03", "{% extends \"t21\" %} skip1--{% block b1 %}the replacement1{% endblock %}--skip2", null, ContextObjects.p("insert1--the replacement1to be replaced22--insert2")));
lst.Add(new TestDescriptor("extends 04", "{% extends \"t21\" %} skip1--{% block b1 %}the replacement1++{{ block.super }}++{% endblock %}--skip2", null,
ContextObjects.p("insert1--the replacement1++to be replaced21++to be replaced22--insert2")));
lst.Add(new TestDescriptor("extends 04 - breaking parents", "{% extends \"t21-withif\" %} skip1--{% block b1 %}the replacement1++{{ block.super }}++{% endblock %}--skip2", null,
ContextObjects.p("insert1--the replacement1++to be replaced21++to be replaced22--insert2")));
lst.Add(new TestDescriptor("extends 05", "{% extends \"t21middle\" %} {% block b2 %} child {% endblock %}", null, ContextObjects.p("text child text")));
// lst.Add(new TestDescriptor("extends 05", "{% extends \"t21middle\" %} {% block b2 %} child {% endblock %}", null, ContextObjects.p("text child text")));
// lst.Add(new TestDescriptor("extends 05-nested", "{% extends \"t21top\" %} {% block b3 %} {{block.super.super}} {% endblock %} {% block b4 %} *{{block.super}}* {% endblock %}", null, ContextObjects.p("text child text")));
// Nested block tags
lst.Add(new TestDescriptor("nestedblocks 01",
@"{% extends ""tBaseNested"" %}
{% block outer %}
{{ block.super }}
new stuff
{% endblock outer %}", null, ContextObjects.p(@"
this is inner1
this is inner2
new stuff
")));
lst.Add(new TestDescriptor("nestedblocks 02",
@"{% extends ""tBaseNested"" %}
{% block outer %}
{{ block.super }}
new stuff
{% endblock outer %}
{% block inner2 %}
new inner2
{% endblock inner2 %}", null, ContextObjects.p(@"
this is inner1
new inner2
new stuff
")));
lst.Add(new TestDescriptor("nestedblocks 03 - \"don't do this!\"",
@"{% extends ""tBaseNested"" %}
{% block outer %}
{{ block.super }}
new stuff
{% block inner2 %}
new inner2
{% endblock inner2 %}
{% endblock outer %}", null, ContextObjects.p(@"
this is inner1
new inner2
new stuff
new inner2
")));
// filter tag
lst.Add(new TestDescriptor("filter-tag", "before <{{ lt }} {% autoescape off %}inside <{{ lt }}{{ gt }}>{% filter escape %} inside filter <{{ lt }}{{ gt }}>{% endfilter %}{% endautoescape %} after {{ gt }}>"
, ContextObjects.p("lt", "<", "gt", ">"), ContextObjects.p("before << inside <<>> inside filter <<>> after >>")));
// include tag
lst.Add(new TestDescriptor("include 01", "value={{ value }} {% include \"include-name\" %}", ContextObjects.p("value", "VALUE"), ContextObjects.p("value=VALUE inside included template VALUE")));
ContextObjects.Person[] people = new ContextObjects.Person[] {
new ContextObjects.Person("George", "Bush", "Male"),
new ContextObjects.Person("Bill", "Clinton", "Male"),
new ContextObjects.Person("Margaret", "Thatcher", "Female"),
new ContextObjects.Person("Condoleezza", "Rice", "Female"),
new ContextObjects.Person("Pat", "Smith", "Unknown")
};
// regroup tag
lst.Add(new TestDescriptor("regroup-01",
@"{% regroup people by gender as gender_list %}<ul>
{% for gender in gender_list %}
<li>{{ gender.grouper }}
<ul>
{% for item in gender.list %}
<li>{{ item.first_name }} {{ item.last_name }}</li>
{% endfor %}
</ul>
</li>
{% endfor %}
</ul>",
ContextObjects.p("people", people),
ContextObjects.p(
@"<ul>
<li>Male
<ul>
<li>George Bush</li>
<li>Bill Clinton</li>
</ul>
</li>
<li>Female
<ul>
<li>Margaret Thatcher</li>
<li>Condoleezza Rice</li>
</ul>
</li>
<li>Unknown
<ul>
<li>Pat Smith</li>
</ul>
</li>
</ul>"
)));
// spaceless tag
lst.Add(new TestDescriptor("spaceless-01", "{% spaceless %}templatetag<h1> \r\n </h1> !\r\n <h2> </h2>{% endspaceless %}", ContextObjects.empty, ContextObjects.p("templatetag<h1></h1> !\r\n <h2></h2>")));
// ssi tag
lst.Add(new TestDescriptor("ssi 01", "value={{ value }} {% ssi include-name parsed %}", ContextObjects.p("value", "VALUE"), ContextObjects.p("value=VALUE inside included template VALUE")));
lst.Add(new TestDescriptor("ssi 02", "value={{ value }} {% ssi include-name %}", ContextObjects.p("value", "VALUE"), ContextObjects.p("value=VALUE inside included template {{ value }}")));
// tho following 3 tests are intended to test the buffer boundary - set the buffer length
// in the ssi tag implementation to 14 for them to make sense
lst.Add(new TestDescriptor("ssi 03", "{% ssi buffer-length %}", ContextObjects.p("value", "VALUE"), ContextObjects.p("buffer-length")));
lst.Add(new TestDescriptor("ssi 04", "{% ssi buffer-length1 %}", ContextObjects.p("value", "VALUE"), ContextObjects.p("buffer-length1")));
lst.Add(new TestDescriptor("ssi 05", "{% ssi buffer-length11 %}", ContextObjects.p("value", "VALUE"), ContextObjects.p("buffer-length11")));
// template tag
lst.Add(new TestDescriptor("templatetag-01", "{% templatetag openblock %} templatetag openblock {% templatetag closeblock %}", ContextObjects.empty, ContextObjects.p("{% templatetag openblock %}")));
// WidthRatio tag
lst.Add(new TestDescriptor("widthratio-01", "{% widthratio value maxValue 100 %}", ContextObjects.p("value", 175, "maxValue", "200"), ContextObjects.p("88")));
// With tag
lst.Add(new TestDescriptor("with-01", "{% with var.otherclass.method as newvar %}{{ newvar }}{% endwith %} {{ newvar }}", ContextObjects.p("var", new ContextObjects.SomeClass(), "newvar", "newvar"), ContextObjects.p("OtherClass.method newvar")));
// URL tag
lst.Add(new TestDescriptor("url-01", "{% url \"hello/{0}\" parm1 %}", ContextObjects.p("parm1", "world"), ContextObjects.p("/appRoot/hello/world")));
lst.Add(new TestDescriptor("url-02", "{% url \"hello/{0}/{1}\" parm1, parm2%}", ContextObjects.p("parm1", "new", "parm2", "world"), ContextObjects.p("/appRoot/hello/new/world")));
lst.Add(new TestDescriptor("url-03", "no {% url \"hello/{0}/{1}\" parm1, parm2 as foo %}url, then {{ foo }}", ContextObjects.p("parm1", "new", "parm2", "world"), ContextObjects.p("no url, then /appRoot/hello/new/world")));
// nested simple tag implementation
lst.Add(new TestDescriptor("simple-nested-tag-01", "{% nested p1 %}{% spaceless %}templatetag<h1> \r\n </h1> !\r\n <h2> </h2>{% endspaceless %}{% endnested %}", ContextObjects.p("p1", "parm1"), ContextObjects.p(typeof(SyntaxException))));
lst.Add(new TestDescriptor("simple-nested-tag-02", "{% nested p1 \"p2\" %}{% spaceless %}templatetag<h1> \r\n </h1> !\r\n <h2> </h2>{% endspaceless %}{% endnested %}woo", ContextObjects.p("p1", "parm1"), ContextObjects.p("parm1p2starttemplatetag<h1></h1> !\r\n <h2></h2>endwoo")));
// non-nested simple tag implementation
lst.Add(new TestDescriptor("simple-non-nested-tag-01", "{% non-nested p1 \"p2\" %}woo", ContextObjects.p("p1", "parm1"), ContextObjects.p("parm1p2woo")));
return(lst);
}
public IList <TestDescriptor> GetIfTagTests()
{
IList <TestDescriptor> lst = new List <TestDescriptor>();
// ### IF TAG ################################################################
lst.Add(new TestDescriptor("if-tag01", "{% if foo %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag02", "{% if foo %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag02-1", "{% if foo %}yes{% else %}no{% endif %}", ContextObjects.p("foo", null), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag03", "{% if foo %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("no")));
// AND
lst.Add(new TestDescriptor("if-tag-and01", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-and02", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and03", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and04", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and05", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and06", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and07", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-and08", "{% if foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("bar", true), ContextObjects.p("no")));
// OR
lst.Add(new TestDescriptor("if-tag-or01", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-or02", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-or03", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-or04", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-or05", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-or06", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-or07", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-or08", "{% if foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("bar", true), ContextObjects.p("yes")));
// TODO, multiple ORs
// NOT
lst.Add(new TestDescriptor("if-tag-not01", "{% if not foo %}no{% else %}yes{% endif %}", ContextObjects.p("foo", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not02", "{% if not %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not03", "{% if not %}yes{% else %}no{% endif %}", ContextObjects.p("not", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not04", "{% if not not %}no{% else %}yes{% endif %}", ContextObjects.p("not", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not05", "{% if not not %}no{% else %}yes{% endif %}", ContextObjects.p(), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not06", "{% if foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not07", "{% if foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not08", "{% if foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not09", "{% if foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not10", "{% if foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not11", "{% if not foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not12", "{% if not foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not13", "{% if not foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not14", "{% if not foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not15", "{% if not foo and bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not16", "{% if foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not17", "{% if foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not18", "{% if foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not19", "{% if foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not20", "{% if foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not21", "{% if not foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not22", "{% if not foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not23", "{% if not foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not24", "{% if not foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not25", "{% if not foo or bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not26", "{% if not foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not27", "{% if not foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not28", "{% if not foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not29", "{% if not foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not30", "{% if not foo and not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not31", "{% if not foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p(), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not32", "{% if not foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("if-tag-not33", "{% if not foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not34", "{% if not foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("if-tag-not35", "{% if not foo or not bar %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p("yes")));
// AND and OR raises a TemplateSyntaxError
lst.Add(new TestDescriptor("if-tag-error01", "{% if foo or bar and baz %}yes{% else %}no{% endif %}", ContextObjects.p("foo", false, "bar", false), ContextObjects.p(typeof(SyntaxException))));
lst.Add(new TestDescriptor("if-tag-error02", "{% if foo and %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p(typeof(SyntaxException))));
lst.Add(new TestDescriptor("if-tag-error03", "{% if foo or %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p(typeof(SyntaxException))));
lst.Add(new TestDescriptor("if-tag-error04", "{% if not foo and %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p(typeof(SyntaxException))));
lst.Add(new TestDescriptor("if-tag-error05", "{% if not foo or %}yes{% else %}no{% endif %}", ContextObjects.p("foo", true), ContextObjects.p(typeof(SyntaxException))));
lst.Add(new TestDescriptor("if-tag-error06", "{% if not foo %}yes{% else %}no", ContextObjects.p("foo", true), ContextObjects.p(typeof(SyntaxException))));
// IFEqual TAG
lst.Add(new TestDescriptor("ifequal-tag-01", "{% ifequal foo bar %}yes{% else %}no{% endifequal %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("ifequal-tag-02", "{% ifequal foo bar %}yes{% else %}no{% endifequal %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("no")));
lst.Add(new TestDescriptor("ifequal-tag-03", "{% ifnotequal foo bar %}yes{% else %}no{% endifnotequal %}", ContextObjects.p("foo", true, "bar", true), ContextObjects.p("no")));
lst.Add(new TestDescriptor("ifequal-tag-04", "{% ifnotequal foo bar %}yes{% else %}no{% endifnotequal %}", ContextObjects.p("foo", true, "bar", false), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("ifequal-tag-05", "{% ifequal foo \"true\" %}yes{% else %}no{% endifequal %}", ContextObjects.p("foo", "true"), ContextObjects.p("yes")));
lst.Add(new TestDescriptor("ifequal-tag-06", "{% ifequal foo bar %}yes{% else %}no{% endifequal %}", ContextObjects.p("foo", "true", "bar", false), ContextObjects.p("no")));
return(lst);
}