public void NonSingleValueQueryNodeShouldFail()
{
this.unaryOperatorBinder = new UnaryOperatorBinder(this.BindMethodThatReturnsCollectionQueryNode);
var unaryOperatorToken = new UnaryOperatorToken(UnaryOperatorKind.Negate, new LiteralToken("foo"));
Action bind = () => this.unaryOperatorBinder.BindUnaryOperator(unaryOperatorToken);
bind.Throws <ODataException>(Strings.MetadataBinder_UnaryOperatorOperandNotSingleValue(UnaryOperatorKind.Negate.ToString()));
}
public void UnaryOperatorQueryTokenDefaultTest()
{
LiteralToken operand = new LiteralToken(null);
UnaryOperatorToken unary = new UnaryOperatorToken(UnaryOperatorKind.Negate, operand);
this.Assert.AreEqual(QueryTokenKind.UnaryOperator, unary.Kind, "The InternalKind property has an unexpected value.");
this.Assert.AreEqual(UnaryOperatorKind.Negate, unary.OperatorKind, "The OperatorKind property should be Negate.");
this.Assert.AreEqual(operand, unary.Operand, "The Operand property has an unexpected value.");
}
public void NotOperatorShouldResultInUnaryOperatorNode()
{
this.unaryOperatorBinder = new UnaryOperatorBinder(this.BindMethodThatReturnsSingleValueQueryNode);
this.parameterSingleValueQueryNode = new SingleValueFunctionCallNode("func", null, EdmCoreModel.Instance.GetBoolean(false));
var unaryOperatorQueryToken = new UnaryOperatorToken(UnaryOperatorKind.Not, new LiteralToken("foo"));
var resultNode = this.unaryOperatorBinder.BindUnaryOperator(unaryOperatorQueryToken);
resultNode.ShouldBeUnaryOperatorNode(UnaryOperatorKind.Not).And.TypeReference.FullName().Should().Be("Edm.Boolean");
}
public void ExtensionSingleValueQueryNodeWithValidTypeReferenceShouldResultInUnaryOperatorNode()
{
this.unaryOperatorBinder = new UnaryOperatorBinder(this.BindMethodThatReturnsSingleValueExtensionQueryNode);
this.extensionSingleValueQueryNode = new SingleValueQueryNodeWithTypeReference();
var unaryOperatorQueryToken = new UnaryOperatorToken(UnaryOperatorKind.Negate, new LiteralToken("foo"));
var resultNode = this.unaryOperatorBinder.BindUnaryOperator(unaryOperatorQueryToken);
resultNode.ShouldBeUnaryOperatorNode(UnaryOperatorKind.Negate).And.TypeReference.FullName().Should().Be("Edm.Int32");
}
public void UnaryOperatorQueryTokenDefaultTest()
{
LiteralToken operand = new LiteralToken(null);
UnaryOperatorToken unary = new UnaryOperatorToken(UnaryOperatorKind.Negate, operand);
this.Assert.AreEqual(QueryTokenKind.UnaryOperator, unary.Kind, "The InternalKind property has an unexpected value.");
this.Assert.AreEqual(UnaryOperatorKind.Negate, unary.OperatorKind, "The OperatorKind property should be Negate.");
this.Assert.AreEqual(operand, unary.Operand, "The Operand property has an unexpected value.");
}
public void SingleValueQueryNodeWithImcompatibleTypeReferenceShouldFail()
{
this.unaryOperatorBinder = new UnaryOperatorBinder(this.BindMethodThatReturnsSingleValueQueryNode);
this.parameterSingleValueQueryNode = new SingleValueFunctionCallNode("func", null, EdmCoreModel.Instance.GetDateTimeOffset(false));
var unaryOperatorQueryToken = new UnaryOperatorToken(UnaryOperatorKind.Negate, new LiteralToken("foo"));
Action bind = () => this.unaryOperatorBinder.BindUnaryOperator(unaryOperatorQueryToken);
bind.Throws <ODataException>(Strings.MetadataBinder_IncompatibleOperandError("Edm.DateTimeOffset", UnaryOperatorKind.Negate));
}
public static UnaryOperatorToken ShouldBeUnaryOperatorQueryToken(this QueryToken token, UnaryOperatorKind expectedOperatorKind)
{
Assert.NotNull(token);
UnaryOperatorToken propertyAccessQueryToken = Assert.IsType <UnaryOperatorToken>(token);
Assert.Equal(QueryTokenKind.UnaryOperator, propertyAccessQueryToken.Kind);
Assert.Equal(expectedOperatorKind, propertyAccessQueryToken.OperatorKind);
return(propertyAccessQueryToken);
}
public void NegateOperatorShouldResultInUnaryOperatorNode()
{
this.unaryOperatorBinder = new UnaryOperatorBinder(this.BindMethodThatReturnsSingleValueQueryNode);
this.parameterSingleValueQueryNode = new UnaryOperatorNode(UnaryOperatorKind.Negate, new UnaryOperatorNode(UnaryOperatorKind.Not, new ConstantNode(null)));
var unaryOperatorQueryToken = new UnaryOperatorToken(UnaryOperatorKind.Negate, new LiteralToken(true));
var resultNode = this.unaryOperatorBinder.BindUnaryOperator(unaryOperatorQueryToken);
resultNode.ShouldBeUnaryOperatorNode(UnaryOperatorKind.Negate);
}
/// <summary>
/// Retrieve SingleValueNode operand from given token.
/// </summary>
/// <param name="unaryOperatorToken">The token</param>
/// <returns>the SingleValueNode operand</returns>
private SingleValueNode GetOperandFromToken(UnaryOperatorToken unaryOperatorToken)
{
SingleValueNode operand = this.bindMethod(unaryOperatorToken.Operand) as SingleValueNode;
if (operand == null)
{
throw new ODataException(ODataErrorStrings.MetadataBinder_UnaryOperatorOperandNotSingleValue(unaryOperatorToken.OperatorKind.ToString()));
}
return operand;
}
/// <summary>
/// Retrieve SingleValueNode operand from given token.
/// </summary>
/// <param name="unaryOperatorToken">The token</param>
/// <returns>the SingleValueNode operand</returns>
private SingleValueNode GetOperandFromToken(UnaryOperatorToken unaryOperatorToken)
{
SingleValueNode operand = this.bindMethod(unaryOperatorToken.Operand) as SingleValueNode;
if (operand == null)
{
throw new ODataException(ODataErrorStrings.MetadataBinder_UnaryOperatorOperandNotSingleValue(unaryOperatorToken.OperatorKind.ToString()));
}
return(operand);
}
public void NegateOperatorOnNullLiteralShouldResultInUnaryOperatorNodeWithNullType()
{
this.unaryOperatorBinder = new UnaryOperatorBinder(this.BindMethodThatReturnsSingleValueQueryNode);
this.parameterSingleValueQueryNode = new ConstantNode(null);
var unaryOperatorQueryToken = new UnaryOperatorToken(UnaryOperatorKind.Negate, new LiteralToken(true));
var resultNode = this.unaryOperatorBinder.BindUnaryOperator(unaryOperatorQueryToken);
resultNode.ShouldBeUnaryOperatorNode(UnaryOperatorKind.Negate)
.And.Operand.ShouldBeConstantQueryNode <object>(null);
resultNode.As <UnaryOperatorNode>().TypeReference.Should().BeNull();
}
/// <summary>
/// Binds a unary operator token.
/// </summary>
/// <param name="unaryOperatorToken">The unary operator token to bind.</param>
/// <returns>The bound unary operator token.</returns>
internal QueryNode BindUnaryOperator(UnaryOperatorToken unaryOperatorToken)
{
ExceptionUtils.CheckArgumentNotNull(unaryOperatorToken, "unaryOperatorToken");
SingleValueNode operand = this.GetOperandFromToken(unaryOperatorToken);
IEdmTypeReference typeReference = UnaryOperatorBinder.PromoteOperandType(operand, unaryOperatorToken.OperatorKind);
Debug.Assert(typeReference == null || typeReference.IsODataPrimitiveTypeKind(), "Only primitive types should be able to get here.");
operand = MetadataBindingUtils.ConvertToTypeIfNeeded(operand, typeReference);
return new UnaryOperatorNode(unaryOperatorToken.OperatorKind, operand);
}
public bool Visit(UnaryOperatorToken tokenIn)
{
UnaryOperatorKind operatorKind = tokenIn.OperatorKind;
if (operatorKind == UnaryOperatorKind.Not)
{
stringBuilder.Append("NOT");
tokenIn.Operand.Accept(this);
stringBuilder.Append(' ');
return(true);
}
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "QueryToken of type '{0}' is not supported.", tokenIn.OperatorKind));
}
/// <summary>
/// Binds a unary operator token.
/// </summary>
/// <param name="unaryOperatorToken">The unary operator token to bind.</param>
/// <returns>The bound unary operator token.</returns>
internal QueryNode BindUnaryOperator(UnaryOperatorToken unaryOperatorToken)
{
ExceptionUtils.CheckArgumentNotNull(unaryOperatorToken, "unaryOperatorToken");
SingleValueNode operand = this.GetOperandFromToken(unaryOperatorToken);
IEdmTypeReference typeReference = UnaryOperatorBinder.PromoteOperandType(operand, unaryOperatorToken.OperatorKind);
Debug.Assert(typeReference == null || typeReference.IsODataPrimitiveTypeKind(), "Only primitive types should be able to get here.");
operand = MetadataBindingUtils.ConvertToTypeIfNeeded(operand, typeReference);
return(new UnaryOperatorNode(unaryOperatorToken.OperatorKind, operand));
}
public void NegateOperatorOnOpenPropertyShouldResultInUnaryOperatorNodeWithNullType()
{
const string OpenPropertyName = "SomeProperty";
this.unaryOperatorBinder = new UnaryOperatorBinder(this.BindMethodThatReturnsSingleValueQueryNode);
this.parameterSingleValueQueryNode = new SingleValueOpenPropertyAccessNode(new ConstantNode(null), OpenPropertyName);
var unaryOperatorQueryToken = new UnaryOperatorToken(UnaryOperatorKind.Negate, new LiteralToken(true));
var resultNode = this.unaryOperatorBinder.BindUnaryOperator(unaryOperatorQueryToken);
resultNode.ShouldBeUnaryOperatorNode(UnaryOperatorKind.Negate)
.And.Operand.ShouldBeSingleValueOpenPropertyAccessQueryNode(OpenPropertyName);
resultNode.As <UnaryOperatorNode>().TypeReference.Should().BeNull();
}
public Expression Visit(UnaryOperatorToken tokenIn)
{
switch (tokenIn.OperatorKind)
{
case UnaryOperatorKind.Negate:
return(Expression.Negate(tokenIn.Operand.Accept(this)));
case UnaryOperatorKind.Not:
return(Expression.Not(tokenIn.Operand.Accept(this)));
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Write the unary token as URI part to this builder.
/// </summary>
/// <param name="unary">To write as URI part.</param>
private void WriteUnary(UnaryOperatorToken unary)
{
ExceptionUtils.CheckArgumentNotNull(unary, "unary");
switch (unary.OperatorKind)
{
case UnaryOperatorKind.Negate:
this.builder.Append(ExpressionConstants.SymbolNegate);
break;
case UnaryOperatorKind.Not:
this.builder.Append(ExpressionConstants.KeywordNot);
this.builder.Append(ExpressionConstants.SymbolEscapedSpace);
break;
default:
throw new ODataException(ODataErrorStrings.General_InternalError(InternalErrorCodes.ODataUriBuilder_WriteUnary_UnreachableCodePath));
}
this.WriteQuery(unary.Operand);
}
/// <summary>
/// Binds a unary operator token.
/// </summary>
/// <param name="unaryOperatorToken">The unary operator token to bind.</param>
/// <returns>The bound unary operator token.</returns>
protected virtual QueryNode BindUnaryOperator(UnaryOperatorToken unaryOperatorToken)
{
UnaryOperatorBinder unaryOperatorBinder = new UnaryOperatorBinder(this.Bind);
return unaryOperatorBinder.BindUnaryOperator(unaryOperatorToken);
}
private static void VerifyUnaryOperatorQueryTokensAreEqual(UnaryOperatorToken expected, UnaryOperatorToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.OperatorKind, actual.OperatorKind, "The unary operator kind doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.Operand, actual.Operand, assert);
}
/// <summary>
/// Visits a UnaryOperatorToken
/// </summary>
/// <param name="tokenIn">The UnaryOperatorToken to bind</param>
/// <returns>A UnaryOperatorNode bound to this UnaryOperatorToken</returns>
public virtual T Visit(UnaryOperatorToken tokenIn)
{
throw new NotImplementedException();
}
private static void VerifyUnaryOperatorQueryTokensAreEqual(UnaryOperatorToken expected, UnaryOperatorToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.OperatorKind, actual.OperatorKind, "The unary operator kind doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.Operand, actual.Operand, assert);
}
/// <summary>
/// Binds a unary operator token.
/// </summary>
/// <param name="unaryOperatorToken">The unary operator token to bind.</param>
/// <returns>The bound unary operator token.</returns>
protected virtual QueryNode BindUnaryOperator(UnaryOperatorToken unaryOperatorToken)
{
UnaryOperatorBinder unaryOperatorBinder = new UnaryOperatorBinder(this.Bind);
return(unaryOperatorBinder.BindUnaryOperator(unaryOperatorToken));
}
