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"); }