1788 lines
71 KiB
C#
1788 lines
71 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Web;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
|
|
namespace Mustache.Test
|
|
{
|
|
/// <summary>
|
|
/// Tests the FormatParser class.
|
|
/// </summary>
|
|
[TestClass]
|
|
public class FormatCompilerTester
|
|
{
|
|
#region Tagless Formats
|
|
|
|
/// <summary>
|
|
/// If the given format is null, an exception should be thrown.
|
|
/// </summary>
|
|
[TestMethod]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void TestCompile_NullFormat_Throws()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
compiler.Compile(null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the format string contains no tag, then the given format string
|
|
/// should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_NoTags_PrintsFormatString()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = "This is an ordinary string.";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual(format, result, "The generated text was wrong.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a line is just whitespace, it should be printed out as is.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_LineAllWhitespace_PrintsWhitespace()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = "\t \t";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual(format, result, "The generated text was wrong.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a line has output, then the next line is blank, then both lines
|
|
/// should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_OutputNewLineBlank_PrintsBothLines()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello{{#newline}}
|
|
";
|
|
|
|
const string expected = @"Hello
|
|
";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Key
|
|
|
|
/// <summary>
|
|
/// Replaces placeholds with the actual value.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Key_ReplacesWithValue()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{Name}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new { Name = "Bob" });
|
|
Assert.AreEqual("Hello, Bob!!!", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we pass null as the source object and the format string contains "this",
|
|
/// then nothing should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ThisIsNull_PrintsNothing()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
Generator generator = compiler.Compile("{{this}}");
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual(String.Empty, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we try to print a key that doesn't exist, an exception should be thrown.
|
|
/// </summary>
|
|
[TestMethod]
|
|
[ExpectedException(typeof(KeyNotFoundException))]
|
|
public void TestCompile_MissingKey_Throws()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{Name}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
generator.Render(new object());
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we try to print a key that doesn't exist, we can provide a
|
|
/// handler to provide a substitute.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_MissingKey_CallsKeyNotFoundHandler()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{Name}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
generator.KeyNotFound += (obj, args) =>
|
|
{
|
|
args.Substitute = "Unknown";
|
|
args.Handled = true;
|
|
};
|
|
string actual = generator.Render(new object());
|
|
string expected = "Hello, Unknown!!!";
|
|
Assert.AreEqual(expected, actual, "The wrong message was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the key is the parent object, the search will go up the hierarchy.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_KeyInParent_LooksUpKeyInParent()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#with Address}}{{FirstName}} from {{City}}{{/with}}";
|
|
Generator generator = compiler.Compile(format);
|
|
string actual = generator.Render(new
|
|
{
|
|
FirstName = "Bob",
|
|
Address = new
|
|
{
|
|
City = "Philadelphia",
|
|
}
|
|
});
|
|
string expected = "Bob from Philadelphia";
|
|
Assert.AreEqual(expected, actual, "The wrong message was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If part of a key is wrong, the full details should be provided.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_MultipartKey_PartMissing_ProvidesFullDetail()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{Customer.Name}}";
|
|
Generator generator = compiler.Compile(format);
|
|
generator.KeyNotFound += (obj, args) =>
|
|
{
|
|
args.Substitute = args.Key + "," + args.MissingMember;
|
|
args.Handled = true;
|
|
};
|
|
string actual = generator.Render(new
|
|
{
|
|
Customer = new
|
|
{
|
|
FirstName = "Bob"
|
|
}
|
|
});
|
|
string expected = "Customer.Name,Name";
|
|
Assert.AreEqual(expected, actual, "The wrong message was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we specify an alignment with a key, the alignment should
|
|
/// be used when rending the value.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_KeyWithNegativeAlignment_AppliesAlignment()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{Name,-10}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new { Name = "Bob" });
|
|
Assert.AreEqual("Hello, Bob !!!", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we specify an alignment with a key, the alignment should
|
|
/// be used when rending the value.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_KeyWithPositiveAlignment_AppliesAlignment()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{Name,10}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new { Name = "Bob" });
|
|
Assert.AreEqual("Hello, Bob!!!", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we specify a positive alignment with a key with an optional + character,
|
|
/// the alignment should be used when rending the value.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_KeyWithPositiveAlignment_OptionalPlus_AppliesAlignment()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{Name,+10}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new { Name = "Bob" });
|
|
Assert.AreEqual("Hello, Bob!!!", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we specify an format with a key, the format should
|
|
/// be used when rending the value.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_KeyWithFormat_AppliesFormatting()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{When:yyyyMMdd}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new { When = new DateTime(2012, 01, 31) });
|
|
Assert.AreEqual("Hello, 20120131!!!", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we specify an alignment with a key, the alignment should
|
|
/// be used when rending the value.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_KeyWithAlignmentAndFormat_AppliesBoth()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{When,10:yyyyMMdd}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new { When = new DateTime(2012, 01, 31) });
|
|
Assert.AreEqual("Hello, 20120131!!!", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we dot separate keys, the value will be found by searching
|
|
/// through the properties.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_NestedKeys_NestedProperties()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{Top.Middle.Bottom}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new { Top = new { Middle = new { Bottom = "Bob" } } });
|
|
Assert.AreEqual("Hello, Bob!!!", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a line has output, then the next line is blank, then both lines
|
|
/// should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_OutputNewLineOutput_PrintsBothLines()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{this}}{{#newline}}
|
|
After";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render("Content");
|
|
const string expected = @"Content
|
|
After";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If there is a line followed by a line with a key, both lines should be
|
|
/// printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_EmptyNewLineKey_PrintsBothLines()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#newline}}
|
|
{{this}}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render("Content");
|
|
const string expected = @"
|
|
Content";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If there is a no-output line followed by a line with a key, the first line
|
|
/// should be removed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_NoOutputNewLineKey_PrintsBothLines()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#! comment }}
|
|
{{this}}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render("Content");
|
|
const string expected = @"Content";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If there is a comment on one line followed by a line with a key, the first line
|
|
/// should be removed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_KeyKey_PrintsBothLines()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{this}}{{#newline}}
|
|
{{this}}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render("Content");
|
|
const string expected = @"Content
|
|
Content";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// We can track all of the keys that appear in a template by
|
|
/// registering with the PlaceholderFound event.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_FindsPlaceholders_RecordsPlaceholders()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
HashSet<string> keys = new HashSet<string>();
|
|
compiler.PlaceholderFound += (o, e) =>
|
|
{
|
|
keys.Add(e.Key);
|
|
};
|
|
compiler.Compile(@"{{FirstName}} {{LastName}}");
|
|
string[] expected = new string[] { "FirstName", "LastName" };
|
|
string[] actual = keys.OrderBy(s => s).ToArray();
|
|
CollectionAssert.AreEqual(expected, actual, "Not all placeholders were found.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// We can track all of the keys that appear in a template by
|
|
/// registering with the PlaceholderFound event.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_FindsVariables_RecordsVariables()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
HashSet<string> variables = new HashSet<string>();
|
|
compiler.VariableFound += (o, e) =>
|
|
{
|
|
variables.Add(e.Name);
|
|
};
|
|
compiler.Compile(@"{{@FirstName}}{{@LastName}}");
|
|
string[] expected = new string[] { "FirstName", "LastName" };
|
|
string[] actual = variables.OrderBy(s => s).ToArray();
|
|
CollectionAssert.AreEqual(expected, actual, "Not all variables were found.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// We can track all of the keys that appear in a template by
|
|
/// registering with the PlaceholderFound event.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_FindsPlaceholdersInIf_RecordsPlaceholders()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
HashSet<string> keys = new HashSet<string>();
|
|
compiler.PlaceholderFound += (o, e) =>
|
|
{
|
|
keys.Add(e.Key);
|
|
};
|
|
compiler.Compile(@"{{#if FirstName}}{{/if}}");
|
|
string[] expected = new string[] { "FirstName" };
|
|
string[] actual = keys.OrderBy(s => s).ToArray();
|
|
CollectionAssert.AreEqual(expected, actual, "Not all placeholders were found.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// We can track all of the keys that appear in a template by
|
|
/// registering with the PlaceholderFound event.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_FindsVariablesInIf_RecordsVariables()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
HashSet<string> variables = new HashSet<string>();
|
|
compiler.VariableFound += (o, e) =>
|
|
{
|
|
variables.Add(e.Name);
|
|
};
|
|
compiler.Compile(@"{{#if @FirstName}}{{/if}}");
|
|
string[] expected = new string[] { "FirstName" };
|
|
string[] actual = variables.OrderBy(s => s).ToArray();
|
|
CollectionAssert.AreEqual(expected, actual, "Not all placeholders were found.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// We can determine the context in which a placeholder is found by looking at the provided context array.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_FindsPlaceholders_ProvidesContext()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
Context[] context = null;
|
|
compiler.PlaceholderFound += (o, e) =>
|
|
{
|
|
context = e.Context;
|
|
};
|
|
compiler.Compile(@"{{#with Address}}{{ZipCode}}{{/with}}");
|
|
|
|
Assert.IsNotNull(context, "The context was not set.");
|
|
Assert.AreEqual(2, context.Length, "The context did not contain the right number of items.");
|
|
|
|
Assert.AreEqual(String.Empty, context[0].TagName, "The top-most context had the wrong tag type.");
|
|
Assert.AreEqual("with", context[1].TagName, "The bottom context had the wrong tag type.");
|
|
|
|
Assert.AreEqual(0, context[0].Parameters.Length, "The top-most context had the wrong number of parameters.");
|
|
Assert.AreEqual(1, context[1].Parameters.Length, "The bottom context had the wrong number of parameters.");
|
|
Assert.AreEqual("Address", context[1].Parameters[0].Argument, "The bottom context had the wrong argument.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// I was leaving behind context even after reaching a closing tag. We need to make sure
|
|
/// that context is like a call stack and that it is cleaned up after leaving the context.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ExitContext_RemoveContext()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
Context[] context = null;
|
|
compiler.PlaceholderFound += (o, e) =>
|
|
{
|
|
context = e.Context;
|
|
};
|
|
compiler.Compile(@"{{#with Address}}{{/with}}{{FirstName}}");
|
|
|
|
Assert.IsNotNull(context, "The context was not set.");
|
|
Assert.AreEqual(1, context.Length, "The context did not contain the right number of items.");
|
|
|
|
Assert.AreEqual(String.Empty, context[0].TagName, "The top-most context had the wrong tag type.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a key refers to a public field, its value should be substituted in the output.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestGenerate_KeyRefersToPublicField_SubstitutesValue()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{Field}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
ClassWithPublicField instance = new ClassWithPublicField() { Field = "Bob" };
|
|
string result = generator.Render(instance);
|
|
Assert.AreEqual("Hello, Bob!!!", result, "The wrong text was generated.");
|
|
}
|
|
|
|
public class ClassWithPublicField
|
|
{
|
|
public string Field;
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a derived class replaces a property/field in the base class (via new)
|
|
/// it should be used, instead of causing an exception or using the base's
|
|
/// property/field.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestGenerate_NewPropertyInDerivedClass_UsesDerivedProperty()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{Value}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
DerivedClass instance = new DerivedClass() { Value = "Derived" };
|
|
string result = generator.Render(instance);
|
|
Assert.AreEqual("Hello, Derived!!!", result, "The wrong text was generated.");
|
|
}
|
|
|
|
public class BaseClass
|
|
{
|
|
public int Value { get; set; }
|
|
}
|
|
|
|
public class DerivedClass : BaseClass
|
|
{
|
|
public DerivedClass()
|
|
{
|
|
base.Value = 1;
|
|
}
|
|
|
|
public new string Value { get; set; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a derived class replaces a property/field in the base class (via new)
|
|
/// it should be used, instead of causing an exception or using the base's
|
|
/// property/field.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestGenerate_NewPropertyInGenericDerivedClass_UsesDerivedProperty()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello, {{Value}}!!!";
|
|
Generator generator = compiler.Compile(format);
|
|
DerivedClass<string> instance = new DerivedClass<string>() { Value = "Derived" };
|
|
string result = generator.Render(instance);
|
|
Assert.AreEqual("Hello, Derived!!!", result, "The wrong text was generated.");
|
|
}
|
|
|
|
public class DerivedClass<T> : BaseClass
|
|
{
|
|
public DerivedClass()
|
|
{
|
|
base.Value = 1;
|
|
}
|
|
|
|
public new T Value { get; set; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Comment
|
|
|
|
/// <summary>
|
|
/// Removes comments from the middle of text.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Comment_RemovesComment()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = "Before{{#! This is a comment }}After";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new object());
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes comments surrounding text.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_CommentContentComment_RemovesComment()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = "{{#! comment }}Middle{{#! comment }}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new object());
|
|
Assert.AreEqual("Middle", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If blank space is surrounded by comments, the line should be removed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_CommentBlankComment_RemovesLine()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = "{{#! comment }} {{#! comment }}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new object());
|
|
Assert.AreEqual(" ", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a comment follows text, the comment should be removed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ContentComment_RemovesComment()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = "Front{{#! comment }}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new object());
|
|
Assert.AreEqual("Front", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a comment follows text, the comment should be removed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ContentCommentContentComment_RemovesComments()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = "Front{{#! comment }}Middle{{#! comment }}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new object());
|
|
Assert.AreEqual("FrontMiddle", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a comment makes up the entire format string, the nothing should be printed out.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_CommentAloneOnlyLine_PrintsSurroundingSpace()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
Generator generator = compiler.Compile(" {{#! comment }} ");
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual(" ", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a comment is on a line by itself, irrespective of leading or trailing whitespace,
|
|
/// the line should be removed from output.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ContentNewLineCommentNewLineContent_RemovesLine()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Before
|
|
{{#! This is a comment }}
|
|
After";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new object());
|
|
const string expected = @"Before After";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If multiple comments are on a line by themselves, irrespective of whitespace,
|
|
/// the line should be removed from output.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ContentNewLineCommentCommentNewLineContent_RemovesLine()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Before
|
|
{{#! This is a comment }} {{#! This is another comment }}
|
|
After";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new object());
|
|
const string expected = @"Before After";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If comments are on a multiple lines by themselves, irrespective of whitespace,
|
|
/// the lines should be removed from output.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_CommentsOnMultipleLines_RemovesLines()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Before
|
|
{{#! This is a comment }}
|
|
{{#! This is another comment }}
|
|
{{#newline}}
|
|
{{#! This is the final comment }}
|
|
After";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new object());
|
|
const string expected = @"Before
|
|
After";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a comment is followed by text, the line should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ContentNewLineCommentContentNewLineContent_PrintsLine()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Before
|
|
{{#! This is a comment }}Extra
|
|
After";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(new object());
|
|
const string expected = @"Before ExtraAfter";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a comment is followed by the last line in a format string,
|
|
/// the comment line should be eliminated and the last line printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_CommentNewLineBlank_PrintsBlank()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @" {{#! comment }}
|
|
";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual(" ", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a comment is followed by the last line in a format string,
|
|
/// the comment line should be eliminated and the last line printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_CommentNewLineContent_PrintsContent()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @" {{#! comment }}
|
|
After";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual(" After", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a line with content is followed by a line with a comment, the first line should
|
|
/// be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ContentNewLineComment_PrintsContent()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"First
|
|
{{#! comment }}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual("First", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a line has a comment, followed by line with content, followed by a line with a comment, only
|
|
/// the content should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_CommentNewLineContentNewLineComment_PrintsContent()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#! comment }}
|
|
First
|
|
{{#! comment }}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual("First", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If there are lines with content, then a comment, then content, then a comment, only
|
|
/// the content should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ContentNewLineCommentNewLineContentNewLineComment_PrintsContent()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"First{{#newline}}
|
|
{{#! comment }}
|
|
Middle
|
|
{{#! comment }}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
const string expected = @"First
|
|
Middle";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If there is content and a comment on a line, followed by a comment,
|
|
/// only the content should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ContentCommentNewLineComment_PrintsContent()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"First{{#! comment }}
|
|
{{#! comment }}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual("First", result, "The wrong text was generated.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region If
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an if statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_If_EvaluatesToFalse_SkipsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Content{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(false);
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an if statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_If_null_SkipsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Content{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an if statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_If_DBNull_SkipsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Content{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(DBNull.Value);
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an if statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_If_EmptyIEnumerable_SkipsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Content{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(Enumerable.Empty<int>());
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an if statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_If_NullChar_SkipsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Content{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render('\0');
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an if statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_If_ZeroInt_SkipsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Content{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(0);
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an if statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_If_ZeroFloat_SkipsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Content{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(0f);
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an if statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_If_ZeroDouble_SkipsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Content{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(0.0);
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an if statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_If_ZeroDecimal_SkipsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Content{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(0m);
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an if statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_If_EvaluatesToTrue_PrintsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Content{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
Assert.AreEqual("BeforeContentAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the header and footer appear on lines by themselves, they should not generate new lines.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfNewLineContentNewLineEndIf_PrintsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"{{#if this}}
|
|
Content
|
|
{{/if}}";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
Assert.AreEqual("Content", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the header and footer appear on lines by themselves, they should not generate new lines.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfNewLineEndIf_PrintsNothing()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"{{#if this}}
|
|
{{/if}}";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
Assert.AreEqual(String.Empty, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the footer has content in front of it, the content should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfNewLineContentEndIf_PrintsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"{{#if this}}
|
|
Content{{/if}}";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
Assert.AreEqual("Content", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the header has content after it, the content should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfContentNewLineEndIf_PrintsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"{{#if this}}Content
|
|
{{/if}}";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
Assert.AreEqual("Content", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the header has content after it, the content should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ContentIfNewLineEndIf_PrintsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"Content{{#if this}}
|
|
{{/if}}";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
Assert.AreEqual("Content", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the header and footer are adjacent, then there is no content.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfEndIf_PrintsNothing()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"{{#if this}}{{/if}}";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
Assert.AreEqual(String.Empty, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the header and footer are adjacent, then there is no inner content.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ContentIfEndIf_PrintsNothing()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"Content{{#if this}}{{/if}}";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
Assert.AreEqual("Content", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the header and footer are adjacent, then there is no inner content.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfNewLineCommentEndIf_PrintsNothing()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"{{#if this}}
|
|
{{#! comment}}{{/if}}";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
Assert.AreEqual(String.Empty, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the a header follows a footer, it shouldn't generate a new line.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfNewLineContentNewLineEndIfIfNewLineContentNewLineEndIf_PrintsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"{{#if this}}
|
|
First
|
|
{{/if}}{{#if this}}
|
|
{{#newline}}
|
|
Last
|
|
{{/if}}";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
const string expected = @"First
|
|
Last";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the content separates two if statements, it should be unaffected.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfNewLineEndIfNewLineContentNewLineIfNewLineEndIf_PrintsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"{{#if this}}
|
|
{{/if}}
|
|
Content
|
|
{{#if this}}
|
|
{{/if}}";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
const string expected = @"Content";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If there is trailing text of any kind, the newline after content should be preserved.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfNewLineEndIfNewLineContentNewLineIfNewLineEndIfContent_PrintsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = @"{{#if this}}
|
|
{{/if}}
|
|
First
|
|
{{#newline}}
|
|
{{#if this}}
|
|
{{/if}}
|
|
Last";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
const string expected = @"First
|
|
Last";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region If/Else
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to false, the content of an else statement should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfElse_EvaluatesToFalse_PrintsElse()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Yay{{#else}}Nay{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(false);
|
|
Assert.AreEqual("BeforeNayAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the condition evaluates to true, the content of an if statement should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfElse_EvaluatesToTrue_PrintsIf()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Yay{{#else}}Nay{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(true);
|
|
Assert.AreEqual("BeforeYayAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Second else blocks will result in an exceptions being thrown.
|
|
/// </summary>
|
|
[TestMethod]
|
|
[ExpectedException(typeof(FormatException))]
|
|
public void TestCompile_IfElse_TwoElses_IncludesSecondElseInElse_Throws()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if this}}Yay{{#else}}Nay{{#else}}Bad{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(false);
|
|
Assert.AreEqual("BeforeNay{{#else}}BadAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region If/Elif/Else
|
|
|
|
/// <summary>
|
|
/// If the if statement evaluates to true, its block should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfElifElse_IfTrue_PrintsIf()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if First}}First{{#elif Second}}Second{{#else}}Third{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { First = true, Second = true });
|
|
Assert.AreEqual("BeforeFirstAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the elif statement evaluates to true, its block should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfElifElse_ElifTrue_PrintsIf()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if First}}First{{#elif Second}}Second{{#else}}Third{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { First = false, Second = true });
|
|
Assert.AreEqual("BeforeSecondAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the elif statement evaluates to false, the else block should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfElifElse_ElifFalse_PrintsElse()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if First}}First{{#elif Second}}Second{{#else}}Third{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { First = false, Second = false });
|
|
Assert.AreEqual("BeforeThirdAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region If/Elif
|
|
|
|
/// <summary>
|
|
/// If the elif statement evaluates to false and there is no else statement, nothing should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfElif_ElifFalse_PrintsNothing()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if First}}First{{#elif Second}}Second{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { First = false, Second = false });
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If there are two elif statements and the first is false, the second elif block should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_IfElifElif_ElifFalse_PrintsSecondElif()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#if First}}First{{#elif Second}}Second{{#elif Third}}Third{{/if}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { First = false, Second = false, Third = true });
|
|
Assert.AreEqual("BeforeThirdAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Each
|
|
|
|
/// <summary>
|
|
/// If we pass an empty collection to an each statement, the content should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Each_EmptyCollection_SkipsContent()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#each this}}{{this}}{{/each}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new int[0]);
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we pass a populated collection to an each statement, the content should be printed
|
|
/// for each item in the collection, using that item as the new scope context.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Each_PopulatedCollection_PrintsContentForEach()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#each this}}{{this}}{{/each}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new int[] { 1, 2, 3 });
|
|
Assert.AreEqual("Before123After", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// We can use the index tag to get the current iteration.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Each_Index_PrintsIndexOfItem()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "<ul>{{#each this}}<li value=\"{{this}}\">Item {{#index}}</li>{{/each}}</ul>";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new int[] { 1, 2, 3 });
|
|
const string expected = @"<ul><li value=""1"">Item 0</li><li value=""2"">Item 1</li><li value=""3"">Item 2</li></ul>";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// A bug was found where the index tag was trying to read the arguments for the next tag.
|
|
/// This was caused by the index tag chewing up more of the input than it was supposed to.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Each_ContextAfterIndexTag()
|
|
{
|
|
List<TestObject> objects = new List<TestObject>()
|
|
{
|
|
new TestObject { Name = "name1", Val = "val1" },
|
|
new TestObject { Name = "name2", Val = "val2" },
|
|
new TestObject { Name = "name3", Val = "val3" }
|
|
};
|
|
|
|
const string template = @"{{#each this}}
|
|
Item Number: {{#index}}<br />{{#newline}}
|
|
{{/each}}
|
|
{{#each this}}
|
|
Item Number: foo<br />{{#newline}}
|
|
{{/each}}";
|
|
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
Generator generator = compiler.Compile(template);
|
|
string actual = generator.Render(objects);
|
|
|
|
const string expected = @"Item Number: 0<br />
|
|
Item Number: 1<br />
|
|
Item Number: 2<br />
|
|
Item Number: foo<br />
|
|
Item Number: foo<br />
|
|
Item Number: foo<br />
|
|
";
|
|
|
|
Assert.AreEqual(expected, actual, "The wrong text was found.");
|
|
}
|
|
|
|
public class TestObject
|
|
{
|
|
public String Name { get; set; }
|
|
|
|
public String Val { get; set; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region With
|
|
|
|
/// <summary>
|
|
/// The object replacing the placeholder should be used as the context of a with statement.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_With_AddsScope()
|
|
{
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#with Nested}}{{this}}{{/with}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { Nested = "Hello" });
|
|
Assert.AreEqual("BeforeHelloAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Default Parameter
|
|
|
|
/// <summary>
|
|
/// If a tag is defined with a default parameter, the default value
|
|
/// should be returned if an argument is not provided.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_MissingDefaultParameter_ProvidesDefault()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
compiler.RegisterTag(new DefaultTagDefinition(), true);
|
|
const string format = @"{{#default}}";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual("123", result, "The wrong text was generated.");
|
|
}
|
|
|
|
private sealed class DefaultTagDefinition : InlineTagDefinition
|
|
{
|
|
public DefaultTagDefinition()
|
|
: base("default")
|
|
{
|
|
}
|
|
|
|
protected override IEnumerable<TagParameter> GetParameters()
|
|
{
|
|
return new TagParameter[] { new TagParameter("param") { IsRequired = false, DefaultValue = 123 } };
|
|
}
|
|
|
|
public override void GetText(TextWriter writer, Dictionary<string, object> arguments, Scope contextScope)
|
|
{
|
|
writer.Write(arguments["param"]);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region eq
|
|
|
|
/// <summary>
|
|
/// If the two values don't match, the content of an eq statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Eq_EvaluatesToFalse_SkipsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#eq OneValue OtherValue}}Content{{/eq}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { OneValue = "Foo", OtherValue = "Bar" });
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the two values match, the content of an eq statement should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Eq_EvaluatesToTrue_PrintsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#eq OneValue OtherValue}}Content{{/eq}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { OneValue = "Foo", OtherValue = "Foo" });
|
|
Assert.AreEqual("BeforeContentAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the two values match, the content of an eq statement should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Eq_EvaluatesToTrueInLoop_PrintsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#each Items}}{{#eq Name OtherValue}}Content{{/eq}}{{/each}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { Items = new List<object> { new {Name="Test"}, new { Name = "Foo" } }, OneValue = "Foo", OtherValue = "Foo" });
|
|
Assert.AreEqual("BeforeContentAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the two values match, the content of an eq statement should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Eq_EvaluatesToTrueInLoopWithNumber_PrintsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#each Items}}{{#eq Name OtherValue}}Content{{/eq}}{{/each}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { Items = new List<object> { new { Name = 1 }, new { Name = 2 } }, OneValue = "1", OtherValue = "2" });
|
|
Assert.AreEqual("BeforeContentAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region gt
|
|
/// <summary>
|
|
/// If first value is not greater than the second, the content of the gt statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Gt_EvaluatesToFalse_SkipsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#gt OneValue OtherValue}}Content{{/gt}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { OneValue = 10, OtherValue = 11 });
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If first value is greater than the second, the content of the gt statement should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Gt_EvaluatesToTrue_PrintsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#gt OneValue OtherValue}}Content{{/gt}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { OneValue = 11.11, OtherValue = 11.1 });
|
|
Assert.AreEqual("BeforeContentAfter", result, "The wrong text was generated.");
|
|
}
|
|
#endregion
|
|
|
|
#region lt
|
|
/// <summary>
|
|
/// If first value is not greater than the second, the content of the gt statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Lt_EvaluatesToFalse_SkipsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#lt OneValue OtherValue}}Content{{/lt}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { OneValue = 11, OtherValue = 10.5 });
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If first value is greater than the second, the content of the gt statement should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Lt_EvaluatesToTrue_PrintsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#lt OneValue OtherValue}}Content{{/lt}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { OneValue = 11.1, OtherValue = 11.11 });
|
|
Assert.AreEqual("BeforeContentAfter", result, "The wrong text was generated.");
|
|
}
|
|
#endregion
|
|
|
|
#region gte
|
|
/// <summary>
|
|
/// If first value is not greater than or equal to the second, the content of the gt statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Gte_EvaluatesToFalse_SkipsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#gte OneValue OtherValue}}Content{{/gte}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { OneValue = 9, OtherValue = 10 });
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If first value is greater than or equal to the second, the content of the gt statement should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Gte_EvaluatesToTrue_PrintsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#gte OneValue OtherValue}}Content{{/gte}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { OneValue = 11.11, OtherValue = 11.11 });
|
|
Assert.AreEqual("BeforeContentAfter", result, "The wrong text was generated.");
|
|
}
|
|
#endregion
|
|
|
|
#region lte
|
|
/// <summary>
|
|
/// If first value is not greater than the second, the content of the gt statement should not be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Lte_EvaluatesToFalse_SkipsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#lte OneValue OtherValue}}Content{{/lte}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { OneValue = 11, OtherValue = 10.5 });
|
|
Assert.AreEqual("BeforeAfter", result, "The wrong text was generated.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If first value is greater than the second, the content of the gt statement should be printed.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_Lte_EvaluatesToTrue_PrintsContent() {
|
|
FormatCompiler parser = new FormatCompiler();
|
|
const string format = "Before{{#lte OneValue OtherValue}}Content{{/lte}}After";
|
|
Generator generator = parser.Compile(format);
|
|
string result = generator.Render(new { OneValue = 11.11, OtherValue = 11.11 });
|
|
Assert.AreEqual("BeforeContentAfter", result, "The wrong text was generated.");
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region Compound Tags
|
|
|
|
/// <summary>
|
|
/// If a format contains multiple tags, they should be handled just fine.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_MultipleTags()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"Hello {{Customer.FirstName}}:
|
|
{{#newline}}
|
|
{{#newline}}
|
|
{{#with Order}}
|
|
{{#if LineItems}}
|
|
Below are your order details:
|
|
{{#newline}}
|
|
{{#newline}}
|
|
{{#each LineItems}}
|
|
{{Name}}: {{UnitPrice:C}} x {{Quantity}}{{#newline}}
|
|
{{/each}}
|
|
{{#newline}}
|
|
Your order total was: {{Total:C}}
|
|
{{/if}}
|
|
{{/with}}";
|
|
Generator generator = compiler.Compile(format);
|
|
|
|
string result = generator.Render(CultureInfo.GetCultureInfo("en-US"), new
|
|
{
|
|
Customer = new { FirstName = "Bob" },
|
|
Order = new
|
|
{
|
|
Total = 7.50m,
|
|
LineItems = new object[]
|
|
{
|
|
new { Name = "Banana", UnitPrice = 2.50m, Quantity = 1 },
|
|
new { Name = "Orange", UnitPrice = .50m, Quantity = 5 },
|
|
new { Name = "Apple", UnitPrice = .25m, Quantity = 10 },
|
|
}
|
|
}
|
|
});
|
|
const string expected = @"Hello Bob:
|
|
|
|
Below are your order details:
|
|
|
|
Banana: $2.50 x 1
|
|
Orange: $0.50 x 5
|
|
Apple: $0.25 x 10
|
|
|
|
Your order total was: $7.50";
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Unknown Tags
|
|
|
|
/// <summary>
|
|
/// If an unknown tag is encountered, an exception should be thrown.
|
|
/// </summary>
|
|
[TestMethod]
|
|
[ExpectedException(typeof(FormatException))]
|
|
public void TestCompile_UnknownTag()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
compiler.Compile("{{#split Names}}");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Context Variables
|
|
|
|
/// <summary>
|
|
/// We will use the index variable to determine whether or not to print out a line.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_CanUseContextVariablesToMakeDecisions()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#each this}}{{#if @index}}{{#index}}{{/if}}{{/each}}";
|
|
Generator generator = compiler.Compile(format);
|
|
string actual = generator.Render(new int[] { 1, 1, 1, 1, });
|
|
string expected = "123";
|
|
Assert.AreEqual(expected, actual, "The numbers were not valid.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// I can set context variables to control the flow of the code generation.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_CanUseContextVariableToToggle()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#set even}}{{#each this}}{{#if @even}}Even {{#else}}Odd {{/if}}{{#set even}}{{/each}}";
|
|
Generator generator = compiler.Compile(format);
|
|
generator.ValueRequested += (sender, e) =>
|
|
{
|
|
e.Value = !(bool)(e.Value ?? false);
|
|
};
|
|
string actual = generator.Render(new int[] { 1, 1, 1, 1 });
|
|
string expected = "Even Odd Even Odd ";
|
|
Assert.AreEqual(expected, actual, "The context variable was not toggled.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// I can set context variables to control the flow of the code generation.
|
|
/// It should even support nested context variables... for some reason.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_CanUseNestedContextVariableToToggle()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#set this.variables.even}}
|
|
{{#each this}}
|
|
{{#if @variables.even}}
|
|
Even
|
|
{{#else}}
|
|
Odd
|
|
{{/if}}
|
|
{{#set variables.even}}
|
|
{{/each}}";
|
|
Generator generator = compiler.Compile(format);
|
|
generator.ValueRequested += (sender, e) =>
|
|
{
|
|
e.Value = !(bool)(e.Value ?? false);
|
|
};
|
|
string actual = generator.Render(new int[] { 1, 1, 1, 1 });
|
|
string expected = "EvenOddEvenOdd";
|
|
Assert.AreEqual(expected, actual, "The context variable was not toggled.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region New Line Management
|
|
|
|
/// <summary>
|
|
/// If the compiler is configured to ignore new lines,
|
|
/// they should not be removed from the output.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_PreserveNewLines()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
compiler.RemoveNewLines = false;
|
|
const string format = @"Hello
|
|
";
|
|
|
|
const string expected = @"Hello
|
|
";
|
|
Generator generator = compiler.Compile(format);
|
|
string result = generator.Render(null);
|
|
Assert.AreEqual(expected, result, "The wrong text was generated.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Strings
|
|
|
|
/// <summary>
|
|
/// We will use a string variable to determine whether or not to print out a line.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_StringArgument_PassedToTag()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#if 'hello'}}Hello{{/if}}";
|
|
Generator generator = compiler.Compile(format);
|
|
string actual = generator.Render(null);
|
|
string expected = "Hello";
|
|
Assert.AreEqual(expected, actual, "The string was not passed to the formatter.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// We will use a string variable to determine whether or not to print out a line.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_EmptyStringArgument_PassedToTag()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#if ''}}Hello{{/if}}";
|
|
Generator generator = compiler.Compile(format);
|
|
string actual = generator.Render(null);
|
|
string expected = "";
|
|
Assert.AreEqual(expected, actual, "The string was not passed to the formatter.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestCompile_EmptyStringProperty()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{Greeting}} {{Name}}";
|
|
var data = new
|
|
{
|
|
Greeting = "Hello",
|
|
Name = ""
|
|
};
|
|
Generator generator = compiler.Compile(format);
|
|
string actual = generator.Render(data);
|
|
string expected = "Hello ";
|
|
Assert.AreEqual(expected, actual, "An empty string property should be rendered as an empty string.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestCompile_NullValueProperty() {
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{Greeting}} {{Name}}";
|
|
var data = new
|
|
{
|
|
Greeting = "Hello",
|
|
Name = (String)null
|
|
};
|
|
Generator generator = compiler.Compile(format);
|
|
string actual = generator.Render(data);
|
|
string expected = "Hello ";
|
|
Assert.AreEqual(expected, actual, "An null valued property should be rendered as an empty string.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TestCompile_AllowSingleCurlyBracesInData() {
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"See this code: {{Code}}!";
|
|
var data = new
|
|
{
|
|
Code = "function() { retrurn 'this is evil'; }"
|
|
};
|
|
Generator generator = compiler.Compile(format);
|
|
string actual = generator.Render(data);
|
|
string expected = "See this code: function() { retrurn 'this is evil'; }!";
|
|
Assert.AreEqual(expected, actual, "Should not touch single curly braces in data values.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Numbers
|
|
|
|
/// <summary>
|
|
/// We will use a number variable to determine whether or not to print out a line.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_NumberArgument_PassedToTag()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#if 4}}Hello{{/if}}";
|
|
Generator generator = compiler.Compile(format);
|
|
string actual = generator.Render(null);
|
|
string expected = "Hello";
|
|
Assert.AreEqual(expected, actual, "The number was not passed to the formatter.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// We will use a string variable to determine whether or not to print out a line.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestCompile_ZeroNumberArgument_PassedToTag()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
const string format = @"{{#if 00.0000}}Hello{{/if}}";
|
|
Generator generator = compiler.Compile(format);
|
|
string actual = generator.Render(null);
|
|
string expected = "";
|
|
Assert.AreEqual(expected, actual, "The number was not passed to the formatter.");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Custom Tags
|
|
|
|
[TestMethod]
|
|
public void TestCompile_NestedContext_ConsolidatesWriter()
|
|
{
|
|
FormatCompiler compiler = new FormatCompiler();
|
|
compiler.RegisterTag(new UrlEncodeTagDefinition(), true);
|
|
|
|
const string format = @"{{#urlencode}}{{url}}{{/urlencode}}";
|
|
Generator generator = compiler.Compile(format);
|
|
|
|
string actual = generator.Render(new { url = "https://google.com" });
|
|
string expected = HttpUtility.UrlEncode("https://google.com");
|
|
Assert.AreEqual(expected, actual, "Value field didn't work");
|
|
}
|
|
|
|
|
|
#endregion
|
|
}
|
|
}
|