public void TryParseEnumMemberWithFlagsOfTwoValuesInJsonShouldBeTrue()
{
var enumType = new EdmEnumType("Ns", "Color", true);
var red = enumType.AddMember("Red", new EdmEnumMemberValue(1));
var green = enumType.AddMember("Green", new EdmEnumMemberValue(2));
var blue = enumType.AddMember("Blue", new EdmEnumMemberValue(4));
var white = enumType.AddMember("White", new EdmEnumMemberValue(8));
// symbolic value
string jsonEnumPath = " Red , White ";
IEnumerable <IEdmEnumMember> parsedMember;
Assert.True(EdmEnumValueParser.TryParseJsonEnumMember(jsonEnumPath, enumType, null, out parsedMember));
Assert.Equal(2, parsedMember.Count());
Assert.Equal(red, parsedMember.First());
Assert.Equal(white, parsedMember.Last());
// numeric value
jsonEnumPath = " 11 "; // 1 + 2 + 8
Assert.True(EdmEnumValueParser.TryParseJsonEnumMember(jsonEnumPath, enumType, null, out parsedMember));
Assert.Equal(3, parsedMember.Count());
Assert.Equal(red, parsedMember.ElementAt(0));
Assert.Equal(green, parsedMember.ElementAt(1));
Assert.Equal(white, parsedMember.ElementAt(2));
}
public void TryParseEnumMemberOfOneValueShouldBeTrue()
{
var enumType = new EdmEnumType("Ns", "Color");
var blue = enumType.AddMember("Blue", new EdmEnumMemberValue(0));
var white = enumType.AddMember("White", new EdmEnumMemberValue(1));
var complexType = new EdmComplexType("Ns", "Address");
string enumPath = " Ns.Color/Blue ";
List <IEdmSchemaType> types = new List <IEdmSchemaType> {
enumType, complexType
};
IEnumerable <IEdmEnumMember> parsedMember;
Assert.True(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember));
Assert.Equal(blue, parsedMember.Single());
// JSON
string jsonEnumPath = "Blue";
Assert.True(EdmEnumValueParser.TryParseJsonEnumMember(jsonEnumPath, enumType, null, out parsedMember));
Assert.Equal(blue, parsedMember.Single());
jsonEnumPath = "1";
Assert.True(EdmEnumValueParser.TryParseJsonEnumMember(jsonEnumPath, enumType, null, out parsedMember));
Assert.Equal(white, parsedMember.Single());
}
public void TryParseEnumMemberWithFlagsOfTwoValuesShouldBeTrue()
{
var enumType = new EdmEnumType("Ns", "Permission", true);
var read = enumType.AddMember("Read", new EdmEnumMemberValue(0));
var write = enumType.AddMember("Write", new EdmEnumMemberValue(1));
var complexType = new EdmComplexType("Ns", "Address");
string enumPath = " Ns.Permission/Read Ns.Permission/Write ";
List <IEdmSchemaType> types = new List <IEdmSchemaType> {
enumType, complexType
};
IEnumerable <IEdmEnumMember> parsedMember;
Assert.True(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember));
Assert.Equal(2, parsedMember.Count());
Assert.Equal(read, parsedMember.First());
Assert.Equal(write, parsedMember.Last());
// JSON
string jsonEnumPath = " Read , Write ";
Assert.True(EdmEnumValueParser.TryParseJsonEnumMember(jsonEnumPath, enumType, null, out parsedMember));
Assert.Equal(2, parsedMember.Count());
Assert.Equal(read, parsedMember.First());
Assert.Equal(write, parsedMember.Last());
}
private IEnumerable <EdmError> ComputeErrors()
{
IEnumerable <IEdmEnumMember> member;
if (!EdmEnumValueParser.TryParseEnumMember(this.expression.EnumMemberPath, this.Schema.Model, this.Location, out member))
{
return(new EdmError[] { new EdmError(this.Location, EdmErrorCode.InvalidEnumMemberPath, Strings.CsdlParser_InvalidEnumMemberPath(this.expression.EnumMemberPath)) });
}
return(Enumerable.Empty <EdmError>());
}
public void TryParseEnumMemberOfMultipleInvalidTypeShouldBeTrue()
{
var complexType = new EdmComplexType("Ns", "Address");
string enumPath = "Ns.Color/Blue Ns.Color/Red";
List <IEdmSchemaType> types = new List <IEdmSchemaType> {
complexType
};
IEnumerable <IEdmEnumMember> parsedMember;
Assert.True(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember));
Assert.Equal(2, parsedMember.Count());
Assert.Equal("Blue", parsedMember.First().Name);
Assert.Equal("Red", parsedMember.ElementAt(1).Name);
}
private IEnumerable <IEdmEnumMember> ComputeReferenced()
{
IEnumerable <IEdmEnumMember> member;
// In OData Json CSDL, a enum member expression is a string value. "@self.HasPattern": "Red"
// But in OData XML CSDL, a enum member expression is an element like: <EnumMember>org.example.Pattern/Red</EnumMember>
// So, in OData JSON CSDL, we have to use the Term type to construct EnumMember.
if (this.expression.EnumType != null)
{
return(EdmEnumValueParser.TryParseJsonEnumMember(this.expression.EnumMemberPath, this.expression.EnumType, this.Location, out member) ? member : null);
}
return(EdmEnumValueParser.TryParseEnumMember(this.expression.EnumMemberPath, this.Schema.Model, this.Location, out member) ? member : null);
}
public void TryParseEnumMemberOfInvalidPathShouldBeFalse()
{
var enumType = new EdmEnumType("Ns", "Color");
enumType.AddMember("Blue", new EdmEnumMemberValue(0));
enumType.AddMember("White", new EdmEnumMemberValue(1));
var complexType = new EdmComplexType("Ns", "Address");
string enumPath = "Ns.Color//Blue";
List <IEdmSchemaType> types = new List <IEdmSchemaType> {
enumType, complexType
};
IEnumerable <IEdmEnumMember> parsedMember;
Assert.False(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember));
}
public void TryParseEnumMemberWithoutFlagsOfTwoValueShouldBeFalse()
{
var enumType = new EdmEnumType("Ns", "Permission");
enumType.AddMember("Read", new EdmEnumMemberValue(0));
enumType.AddMember("Write", new EdmEnumMemberValue(1));
var complexType = new EdmComplexType("Ns", "Address");
string enumPath = "Ns.Permission/Read Ns.Permission/Write";
List <IEdmSchemaType> types = new List <IEdmSchemaType> {
enumType, complexType
};
IEnumerable <IEdmEnumMember> parsedMember;
Assert.False(EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember));
}
public void TryParseEnumMemberOfTwoValuesWithInvalidEnumTypeShouldBeFalse()
{
var enumType = new EdmEnumType("Ns", "Permission", EdmPrimitiveTypeKind.String, true);
enumType.AddMember("Read", new EdmStringConstant("1"));
enumType.AddMember("Write", new EdmStringConstant("2"));
var complexType = new EdmComplexType("Ns", "Address");
string enumPath = "Ns.Permission/Read Ns.Permissions/Write";
List <IEdmSchemaType> types = new List <IEdmSchemaType> {
enumType, complexType
};
IEnumerable <IEdmEnumMember> parsedMember;
EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeFalse();
}
public void TryParseEnumMemberOfInvalidEnumMemberShouldBeFalse()
{
var enumType = new EdmEnumType("Ns", "Color");
enumType.AddMember("Blue", new EdmIntegerConstant(0));
enumType.AddMember("White", new EdmIntegerConstant(1));
var complexType = new EdmComplexType("Ns", "Address");
string enumPath = "Ns.Color/Green";
List <IEdmSchemaType> types = new List <IEdmSchemaType> {
enumType, complexType
};
IEnumerable <IEdmEnumMember> parsedMember;
EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeFalse();
}
public void TryParseEnumMemberOfOneValueShouldBeTrue()
{
var enumType = new EdmEnumType("Ns", "Color");
var blue = enumType.AddMember("Blue", new EdmEnumMemberValue(0));
enumType.AddMember("White", new EdmEnumMemberValue(1));
var complexType = new EdmComplexType("Ns", "Address");
string enumPath = " Ns.Color/Blue ";
List <IEdmSchemaType> types = new List <IEdmSchemaType> {
enumType, complexType
};
IEnumerable <IEdmEnumMember> parsedMember;
EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeTrue();
parsedMember.Single().Should().Be(blue);
}
public void TryParseEnumMemberWithFlagsOfMultiValueShouldBeTrue()
{
var enumType = new EdmEnumType("Ns", "Permission", true);
var read = enumType.AddMember("Read", new EdmEnumMemberValue(1));
var write = enumType.AddMember("Write", new EdmEnumMemberValue(2));
var readwrite = enumType.AddMember("ReadWrite", new EdmEnumMemberValue(3));
var complexType = new EdmComplexType("Ns", "Address");
string enumPath = "Ns.Permission/Read Ns.Permission/Write Ns.Permission/ReadWrite";
List <IEdmSchemaType> types = new List <IEdmSchemaType> {
enumType, complexType
};
IEnumerable <IEdmEnumMember> parsedMember;
EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeTrue();
parsedMember.Count().Should().Be(3);
parsedMember.Should().Contain(read).And.Contain(write).And.Contain(readwrite);
}
public void TryParseEnumMemberWithFlagsOfTwoValuesShouldBeTrue()
{
var enumType = new EdmEnumType("Ns", "Permission", true);
var read = enumType.AddMember("Read", new EdmIntegerConstant(0));
var write = enumType.AddMember("Write", new EdmIntegerConstant(1));
var complexType = new EdmComplexType("Ns", "Address");
string enumPath = " Ns.Permission/Read Ns.Permission/Write ";
List <IEdmSchemaType> types = new List <IEdmSchemaType> {
enumType, complexType
};
IEnumerable <IEdmEnumMember> parsedMember;
EdmEnumValueParser.TryParseEnumMember(enumPath, BuildModelFromTypes(types), null, out parsedMember).Should().BeTrue();
parsedMember.Count().Should().Be(2);
parsedMember.First().Should().Be(read);
parsedMember.Last().Should().Be(write);
}
private IEdmValue Eval(IEdmExpression expression, IEdmStructuredValue context)
{
switch (expression.ExpressionKind)
{
case EdmExpressionKind.IntegerConstant:
return((IEdmIntegerConstantExpression)expression);
case EdmExpressionKind.StringConstant:
return((IEdmStringConstantExpression)expression);
case EdmExpressionKind.BinaryConstant:
return((IEdmBinaryConstantExpression)expression);
case EdmExpressionKind.BooleanConstant:
return((IEdmBooleanConstantExpression)expression);
case EdmExpressionKind.DateTimeOffsetConstant:
return((IEdmDateTimeOffsetConstantExpression)expression);
case EdmExpressionKind.DecimalConstant:
return((IEdmDecimalConstantExpression)expression);
case EdmExpressionKind.FloatingConstant:
return((IEdmFloatingConstantExpression)expression);
case EdmExpressionKind.GuidConstant:
return((IEdmGuidConstantExpression)expression);
case EdmExpressionKind.DurationConstant:
return((IEdmDurationConstantExpression)expression);
case EdmExpressionKind.DateConstant:
return((IEdmDateConstantExpression)expression);
case EdmExpressionKind.TimeOfDayConstant:
return((IEdmTimeOfDayConstantExpression)expression);
case EdmExpressionKind.Null:
return((IEdmNullExpression)expression);
case EdmExpressionKind.Path:
{
if (context == null)
{
throw new InvalidOperationException(Strings.Edm_Evaluator_NoContextPath);
}
IEdmPathExpression pathExpression = (IEdmPathExpression)expression;
IEdmValue result = context;
#if NET35
// [EdmLib] Need to handle paths that bind to things other than properties.
foreach (string hop in pathExpression.PathSegments)
{
result = FindProperty(hop, result);
if (result == null)
{
throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundPath(hop));
}
}
#else
// Only Support Annotation in EntityType or ComplexType or Property or NavigationProperty.
// Empty Path is not supported.
foreach (string hop in pathExpression.PathSegments)
{
if (hop.Contains("@"))
{
var currentPathSegementInfos = hop.Split('@');
var propertyName = currentPathSegementInfos[0];
var termInfo = currentPathSegementInfos[1];
IEdmExpression termCastExpression = null;
if (!Utils.StringIsNullOrWhitespace(termInfo))
{
var termInfos = termInfo.Split('#');
if (termInfos.Length <= 2)
{
string termName = termInfos[0];
string qualifier = termInfos.Length == 2 ? termInfos[1] : null;
if (Utils.StringIsNullOrWhitespace(propertyName) && this.getAnnotationExpressionForType != null)
{
termCastExpression = this.getAnnotationExpressionForType(this.edmModel, context.Type.Definition, termName, qualifier);
}
else if (!Utils.StringIsNullOrWhitespace(propertyName) && this.getAnnotationExpressionForProperty != null)
{
termCastExpression = this.getAnnotationExpressionForProperty(this.edmModel, context.Type.Definition, propertyName, termName, qualifier);
}
}
}
if (termCastExpression == null)
{
result = null;
break;
}
result = this.Eval(termCastExpression, context);
}
else if (hop == "$count")
{
var edmCollectionValue = result as IEdmCollectionValue;
if (edmCollectionValue != null)
{
result = new EdmIntegerConstant(edmCollectionValue.Elements.Count());
}
else
{
result = null;
break;
}
}
else if (hop.Contains("."))
{
if (this.edmModel == null)
{
throw new InvalidOperationException(Strings.Edm_Evaluator_TypeCastNeedsEdmModel);
}
IEdmType typeSegmentClientType = this.resolveTypeFromName(hop, this.edmModel);
if (typeSegmentClientType == null)
{
result = null;
break;
}
IEdmTypeReference operandType = result.Type;
EdmValueKind operandKind = result.ValueKind;
if (operandKind == EdmValueKind.Collection)
{
List <IEdmDelayedValue> elementValues = new List <IEdmDelayedValue>();
var collection = result as IEdmCollectionValue;
foreach (IEdmDelayedValue element in collection.Elements)
{
if (element.Value.Type.Definition.IsOrInheritsFrom(typeSegmentClientType))
{
elementValues.Add(element);
}
}
result = new EdmCollectionValue(
new EdmCollectionTypeReference(new EdmCollectionType(typeSegmentClientType.GetTypeReference(false))),
elementValues);
}
else if (operandKind != EdmValueKind.Structured ||
(operandKind == EdmValueKind.Structured &&
!operandType.Definition.IsOrInheritsFrom(typeSegmentClientType)))
{
result = null;
break;
}
}
else
{
result = FindProperty(hop, result);
if (result == null)
{
throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundPath(hop));
}
}
}
#endif
return(result);
}
case EdmExpressionKind.PropertyPath:
case EdmExpressionKind.NavigationPropertyPath:
{
EdmUtil.CheckArgumentNull(context, "context");
IEdmPathExpression pathExpression = (IEdmPathExpression)expression;
IEdmValue result = context;
// [EdmLib] Need to handle paths that bind to things other than properties.
foreach (string hop in pathExpression.PathSegments)
{
result = FindProperty(hop, result);
if (result == null)
{
throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundPath(hop));
}
}
return(result);
}
case EdmExpressionKind.FunctionApplication:
{
IEdmApplyExpression apply = (IEdmApplyExpression)expression;
IEdmFunction target = apply.AppliedFunction;
if (target != null)
{
IList <IEdmExpression> argumentExpressions = apply.Arguments.ToList();
IEdmValue[] arguments = new IEdmValue[argumentExpressions.Count()];
{
int argumentIndex = 0;
foreach (IEdmExpression argument in argumentExpressions)
{
arguments[argumentIndex++] = this.Eval(argument, context);
}
}
//// Static validation will have checked that the number and types of arguments are correct,
//// so those checks are not performed dynamically.
Func <IEdmValue[], IEdmValue> operationEvaluator;
if (this.builtInFunctions.TryGetValue(target, out operationEvaluator))
{
return(operationEvaluator(arguments));
}
if (this.lastChanceOperationApplier != null)
{
return(this.lastChanceOperationApplier(target.FullName(), arguments));
}
}
throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundFunction(target != null ? target.ToTraceString() : string.Empty));
}
case EdmExpressionKind.If:
{
IEdmIfExpression ifExpression = (IEdmIfExpression)expression;
if (((IEdmBooleanValue)this.Eval(ifExpression.TestExpression, context)).Value)
{
return(this.Eval(ifExpression.TrueExpression, context));
}
return(this.Eval(ifExpression.FalseExpression, context));
}
case EdmExpressionKind.IsType:
{
IEdmIsTypeExpression isType = (IEdmIsTypeExpression)expression;
IEdmValue operand = this.Eval(isType.Operand, context);
IEdmTypeReference targetType = isType.Type;
return(new EdmBooleanConstant(MatchesType(targetType, operand)));
}
case EdmExpressionKind.Cast:
{
IEdmCastExpression castType = (IEdmCastExpression)expression;
IEdmValue operand = this.Eval(castType.Operand, context);
IEdmTypeReference targetType = castType.Type;
return(Cast(targetType, operand));
}
case EdmExpressionKind.Record:
{
IEdmRecordExpression record = (IEdmRecordExpression)expression;
DelayedExpressionContext recordContext = new DelayedExpressionContext(this, context);
List <IEdmPropertyValue> propertyValues = new List <IEdmPropertyValue>();
//// Static validation will have checked that the set of supplied properties are appropriate
//// for the supplied type and have no duplicates, so those checks are not performed dynamically.
foreach (IEdmPropertyConstructor propertyConstructor in record.Properties)
{
propertyValues.Add(new DelayedRecordProperty(recordContext, propertyConstructor));
}
EdmStructuredValue result = new EdmStructuredValue(record.DeclaredType != null ? record.DeclaredType.AsStructured() : null, propertyValues);
return(result);
}
case EdmExpressionKind.Collection:
{
IEdmCollectionExpression collection = (IEdmCollectionExpression)expression;
DelayedExpressionContext collectionContext = new DelayedExpressionContext(this, context);
List <IEdmDelayedValue> elementValues = new List <IEdmDelayedValue>();
//// Static validation will have checked that the result types of the element expressions are
//// appropriate and so these checks are not performed dynamically.
foreach (IEdmExpression element in collection.Elements)
{
elementValues.Add(this.MapLabeledExpressionToDelayedValue(element, collectionContext, context));
}
EdmCollectionValue result = new EdmCollectionValue(collection.DeclaredType != null ? collection.DeclaredType.AsCollection() : null, elementValues);
return(result);
}
case EdmExpressionKind.LabeledExpressionReference:
{
return(this.MapLabeledExpressionToDelayedValue(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression, null, context).Value);
}
case EdmExpressionKind.Labeled:
return(this.MapLabeledExpressionToDelayedValue(expression, new DelayedExpressionContext(this, context), context).Value);
case EdmExpressionKind.EnumMember:
IEdmEnumMemberExpression enumMemberExpression = (IEdmEnumMemberExpression)expression;
var enumMembers = enumMemberExpression.EnumMembers.ToList();
IEdmEnumType enumType = enumMembers.First().DeclaringType;
IEdmEnumTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, false);
if (enumMembers.Count() == 1)
{
return(new EdmEnumValue(enumTypeReference, enumMemberExpression.EnumMembers.Single()));
}
else
{
if (!enumType.IsFlags || !EdmEnumValueParser.IsEnumIntegerType(enumType))
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Type {0} cannot be assigned with multi-values.", enumType.FullName()));
}
long result = 0;
foreach (var enumMember in enumMembers)
{
long value = enumMember.Value.Value;
result |= value;
}
return(new EdmEnumValue(enumTypeReference, new EdmEnumMemberValue(result)));
}
default:
throw new InvalidOperationException(Strings.Edm_Evaluator_UnrecognizedExpressionKind(((int)expression.ExpressionKind).ToString(System.Globalization.CultureInfo.InvariantCulture)));
}
}
private IEnumerable <IEdmEnumMember> ComputeReferenced()
{
IEnumerable <IEdmEnumMember> member;
return(EdmEnumValueParser.TryParseEnumMember(this.expression.EnumMemberPath, this.Schema.Model, this.Location, out member) ? member : null);
}