public void testExpressionFunctions_roundDonwTimePart()
{
var dialect = new StandardDialect();
var date = new DateTime(2009, 1, 23, 12, 34, 56);
dialect.TruncateTime(date).Is(new DateTime(2009, 1, 23));
}
internal ValueObject(SqlParserConfig config,
string parameterName, object parameterValue, Type parameterType)
{
_dialect = config.Dialect;
PropertyName = parameterName;
Value = parameterValue;
DataType = parameterType;
}
public void TestCaseUnparsedTextDecoration()
{
var dialect = new StandardDialect();
var context = CreateContext(StringComparer.OrdinalIgnoreCase);
ExpectArgumentNullException("context", () => dialect.DecorateUnParsedText(null, string.Empty));
Assert.AreEqual(string.Empty, dialect.DecorateUnParsedText(context, null));
Assert.AreEqual(string.Empty, dialect.DecorateUnParsedText(context, string.Empty));
Assert.AreEqual(string.Empty, dialect.DecorateUnParsedText(context, " \r\n"));
}
public void TestCaseDefaultConstructedAndStatic()
{
var parameterless = new StandardDialect();
var iic = new StandardDialect(CultureInfo.InvariantCulture, DialectCasing.IgnoreCase);
var iuc = new StandardDialect(CultureInfo.InvariantCulture, DialectCasing.UpperCase);
Assert.AreEqual(iic, parameterless);
Assert.AreEqual(iic.GetHashCode(), parameterless.GetHashCode());
Assert.AreEqual(iuc, StandardDialect.Default);
Assert.AreEqual(iuc.GetHashCode(), StandardDialect.Default.GetHashCode());
Assert.AreEqual(iic, StandardDialect.DefaultIgnoreCase);
Assert.AreEqual(iic.GetHashCode(), StandardDialect.DefaultIgnoreCase.GetHashCode());
}
public void TestCaseSpecialKeywordsCaseSensitiveLower()
{
var dialect = new StandardDialect(CultureInfo.InvariantCulture, DialectCasing.LowerCase);
var undefined = XLTemplate.Evaluate(dialect, "{undefined}");
var _true = XLTemplate.Evaluate(dialect, "{true}");
var _false = XLTemplate.Evaluate(dialect, "{false}");
var nan = XLTemplate.Evaluate(dialect, "{nan}");
var infinity = XLTemplate.Evaluate(dialect, "{infinity}");
Assert.AreEqual("undefined", undefined);
Assert.AreEqual("true", _true);
Assert.AreEqual("false", _false);
Assert.AreEqual("nan", nan);
Assert.AreEqual("infinity", infinity);
}
public void TestCaseSpecialKeywordsCaseSensitiveUpper()
{
var dialect = new StandardDialect(CultureInfo.InvariantCulture, DialectCasing.UpperCase);
var undefined = XLTemplate.Evaluate(dialect, "{UNDEFINED}");
var _true = XLTemplate.Evaluate(dialect, "{TRUE}");
var _false = XLTemplate.Evaluate(dialect, "{FALSE}");
var nan = XLTemplate.Evaluate(dialect, "{NAN}");
var infinity = XLTemplate.Evaluate(dialect, "{INFINITY}");
Assert.AreEqual("UNDEFINED", undefined);
Assert.AreEqual("TRUE", _true);
Assert.AreEqual("FALSE", _false);
Assert.AreEqual("NAN", nan);
Assert.AreEqual("INFINITY", infinity);
}
public void TestCaseSpecialKeywordsCaseInsensitive()
{
var dialect = new StandardDialect(CultureInfo.InvariantCulture, DialectCasing.IgnoreCase);
var undefined = XLTemplate.Evaluate(dialect, "{undeFIned}");
var _true = XLTemplate.Evaluate(dialect, "{tRUe}");
var _false = XLTemplate.Evaluate(dialect, "{faLSe}");
var nan = XLTemplate.Evaluate(dialect, "{nAn}");
var infinity = XLTemplate.Evaluate(dialect, "{infinitY}");
Assert.AreEqual("Undefined", undefined);
Assert.AreEqual("True", _true);
Assert.AreEqual("False", _false);
Assert.AreEqual("NaN", nan);
Assert.AreEqual("Infinity", infinity);
}
public void testExpressionFunctions_escape_withBackslash()
{
var dialect = new StandardDialect();
dialect.Escape("a\\a%a_", '\\').Is("a\\\\a\\%a\\_");
//var input = "a\\a%a_";
//var result = Regex.Replace(input, "[\\%\\\\_]", "\\$0");
//result.Is("a\\\\a\\%a\\_");
//var input = "a\\a%a_";
//var result = Regex.Replace(input, @"[\\%\\_]", "\\$0");
//result.Is("a\\\\a\\%a\\_");
//var input = "a\\a%a_";
//var result = Regex.Replace(input, "[\\\\%\\\\_]", "\\$0");
//result.Is("a\\\\a\\%a\\_");
}
public void TestCaseEquality()
{
/* Build dialects. */
var iic = new CodeMonkeyDialect(DialectCasing.IgnoreCase);
var iuc = new CodeMonkeyDialect(DialectCasing.UpperCase);
var ilc = new CodeMonkeyDialect(DialectCasing.LowerCase);
/* 1 */
Assert.AreEqual(iic, iic);
Assert.AreNotEqual(iic, iuc);
Assert.AreNotEqual(iic.GetHashCode(), iuc.GetHashCode());
Assert.AreNotEqual(iic, ilc);
Assert.AreNotEqual(iic.GetHashCode(), ilc.GetHashCode());
/* 2 */
Assert.AreEqual(iuc, iuc);
Assert.AreNotEqual(iuc, ilc);
Assert.AreNotEqual(iuc.GetHashCode(), ilc.GetHashCode());
/* 3 */
Assert.AreEqual(ilc, ilc);
/* 4 */
var siic = new StandardDialect(CultureInfo.InvariantCulture, DialectCasing.IgnoreCase);
var siuc = new StandardDialect(CultureInfo.InvariantCulture, DialectCasing.UpperCase);
var silc = new StandardDialect(CultureInfo.InvariantCulture, DialectCasing.LowerCase);
Assert.AreNotEqual(iic, siic);
Assert.AreNotEqual(iuc, siuc);
Assert.AreNotEqual(ilc, silc);
Assert.AreNotEqual(iic.GetHashCode(), siic.GetHashCode());
Assert.AreNotEqual(iuc.GetHashCode(), siuc.GetHashCode());
Assert.AreNotEqual(ilc.GetHashCode(), silc.GetHashCode());
/* Special */
Assert.AreNotEqual(iic, this);
Assert.AreNotEqual(iic, null);
}
public void testExpressionFunctions_infix()
{
var dialect = new StandardDialect();
dialect.Contains("a$a%a_").Is("%a$$a$%a$_%");
}
public void testExpressionFunctions_infix_escapeWithBackslash()
{
var dialect = new StandardDialect();
dialect.Contains("a\\a%a_", '\\').Is("%a\\\\a\\%a\\_%");
}
public void testExpressionFunctions_suffix()
{
var dialect = new StandardDialect();
dialect.EndsWith("a$a%a_").Is("%a$$a$%a$_");
}
public void testExpressionFunctions_prefix_escape()
{
var dialect = new StandardDialect();
dialect.StartsWith("a!a%a_", '!').Is("a!!a!%a!_%");
}
public void testExpressionFunctions_prefix()
{
var dialect = new StandardDialect();
dialect.StartsWith("a$a%a_").Is("a$$a$%a$_%");
}
public void testExpressionFunctions_escape_withExclamation()
{
var dialect = new StandardDialect();
dialect.Escape("a!a%a_", '!').Is("a!!a!%a!_");
}
public void testExpressionFunctions_escape()
{
var dialect = new StandardDialect();
dialect.Escape("a$a%a_").Is("a$$a$%a$_");
}
private static StandardDialect TestDialect(CultureInfo culture, DialectCasing casing)
{
var dialect = new StandardDialect(culture, casing);
Assert.IsInstanceOf <StandardSelfObject>(dialect.Self);
Assert.AreEqual(dialect.Culture, culture);
Assert.AreEqual('"', dialect.EndStringLiteralCharacter);
Assert.AreEqual('}', dialect.EndTagCharacter);
Assert.AreEqual(culture.NumberFormat.CurrencyDecimalSeparator[0], dialect.NumberDecimalSeparatorCharacter);
Assert.AreEqual('"', dialect.StartStringLiteralCharacter);
Assert.AreEqual('{', dialect.StartTagCharacter);
Assert.AreEqual('\\', dialect.StringLiteralEscapeCharacter);
Assert.NotNull(dialect.FlowSymbols);
Assert.AreEqual("(", dialect.FlowSymbols.GroupOpen);
Assert.AreEqual(")", dialect.FlowSymbols.GroupClose);
Assert.AreEqual(",", dialect.FlowSymbols.Separator);
Assert.AreEqual(".", dialect.FlowSymbols.MemberAccess);
var expectedComparer = StringComparer.Create(dialect.Culture, casing == DialectCasing.IgnoreCase);
Assert.AreEqual(dialect.IdentifierComparer, expectedComparer);
Assert.AreEqual(dialect.StringLiteralComparer, expectedComparer);
Func <string, string> transformer = input => input;
if (casing == DialectCasing.LowerCase)
{
transformer = input => input.ToLower(culture);
}
else if (casing == DialectCasing.UpperCase)
{
transformer = input => input.ToUpper(culture);
}
Assert.AreEqual(5, dialect.SpecialKeywords.Count);
Assert.IsTrue(dialect.SpecialKeywords.ContainsKey(transformer("True")) && dialect.SpecialKeywords[transformer("True")].Equals(true));
Assert.IsTrue(dialect.SpecialKeywords.ContainsKey(transformer("False")) && dialect.SpecialKeywords[transformer("False")].Equals(false));
Assert.IsTrue(dialect.SpecialKeywords.ContainsKey(transformer("Undefined")) && dialect.SpecialKeywords[transformer("Undefined")] == null);
Assert.IsTrue(dialect.SpecialKeywords.ContainsKey(transformer("NaN")) && dialect.SpecialKeywords[transformer("NaN")].Equals(double.NaN));
Assert.IsTrue(dialect.SpecialKeywords.ContainsKey(transformer("Infinity")) && dialect.SpecialKeywords[transformer("Infinity")].Equals(double.PositiveInfinity));
Assert.AreEqual(7, dialect.Directives.Count);
foreach (var directive in dialect.Directives)
{
if (directive is ConditionalInterpolationDirective)
{
Assert.AreEqual(transformer("{$ IF $}"), directive.ToString());
}
else if (directive is ForEachDirective)
{
Assert.AreEqual(transformer("{FOR EACH ? IN $}...{END}"), directive.ToString());
}
else if (directive is IfDirective)
{
Assert.AreEqual(transformer("{IF $ THEN}...{END}"), directive.ToString());
}
else if (directive is IfElseDirective)
{
Assert.AreEqual(transformer("{IF $ THEN}...{ELSE}...{END}"), directive.ToString());
}
else if (directive is InterpolationDirective)
{
Assert.AreEqual("{$}", directive.ToString());
}
else if (directive is RepeatDirective)
{
Assert.AreEqual(transformer("{REPEAT $ TIMES}...{END}"), directive.ToString());
}
else if (directive is PreFormattedUnParsedTextDirective)
{
Assert.AreEqual(transformer("{PREFORMATTED}...{END}"), directive.ToString());
}
else
{
Assert.Fail();
}
}
Assert.AreEqual(24, dialect.Operators.Count);
foreach (var @operator in dialect.Operators)
{
if (@operator is RelationalEqualsOperator)
{
Assert.AreEqual("==", @operator.ToString());
}
else if (@operator is RelationalNotEqualsOperator)
{
Assert.AreEqual("!=", @operator.ToString());
}
else if (@operator is RelationalGreaterThanOperator)
{
Assert.AreEqual(">", @operator.ToString());
}
else if (@operator is RelationalGreaterThanOrEqualsOperator)
{
Assert.AreEqual(">=", @operator.ToString());
}
else if (@operator is RelationalLowerThanOperator)
{
Assert.AreEqual("<", @operator.ToString());
}
else if (@operator is RelationalLowerThanOrEqualsOperator)
{
Assert.AreEqual("<=", @operator.ToString());
}
else if (@operator is LogicalAndOperator)
{
Assert.AreEqual("&&", @operator.ToString());
}
else if (@operator is LogicalOrOperator)
{
Assert.AreEqual("||", @operator.ToString());
}
else if (@operator is LogicalNotOperator)
{
Assert.AreEqual("!", @operator.ToString());
}
else if (@operator is BitwiseAndOperator)
{
Assert.AreEqual("&", @operator.ToString());
}
else if (@operator is BitwiseOrOperator)
{
Assert.AreEqual("|", @operator.ToString());
}
else if (@operator is BitwiseXorOperator)
{
Assert.AreEqual("^", @operator.ToString());
}
else if (@operator is BitwiseNotOperator)
{
Assert.AreEqual("~", @operator.ToString());
}
else if (@operator is BitwiseShiftLeftOperator)
{
Assert.AreEqual("<<", @operator.ToString());
}
else if (@operator is BitwiseShiftRightOperator)
{
Assert.AreEqual(">>", @operator.ToString());
}
else if (@operator is ArithmeticDivideOperator)
{
Assert.AreEqual("/", @operator.ToString());
}
else if (@operator is ArithmeticModuloOperator)
{
Assert.AreEqual("%", @operator.ToString());
}
else if (@operator is ArithmeticMultiplyOperator)
{
Assert.AreEqual("*", @operator.ToString());
}
else if (@operator is ArithmeticNegateOperator)
{
Assert.AreEqual("-", @operator.ToString());
}
else if (@operator is ArithmeticNeutralOperator)
{
Assert.AreEqual("+", @operator.ToString());
}
else if (@operator is ArithmeticSubtractOperator)
{
Assert.AreEqual("-", @operator.ToString());
}
else if (@operator is ArithmeticSumOperator)
{
Assert.AreEqual("+", @operator.ToString());
}
else if (@operator is SequenceOperator)
{
Assert.AreEqual("..", @operator.ToString());
}
else if (@operator is FormatOperator)
{
Assert.AreEqual(":", @operator.ToString());
}
else
{
Assert.Fail();
}
}
return(dialect);
}
public void testExpressionFunctions_suffix_escape()
{
var dialect = new StandardDialect();
dialect.EndsWith("a!a%a_", '!').Is("%a!!a!%a!_");
}
public void testExpressionFunctions_suffix_escapeWithBackslash()
{
var dialect = new StandardDialect();
dialect.EndsWith("a\\a%a_", '\\').Is("%a\\\\a\\%a\\_");
}
public void testExpressionFunctions_infix_escape()
{
var dialect = new StandardDialect();
dialect.Contains("a!a%a_", '!').Is("%a!!a!%a!_%");
}
