public void CanCreateLangFunctionWithLiteralParameter() { // given LiteralExpression literal = new TypedLiteralExpression <string>("1000"); // when LiteralExpression lang = Builder.Lang(literal); // then Assert.True(lang.Expression is LangFunction); Assert.Same(literal.Expression, lang.Expression.Arguments.ElementAt(0)); }
public void CanCreateStrFunctionWithLiteralParameter() { // given LiteralExpression literal = new TypedLiteralExpression <string>("1000"); // when LiteralExpression str = Builder.Str(literal); // then Assert.IsTrue(str.Expression is StrFunction); Assert.AreSame(literal.Expression, str.Expression.Arguments.ElementAt(0)); }
public void ShouldAllowCreatingCallToStrlenFunctionWithStringLiteralParameter() { // given var literal = new TypedLiteralExpression <string>("mail"); // when NumericExpression <int> strlen = Builder.StrLen(literal); // then Assert.True(strlen.Expression is StrLenFunction); Assert.Same(literal.Expression, strlen.Expression.Arguments.ElementAt(0)); }
public void CanCreateOldDatatypeFunctionWithLiteralParameter() { // given LiteralExpression literal = new TypedLiteralExpression <string>("1000"); // when IriExpression lang = Builder.Datatype(literal); // then Assert.IsTrue(lang.Expression is DataTypeFunction); Assert.AreSame(literal.Expression, lang.Expression.Arguments.ElementAt(0)); }
public void CanCreateBNodeFunctionWithStringLiteralExpressionParameter() { // given var expression = new TypedLiteralExpression <string>("str"); // when BlankNodeExpression bnode = Builder.BNode(expression); // then Assert.IsTrue(bnode.Expression is BNodeFunction); Assert.AreSame(expression.Expression, bnode.Expression.Arguments.ElementAt(0)); }
public void CanCreateEqualityComparisonBetweenUntypedLiteralAndConcreteValueReversed() { // given LiteralExpression lit = new TypedLiteralExpression <string>("text"); // when var areEqual = ("some value" == lit).Expression; // then Assert.IsTrue(areEqual is EqualsExpression); Assert.IsTrue(areEqual.Arguments.ElementAt(0) is ConstantTerm); Assert.IsTrue(areEqual.Arguments.ElementAt(1) is ConstantTerm); }
public void ShouldAllowCreatingCallToLangMatchesFunctionWithLiteralExpressionAndStringParameters() { // given var languageTag = new TypedLiteralExpression <string>("title"); // when BooleanExpression strlen = Builder.LangMatches(languageTag, "fr"); // then Assert.True(strlen.Expression is LangMatchesFunction); Assert.Same(languageTag.Expression, strlen.Expression.Arguments.ElementAt(0)); Assert.Equal("\"fr\"", strlen.Expression.Arguments.ElementAt(1).ToString()); }
public void ShouldAllowCreatingCallToSubstrFunctionWithLiteralExpressionAndVariableParameters() { // given var literal = new TypedLiteralExpression <string>("mail"); var startLocation = new VariableExpression("startFrom"); // when TypedLiteralExpression <string> strlen = Builder.Substr(literal, startLocation); // then Assert.True(strlen.Expression is SubStrFunction); Assert.Same(literal.Expression, strlen.Expression.Arguments.ElementAt(0)); Assert.Same(startLocation.Expression, strlen.Expression.Arguments.ElementAt(1)); }
public void ShouldAllowCreatingCallToLangMatchesFunctionWithLiteralExpressionAndVariableParameters() { // given LiteralExpression languageTag = new TypedLiteralExpression <string>("title"); var languageRange = new VariableExpression("range"); // when BooleanExpression strlen = Builder.LangMatches(languageTag, languageRange); // then Assert.True(strlen.Expression is LangMatchesFunction); Assert.Same(languageTag.Expression, strlen.Expression.Arguments.ElementAt(0)); Assert.Same(languageRange.Expression, strlen.Expression.Arguments.ElementAt(1)); }
public void CanCreateEqualityComparisonBetweenConstantAndVariable() { // given VariableExpression v1 = new VariableExpression("v1"); LiteralExpression lit = new TypedLiteralExpression <string>("text"); // when var areEqual = (lit == v1).Expression; // then Assert.IsTrue(areEqual is EqualsExpression); Assert.IsTrue(areEqual.Arguments.ElementAt(0) is ConstantTerm); Assert.IsTrue(areEqual.Arguments.ElementAt(1) is VariableTerm); }
public void ShouldAllowCreatingCallToSubstrFunctionWithVariableAndIntegerParameter() { // given var literal = new VariableExpression("mail"); var startLocation = new NumericExpression <int>(5); // when TypedLiteralExpression <string> strlen = Builder.Substr(literal, 5); // then Assert.True(strlen.Expression is SubStrFunction); Assert.Same(literal.Expression, strlen.Expression.Arguments.ElementAt(0)); Assert.Equal(startLocation.Expression.ToString(), strlen.Expression.Arguments.ElementAt(1).ToString()); }
public void ShouldAllowCreatingCallToSubstrFunctionWithStringLiteralAndNumericExpressionParameter() { // given var literal = new TypedLiteralExpression <string>("mail"); var startLocation = new NumericExpression <int>(5); // when TypedLiteralExpression <string> strlen = Builder.Substr(literal, startLocation); // then Assert.True(strlen.Expression is SubStrFunction); Assert.Same(literal.Expression, strlen.Expression.Arguments.ElementAt(0)); Assert.Same(startLocation.Expression, strlen.Expression.Arguments.ElementAt(1)); }
public void CanCreateIfFunctionCall() { // given var ifExpr = new BooleanExpression(new VariableTerm("if")); SparqlExpression thenExpr = new TypedLiteralExpression <string>("then this"); SparqlExpression elseExpr = new TypedLiteralExpression <string>("else that"); // when RdfTermExpression expression = Builder.If(ifExpr).Then(thenExpr).Else(elseExpr); // then Assert.IsTrue(expression.Expression is IfElseFunction); Assert.AreSame(expression.Expression.Arguments.ElementAt(0), ifExpr.Expression); Assert.AreSame(expression.Expression.Arguments.ElementAt(1), thenExpr.Expression); Assert.AreSame(expression.Expression.Arguments.ElementAt(2), elseExpr.Expression); }
public void ShouldAllowCreatingCallToSubstrFunctionWithStringLiteralAndIntegerAndIntegerExpressionParameter() { // given var literal = new TypedLiteralExpression <string>("mail"); var startLocation = new NumericExpression <int>(5); var length = new NumericExpression <int>(5); // when TypedLiteralExpression <string> strlen = Builder.Substr(literal, 5, length); // then Assert.IsTrue(strlen.Expression is SubStrFunction); Assert.AreSame(literal.Expression, strlen.Expression.Arguments.ElementAt(0)); Assert.AreEqual(startLocation.Expression.ToString(), strlen.Expression.Arguments.ElementAt(1).ToString()); Assert.AreSame(length.Expression, strlen.Expression.Arguments.ElementAt(2)); }
public void ShouldAllowCreatingCallToSubstrFunctionWithVariableAndNumericExpressionAndVariableExpressionParameter() { // given var literal = new VariableExpression("mail"); var startLocation = new NumericExpression <int>(5); var length = new VariableExpression("len"); // when TypedLiteralExpression <string> strlen = Builder.Substr(literal, startLocation, length); // then Assert.IsTrue(strlen.Expression is SubStrFunction); Assert.AreSame(literal.Expression, strlen.Expression.Arguments.ElementAt(0)); Assert.AreSame(startLocation.Expression, strlen.Expression.Arguments.ElementAt(1)); Assert.AreSame(length.Expression, strlen.Expression.Arguments.ElementAt(2)); }
public void CanCreateTheCoalesceFunctionCall() { // given SparqlExpression expr1 = new VariableExpression("x"); SparqlExpression expr2 = new TypedLiteralExpression <string>("str"); SparqlExpression expr3 = new NumericExpression <int>(10); SparqlExpression expr4 = new NumericExpression <float>(10.5f) / new NumericExpression <float>(0); // when RdfTermExpression coalesce = Builder.Coalesce(expr1, expr2, expr3, expr4); // then Assert.IsTrue(coalesce.Expression is CoalesceFunction); Assert.AreSame(expr1.Expression, coalesce.Expression.Arguments.ElementAt(0)); Assert.AreSame(expr2.Expression, coalesce.Expression.Arguments.ElementAt(1)); Assert.AreSame(expr3.Expression, coalesce.Expression.Arguments.ElementAt(2)); Assert.AreSame(expr4.Expression, coalesce.Expression.Arguments.ElementAt(3)); }
public void ShouldAllowComparisonOperationOnTypedLiteralExpressions() { // given TypedLiteralExpression <bool> left = new TypedLiteralExpression <bool>(true); Left = left.Expression; TypedLiteralExpression <bool> right = new TypedLiteralExpression <bool>(true); Right = right.Expression; // then AssertExpressionTypeAndCorrectArguments <EqualsExpression>(left == right); AssertExpressionTypeAndCorrectArguments <GreaterThanExpression>(left > right); AssertExpressionTypeAndCorrectArguments <GreaterThanOrEqualToExpression>(left >= right); AssertExpressionTypeAndCorrectArguments <LessThanExpression>(left < right); AssertExpressionTypeAndCorrectArguments <LessThanOrEqualToExpression>(left <= right); AssertExpressionTypeAndCorrectArguments <NotEqualsExpression>(left != right); }
public void ShouldAllowComparisonOperationOnLiteralValueAndTypedLiteralExpression() { // given const float value = 10.5f; TypedLiteralExpression <float> right = new TypedLiteralExpression <float>(120); Right = right.Expression; // then AssertExpressionTypeAndCorrectArguments <EqualsExpression>(value == right, assertLeftOperand: ex => AssertCorrectConstantTerm(ex, value)); AssertExpressionTypeAndCorrectArguments <GreaterThanExpression>(value > right, assertLeftOperand: ex => AssertCorrectConstantTerm(ex, value)); AssertExpressionTypeAndCorrectArguments <GreaterThanOrEqualToExpression>(value >= right, assertLeftOperand: ex => AssertCorrectConstantTerm(ex, value)); AssertExpressionTypeAndCorrectArguments <LessThanExpression>(value < right, assertLeftOperand: ex => AssertCorrectConstantTerm(ex, value)); AssertExpressionTypeAndCorrectArguments <LessThanOrEqualToExpression>(value <= right, assertLeftOperand: ex => AssertCorrectConstantTerm(ex, value)); AssertExpressionTypeAndCorrectArguments <NotEqualsExpression>(value != right, assertLeftOperand: ex => AssertCorrectConstantTerm(ex, value)); }
public void ShouldAllowComparisonOperationOnTypedLiteralExpressionAndLiteralValue() { // given const decimal value = 10; TypedLiteralExpression <decimal> left = new TypedLiteralExpression <decimal>(120); Left = left.Expression; // then AssertExpressionTypeAndCorrectArguments <EqualsExpression>(left == value, assertRightOperand: ex => AssertCorrectConstantTerm(ex, value)); AssertExpressionTypeAndCorrectArguments <GreaterThanExpression>(left > value, assertRightOperand: ex => AssertCorrectConstantTerm(ex, value)); AssertExpressionTypeAndCorrectArguments <GreaterThanOrEqualToExpression>(left >= value, assertRightOperand: ex => AssertCorrectConstantTerm(ex, value)); AssertExpressionTypeAndCorrectArguments <LessThanExpression>(left < value, assertRightOperand: ex => AssertCorrectConstantTerm(ex, value)); AssertExpressionTypeAndCorrectArguments <LessThanOrEqualToExpression>(left <= value, assertRightOperand: ex => AssertCorrectConstantTerm(ex, value)); AssertExpressionTypeAndCorrectArguments <NotEqualsExpression>(left != value, assertRightOperand: ex => AssertCorrectConstantTerm(ex, value)); }