C# EdmLibTestErrors类代码示例

        public void RoundTripValueAnnotationWithCollectionComplexTypeCsdl()
        {
            var expectedErrors = new EdmLibTestErrors();
            this.VerifySemanticValidation(VocabularyTestModelBuilder.ValueAnnotationWithCollectionComplexTypeCsdl(), EdmVersion.V40, expectedErrors);

            this.RoundTripValidator(VocabularyTestModelBuilder.ValueAnnotationWithCollectionComplexTypeCsdl(), EdmVersion.V40);
        }

 public void NullCannotBeAssertedToBeANonNullableType()
 {
     var expectedErrors = new EdmLibTestErrors() 
     {
         {6, 8, EdmErrorCode.NullCannotBeAssertedToBeANonNullableType}
     };
     this.VerifySemanticValidation(ExpressionValidationTestModelBuilder.NullForNonNullableTerm(this.EdmVersion), expectedErrors);
 }

 public void IncorrectPrimitiveTypeForTerm()
 {
     var expectedErrors = new EdmLibTestErrors() 
     {
         {5, 6, EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType}
     };
     this.VerifySemanticValidation(ExpressionValidationTestModelBuilder.IncorrectPrimitiveTypeForTerm(this.EdmVersion), expectedErrors);
 }

 public void ValidatePropertyRefAnnotationElementSupportInV40()
 {
     var expectedErrors = new EdmLibTestErrors()
     {
         // [EdmLib] Key, ReturnType, Schema, Principle, Dependent, OnDelete do not support annotations. - won't fixed. 
     };
     this.VerifySemanticValidation(ValidationTestModelBuilder.PropertyRefAnnotationElementSupportInV40(this.EdmVersion), expectedErrors);
 }

 public void ValidateAnnotationElementFullNameShouldBeUnique()
 {
     var expectedErrors = new EdmLibTestErrors()
     {
         { null, null, EdmErrorCode.DuplicateDirectValueAnnotationFullName}
     };
     this.VerifySemanticValidation(ValidationTestModelBuilder.AnnotationElementFullNameShouldBeUnique(this.EdmVersion), expectedErrors);
 }

 public void BadCollectionTermItemOfIncorrectType()
 {
     var expectedErrors = new EdmLibTestErrors()
     {
         {9, 14, EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType}
     };
     this.VerifySemanticValidation(ExpressionValidationTestModelBuilder.BadCollectionTermItemOfIncorrectType(this.EdmVersion), expectedErrors);
 }

 public void ValidateNavigationMultiplePrincipalWithAllNullableDependentCsdl()
 {
     var expectedErrors = new EdmLibTestErrors()
     {
         { null, null, EdmErrorCode.InvalidMultiplicityOfPrincipalEnd }
     };
     this.VerifySemanticValidation(NavigationTestModelBuilder.NavigationMultiplePrincipalWithAllNullableDependentCsdl(), EdmVersion.V40, expectedErrors);
 }

 public void CannotReconcilePrimitiveExpressionWithNonPrimitiveType()
 {
     var expectedErrors = new EdmLibTestErrors() 
     {
         {5, 6, EdmErrorCode.PrimitiveConstantExpressionNotValidForNonPrimitiveType}
     };
     this.VerifySemanticValidation(ExpressionValidationTestModelBuilder.PrimitiveForNonPrimitiveTerm(this.EdmVersion), expectedErrors);
 }

        public void ValueAnnotation_TargetNotResolvable()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                {8, 6, EdmErrorCode.BadUnresolvedType},
            };

            this.VerifySemanticValidation(VocabularyTestModelBuilder.ValueAnnotationTargetNotResolvableCsdl(), expectedErrors);
        }

        public void ValueTerm_NameConflict_WithOthers()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                {3, 4, EdmErrorCode.AlreadyDefined},
            };

            this.VerifySemanticValidation(VocabularyTestModelBuilder.ValueTermNameConflictWithOthersCsdl(), expectedErrors);
        }

        public void ValidateEntityContainerAnnotationElementSupportInV40()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                { 5, 6, EdmErrorCode.DuplicateDirectValueAnnotationFullName}, 
            };

            this.VerifySemanticValidation(ValidationTestModelBuilder.EntityContainerAnnotationElementSupportInV40(EdmVersion.V40), EdmVersion.V40, expectedErrors);
        }

        public void ValidateValueAnnotationInvalidFloatConstantAttributeCsdl()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                { null, null, EdmErrorCode.InvalidFloatingPoint }
            };

            this.VerifySemanticValidation(ConstantExpressionModelBuilder.ValueAnnotationInvalidFloatConstantAttributeCsdl(), EdmVersion.V40, expectedErrors);
        }

 public void SerializerTestNoContentModel()
 {
     IEnumerable<EdmError> actualSerializationErrors;
     IEnumerable<EdmError> expectedSerializationErrors = new EdmLibTestErrors() 
     {
         {0, 0, EdmErrorCode.NoSchemasProduced},
     };
     IEnumerable<string> csdlStrings = this.GetSerializerResult(new EdmModel(), out actualSerializationErrors);
     Assert.AreEqual(0, csdlStrings.Count(), "CsdlWriter.WriteCsdl should not generate no ");
     CompareErrors(actualSerializationErrors, expectedSerializationErrors);
 }

        public void TestInterfaceCriticalKindValueMismatchOnlyModel()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                { null, null, EdmErrorCode.InterfaceCriticalKindValueMismatch }
            };

            var model = InterfaceCriticalModelBuilder.InterfaceCriticalKindValueMismatchOnlyModel();

            this.ValidateUsingEdmValidator(model, expectedErrors);
            this.ValidateUsingEdmValidator(model, EdmConstants.EdmVersion4, expectedErrors);
            this.ValidateUsingEdmValidator(model, ValidationRuleSet.GetEdmModelRuleSet(EdmConstants.EdmVersion4), expectedErrors);
        }

        public void TestInterfaceCriticalPropertyValueMustNotBeNullCsdl()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                { null, null, EdmErrorCode.InterfaceCriticalPropertyValueMustNotBeNull }
            };

            var csdls = InterfaceCriticalModelBuilder.InterfaceCriticalPropertyValueMustNotBeNullOnlyCsdl();
            var model = this.GetParserResult(csdls);

            this.ValidateUsingEdmValidator(model, expectedErrors);
            this.ValidateUsingEdmValidator(model, EdmConstants.EdmVersion4, expectedErrors);
            this.ValidateUsingEdmValidator(model, ValidationRuleSet.GetEdmModelRuleSet(EdmConstants.EdmVersion4), expectedErrors);
        }