public void FhirPath_Lex_Identifier()
{
var parser = Lexer.Identifier.End();
AssertParser.SucceedsMatch(parser, "A34", "A34");
AssertParser.FailsMatch(parser, "34");
AssertParser.FailsMatch(parser, "'Hello'");
AssertParser.FailsMatch(parser, "@2013");
}
public void FhirPath_Lex_Axis()
{
var parser = Lexer.Axis.End();
AssertParser.SucceedsMatch(parser, "$this", "this");
AssertParser.SucceedsMatch(parser, "$index", "index");
AssertParser.SucceedsMatch(parser, "$total", "total");
AssertParser.FailsMatch(parser, "$that");
}
private void SucceedsConstantValueMatch(Parser <ConstantExpression> parser, string expr, object value, TypeInfo expected)
{
AssertParser.SucceedsWith(parser, expr,
v =>
{
Assert.Equal(v.Value, value);
Assert.Equal(v.ExpressionType, expected);
});
}
public void FhirPath_Gramm_Expression_Polarity()
{
var parser = Grammar.PolarityExpression.End();
AssertParser.SucceedsMatch(parser, "4", new ConstantExpression(4));
AssertParser.SucceedsMatch(parser, "-4", new UnaryExpression('-', new ConstantExpression(4)));
AssertParser.SucceedsMatch(parser, "-Patient.name", new UnaryExpression('-', patientName));
AssertParser.SucceedsMatch(parser, "+Patient.name", new UnaryExpression('+', patientName));
}
public void FhirPath_Gramm_Add()
{
var parser = Grammar.AddExpression.End();
AssertParser.SucceedsMatch(parser, "-4", new UnaryExpression('-', new ConstantExpression(4)));
AssertParser.SucceedsMatch(parser, "4 + 6", constOp("+", 4, 6));
AssertParser.FailsMatch(parser, "4+");
// AssertParser.FailsMatch(parser, "5div6"); oops
}
public void FhirPath_Gramm_Type()
{
var parser = Grammar.TypeExpression.End();
AssertParser.SucceedsMatch(parser, "4 is integer", new BinaryExpression("is", new ConstantExpression(4), new ConstantExpression("integer")));
AssertParser.SucceedsMatch(parser, "8 as notoddbuteven", new BinaryExpression("as", new ConstantExpression(8), new ConstantExpression("notoddbuteven")));
AssertParser.FailsMatch(parser, "4 is 5");
// AssertParser.FailsMatch(parser, "5div6"); oops
}
public void FhirPath_Lex_QualifiedIdentifier()
{
var parser = Lexer.QualifiedIdentifier.End();
AssertParser.SucceedsMatch(parser, "name");
AssertParser.SucceedsMatch(parser, "name.name2");
AssertParser.SucceedsMatch(parser, "name.name2.name3");
AssertParser.SucceedsMatch(parser, "name.\"name2\"", "name.name2");
AssertParser.SucceedsMatch(parser, "\"name\".\"name2\"", "name.name2");
}
public void FhirPath_Lex_Identifier()
{
var parser = Lexer.Identifier.End();
AssertParser.SucceedsMatch(parser, "A34", "A34");
AssertParser.SucceedsMatch(parser, "\"A\uface%$#34\"", "A\uface%$#34");
AssertParser.FailsMatch(parser, "34");
AssertParser.FailsMatch(parser, "'Hello'");
AssertParser.FailsMatch(parser, "@2013");
//AssertParser.FailsMatch(parser, "true"); - this is an identifier, parser will only call in right context so no ambiguity
}
public void FhirPath_Gramm_Mul()
{
var parser = Grammar.MulExpression.End();
AssertParser.SucceedsMatch(parser, "Patient.name", patientName);
AssertParser.SucceedsMatch(parser, "4* Patient.name", new BinaryExpression('*', new ConstantExpression(4), patientName));
AssertParser.SucceedsMatch(parser, "5 div 6", constOp("div", 5, 6));
AssertParser.FailsMatch(parser, "4*");
// AssertParser.FailsMatch(parser, "5div6"); oops
}
public void FhirPath_Gramm_Eq()
{
var parser = Grammar.Expression.End();
AssertParser.SucceedsMatch(parser, "4=4 implies 4 != 5 and ('h' ~ 'H' or 'a' !~ 'b')",
new BinaryExpression("implies", constOp("=", 4, 4),
new BinaryExpression("and",
constOp("!=", 4, 5), new BinaryExpression("or", constOp("~", 'h', 'H'), constOp("!~", 'a', 'b')))));
AssertParser.FailsMatch(parser, "true implies false and 4 != 5 and 4 <> 6 and ('h' ~ 'H' or 'a' !~ 'b')");
}
public void FhirPath_Lex_QualifiedIdentifier()
{
var parser = Lexer.QualifiedIdentifier.End();
AssertParser.SucceedsMatch(parser, "name");
AssertParser.SucceedsMatch(parser, "name.name2");
AssertParser.SucceedsMatch(parser, "name.name2.name3");
AssertParser.SucceedsMatch(parser, "name.`name2`", "name.name2");
AssertParser.SucceedsMatch(parser, "`name`.`name2`", "name.name2");
AssertParser.SucceedsMatch(parser, "name.\"name2\"", "name.name2"); // should still support the pre-normative syntax
AssertParser.SucceedsMatch(parser, "\"name\".\"name2\"", "name.name2");
}
public void FhirPath_Gramm_Expression_Invocation()
{
var parser = Grammar.InvocationExpression.End();
AssertParser.SucceedsMatch(parser, "Patient.name.doSomething(true)",
new FunctionCallExpression(patientName, "doSomething", TypeSpecifier.Any, new ConstantExpression(true)));
AssertParser.FailsMatch(parser, "Patient.");
//AssertParser.FailsMatch(parser, "Patient. name"); //oops
//AssertParser.FailsMatch(parser, "Patient . name");
//AssertParser.FailsMatch(parser, "Patient .name");
}
public void FhirPath_Gramm_Term_ExternalRef()
{
var parser = Grammar.Term.End();
AssertParser.SucceedsMatch(parser, "%`ext-11179-de-is-data-element-concept`",
new FunctionCallExpression(AxisExpression.That, "builtin.coreexturl", TypeSpecifier.String,
new ConstantExpression("11179-de-is-data-element-concept")));
AssertParser.SucceedsMatch(parser, "%`vs-administrative-gender`",
new FunctionCallExpression(AxisExpression.That, "builtin.corevsurl", TypeSpecifier.String,
new ConstantExpression("administrative-gender")));
}
public void FhirPath_Lex_Mul()
{
var parser = Lexer.MulOperator.End();
AssertParser.SucceedsMatch(parser, "*");
AssertParser.SucceedsMatch(parser, "/");
AssertParser.SucceedsMatch(parser, "div");
AssertParser.SucceedsMatch(parser, "mod");
AssertParser.FailsMatch(parser, "*/");
AssertParser.FailsMatch(parser, "Div");
AssertParser.FailsMatch(parser, "");
}
public void FhirPath_Gramm_InEq()
{
var parser = Grammar.Expression.End();
AssertParser.SucceedsMatch(parser, "4 < 5 and 5 > 4 or 4 <= 6 xor 6 >= 5",
new BinaryExpression("xor",
new BinaryExpression("or",
new BinaryExpression("and", constOp("<", 4, 5), constOp(">", 5, 4)),
constOp("<=", 4, 6)),
constOp(">=", 6, 5)));
AssertParser.FailsMatch(parser, "<>");
}
public void FhirPath_Lex_QuotedIdentifier()
{
var parser = Lexer.QuotedIdentifier.End();
SucceedsDelimitedString(parser, "\"2a\"");
SucceedsDelimitedString(parser, "\"_\"");
SucceedsDelimitedString(parser, "\"_Abcdef_ghijklmnopqrstuvwxyz_\"");
SucceedsDelimitedString(parser, "\"Hi \uface\"");
SucceedsDelimitedString(parser, "\"@#$%^&*().'\"");
SucceedsDelimitedString(parser, "\"3.1415\"");
AssertParser.FailsMatch(parser, "NoQuotes");
AssertParser.FailsMatch(parser, @"'wrong es\qape'");
}
public void FhirPath_Lex_Unicode()
{
var parser = Lexer.Unicode.End();
AssertParser.SucceedsMatch(parser, @"uface", "face");
AssertParser.SucceedsMatch(parser, "u0000", "0000");
AssertParser.SucceedsMatch(parser, "u09af", "09af");
AssertParser.SucceedsMatch(parser, "uffff", "ffff");
AssertParser.FailsMatch(parser, "u");
AssertParser.FailsMatch(parser, "u0");
AssertParser.FailsMatch(parser, "u00");
AssertParser.FailsMatch(parser, "u000");
AssertParser.FailsMatch(parser, "u00000");
AssertParser.FailsMatch(parser, "ugggg");
}
public void FhirPath_Gramm_Quantity()
{
var parser = Grammar.Quantity.End();
AssertParser.SucceedsMatch(parser, "78 'kg'", new Quantity(78m, "kg"));
AssertParser.SucceedsMatch(parser, "78.0 'kg'", new Quantity(78m, "kg"));
AssertParser.SucceedsMatch(parser, "78.0'kg'", new Quantity(78m, "kg"));
AssertParser.SucceedsMatch(parser, "4 months", new Quantity(4m, "mo"));
AssertParser.SucceedsMatch(parser, "1 '1'", new Quantity(1m, "1"));
AssertParser.FailsMatch(parser, "78"); // still a integer
AssertParser.FailsMatch(parser, "78.0"); // still a decimal
AssertParser.FailsMatch(parser, "78 kg");
AssertParser.FailsMatch(parser, "four 'kg'");
AssertParser.FailsMatch(parser, "4 decennia");
}
public void FhirPath_Gramm_Literal()
{
var parser = Grammar.Literal.End();
AssertParser.SucceedsMatch(parser, "'hi there'", new ConstantExpression("hi there"));
AssertParser.SucceedsMatch(parser, "3", new ConstantExpression(3L));
AssertParser.SucceedsMatch(parser, "3.14", new ConstantExpression(3.14m));
AssertParser.SucceedsMatch(parser, "@2013-12", new ConstantExpression(PartialDateTime.Parse("2013-12")));
AssertParser.SucceedsMatch(parser, "@T12:23:34Z", new ConstantExpression(PartialTime.Parse("12:23:34Z")));
AssertParser.SucceedsMatch(parser, "true", new ConstantExpression(true));
AssertParser.SucceedsMatch(parser, "@2014-12-13T12:00:00+02:00", new ConstantExpression(PartialDateTime.Parse("2014-12-13T12:00:00+02:00")));
AssertParser.FailsMatch(parser, "%constant");
AssertParser.FailsMatch(parser, "\"quotedstring\"");
AssertParser.FailsMatch(parser, "A23identifier");
}
public void FhirPath_Gramm_Term()
{
var parser = Grammar.Term.End();
AssertParser.SucceedsMatch(parser, "childname", new ChildExpression(AxisExpression.This, "childname"));
AssertParser.SucceedsMatch(parser, "$this", AxisExpression.This);
AssertParser.SucceedsMatch(parser, "doSomething()", new FunctionCallExpression(AxisExpression.This, "doSomething", TypeInfo.Any));
AssertParser.SucceedsMatch(parser, "doSomething('hi', 3.14)", new FunctionCallExpression(AxisExpression.This, "doSomething", TypeInfo.Any,
new ConstantExpression("hi"), new ConstantExpression(3.14m)));
AssertParser.SucceedsMatch(parser, "%external", new VariableRefExpression("external"));
AssertParser.SucceedsMatch(parser, "@2013-12", new ConstantExpression(PartialDateTime.Parse("2013-12")));
AssertParser.SucceedsMatch(parser, "3", new ConstantExpression(3L));
AssertParser.SucceedsMatch(parser, "true", new ConstantExpression(true));
AssertParser.SucceedsMatch(parser, "(3)", new ConstantExpression(3L));
AssertParser.SucceedsMatch(parser, "{}", NewNodeListInitExpression.Empty);
AssertParser.SucceedsMatch(parser, "@2014-12-13T12:00:00+02:00", new ConstantExpression(PartialDateTime.Parse("2014-12-13T12:00:00+02:00")));
}
public void FhirPath_Lex_Bool()
{
var parser = Lexer.Bool.End();
AssertParser.SucceedsMatch(parser, "true", true);
AssertParser.SucceedsMatch(parser, "false", false);
AssertParser.Fails(parser, "");
AssertParser.Fails(parser, "True");
AssertParser.Fails(parser, "TRUE");
AssertParser.Fails(parser, "False");
AssertParser.Fails(parser, "FALSE");
AssertParser.Fails(parser, "xyz");
AssertParser.Fails(parser, "1");
AssertParser.Fails(parser, "0");
}
public void FhirPath_Lex_Int()
{
var parser = Lexer.IntegerNumber.End();
AssertParser.SucceedsMatch(parser, "0", 0);
AssertParser.SucceedsMatch(parser, "01", 1);
for (long i = 1; i < 100; i++)
{
AssertParser.SucceedsMatch(parser, i.ToString(), i);
}
AssertParser.FailsMatch(parser, "");
AssertParser.FailsMatch(parser, "a0");
AssertParser.FailsMatch(parser, "0.1");
AssertParser.FailsMatch(parser, "-3"); // use unary '-' operator to make negative
}
public void FhirPath_Gramm_Quantity()
{
var parser = Grammar.Quantity.End();
AssertParser.SucceedsMatch(parser, "78 'kg'", new P.Quantity(78m, "kg"));
AssertParser.SucceedsMatch(parser, "78.0 'kg'", new P.Quantity(78m, "kg"));
AssertParser.SucceedsMatch(parser, "78.0'kg'", new P.Quantity(78m, "kg"));
AssertParser.SucceedsMatch(parser, "4 months", P.Quantity.ForCalendarDuration(4m, "month"));
AssertParser.SucceedsMatch(parser, "4 'mo'", new P.Quantity(4m, "mo"));
AssertParser.SucceedsMatch(parser, "1 '1'", new P.Quantity(1m, P.Quantity.UCUM_UNIT));
AssertParser.FailsMatch(parser, "78"); // still a integer
AssertParser.FailsMatch(parser, "78.0"); // still a decimal
AssertParser.FailsMatch(parser, "78 kg");
AssertParser.FailsMatch(parser, "four 'kg'");
AssertParser.FailsMatch(parser, "4 decennia");
}
public void FhirPath_Lex_Date()
{
var parser = Lexer.Date.End();
accept("@2018-04-05");
accept("@2018-04");
accept("@2018");
reject("@2018-04-05T");
reject("@2018-04-05TZ");
reject("@2018-04-05Z");
reject("@2018-04-05T10:00:00");
reject("@2018-04-05T10:00:00Z");
void accept(string s) => AssertParser.SucceedsMatch(parser, s, P.Date.Parse(s.Substring(1)));
void reject(string s) => AssertParser.FailsMatch(parser, s);
}
public void FhirPath_Lex_Const()
{
var parser = Lexer.ExternalConstant.End();
SucceedsPrefixString(parser, "%c");
SucceedsPrefixString(parser, "%const");
SucceedsPrefixString(parser, "%a1");
SucceedsPrefixString(parser, "%a__1");
AssertParser.SucceedsMatch(parser, "%\"forbidden-characters-1234\"", "forbidden-characters-1234");
AssertParser.FailsMatch(parser, "%0");
AssertParser.FailsMatch(parser, "%0123");
AssertParser.FailsMatch(parser, "%");
AssertParser.FailsMatch(parser, "%%");
AssertParser.FailsMatch(parser, "%%a");
AssertParser.FailsMatch(parser, "%-");
AssertParser.FailsMatch(parser, "%*");
}
public void FhirPath_Gramm_Expression_Indexer()
{
var parser = Grammar.InvocationExpression.End();
AssertParser.SucceedsMatch(parser, "Patient.name", patientName);
AssertParser.SucceedsMatch(parser, "Patient.name [4 ]",
new IndexerExpression(patientName, new ConstantExpression(4)));
AssertParser.SucceedsMatch(parser, "$this[4].name",
new ChildExpression(
new IndexerExpression(AxisExpression.This, new ConstantExpression(4)),
"name"));
AssertParser.FailsMatch(parser, "Patient.name[");
AssertParser.FailsMatch(parser, "Patient.name]");
AssertParser.FailsMatch(parser, "Patient.name[]");
AssertParser.FailsMatch(parser, "Patient.name[4,]");
AssertParser.FailsMatch(parser, "Patient.name[4,5]");
}
public void FhirPath_Lex_DateTime()
{
var parser = Lexer.DateTime.End();
SucceedsPartialDateTime(parser, "@2015-01");
SucceedsPartialDateTime(parser, "@2015-01-02T12:34:00Z");
SucceedsPartialDateTime(parser, "@2015-01-03T12:34:34+02:30");
SucceedsPartialDateTime(parser, "@2015-01-03T12:34:34");
// SucceedsPartialDateTime(parser, "@2015-01-01T23"); TODO: Make this work
AssertParser.FailsMatch(parser, "@2015-32-02T12:34:00Z");
AssertParser.FailsMatch(parser, "@2015-01-02T28:34:00Z");
AssertParser.FailsMatch(parser, "T12:34:34+02:30");
AssertParser.FailsMatch(parser, "12:34:34+02:30");
AssertParser.FailsMatch(parser, "@T12:34:34+02:30");
AssertParser.FailsMatch(parser, "@12:34:34+02:30");
AssertParser.FailsMatch(parser, "@20150103T12:34:34+02:30");
AssertParser.FailsMatch(parser, "@-2015-01");
}
public void FhirPath_Lex_Decimal()
{
var parser = Lexer.DecimalNumber.End();
AssertParser.SucceedsMatch(parser, "3.4", 3.4m);
// FHIR allows leading zeroes since STU3
AssertParser.SucceedsMatch(parser, "01.00", 1.00m);
AssertParser.SucceedsMatch(parser, "3.1415926535897932384626433", 3.1415926535897932384626433m);
// Shall not accept integer values
AssertParser.FailsMatch(parser, "3");
// Test invalid values
AssertParser.FailsMatch(parser, "");
AssertParser.FailsMatch(parser, "a0");
AssertParser.FailsMatch(parser, "0d");
AssertParser.FailsMatch(parser, "0x0");
AssertParser.FailsMatch(parser, "0.314+E01");
}
public void FhirPath_Lex_String()
{
var parser = Lexer.String.End();
SucceedsDelimitedString(parser, @"'single quotes'");
SucceedsDelimitedString(parser, @"'""single quotes with doubles""'");
AssertParser.SucceedsMatch(parser, @"'single \' quotes'", @"single ' quotes");
SucceedsDelimitedString(parser, @"''");
AssertParser.SucceedsMatch(parser, @"'xxx \u0040 yyy \\\/\f\n\r\t zzz !@#$%^&*()_-=+[]{}|;:,.<>?`~'",
"xxx @ yyy \\/\f\n\r\t zzz " + @"!@#$%^&*()_-=+[]{}|;:,.<>?`~");
AssertParser.SucceedsMatch(parser, @"'\\b(?<month>\\d{1,2})/(?<day>\\d{1,2})/(?<year>\\d{2,4})\\b'",
@"\b(?<month>\d{1,2})/(?<day>\d{1,2})/(?<year>\d{2,4})\b");
AssertParser.FailsMatch(parser, @"'\q incorrect escape'");
AssertParser.FailsMatch(parser, @"""double quotes""");
AssertParser.FailsMatch(parser, @"no quotes");
AssertParser.FailsMatch(parser, @"""mixed quotes'");
}
public void FhirPath_Lex_Time()
{
var parser = Lexer.Time.End();
SucceedsTime(parser, "@T12:34:00Z");
SucceedsTime(parser, "@T12:34:34+02:30");
SucceedsTime(parser, "@T12:34:34");
// SucceedsTime(parser, "@T12:35"); TODO: make this work
// SucceedsTime(parser, "@T12");
AssertParser.FailsMatch(parser, "2001-01-01T12:34:34+02:30");
AssertParser.FailsMatch(parser, "@2001-01-01T12:34:34+02:30");
AssertParser.FailsMatch(parser, "T12:34:34+02:30");
AssertParser.FailsMatch(parser, "12:34:34+02:30");
AssertParser.FailsMatch(parser, "@12:34:34+02:30");
AssertParser.FailsMatch(parser, "@T12:34:34+48:30");
}
