public ODataJsonLightCollectionWriterTests()
{
collectionStartWithoutSerializationInfo = new ODataCollectionStart();
collectionStartWithSerializationInfo = new ODataCollectionStart();
collectionStartWithSerializationInfo.SetSerializationInfo(new ODataCollectionStartSerializationInfo {
CollectionTypeName = "Collection(ns.Address)"
});
address = new ODataComplexValue {
Properties = new[] { new ODataProperty {
Name = "Street", Value = "1 Microsoft Way"
}, new ODataProperty {
Name = "Zipcode", Value = 98052
}, new ODataProperty {
Name = "State", Value = new ODataEnumValue("WA", "ns.StateEnum")
} }
};
items = new[] { address };
EdmComplexType addressType = new EdmComplexType("ns", "Address");
addressType.AddProperty(new EdmStructuralProperty(addressType, "Street", EdmCoreModel.Instance.GetString(isNullable: true)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "Zipcode", EdmCoreModel.Instance.GetInt32(isNullable: true)));
var stateEnumType = new EdmEnumType("ns", "StateEnum", isFlags: true);
stateEnumType.AddMember("IL", new EdmIntegerConstant(1));
stateEnumType.AddMember("WA", new EdmIntegerConstant(2));
addressType.AddProperty(new EdmStructuralProperty(addressType, "State", new EdmEnumTypeReference(stateEnumType, true)));
addressTypeReference = new EdmComplexTypeReference(addressType, isNullable: false);
}
public ODataJsonLightValueSerializerAsyncTests()
{
this.model = new EdmModel();
this.colorEnumType = new EdmEnumType("NS", "Color");
colorEnumType.AddMember(new EdmEnumMember(colorEnumType, "Black", new EdmEnumMemberValue(0)));
colorEnumType.AddMember(new EdmEnumMember(colorEnumType, "White", new EdmEnumMemberValue(1)));
this.model.AddElement(this.colorEnumType);
attributesComplexType = new EdmComplexType("NS", "Attributes");
attributesComplexType.AddStructuralProperty("LuckyNumber", EdmPrimitiveTypeKind.Int32);
attributesComplexType.AddStructuralProperty("FavoriteColor", new EdmEnumTypeReference(colorEnumType, false));
this.model.AddElement(this.attributesComplexType);
EdmComplexTypeReference attributesComplexTypeRef = new EdmComplexTypeReference(attributesComplexType, true);
this.entityType = new EdmEntityType("NS", "EntityType");
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
entityType.AddStructuralProperty("Attributes", new EdmCollectionTypeReference(new EdmCollectionType(attributesComplexTypeRef)));
this.model.AddElement(this.entityType);
this.stream = new MemoryStream();
this.settings = new ODataMessageWriterSettings {
EnableMessageStreamDisposal = false, Version = ODataVersion.V4
};
this.settings.SetServiceDocumentUri(new Uri("http://tempuri.org"));
}
public static IEdmModel SimpleOpenTypeModel()
{
var model = new EdmModel();
// Address is an open complex type
var addressType = new EdmComplexType("Default", "Address", null, false, true);
addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
model.AddElement(addressType);
// ZipCode is an open complex type also
var zipCodeType = new EdmComplexType("Default", "ZipCode", null, false, true);
zipCodeType.AddStructuralProperty("Code", EdmPrimitiveTypeKind.Int32);
model.AddElement(zipCodeType);
// Enum type simpleEnum
EdmEnumType simpleEnum = new EdmEnumType("Default", "SimpleEnum");
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "First", new EdmIntegerConstant(0)));
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Second", new EdmIntegerConstant(1)));
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Third", new EdmIntegerConstant(2)));
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Fourth", new EdmIntegerConstant(3)));
model.AddElement(simpleEnum);
var container = new EdmEntityContainer("Default", "Container");
model.AddElement(container);
return(model);
}
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 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 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());
}
public async Task WriteItemAsync_WritesEnumCollectionItem(string enumValue, string expected)
{
var model = new EdmModel();
var colorEnumType = new EdmEnumType("NS", "Color");
colorEnumType.AddMember(new EdmEnumMember(colorEnumType, "Black", new EdmEnumMemberValue(0)));
colorEnumType.AddMember(new EdmEnumMember(colorEnumType, "White", new EdmEnumMemberValue(0)));
model.AddElement(colorEnumType);
var collectionStart = new ODataCollectionStart
{
SerializationInfo = new ODataCollectionStartSerializationInfo
{
CollectionTypeName = "Collection(NS.Color)"
}
};
var itemTypeReference = new EdmEnumTypeReference(colorEnumType, true);
var result = await SetupJsonLightCollectionWriterAndRunTestAsync(
async (jsonLightCollectionWriter) =>
{
await jsonLightCollectionWriter.WriteStartAsync(collectionStart);
await jsonLightCollectionWriter.WriteItemAsync(new ODataEnumValue(enumValue));
await jsonLightCollectionWriter.WriteEndAsync();
},
model,
itemTypeReference);
Assert.Equal("{\"@odata.context\":\"http://odata.org/test/$metadata#Collection(NS.Color)\"," +
$"\"value\":[{expected}]}}", result);
}
public void ParseWithCustomFunction_EnumParameter()
{
try
{
var enumType = new EdmEnumType("Fully.Qualified.Namespace", "NonFlagShape", EdmPrimitiveTypeKind.SByte, false);
enumType.AddMember("Rectangle", new EdmEnumMemberValue(1));
enumType.AddMember("Triangle", new EdmEnumMemberValue(2));
enumType.AddMember("foursquare", new EdmEnumMemberValue(3));
var enumTypeRef = new EdmEnumTypeReference(enumType, false);
FunctionSignatureWithReturnType signature =
new FunctionSignatureWithReturnType(EdmCoreModel.Instance.GetBoolean(false), enumTypeRef);
CustomUriFunctions.AddCustomUriFunction("enumFunc", signature);
var fullUri = new Uri("http://www.odata.com/OData/People" + "?$filter=enumFunc('Rectangle')");
ODataUriParser parser = new ODataUriParser(HardCodedTestModel.TestModel, new Uri("http://www.odata.com/OData/"), fullUri);
var enumFuncWithArgs = parser.ParseFilter().Expression.ShouldBeSingleValueFunctionCallQueryNode("enumFunc").Parameters.ToList();
enumFuncWithArgs[0].ShouldBeEnumNode(enumType, "Rectangle");
}
finally
{
Assert.True(CustomUriFunctions.RemoveCustomUriFunction("enumFunc"));
}
}
private static IEdmModel GetEdmModel()
{
EdmModel model = new EdmModel();
// Enum type
EdmEnumType enumType = new EdmEnumType("NS", "TestEnum");
enumType.AddMember(new EdmEnumMember(enumType, "FirstValue", new EdmEnumMemberValue(0)));
enumType.AddMember(new EdmEnumMember(enumType, "FirstValue", new EdmEnumMemberValue(1)));
model.AddElement(enumType);
model.SetAnnotationValue(model.FindDeclaredType("NS.TestEnum"), new ClrTypeAnnotation(typeof(TestEnum)));
// Entity type
EdmEntityType productType = new EdmEntityType("NS", "Product");
productType.AddKeys(productType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
model.AddElement(productType);
model.SetAnnotationValue(model.FindDeclaredType("NS.Product"), new ClrTypeAnnotation(typeof(Product)));
// Complex type
EdmComplexType address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
model.AddElement(address);
model.SetAnnotationValue(model.FindDeclaredType("NS.Address"), new ClrTypeAnnotation(typeof(Address)));
return(model);
}
private void InitializeModel()
{
this.model = new EdmModel();
var colorEnumType = new EdmEnumType("NS", "Color");
colorEnumType.AddMember(new EdmEnumMember(colorEnumType, "Black", new EdmEnumMemberValue(0)));
colorEnumType.AddMember(new EdmEnumMember(colorEnumType, "White", new EdmEnumMemberValue(0)));
this.model.AddElement(colorEnumType);
}
public void RoundTripEnumsWithValues()
{
var directionType = new EdmEnumType("NS1", "Direction");
directionType.AddMember("East", new EdmEnumMemberValue(100L));
directionType.AddMember("West", new EdmEnumMemberValue(1L));
directionType.AddMember("South", new EdmEnumMemberValue(-2L));
directionType.AddMember("North", new EdmEnumMemberValue(3L));
this.BasicRoundtripTest(ModelBuilder.ModelWithEnumEdm(directionType));
}
public void RoundTripEnumsWithFlagsandUnderlyingInt64()
{
var directionType = new EdmEnumType("NS1", "Direction", EdmPrimitiveTypeKind.Int64, isFlags: true);
directionType.AddMember("East", new EdmEnumMemberValue(0L));
directionType.AddMember("West", new EdmEnumMemberValue(1L));
directionType.AddMember("South", new EdmEnumMemberValue(2L));
directionType.AddMember("North", new EdmEnumMemberValue(3L));
this.BasicRoundtripTest(ModelBuilder.ModelWithEnumEdm(directionType));
}
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);
}
private static IEdmModel GetEnumModel()
{
EdmModel model = new EdmModel();
EdmEnumType enumType = new EdmEnumType("TestModel", "TestEnum");
enumType.AddMember(new EdmEnumMember(enumType, "FirstValue", new EdmEnumMemberValue(0)));
enumType.AddMember(new EdmEnumMember(enumType, "FirstValue", new EdmEnumMemberValue(1)));
model.AddElement(enumType);
model.SetAnnotationValue(model.FindDeclaredType("TestModel.TestEnum"), new ClrTypeAnnotation(typeof(TestEnum)));
return(model);
}
public void GetClrTypeNameShouldReturnICollectionStructureTemplateForCollectionOfEnumType()
{
var gender = new EdmEnumType("Namespace", "Gender", EdmPrimitiveTypeKind.Byte, true);
gender.AddMember("Male", new EdmEnumMemberValue(1));
gender.AddMember("Female", new EdmEnumMemberValue(2));
IEdmTypeReference elementTypeReference = new EdmTypeReferenceForTest(gender, false);
IEdmCollectionType collectionType = new EdmCollectionType(elementTypeReference);
IEdmTypeReference collectionTypeReference = new EdmTypeReferenceForTest(collectionType, false);
ODataT4CodeGenerator.Utils.GetClrTypeName(collectionTypeReference, false, template, context, true, true, true)
.Should().Be("global::System.Collections.Generic.ICollection<global::NamespacePrefix.Gender>");
}
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 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 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 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 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 IHttpActionResult Get(int key)
{
EdmEntityType customerType = new EdmEntityType("NS", "UntypedSimpleOpenCustomer", null, false, true);
customerType.AddKeys(customerType.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32));
EdmEntityObject customer = new EdmEntityObject(customerType);
customer.TrySetPropertyValue("CustomerId", 1);
EdmEnumType colorType = new EdmEnumType("NS", "Color");
colorType.AddMember(new EdmEnumMember(colorType, "Red", new EdmIntegerConstant(0)));
EdmEnumObject color = new EdmEnumObject(colorType, "Red");
EdmEnumObject color2 = new EdmEnumObject(colorType, "0");
customer.TrySetPropertyValue("Color", color);
List <IEdmEnumObject> colorList = new List <IEdmEnumObject>();
colorList.Add(color);
colorList.Add(color2);
IEdmCollectionTypeReference collectionType = new EdmCollectionTypeReference(new EdmCollectionType(colorType.ToEdmTypeReference(false)));
EdmEnumObjectCollection colors = new EdmEnumObjectCollection(collectionType, colorList);
customer.TrySetPropertyValue("Colors", colors);
return(Ok(customer));
}
private static IEdmModel BuildEdmModel()
{
var model = new EdmModel();
// open complex type address
EdmComplexType address = new EdmComplexType("NS", "Address", null, false, true);
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
model.AddElement(address);
// enum type color
EdmEnumType color = new EdmEnumType("NS", "Color");
color.AddMember(new EdmEnumMember(color, "Red", new EdmIntegerConstant(0)));
model.AddElement(color);
// open entity type customer
EdmEntityType customer = new EdmEntityType("NS", "Customer", null, false, true);
customer.AddKeys(customer.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String, false);
customer.AddStructuralProperty("Color", new EdmEnumTypeReference(color, isNullable: true));
model.AddElement(customer);
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
container.AddEntitySet("Customers", customer);
model.AddElement(container);
return(model);
}
private static IEdmEnumTypeReference GetEnumTypeReference(
EdmProperty efProperty,
EdmModel model,
IDictionary <MetadataItem, IEdmElement> elementMap)
{
var efEnumType = efProperty.EnumType;
EdmEnumType enumType;
IEdmElement element;
if (elementMap.TryGetValue(efEnumType, out element))
{
enumType = (EdmEnumType)element;
}
else
{
enumType = new EdmEnumType(efEnumType.NamespaceName, efEnumType.Name);
elementMap.Add(efEnumType, enumType);
model.AddElement(enumType);
foreach (var member in efEnumType.Members)
{
var longValue = Convert.ToInt64(member.Value, CultureInfo.InvariantCulture);
enumType.AddMember(member.Name, new EdmIntegerConstant(longValue));
}
}
return(new EdmEnumTypeReference(enumType, efProperty.Nullable));
}
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);
}
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);
}
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 JsonLightInstanceAnnotationWriterAsyncTests()
{
this.model = new EdmModel();
this.dayEnumType = new EdmEnumType("NS", "Day");
dayEnumType.AddMember(new EdmEnumMember(dayEnumType, "Monday", new EdmEnumMemberValue(0)));
dayEnumType.AddMember(new EdmEnumMember(dayEnumType, "Tuesday", new EdmEnumMemberValue(1)));
dayEnumType.AddMember(new EdmEnumMember(dayEnumType, "Wednesday", new EdmEnumMemberValue(2)));
dayEnumType.AddMember(new EdmEnumMember(dayEnumType, "Thursday", new EdmEnumMemberValue(3)));
dayEnumType.AddMember(new EdmEnumMember(dayEnumType, "Friday", new EdmEnumMemberValue(4)));
dayEnumType.AddMember(new EdmEnumMember(dayEnumType, "Saturday", new EdmEnumMemberValue(5)));
dayEnumType.AddMember(new EdmEnumMember(dayEnumType, "Sunday", new EdmEnumMemberValue(6)));
this.model.AddElement(this.dayEnumType);
mealComplexType = new EdmComplexType("NS", "Meal");
mealComplexType.AddStructuralProperty("Starter", EdmPrimitiveTypeKind.String);
mealComplexType.AddStructuralProperty("MainCourse", EdmPrimitiveTypeKind.String);
mealComplexType.AddStructuralProperty("Dessert", EdmPrimitiveTypeKind.String);
this.model.AddElement(this.mealComplexType);
this.stream = new MemoryStream();
this.settings = new ODataMessageWriterSettings
{
EnableMessageStreamDisposal = false,
Version = ODataVersion.V4
};
this.settings.SetServiceDocumentUri(new Uri("http://tempuri.org"));
}
public static IEdmModel GetUntypedEdmModel()
{
if (_untypedEdmModel != null)
{
return(_untypedEdmModel);
}
var model = new EdmModel();
// complex type address
EdmComplexType address = new EdmComplexType("NS", "Address", null, false, true);
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
model.AddElement(address);
IEdmCollectionTypeReference complexCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(address.ToEdmTypeReference(false)));
// enum type color
EdmEnumType color = new EdmEnumType("NS", "Color");
color.AddMember(new EdmEnumMember(color, "Red", new EdmEnumMemberValue(0)));
model.AddElement(color);
IEdmCollectionTypeReference enumCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(color.ToEdmTypeReference(false)));
// primitive collection type
IEdmTypeReference intType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: true);
EdmCollectionTypeReference primitiveCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(intType));
// entity type customer
EdmEntityType customer = new EdmEntityType("NS", "UntypedSimpleOpenCustomer", null, false, true);
customer.AddKeys(customer.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Color", new EdmEnumTypeReference(color, isNullable: true));
customer.AddStructuralProperty("DeclaredAddresses", complexCollectionType);
customer.AddStructuralProperty("DeclaredColors", enumCollectionType);
customer.AddStructuralProperty("DeclaredNumbers", primitiveCollectionType);
model.AddElement(customer);
EdmAction action = new EdmAction(
"NS",
"AddColor",
null,
isBound: true,
entitySetPathExpression: null);
action.AddParameter("bindingParameter", new EdmEntityTypeReference(customer, false));
action.AddParameter("Color", new EdmEnumTypeReference(color, true));
model.AddElement(action);
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
container.AddEntitySet("UntypedSimpleOpenCustomers", customer);
model.AddElement(container);
_untypedEdmModel = model;
return(model);
}
public static IEdmModel BuildEdmModel()
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(DefaultNamespace, "DefaultContainer");
model.AddElement(defaultContainer);
// Create an Enum type.
var colorType = new EdmEnumType(DefaultNamespace, "Color", isFlags: false);
colorType.AddMember("Red", new EdmIntegerConstant(1));
colorType.AddMember("Green", new EdmIntegerConstant(2));
colorType.AddMember("Blue", new EdmIntegerConstant(4));
model.AddElement(colorType);
// Create another Enum type with isFlage=true.
var accessLevelType = new EdmEnumType(DefaultNamespace, "AccessLevel", isFlags: true);
accessLevelType.AddMember("None", new EdmIntegerConstant(0));
accessLevelType.AddMember("Read", new EdmIntegerConstant(1));
accessLevelType.AddMember("Write", new EdmIntegerConstant(2));
accessLevelType.AddMember("Execute", new EdmIntegerConstant(4));
accessLevelType.AddMember("ReadWrite", new EdmIntegerConstant(3));
model.AddElement(accessLevelType);
// Create an Entity type which contains Enum properties.
var productType = new EdmEntityType(DefaultNamespace, "Product");
var ProductIdProperty = new EdmStructuralProperty(productType, "ProductId", EdmCoreModel.Instance.GetInt32(false));
productType.AddProperty(ProductIdProperty);
productType.AddKeys(ProductIdProperty);
productType.AddProperty(new EdmStructuralProperty(productType, "Name", EdmCoreModel.Instance.GetString(false)));
productType.AddProperty(new EdmStructuralProperty(productType, "UserAccess", new EdmEnumTypeReference(accessLevelType, true)));
productType.AddProperty(new EdmStructuralProperty(productType, "SkinColor", new EdmEnumTypeReference(colorType, true)));
model.AddElement(productType);
var productSet = new EdmEntitySet(defaultContainer, "Products", productType);
defaultContainer.AddElement(productSet);
return(model);
}
public static IEdmModel SimpleOpenTypeModel()
{
var model = new EdmModel();
// Address is an open complex type
var addressType = new EdmComplexType("Default", "Address", null, false, true);
addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
model.AddElement(addressType);
// ZipCode is an open complex type also
var zipCodeType = new EdmComplexType("Default", "ZipCode", null, false, true);
zipCodeType.AddStructuralProperty("Code", EdmPrimitiveTypeKind.Int32);
model.AddElement(zipCodeType);
// Enum type simpleEnum
EdmEnumType simpleEnum = new EdmEnumType("Default", "SimpleEnum");
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "First", new EdmEnumMemberValue(0)));
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Second", new EdmEnumMemberValue(1)));
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Third", new EdmEnumMemberValue(2)));
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Fourth", new EdmEnumMemberValue(3)));
model.AddElement(simpleEnum);
// Customer is an open entity type
var customerType = new EdmEntityType("Default", "Customer", null, false, true);
customerType.AddKeys(customerType.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32));
customerType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
customerType.AddStructuralProperty("Address", addressType.ToEdmTypeReference(false));
model.AddElement(customerType);
var container = new EdmEntityContainer("Default", "Container");
model.AddElement(container);
var customers = new EdmEntitySet(container, "Customers", customerType);
container.AddElement(customers);
return(model);
}