public void Constructor_SetsProperties()
{
var edmEnumMember = new EdmEnumMember("Read", 1);
Assert.Equal("Read", edmEnumMember.Name);
Assert.Equal(1, edmEnumMember.Value);
}
/// <inheritdoc/>
public override IEdmExpression ToEdmExpression()
{
var properties = new List <IEdmPropertyConstructor>();
if (_navigability.HasValue)
{
var enumType = new EdmEnumType("Org.OData.Capabilities.V1", "NavigationType", false);
var enumMember = new EdmEnumMember(enumType, _navigability.ToString(), new EdmEnumMemberValue((long)_navigability.Value));
properties.Add(new EdmPropertyConstructor("Navigability", new EdmEnumMemberExpression(enumMember)));
}
if (_restrictedProperties.Any())
{
var collection = _restrictedProperties.Select(item => item.ToEdmExpression()).Where(item => item != null);
if (collection.Any())
{
properties.Add(new EdmPropertyConstructor("RestrictedProperties", new EdmCollectionExpression(collection)));
}
}
if (!properties.Any())
{
return(null);
}
return(new EdmRecordExpression(properties));
}
public void GetClrValue()
{
Type type = typeof(AccessLevel);
var members = new EdmEnumMember[] { new EdmEnumMember("Read", 1) };
var edmEnumType = new EdmEnumType(type, members);
Assert.Equal(AccessLevel.Read, edmEnumType.GetClrValue("Read"));
}
public ODataAtomReaderEnumIntegrationTests()
{
this.userModel = new EdmModel();
// enum without flags
var enumType = new EdmEnumType("NS", "Color");
var red = new EdmEnumMember(enumType, "Red", new EdmIntegerConstant(1));
enumType.AddMember(red);
enumType.AddMember("Green", new EdmIntegerConstant(2));
enumType.AddMember("Blue", new EdmIntegerConstant(3));
this.userModel.AddElement(enumType);
// enum with flags
var enumFlagsType = new EdmEnumType("NS", "ColorFlags", isFlags: true);
enumFlagsType.AddMember("Red", new EdmIntegerConstant(1));
enumFlagsType.AddMember("Green", new EdmIntegerConstant(2));
enumFlagsType.AddMember("Blue", new EdmIntegerConstant(4));
this.userModel.AddElement(enumFlagsType);
this.entityType = new EdmEntityType("NS", "MyEntityType", isAbstract: false, isOpen: true, baseType: null);
EdmStructuralProperty floatId = new EdmStructuralProperty(this.entityType, "FloatId", EdmCoreModel.Instance.GetSingle(false));
this.entityType.AddKeys(floatId);
this.entityType.AddProperty(floatId);
var enumTypeReference = new EdmEnumTypeReference(enumType, true);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "Color", enumTypeReference));
var enumFlagsTypeReference = new EdmEnumTypeReference(enumFlagsType, false);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "ColorFlags", enumFlagsTypeReference));
// enum in complex type
EdmComplexType myComplexType = new EdmComplexType("NS", "MyComplexType");
myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "MyColorFlags", enumFlagsTypeReference));
myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "Height", EdmCoreModel.Instance.GetDouble(false)));
this.userModel.AddElement(myComplexType);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyComplexType", new EdmComplexTypeReference(myComplexType, true)));
// enum in collection type
EdmCollectionType myCollectionType = new EdmCollectionType(enumFlagsTypeReference);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyCollectionType", new EdmCollectionTypeReference(myCollectionType)));
this.userModel.AddElement(this.entityType);
var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer");
this.entitySet = new EdmEntitySet(defaultContainer, "MySet", this.entityType);
defaultContainer.AddEntitySet(this.entitySet.Name, this.entityType);
this.userModel.AddElement(defaultContainer);
}
internal static EdmEnumType CreateEdmEnumType(Type clrEnumType)
{
var edmEnumType = new EdmEnumType(clrEnumType.Namespace, clrEnumType.Name);
foreach (Enum clrMember in Enum.GetValues(clrEnumType))
{
long value = Convert.ToInt64(clrMember, CultureInfo.InvariantCulture);
var edmMember = new EdmEnumMember(edmEnumType, clrMember.ToString(), new EdmEnumMemberValue(value));
edmEnumType.AddMember(edmMember);
}
return(edmEnumType);
}
public void Constructor_SetsProperties()
{
Type type = typeof(AccessLevel);
var members = new EdmEnumMember[0];
var edmEnumType = new EdmEnumType(type, members);
Assert.Same(type, edmEnumType.ClrType);
Assert.Equal(type.FullName, edmEnumType.FullName);
Assert.Equal(type.Name, edmEnumType.Name);
Assert.Same(members, edmEnumType.Members);
}
public void GetEnumWorks()
{
// Arrange
IEdmEnumType enumType = new EdmEnumType("NS", "Color");
EdmEnumMember member = new EdmEnumMember(enumType, "Red", new EdmEnumMemberValue(2));
IEdmRecordExpression record = new EdmRecordExpression(
new EdmPropertyConstructor("prop", new EdmEnumMemberExpression(member)));
// Act
Color?actual = record.GetEnum <Color>("prop");
// Assert
Assert.NotNull(actual);
Assert.Equal(Color.Red, actual.Value);
}
public EnumFilterFunctionalTests()
{
// set up the edm model etc
this.userModel = new EdmModel();
var enumType = new EdmEnumType("NS", "Color", EdmPrimitiveTypeKind.Int32, false);
var red = new EdmEnumMember(enumType, "Red", new EdmEnumMemberValue(1));
enumType.AddMember(red);
enumType.AddMember("Green", new EdmEnumMemberValue(2));
enumType.AddMember("Blue", new EdmEnumMemberValue(3));
enumType.AddMember("White", new EdmEnumMemberValue(-10));
// add to model
this.userModel.AddElement(enumType);
// add enum property
this.entityType = new EdmEntityType("NS", "MyEntityType", isAbstract: false, isOpen: true, baseType: null);
var enumTypeReference = new EdmEnumTypeReference(enumType, true);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "Color", enumTypeReference));
// enum with flags
var enumFlagsType = new EdmEnumType("NS", "ColorFlags", EdmPrimitiveTypeKind.Int64, true);
enumFlagsType.AddMember("Red", new EdmEnumMemberValue(1L));
enumFlagsType.AddMember("Green", new EdmEnumMemberValue(2L));
enumFlagsType.AddMember("Blue", new EdmEnumMemberValue(4L));
enumFlagsType.AddMember("GreenRed", new EdmEnumMemberValue(3L));
// add to model
this.userModel.AddElement(enumFlagsType);
// add enum with flags
var enumFlagsTypeReference = new EdmEnumTypeReference(enumFlagsType, true);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "ColorFlags", enumFlagsTypeReference));
this.userModel.AddElement(this.entityType);
var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer");
this.userModel.AddElement(defaultContainer);
this.entitySet = new EdmEntitySet(defaultContainer, "MySet", this.entityType);
defaultContainer.AddElement(this.entitySet);
}
private IEdmEnumMember ConvertToStockMember(IEdmEnumMember edmMember, IEdmModel edmModel, EdmModel stockModel)
{
var stockMemberDeclaringType = stockModel.FindType(GetFullName(edmMember.DeclaringType)) as IEdmEnumType;
var stockMember = new EdmEnumMember(
stockMemberDeclaringType,
edmMember.Name,
edmMember.Value
);
((EdmEnumType)stockMemberDeclaringType).AddMember(stockMember);
// TODO: Documentation
this.SetImmediateAnnotations(edmMember, stockMember, edmModel, stockModel);
return(stockMember);
}
public void EdmEnumMemberReferenceExpression()
{
var et = new EdmEnumType("NS", "Spicy");
var em = new EdmEnumMember(et, "Hot", new EdmIntegerConstant(5));
var e = new EdmEnumMemberReferenceExpression(em);
Assert.AreEqual(EdmExpressionKind.EnumMemberReference, e.ExpressionKind, "e.ExpressionKind");
Assert.AreEqual("Hot", e.ReferencedEnumMember.Name, "e.ReferencedEnumMember");
Assert.IsFalse(e.IsBad(), "e good");
this.VerifyThrowsException(typeof(ArgumentNullException), () => new EdmEnumMemberReferenceExpression(null));
var ee = new MutableEdmEnumMemberReferenceExpression();
Assert.IsNull(ee.ReferencedEnumMember, "e.ReferencedEntitySet");
Assert.IsTrue(ee.IsBad(), "Expression is bad.");
Assert.AreEqual(1, ee.Errors().Count(), "Expression has errors");
}
public void EdmEnumMemberExpression()
{
var et = new EdmEnumType("NS", "Spicy");
var em = new EdmEnumMember(et, "Hot", new EdmEnumMemberValue(5));
var e = new EdmEnumMemberExpression(em);
Assert.AreEqual(EdmExpressionKind.EnumMember, e.ExpressionKind, "e.ExpressionKind");
Assert.AreEqual("Hot", e.EnumMembers.Single().Name, "e.EnumMembers");
Assert.IsFalse(e.IsBad(), "e good");
this.VerifyThrowsException(typeof(ArgumentNullException), () => new EdmEnumMemberExpression(null));
var ee = new MutableEdmEnumMemberExpression();
Assert.IsNull(ee.EnumMembers, "e.EnumMembers");
Assert.IsTrue(ee.IsBad(), "Expression is bad.");
Assert.AreEqual(1, ee.Errors().Count(), "Expression has errors");
}
/// <inheritdoc/>
public override IEdmExpression ToEdmExpression()
{
var properties = new List <IEdmPropertyConstructor>();
if (_conformanceLevel.HasValue)
{
var enumType = new EdmEnumType("Org.OData.Capabilities.V1", "ConformanceLevelType", false);
var enumMember = new EdmEnumMember(enumType, _conformanceLevel.ToString(), new EdmEnumMemberValue((long)_conformanceLevel.Value));
properties.Add(new EdmPropertyConstructor("ConformanceLevel", new EdmEnumMemberExpression(enumMember)));
}
if (!properties.Any())
{
return(null);
}
return(new EdmRecordExpression(properties));
}
/// <inheritdoc/>
public override IEdmExpression ToEdmExpression()
{
var properties = new List <IEdmPropertyConstructor>();
if (_isolationSupported.HasValue)
{
var enumType = new EdmEnumType("Org.OData.Capabilities.V1", "IsolationLevel", true);
var enumMember = new EdmEnumMember(enumType, _isolationSupported.ToString(), new EdmEnumMemberValue((long)_isolationSupported.Value));
properties.Add(new EdmPropertyConstructor("IsolationSupported", new EdmEnumMemberExpression(enumMember)));
}
if (!properties.Any())
{
return(null);
}
return(new EdmRecordExpression(properties));
}
private EdmEnumType BuildEnumType(RdmEnumType definition)
{
var edmType = edmModel.FindType(rdmModel.Namespace.NamespaceName + "." + definition.Name) as EdmEnumType;
var flags = definition.IsFlags;
for (int i = 0; i < definition.Members.Count; i++)
{
var elem = definition.Members[i];
var value = flags ? (1 << i) : i;
var member = new EdmEnumMember(edmType, elem.Name, new EdmEnumMemberValue(value));
edmType.AddMember(member);
foreach (var annotation in elem.Annotations)
{
annotationBuilder.AddAnnotation(edmModel, member, annotation);
}
}
return(edmType);
}
/// <inheritdoc/>
public override IEdmExpression ToEdmExpression()
{
var properties = new List <IEdmPropertyConstructor>();
if (_searchable.HasValue)
{
properties.Add(new EdmPropertyConstructor("Searchable", new EdmBooleanConstant(_searchable.Value)));
}
if (_unsupportedExpressions.HasValue)
{
var enumType = new EdmEnumType("Org.OData.Capabilities.V1", "SearchExpressions", true);
var enumMember = new EdmEnumMember(enumType, _unsupportedExpressions.ToString(), new EdmEnumMemberValue((long)_unsupportedExpressions.Value));
properties.Add(new EdmPropertyConstructor("UnsupportedExpressions", new EdmEnumMemberExpression(enumMember)));
}
if (!properties.Any())
{
return(null);
}
return(new EdmRecordExpression(properties));
}
private void CreateEnumTypeBody(EdmEnumType type, EnumTypeConfiguration config)
{
Contract.Assert(type != null);
Contract.Assert(config != null);
foreach (EnumMemberConfiguration member in config.Members)
{
// EdmIntegerConstant can only support a value of long type.
long value;
try
{
value = Convert.ToInt64(member.MemberInfo, CultureInfo.InvariantCulture);
}
catch
{
throw Error.Argument("value", SRResources.EnumValueCannotBeLong, Enum.GetName(member.MemberInfo.GetType(), member.MemberInfo));
}
EdmEnumMember edmMember = new EdmEnumMember(type, member.Name,
new EdmEnumMemberValue(value));
type.AddMember(edmMember);
_members[member.MemberInfo] = edmMember;
}
}
/// <inheritdoc/>
public IEdmExpression ToEdmExpression()
{
var properties = new List <IEdmPropertyConstructor>();
if (_navigationProperty != null)
{
properties.Add(new EdmPropertyConstructor("NavigationProperty", _navigationProperty));
}
if (_navigability.HasValue)
{
var enumType = new EdmEnumType("Org.OData.Capabilities.V1", "NavigationType", false);
var enumMember = new EdmEnumMember(enumType, _navigability.ToString(), new EdmEnumMemberValue((long)_navigability.Value));
properties.Add(new EdmPropertyConstructor("Navigability", new EdmEnumMemberExpression(enumMember)));
}
if (_filterFunctions.Any())
{
var collection = _filterFunctions.Select(item => item.ToEdmExpression()).Where(item => item != null);
if (collection.Any())
{
properties.Add(new EdmPropertyConstructor("FilterFunctions", new EdmCollectionExpression(collection)));
}
}
if (_filterRestrictions != null)
{
properties.Add(new EdmPropertyConstructor("FilterRestrictions", _filterRestrictions.ToEdmExpression()));
}
if (_searchRestrictions != null)
{
properties.Add(new EdmPropertyConstructor("SearchRestrictions", _searchRestrictions.ToEdmExpression()));
}
if (_sortRestrictions != null)
{
properties.Add(new EdmPropertyConstructor("SortRestrictions", _sortRestrictions.ToEdmExpression()));
}
if (_topSupported.HasValue)
{
properties.Add(new EdmPropertyConstructor("TopSupported", new EdmBooleanConstant(_topSupported.Value)));
}
if (_skipSupported.HasValue)
{
properties.Add(new EdmPropertyConstructor("SkipSupported", new EdmBooleanConstant(_skipSupported.Value)));
}
if (_selectSupport != null)
{
properties.Add(new EdmPropertyConstructor("SelectSupport", _selectSupport.ToEdmExpression()));
}
if (_indexableByKey.HasValue)
{
properties.Add(new EdmPropertyConstructor("IndexableByKey", new EdmBooleanConstant(_indexableByKey.Value)));
}
if (_insertRestrictions != null)
{
properties.Add(new EdmPropertyConstructor("InsertRestrictions", _insertRestrictions.ToEdmExpression()));
}
if (_deepInsertSupport != null)
{
properties.Add(new EdmPropertyConstructor("DeepInsertSupport", _deepInsertSupport.ToEdmExpression()));
}
if (_updateRestrictions != null)
{
properties.Add(new EdmPropertyConstructor("UpdateRestrictions", _updateRestrictions.ToEdmExpression()));
}
if (_deepUpdateSupport != null)
{
properties.Add(new EdmPropertyConstructor("DeepUpdateSupport", _deepUpdateSupport.ToEdmExpression()));
}
if (_deleteRestrictions != null)
{
properties.Add(new EdmPropertyConstructor("DeleteRestrictions", _deleteRestrictions.ToEdmExpression()));
}
if (_optimisticConcurrencyControl.HasValue)
{
properties.Add(new EdmPropertyConstructor("OptimisticConcurrencyControl", new EdmBooleanConstant(_optimisticConcurrencyControl.Value)));
}
if (_readRestrictions != null)
{
properties.Add(new EdmPropertyConstructor("ReadRestrictions", _readRestrictions.ToEdmExpression()));
}
if (!properties.Any())
{
return(null);
}
return(new EdmRecordExpression(properties));
}
