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