public void Format_TypeValue_FormattedResult([Values(typeof(bool), typeof(Guid), typeof(string), typeof(sbyte), typeof(byte), typeof(short), typeof(int), typeof(long), typeof(float), typeof(double), typeof(decimal), typeof(DateTime), typeof(DateTimeOffset), typeof(TimeSpan))] Type type) { var value = type; var result = _formatter.Format(value); Assert.That(result, Is.EqualTo(EdmTypeNames.Lookup(value))); }
public void Lookup_DoubleEdmTypeName_ReturnsDouble() { const string edmTypeName = "edm.double"; var expected = typeof(double); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_NullableDecimal_ReturnsEdmTypeName() { var type = typeof(decimal?); const string expected = "edm.decimal"; var actual = EdmTypeNames.Lookup(type); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_GuidEdmTypeName_ReturnsGuid() { const string edmTypeName = "edm.guid"; var expected = typeof(Guid); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_Int16EdmTypeName_ReturnsShort() { const string edmTypeName = "edm.int16"; var expected = typeof(short); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_StringEdmTypeName_ReturnsString() { const string edmTypeName = "edm.string"; var expected = typeof(string); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_SingleEdmTypeName_ReturnsFloat() { const string edmTypeName = "edm.single"; var expected = typeof(float); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_DecimalEdmTypeName_ReturnsDecimal() { const string edmTypeName = "edm.decimal"; var expected = typeof(decimal); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_TimeEdmTypeName_ReturnsTimeSpan() { const string edmTypeName = "edm.time"; var expected = typeof(TimeSpan); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_NullableBoolean_ReturnsEdmTypeName() { var type = typeof(bool?); const string expected = "edm.boolean"; var actual = EdmTypeNames.Lookup(type); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_SignedByteEdmTypeName_ReturnsSignedByte() { const string edmTypeName = "edm.sbyte"; var expected = typeof(sbyte); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_Integer_ReturnsEdmTypeName() { var type = typeof(int); const string expected = "edm.int32"; var actual = EdmTypeNames.Lookup(type); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_NullableLong_ReturnsEdmTypeName() { var type = typeof(long?); const string expected = "edm.int64"; var actual = EdmTypeNames.Lookup(type); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_NullableFloat_ReturnsEdmTypeName() { var type = typeof(float?); const string expected = "edm.float"; var actual = EdmTypeNames.Lookup(type); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_DateTimeOffsetEdmTypeName_ReturnsDateTimeOffset() { const string edmTypeName = "edm.datetimeoffset"; var expected = typeof(DateTimeOffset); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_NullableDateTime_ReturnsEdmTypeName() { var type = typeof(DateTime?); const string expected = "edm.datetime"; var actual = EdmTypeNames.Lookup(type); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_Int32EdmTypeName_ReturnsInteger() { const string edmTypeName = "edm.int32"; var expected = typeof(int); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_BooleanEdmTypeName_ReturnsBoolean() { const string edmTypeName = "edm.boolean"; var expected = typeof(bool); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_Int64EdmTypeName_ReturnsLong() { const string edmTypeName = "edm.int64"; var expected = typeof(long); var actual = EdmTypeNames.Lookup(edmTypeName); Assert.That(expected, Is.EqualTo(actual)); }
public void Lookup_Byte_ReturnsEdmTypeName() { var type = typeof(byte); const string expected = "edm.byte"; var actual = EdmTypeNames.Lookup(type); Assert.That(expected, Is.EqualTo(actual)); }
protected override Expression VisitTypeBinary(TypeBinaryExpression node) { var result = base.VisitTypeBinary(node); _expression.Push(TokenType.Primitive, EdmTypeNames.Lookup(node.TypeOperand)); _expression.Push(TokenType.Function, "isof"); return(result); }
protected override Type Parse(string text) { var result = EdmTypeNames.Lookup(text); if (result == null) { throw new ArgumentException(String.Format("'{0}' is not recognized as an OData specified primitive type.", text)); } return(result); }
protected override Expression VisitUnary(UnaryExpression node) { var result = base.VisitUnary(node); switch (node.NodeType) { case ExpressionType.Convert: _expression.Push(TokenType.Name, EdmTypeNames.Lookup(node.Type)); _expression.Push(TokenType.Function, Function.Cast.GetODataQueryMethodName()); break; case ExpressionType.TypeAs: _expression.Push(TokenType.Name, EdmTypeNames.Lookup(node.Type)); _expression.Push(TokenType.Function, Function.Cast.GetODataQueryMethodName()); break; case ExpressionType.Negate: _expression.Push(TokenType.UnaryOperator, FilterExpressionOperator.Negate.GetODataQueryOperatorString()); break; case ExpressionType.NegateChecked: _expression.Push(TokenType.UnaryOperator, FilterExpressionOperator.Negate.GetODataQueryOperatorString()); break; case ExpressionType.Not: _expression.Push(TokenType.UnaryOperator, FilterExpressionOperator.Not.GetODataQueryOperatorString()); break; case ExpressionType.Increment: _expression.Push(TokenType.Integer, "1"); _expression.Push(TokenType.BinaryOperator, FilterExpressionOperator.Add.GetODataQueryOperatorString()); break; case ExpressionType.Decrement: _expression.Push(TokenType.Integer, "1"); _expression.Push(TokenType.BinaryOperator, FilterExpressionOperator.Subtract.GetODataQueryOperatorString()); break; // TODO: figure these two out //case ExpressionType.IsTrue: // break; //case ExpressionType.IsFalse: // break; default: throw new ArgumentOutOfRangeException(); } return(result); }
public void BuildExpression_StackContainingPrimitiveToken_ReturnsCorrectConstantExpression() { var value = typeof(int); var oDataLiteral = String.Format("{0}", EdmTypeNames.Lookup(value)); var stack = new Stack <Token>(); stack.Push(TokenType.Primitive, oDataLiteral); var expression = _strategy.BuildExpression(stack); Assert.That(expression, Is.Not.Null); Assert.That(expression, Is.TypeOf <ConstantFilterExpression>()); Assert.That(expression, Has.Property("Type").EqualTo(typeof(Type))); Assert.That(expression, Has.Property("Value").EqualTo(value)); }
public FilterExpression BuildExpression(Stack <Token> stack) { if (stack == null) { throw new ArgumentNullException("stack", "Cannot build expression from null expression stack."); } if (stack.Count < 1) { throw new ArgumentException("Cannot build expression from empty expression stack.", "stack"); } var token = stack.Pop(); if (token == null) { throw new ArgumentException("Cannot build expression from null token."); } ConstantFilterExpression result; var match = TypeSpecified.Match(token.Value); if (match.Success) { // TODO: need to support more than just the EDM type primitives defined in the OData ABNF var typeName = match.Groups.Cast <Group>().Skip(1).Single() .Captures.Cast <Capture>().Single().Value; var type = EdmTypeNames.Lookup(typeName); result = FilterExpression.Constant(null, type); } else { result = FilterExpression.Constant <object>(null); } return(result); }
protected override string Format(Type value) { return(EdmTypeNames.Lookup(value)); }