public void EdmSingletonAnnotationTests() { EdmModel model = new EdmModel(); EdmStructuralProperty customerProperty = new EdmStructuralProperty(customerType, "Name", EdmCoreModel.Instance.GetString(false)); customerType.AddProperty(customerProperty); model.AddElement(this.customerType); EdmSingleton vipCustomer = new EdmSingleton(this.entityContainer, "VIP", this.customerType); EdmTerm term = new EdmTerm(myNamespace, "SingletonAnnotation", EdmPrimitiveTypeKind.String); var annotation = new EdmAnnotation(vipCustomer, term, new EdmStringConstant("Singleton Annotation")); model.AddVocabularyAnnotation(annotation); var singletonAnnotation = vipCustomer.VocabularyAnnotations(model).Single(); Assert.Equal(vipCustomer, singletonAnnotation.Target); Assert.Equal("SingletonAnnotation", singletonAnnotation.Term.Name); singletonAnnotation = model.FindDeclaredVocabularyAnnotations(vipCustomer).Single(); Assert.Equal(vipCustomer, singletonAnnotation.Target); Assert.Equal("SingletonAnnotation", singletonAnnotation.Term.Name); EdmTerm propertyTerm = new EdmTerm(myNamespace, "SingletonPropertyAnnotation", EdmPrimitiveTypeKind.String); var propertyAnnotation = new EdmAnnotation(customerProperty, propertyTerm, new EdmStringConstant("Singleton Property Annotation")); model.AddVocabularyAnnotation(propertyAnnotation); var singletonPropertyAnnotation = customerProperty.VocabularyAnnotations(model).Single(); Assert.Equal(customerProperty, singletonPropertyAnnotation.Target); Assert.Equal("SingletonPropertyAnnotation", singletonPropertyAnnotation.Term.Name); }
public void AmbiguousValueTermTest() { EdmModel model = new EdmModel(); IEdmValueTerm term1 = new EdmTerm("Foo", "Bar", EdmPrimitiveTypeKind.Byte); IEdmValueTerm term2 = new EdmTerm("Foo", "Bar", EdmPrimitiveTypeKind.Decimal); IEdmValueTerm term3 = new EdmTerm("Foo", "Bar", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Double, false)); Assert.AreEqual(EdmTermKind.Value, term1.TermKind, "EdmTermKind is correct."); model.AddElement(term1); Assert.AreEqual(term1, model.FindValueTerm("Foo.Bar"), "Correct item."); model.AddElement(term2); model.AddElement(term3); IEdmValueTerm ambiguous = model.FindValueTerm("Foo.Bar"); Assert.IsTrue(ambiguous.IsBad(), "Ambiguous binding is bad"); Assert.AreEqual(EdmSchemaElementKind.ValueTerm, ambiguous.SchemaElementKind, "Correct schema element kind."); Assert.AreEqual("Foo", ambiguous.Namespace, "Correct Namespace"); Assert.AreEqual("Bar", ambiguous.Name, "Correct Name"); Assert.AreEqual(EdmTermKind.Value, ambiguous.TermKind, "Correct term kind."); Assert.IsTrue(ambiguous.Type.IsBad(), "Type is bad."); }
private static void EnumMemberExpressionDemo() { Console.WriteLine("EnumMemberExpressionDemo"); var model = new EdmModel(); var personType = new EdmEntityType("TestNS", "Person"); model.AddElement(personType); var pid = personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false); personType.AddKeys(pid); personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); var colorType = new EdmEnumType("TestNS2", "Color", true); model.AddElement(colorType); colorType.AddMember("Cyan", new EdmIntegerConstant(1)); colorType.AddMember("Blue", new EdmIntegerConstant(2)); var outColorTerm = new EdmTerm("TestNS", "OutColor", new EdmEnumTypeReference(colorType, true)); model.AddElement(outColorTerm); var exp = new EdmEnumMemberExpression( new EdmEnumMember(colorType, "Blue", new EdmIntegerConstant(2)) ); var annotation = new EdmAnnotation(personType, outColorTerm, exp); annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline); model.SetVocabularyAnnotation(annotation); ShowModel(model); var ann = model.FindVocabularyAnnotations<IEdmValueAnnotation>(personType, "TestNS.OutColor").First(); var memberExp = (IEdmEnumMemberExpression)ann.Value; foreach (var member in memberExp.EnumMembers) { Console.WriteLine(member.Name); } }
public void EnsureDuplicateTermAndFunctionReturnTrue() { EdmModel model = new EdmModel(); var edmFunction = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetString(true), false /*isBound*/, null /*entitySetPath*/, false /*isComposable*/); model.AddElement(edmFunction); EdmModel otherModel = new EdmModel(); var edmTerm = new EdmTerm("n.s", "GetStuff", EdmPrimitiveTypeKind.Int32); otherModel.AddElement(edmTerm); model.AddReferencedModel(otherModel); model.OperationOrNameExistsInReferencedModel(edmFunction, edmFunction.FullName()).Should().BeTrue(); }
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullOnlyModel() { var model = new EdmModel(); var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetString(true)); model.AddElement(valueTerm); var valueAnnotation = new MutableValueAnnotation() { Target = valueTerm }; model.AddVocabularyAnnotation(valueAnnotation); return model; }
public static IEdmModel EdmValueKindInterfaceCriticalKindValueUnexpectedOnlyModel() { var model = new EdmModel(); var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetString(true)); model.AddElement(valueTerm); var badString = new CustomStringConstant("foo", EdmExpressionKind.StringConstant, (EdmValueKind)123); var valueAnnotation = new EdmAnnotation( valueTerm, valueTerm, badString); model.AddVocabularyAnnotation(valueAnnotation); return model; }
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingCollectionTypeModel() { var model = new EdmModel(); var badType = new CustomCollectionType(null, EdmTypeKind.Collection); var badTypeRef = new EdmCollectionTypeReference(badType); var valueTerm = new EdmTerm("NS", "Note", badTypeRef); model.AddElement(valueTerm); return model; }
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingEnumValueNullMemberModel() { var model = new EdmModel(); var enumType = new EdmEnumType("NS", "Enum"); var enumMember = new CustomEnumMember(enumType, "foo", null); var enumTypeRef = new EdmEnumTypeReference(enumType, true); enumType.AddMember(new EdmEnumMember(enumType, "bar", new EdmEnumValue(enumTypeRef, enumMember))); var valueTerm = new EdmTerm("NS", "Note", enumTypeRef); model.AddElement(valueTerm); return model; }
public static IEdmModel InterfaceCriticalKindValueMismatchOnlyUsingCollectionTypeReferenceModel() { var model = new EdmModel(); var badType = new CustomCollectionType(new EdmStringTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), false), EdmTypeKind.Enum); var badTypeRef = new EdmCollectionTypeReference(badType); var valueTerm = new EdmTerm("NS", "Note", badTypeRef); model.AddElement(valueTerm); return model; }
public static IEdmModel InterfaceCriticalKindValueMismatchOnlyUsingEnumTypeReferenceModel() { var model = new EdmModel(); var badType = new CustomEnumType("NS", "Enum", EdmTypeKind.Complex); var badTypeRef = new EdmEnumTypeReference(badType, true); var valueTerm = new EdmTerm("NS", "Note", badTypeRef); model.AddElement(valueTerm); return model; }
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingEnumTypeReferenceModel() { var model = new EdmModel(); var badType = new CustomEnumType("NS", "Enum", (IEdmPrimitiveType)null); var badTypeRef = new EdmEnumTypeReference(badType, true); var valueTerm = new EdmTerm("NS", "Note", badTypeRef); model.AddElement(valueTerm); return model; }
public static IEdmModel InterfaceCriticalKindValueUnexpectedWithOtherErrorsModel() { var model = new EdmModel(); var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetString(true)); model.AddElement(valueTerm); model.AddElement(valueTerm); var entity = new EdmEntityType("DefaultNamespace", "foo"); model.AddElement(entity); var entityContainer = new EdmEntityContainer("DefaultNamespace", "container"); model.AddElement(entityContainer); var badString = new CustomStringConstant("foo", EdmExpressionKind.None, EdmValueKind.String); var valueAnnotation = new EdmAnnotation( valueTerm, valueTerm, badString); model.AddVocabularyAnnotation(valueAnnotation); var valueAnnotation2 = new EdmAnnotation( valueTerm, valueTerm, new EdmStringConstant("foo")); model.AddVocabularyAnnotation(valueAnnotation2); return model; }
private EdmModel BuildBasicModelWithValueTerm(IEdmTypeReference valueKindType) { var model = new EdmModel(); var container = new EdmEntityContainer("foo", "Container"); model.AddElement(container); var valueTerm = new EdmTerm("foo", "ValueTerm", valueKindType); model.AddElement(valueTerm); return model; }
public static IEdmModel ValueAnnotationValidDefaultDurationConstantModel() { var model = new EdmModel(); var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetDuration(true)); model.AddElement(valueTerm); var valueAnnotation = new EdmAnnotation( valueTerm, valueTerm, new EdmDurationConstant(new TimeSpan())); valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine); model.AddVocabularyAnnotation(valueAnnotation); return model; }
private void AddStockVocabularies(IEdmModel edmModel, EdmModel stockModel) { foreach (var valueTypeTerm in edmModel.SchemaElements.OfType<IEdmValueTerm>()) { var stockValueTerm = new EdmTerm(valueTypeTerm.Namespace, valueTypeTerm.Name, this.ConvertToStockTypeReference(valueTypeTerm.Type, stockModel)); stockModel.AddElement(stockValueTerm); } foreach (var edmAnnotation in edmModel.VocabularyAnnotations.OfType<IEdmValueAnnotation>()) { var stockAnnotation = new EdmAnnotation( this.ConvertToStockVocabularyAnnotatable(edmAnnotation.Target, stockModel), stockModel.FindValueTerm(((IEdmSchemaElement)edmAnnotation.Term).FullName()), edmAnnotation.Qualifier, this.ConvertToStockExpression(edmAnnotation.Value, stockModel) // TODO: Do we need FullName()? // TODO: FullName() is Namespace.Name, but should it be NamespaceUri.Name? // TODO: FullName() on Annotation.Term returns Vocabulary0.TermName. Vocabulary0 is the using Alias. Is this correct? // TODO: Namepsace on Annotation.Term returns Vocabulary0, which is the using Alias. Is this correct? ); stockModel.AddVocabularyAnnotation(stockAnnotation); } }
public static IEdmModel InvalidPropertyTypeUsingIsTypeOnOutOfLineAnnotationModel() { var model = new EdmModel(); var friendName = new EdmTerm("NS", "FriendName", EdmCoreModel.Instance.GetString(true)); model.AddElement(friendName); var valueAnnotation = new EdmAnnotation( friendName, friendName, new EdmIsTypeExpression(new EdmStringConstant("foo"), EdmCoreModel.Instance.GetString(true))); valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine); model.AddVocabularyAnnotation(valueAnnotation); return model; }
public static IEdmModel InvalidPropertyTypeUsingIsTypeOnInlineAnnotationModel() { var model = new EdmModel(); var bike = new EdmComplexType("NS", "Bike"); bike.AddStructuralProperty("Color", EdmCoreModel.Instance.GetString(true)); model.AddElement(bike); var car = new EdmComplexType("NS", "Car"); var carExpensive = car.AddStructuralProperty("Expensive", new EdmComplexTypeReference(bike, true)); model.AddElement(car); var carTerm = new EdmTerm("NS", "CarTerm", new EdmComplexTypeReference(car, true)); model.AddElement(carTerm); var valueAnnotation = new EdmAnnotation( car, carTerm, new EdmRecordExpression( new EdmPropertyConstructor(carExpensive.Name, new EdmIsTypeExpression(new EdmStringConstant("foo"), EdmCoreModel.Instance.GetString(true))))); valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline); model.AddVocabularyAnnotation(valueAnnotation); return model; }
public static IEdmModel CastResultTrueEvaluationModel() { var model = new EdmModel(); var address = new EdmComplexType("NS", "Address"); address.AddStructuralProperty("StreetNumber", EdmCoreModel.Instance.GetInt32(true)); address.AddStructuralProperty("StreetName", EdmCoreModel.Instance.GetString(true)); model.AddElement(address); var friend = new EdmEntityType("NS", "Friend"); var friendName = friend.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false)); friend.AddKeys(friendName); var friendAddress = friend.AddStructuralProperty("Address", new EdmComplexTypeReference(address, true)); model.AddElement(friend); var addressRecord = new EdmRecordExpression(new EdmPropertyConstructor[] { new EdmPropertyConstructor("StreetNumber", new EdmIntegerConstant(3)), new EdmPropertyConstructor("StreetName", new EdmStringConstant("에O詰 갂คำŚёæ")) }); var friendAddressCast = new EdmCastExpression(addressRecord, new EdmComplexTypeReference(address, true)); var friendTerm = new EdmTerm("NS", "FriendTerm", new EdmEntityTypeReference(friend, true)); model.AddElement(friendTerm); var valueAnnotation = new EdmAnnotation( friend, friendTerm, new EdmRecordExpression( new EdmPropertyConstructor(friendName.Name, new EdmStringConstant("foo")), new EdmPropertyConstructor(friendAddress.Name, friendAddressCast))); valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine); model.AddVocabularyAnnotation(valueAnnotation); return model; }
public static IEdmModel CastNullableToNonNullableOnInlineAnnotationModel() { var model = new EdmModel(); var address = new EdmComplexType("NS", "Address"); address.AddStructuralProperty("StreetNumber", EdmCoreModel.Instance.GetInt32(true)); address.AddStructuralProperty("StreetName", EdmCoreModel.Instance.GetString(true)); model.AddElement(address); var friend = new EdmComplexType("NS", "Friend"); friend.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true)); friend.AddStructuralProperty("NickNames", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(true))); friend.AddStructuralProperty("Address", new EdmComplexTypeReference(address, true)); model.AddElement(friend); var friendInfo = new EdmTerm("NS", "FriendInfo", EdmCoreModel.GetCollection(new EdmComplexTypeReference(friend, true))); model.AddElement(friendInfo); var valueAnnotationCast = new EdmCastExpression(new EdmCollectionExpression(new EdmStringConstant("foo"), new EdmStringConstant("bar")), new EdmComplexTypeReference(friend, true)); var valueAnnotation = new EdmAnnotation( friendInfo, friendInfo, valueAnnotationCast); valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline); model.AddVocabularyAnnotation(valueAnnotation); return model; }
public static IEdmModel IsTypeResultTrueEvaluationModel() { var model = new EdmModel(); var booleanFlag = new EdmComplexType("NS", "BooleanFlag"); var flag = booleanFlag.AddStructuralProperty("Flag", EdmCoreModel.Instance.GetBoolean(true)); model.AddElement(booleanFlag); var booleanFlagTerm = new EdmTerm("NS", "BooleanFlagTerm", new EdmComplexTypeReference(booleanFlag, true)); model.AddElement(booleanFlagTerm); var valueAnnotation = new EdmAnnotation( booleanFlag, booleanFlagTerm, new EdmRecordExpression( new EdmPropertyConstructor(flag.Name, new EdmIsTypeExpression(new EdmStringConstant("foo"), EdmCoreModel.Instance.GetString(true))))); valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine); model.AddVocabularyAnnotation(valueAnnotation); return model; }
public static EdmModel ValueTermWithAnnotationModel() { EdmModel model = new EdmModel(); EdmTerm note = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetString(true)); model.AddElement(note); var annotationElement = new XElement("{http://foo}Annotation", 1); var annotation = new EdmStringConstant(EdmCoreModel.Instance.GetString(false), annotationElement.ToString()); annotation.SetIsSerializedAsElement(model, true); model.SetAnnotationValue(note, "http://foo", "Annotation", annotation); return model; }
public static EdmModel OutOfLineValueAnnotationWithAnnotationModel() { EdmModel model = new EdmModel(); EdmComplexType simpleType = new EdmComplexType("DefaultNamespace", "SimpleType"); simpleType.AddStructuralProperty("Data", EdmCoreModel.Instance.GetString(true)); model.AddElement(simpleType); EdmTerm note = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetString(true)); model.AddElement(note); EdmAnnotation valueAnnotation = new EdmAnnotation( simpleType, note, new EdmStringConstant("ComplexTypeNote")); valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine); model.AddVocabularyAnnotation(valueAnnotation); XElement annotationElement = new XElement("{http://foo}Annotation", "1"); var annotation = new EdmStringConstant(EdmCoreModel.Instance.GetString(false), annotationElement.ToString()); annotation.SetIsSerializedAsElement(model, true); model.SetAnnotationValue(valueAnnotation, "http://foo", "Annotation", annotation); return model; }
public static IEdmModel AllInterfaceCriticalModel() { var model = new EdmModel(); var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetString(true)); model.AddElement(valueTerm); var badString = new CustomStringConstant("foo", EdmExpressionKind.None, EdmValueKind.Integer); var valueAnnotation = new EdmAnnotation( valueTerm, valueTerm, badString); model.AddVocabularyAnnotation(valueAnnotation); var mutableValueAnnotationueAnnotation = new MutableValueAnnotation() { Target = valueTerm }; model.AddVocabularyAnnotation(mutableValueAnnotationueAnnotation); var customEntity = new CustomEntityType(new List<IEdmProperty>() { null }); model.AddElement(customEntity); var entity = new EdmEntityType("DefaultNamespace", "bar"); var entity2 = new EdmEntityType("DefaultNamespace", "bar2"); var navProperty = new StubEdmNavigationProperty("Nav") { DeclaringType = entity, Type = new EdmEntityTypeReference(entity2, false) }; navProperty.Partner = navProperty; entity.AddProperty(navProperty); model.AddElement(entity); model.AddElement(entity2); return model; }
public static IEdmModel InterfaceCriticalKindValueMismatchOnlyUsingStringTypeReferenceModel() { var model = new EdmModel(); var badTypeRef = new EdmStringTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Double), true); var valueTerm = new EdmTerm("NS", "Note", badTypeRef); model.AddElement(valueTerm); return model; }
public static IEdmModel IsTypeResultFalseEvaluationModel() { var model = new EdmModel(); var booleanFlag = new EdmTerm("NS", "BooleanFlag", EdmCoreModel.Instance.GetBoolean(true)); model.AddElement(booleanFlag); var valueAnnotation = new EdmAnnotation( booleanFlag, booleanFlag, new EdmIsTypeExpression(new EdmIntegerConstant(32), EdmCoreModel.Instance.GetString(true))); valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine); model.AddVocabularyAnnotation(valueAnnotation); return model; }
private static void CustomTermDemo() { Console.WriteLine("CustomTermDemo"); var model = new EdmModel(); var term = new EdmTerm("ns", "ErrorCodes", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))); model.AddElement(term); var entity1 = new EdmEntityType("ns", "entity1"); entity1.AddKeys(entity1.AddStructuralProperty("id", EdmPrimitiveTypeKind.Guid)); model.AddElement(entity1); var container = new EdmEntityContainer("ns", "default"); model.AddElement(container); var e1 = container.AddSingleton("E1", entity1); var annotation = new EdmAnnotation(e1, term, new EdmCollectionExpression( new EdmStringConstant("Entity Not Found"), new EdmStringConstant("Deleting link failed"))); model.AddVocabularyAnnotation(annotation); ShowModel(model); }
public static IEdmModel ValueAnnotationInvalidTypeReferenceDurationConstantModel() { var model = new EdmModel(); var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetDuration(true)); model.AddElement(valueTerm); var valueAnnotation = new EdmAnnotation( valueTerm, valueTerm, new EdmDurationConstant(EdmCoreModel.Instance.GetDateTimeOffset(false), new TimeSpan(1, 99, 99, 99, 999))); valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine); model.AddVocabularyAnnotation(valueAnnotation); return model; }
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingEntityReferenceTypeModel() { var model = new EdmModel(); var badTypeRef = new EdmEntityReferenceTypeReference(new CustomEntityReferenceType(null), true); var valueTerm = new EdmTerm("NS", "Note", badTypeRef); model.AddElement(valueTerm); return model; }
public void Term_Definition_Collection() { this.SetupModels(); var definitionModel = new EdmModel(); var collectionOfInt16 = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt16(false /*isNullable*/))); var valueTermInt16 = new EdmTerm("NS2", "CollectionOfInt16", collectionOfInt16); definitionModel.AddElement(valueTermInt16); var collectionOfPerson = new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(this.baseModel.FindEntityType("NS1.Person"), true))); var valueTermPerson = new EdmTerm("NS2", "CollectionOfPerson", collectionOfPerson); definitionModel.AddElement(valueTermPerson); string expectedCsdl = @"<Schema Namespace=""NS2"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""> <Term Name=""CollectionOfInt16"" Type=""Collection(Edm.Int16)"" Nullable=""false"" /> <Term Name=""CollectionOfPerson"" Type=""Collection(NS1.Person)"" /> </Schema>"; this.SerializeAndVerifyAgainst(definitionModel, expectedCsdl); }
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingBinaryValueModel() { var model = new EdmModel(); var valueTerm = new EdmTerm("NS", "Note", EdmCoreModel.Instance.GetBinary(true)); model.AddElement(valueTerm); var badValue = new CustomBinaryConstant(null); var valueAnnotation = new EdmAnnotation( valueTerm, valueTerm, badValue); model.AddVocabularyAnnotation(valueAnnotation); return model; }