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