public void ExerciseBadtypes() { IEdmModel model = new EdmModel(); IEdmEntityType entityDef = new EdmEntityType("MyNamespace", "BadEntity"); IEdmEntityTypeReference entityRef = new EdmEntityTypeReference(entityDef, false); IEdmComplexType complexDef = new EdmComplexType("MyNamespace", "BadComplex"); IEdmComplexTypeReference complexRef = new EdmComplexTypeReference(complexDef, false); IEdmCollectionTypeReference badCollectionRef = entityRef.AsCollection(); IEdmEntityTypeReference badEntityRef = complexRef.AsEntity(); IEdmComplexTypeReference badComplexRef = entityRef.AsComplex(); IEdmEntityReferenceTypeReference badEntityRefRef = entityRef.AsEntityReference(); IEdmPrimitiveTypeReference badTemporal = entityRef.AsTemporal(); IEdmPrimitiveTypeReference badDecimal = entityRef.AsDecimal(); IEdmPrimitiveTypeReference badString = entityRef.AsString(); IEdmPrimitiveTypeReference badSpatial = entityRef.AsSpatial(); IEdmPrimitiveTypeReference badBinary = entityRef.AsBinary(); IEdmPrimitiveTypeReference badPrimitive = entityRef.AsPrimitive(); IEdmEnumTypeReference badEnum = entityRef.AsEnum(); Assert.IsTrue(badCollectionRef.IsCollection(), "Bad collection is collection"); Assert.IsTrue(badEntityRef.IsEntity(), "Bad Entity is Entity"); Assert.AreEqual(0, badEntityRef.Key().Count(), "Bad Entity has no key"); Assert.AreEqual("MyNamespace.BadComplex", badEntityRef.FullName(), "Bad named refs keep name"); Assert.AreEqual(EdmSchemaElementKind.TypeDefinition, badEntityRef.EntityDefinition().SchemaElementKind, "Bad named type definitions are still type definitions"); Assert.IsNull(badEntityRef.EntityDefinition().BaseType, "Bad Entity has no base type"); Assert.AreEqual(Enumerable.Empty<IEdmProperty>(), badEntityRef.EntityDefinition().DeclaredProperties, "Bad structured types have no properties"); Assert.IsFalse(badEntityRef.EntityDefinition().IsAbstract, "Bad structured types are not abstract"); Assert.IsFalse(badEntityRef.EntityDefinition().IsOpen, "Bad structured types are not open"); model.SetAnnotationValue(badEntityRef.Definition, "foo", "bar", new EdmStringConstant(new EdmStringTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), false), "baz")); Assert.AreEqual(1, model.DirectValueAnnotations(badEntityRef.Definition).Count(), "Bad Entity can hold annotations"); Assert.IsNotNull(model.GetAnnotationValue(badEntityRef.Definition, "foo", "bar"), "Bad Entity can find annotations"); Assert.AreEqual(EdmTermKind.Type, badEntityRef.EntityDefinition().TermKind, "EntityType has correct term kind"); Assert.IsTrue(badComplexRef.IsComplex(), "Bad Complex is Bad"); Assert.IsNull(badComplexRef.ComplexDefinition().FindProperty("PropertyName"), "Bad structured types return null for find property"); Assert.AreEqual(EdmTypeKind.EntityReference, badEntityRefRef.TypeKind(), "Bad Entity Reference is Entity Reference"); Assert.AreEqual(String.Empty, badEntityRefRef.EntityType().Name, "Bad Entity Reference has empty named EntityType"); model.SetAnnotationValue(badEntityRefRef.Definition, "foo", "bar", new EdmStringConstant(new EdmStringTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), false), "baz")); Assert.AreEqual(1, model.DirectValueAnnotations(badEntityRefRef.Definition).Count(), "Bad Entity Reference can hold annotations"); Assert.IsNotNull(model.GetAnnotationValue(badEntityRefRef.Definition, "foo", "bar"), "Bad Entity Reference can find annotations"); Assert.AreEqual(EdmPrimitiveTypeKind.None, badPrimitive.PrimitiveKind(), "Bad Primitive has no primitive kind"); Assert.AreEqual(EdmTypeKind.Primitive, badPrimitive.TypeKind(), "Bad Primitive has primitive type kind"); Assert.AreEqual(EdmSchemaElementKind.TypeDefinition, badPrimitive.PrimitiveDefinition().SchemaElementKind, "Bad Primitive is still Type Definition"); Assert.AreEqual("BadEntity", badPrimitive.PrimitiveDefinition().Name, "Bad Primitive retains name"); Assert.AreEqual("MyNamespace", badPrimitive.PrimitiveDefinition().Namespace, "Bad Primitive retains namespace name"); Assert.AreEqual(EdmTypeKind.Enum, badEnum.TypeKind(), "Bad enum has right kind."); Assert.AreEqual(EdmPrimitiveTypeKind.Int32, badEnum.EnumDefinition().UnderlyingType.PrimitiveKind, "Underlying type has correct kind."); Assert.AreEqual(0, badEnum.EnumDefinition().Members.Count(), "bad enum has no members."); Assert.AreEqual(false, badEnum.EnumDefinition().IsFlags, "bad enum not treated as bits."); Assert.AreEqual(EdmSchemaElementKind.TypeDefinition, badEnum.EnumDefinition().SchemaElementKind, "bad enum is type definition."); Assert.AreEqual("BadEntity", badEnum.EnumDefinition().Name, "Bad enum retains name"); Assert.AreEqual("MyNamespace", badEnum.EnumDefinition().Namespace, "Bad enum retains namespace name"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badSpatial.Definition.Errors().First().ErrorCode, "Bad spatial has correct error code."); }
public void NonPrimitiveAsXXXMethods() { IEdmPrimitiveType intDef = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32); IEdmPrimitiveTypeReference intRef = new EdmPrimitiveTypeReference(intDef, false); IEdmEntityType entityDef = new EdmEntityType("MyNamespace", "MyEntity"); IEdmEntityTypeReference entityRef = new EdmEntityTypeReference(entityDef, false); IEdmComplexType complexDef = new EdmComplexType("MyNamespace", "MyComplex"); IEdmComplexTypeReference complexRef = new EdmComplexTypeReference(complexDef, false); IEdmCollectionType collectionDef = new EdmCollectionType(intRef); IEdmCollectionTypeReference collectionRef = new EdmCollectionTypeReference(collectionDef); IEdmCollectionTypeReference badCollectionRef = entityRef.AsCollection(); IEdmEntityTypeReference badEntityRef = collectionRef.AsEntity(); IEdmComplexTypeReference badComplexRef = entityRef.AsComplex(); IEdmEntityReferenceTypeReference badEntityRefRef= entityRef.AsEntityReference(); Assert.IsTrue(badCollectionRef.IsBad(), "Bad Collection is bad"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badCollectionRef.Errors().First().ErrorCode, "Reference is bad from conversion"); Assert.AreEqual("[Collection([UnknownType Nullable=True]) Nullable=True]", badCollectionRef.ToString(), "Correct tostring"); Assert.IsTrue(badComplexRef.IsBad(), "Bad Complex is Bad"); Assert.IsTrue(badComplexRef.Definition.IsBad(), "Bad Complex definition is Bad"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badComplexRef.Definition.Errors().First().ErrorCode, "Reference is bad from conversion"); Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.MyEntity Nullable=False]", badComplexRef.ToString(), "Correct tostring"); Assert.IsTrue(badEntityRef.IsBad(), "Bad Entity is bad"); Assert.IsTrue(badEntityRef.Definition.IsBad(), "Bad Entity Definition is bad"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badEntityRef.Definition.Errors().First().ErrorCode, "Reference is bad from conversion"); Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[Collection(Edm.Int32) Nullable=False]", badEntityRef.ToString(), "Correct tostring"); Assert.IsTrue(badEntityRefRef.IsBad(), "Bad Entity Reference is Bad"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badEntityRefRef.Errors().First().ErrorCode, "Reference is bad from conversion"); Assert.AreEqual("[EntityReference(.) Nullable=False]", badEntityRefRef.ToString(), "Correct tostring"); Assert.IsFalse(entityRef.AsEntity().IsBad(), "Entity converted to Entity is good"); Assert.IsFalse(complexRef.AsComplex().IsBad(), "Complex converted to complex is good"); Assert.IsFalse(collectionRef.AsCollection().IsBad(), "Collection converted to collection is good"); Assert.IsTrue(entityRef.AsStructured().IsEntity(), "Entity as structured is entity"); Assert.IsFalse(entityRef.AsStructured().IsBad(), "Entity as structured is good"); Assert.IsTrue(complexRef.AsStructured().IsComplex(), "Complex as structured is complex"); Assert.IsFalse(complexRef.AsStructured().IsBad(), "Complex as structured is good"); Assert.IsFalse(collectionRef.AsStructured().IsCollection(), "Collection as structured is not collection"); Assert.IsTrue(collectionRef.AsStructured().IsBad(), "Collection as structured is bad"); Assert.IsTrue(collectionRef.AsStructured().Definition.IsBad(), "Collection as structured definition is bad"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, collectionRef.AsStructured().Definition.Errors().First().ErrorCode, "Reference is bad from conversion"); }