public CsdlSemanticsEntitySetTests() { var referentialConstraints = new List<CsdlReferentialConstraint>(); var csdlNavigation = new CsdlNavigationProperty("Navigation", null, null, null, false, null, referentialConstraints, null, null); this.csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, null, Enumerable.Empty<CsdlProperty>(), new[] { csdlNavigation }, null, null); var goodBinding = new CsdlNavigationPropertyBinding("Navigation", "EntitySet", null, new CsdlLocation(1, 1)); this.csdlEntitySet = new CsdlEntitySet("EntitySet", "FQ.NS.EntityType", new[] { goodBinding }, null, null); this.csdlContainer = new CsdlEntityContainer("Container", null, new[] { this.csdlEntitySet }, Enumerable.Empty<CsdlSingleton>(), Enumerable.Empty<CsdlOperationImport>(), null, null); var derivedCsdlNavigation = new CsdlNavigationProperty("DerivedNavigation", null, null, null, false, null, referentialConstraints, null, null); var derivedCsdlEntityType = new CsdlEntityType("DerivedEntityType", "FQ.NS.EntityType", false, false, false, null, Enumerable.Empty<CsdlProperty>(), new[] { derivedCsdlNavigation }, null, null); var unrelatedCsdlEntityType = new CsdlEntityType("UnrelatedEntityType", null, false, false, false, null, Enumerable.Empty<CsdlProperty>(), Enumerable.Empty<CsdlNavigationProperty>(), null, null); var csdlSchema = new CsdlSchema("FQ.NS", null, null, new[] { this.csdlEntityType, derivedCsdlEntityType, unrelatedCsdlEntityType }, Enumerable.Empty<CsdlEnumType>(), Enumerable.Empty<CsdlOperation>(),Enumerable.Empty<CsdlTerm>(),Enumerable.Empty<CsdlEntityContainer>(),Enumerable.Empty<CsdlAnnotations>(), Enumerable.Empty<CsdlTypeDefinition>(), null, null); var csdlModel = new CsdlModel(); csdlModel.AddSchema(csdlSchema); var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()); this.semanticSchema = new CsdlSemanticsSchema(semanticModel, csdlSchema); this.semanticContainer = new CsdlSemanticsEntityContainer(this.semanticSchema, this.csdlContainer); this.semanticEntityType = semanticModel.FindType("FQ.NS.EntityType") as CsdlSemanticsEntityTypeDefinition; this.semanticEntityType.Should().NotBeNull(); this.navigationProperty = this.semanticEntityType.FindProperty("Navigation") as CsdlSemanticsNavigationProperty; this.navigationProperty.Should().NotBeNull(); }
public CsdlSemanticsPrimitiveTypeReference(CsdlSemanticsSchema schema, CsdlPrimitiveTypeReference reference) : base(reference) { this.schema = schema; this.Reference = reference; this.definition = EdmCoreModel.Instance.GetPrimitiveType(this.Reference.Kind); }
public CsdlSemanticsRecordExpression(CsdlRecordExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression) { this.declaredTypeCache = new Cache<CsdlSemanticsRecordExpression, IEdmStructuredTypeReference>(); this.propertiesCache = new Cache<CsdlSemanticsRecordExpression, IEnumerable<IEdmPropertyConstructor>>(); this.expression = expression; this.bindingContext = bindingContext; }
public CsdlSemanticsApplyExpression(CsdlApplyExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression) { this.expression = expression; this.bindingContext = bindingContext; this.schema = schema; }
public CsdlSemanticsPropertyReferenceExpression(CsdlPropertyReferenceExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression) { this.baseCache = new Cache<CsdlSemanticsPropertyReferenceExpression, IEdmExpression>(); this.elementCache = new Cache<CsdlSemanticsPropertyReferenceExpression, IEdmProperty>(); this.expression = expression; this.bindingContext = bindingContext; }
public void EnsureFunctionImportFunctionPropertyIsUnresolvedFunction() { var functionImport = new CsdlFunctionImport("GetStuff", "FQ.NS.GetStuff", null /*entitySet*/, true /*includeInServiceDocument*/, null /*documentation*/, testLocation); var csdlEntityContainer = CsdlBuilder.EntityContainer("Container", operationImports: new CsdlOperationImport[] {functionImport}); var schema = CsdlBuilder.Schema("FQ.NS", csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()), schema); CsdlSemanticsEntityContainer container = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var imports = container.OperationImports().ToList(); imports.Should().HaveCount(1); var csdlFunctionImport = (IEdmFunctionImport)imports[0]; csdlFunctionImport.Name.Should().Be("GetStuff"); csdlFunctionImport.Operation.GetType().Should().Be(typeof(UnresolvedFunction)); var errors = csdlFunctionImport.Operation.As<BadElement>().Errors.ToList(); errors.Should().HaveCount(1); errors.First().ErrorMessage.Should().Be(Strings.Bad_UnresolvedOperation("FQ.NS.GetStuff")); csdlFunctionImport.Container.Name.Should().Be("Container"); csdlFunctionImport.Location().Should().Be(testLocation); csdlFunctionImport.ContainerElementKind.Should().Be(EdmContainerElementKind.FunctionImport); csdlFunctionImport.EntitySet.Should().BeNull(); csdlFunctionImport.IncludeInServiceDocument.Should().BeTrue(); csdlFunctionImport.Function.IsComposable.Should().BeFalse(); }
public CsdlSemanticsAssertTypeExpression(CsdlAssertTypeExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression) { this.operandCache = new Cache<CsdlSemanticsAssertTypeExpression, IEdmExpression>(); this.typeCache = new Cache<CsdlSemanticsAssertTypeExpression, IEdmTypeReference>(); this.expression = expression; this.bindingContext = bindingContext; }
public CsdlSemanticsCollectionExpression(CsdlCollectionExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression) { this.declaredTypeCache = new Cache<CsdlSemanticsCollectionExpression, IEdmTypeReference>(); this.elementsCache = new Cache<CsdlSemanticsCollectionExpression, IEnumerable<IEdmExpression>>(); this.expression = expression; this.bindingContext = bindingContext; }
public CsdlSemanticsApplyExpression(CsdlApplyExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression) { this.appliedFunctionCache = new Cache<CsdlSemanticsApplyExpression, IEdmExpression>(); this.argumentsCache = new Cache<CsdlSemanticsApplyExpression, IEnumerable<IEdmExpression>>(); this.expression = expression; this.bindingContext = bindingContext; this.schema = schema; }
public CsdlSemanticsLabeledExpression(string name, CsdlExpressionBase element, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(element) { this.expressionCache = new Cache<CsdlSemanticsLabeledExpression, IEdmExpression>(); this.name = name; this.sourceElement = element; this.bindingContext = bindingContext; this.schema = schema; }
public CsdlSemanticsIfExpression(CsdlIfExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression) { this.testCache = new Cache<CsdlSemanticsIfExpression, IEdmExpression>(); this.ifTrueCache = new Cache<CsdlSemanticsIfExpression, IEdmExpression>(); this.ifFalseCache = new Cache<CsdlSemanticsIfExpression, IEdmExpression>(); this.expression = expression; this.bindingContext = bindingContext; }
protected CsdlSemanticsVocabularyAnnotation(CsdlSemanticsSchema schema, IEdmVocabularyAnnotatable targetContext, CsdlSemanticsAnnotations annotationsContext, CsdlAnnotation annotation, string qualifier) : base(annotation) { this.schema = schema; this.Annotation = annotation; this.qualifier = qualifier ?? annotation.Qualifier; this.targetContext = targetContext; this.annotationsContext = annotationsContext; }
public CsdlSemanticsOperationTests() { this.csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, null, Enumerable.Empty<CsdlProperty>(), Enumerable.Empty<CsdlNavigationProperty>(), null, null); var csdlSchema = CsdlBuilder.Schema("FQ.NS", csdlStructuredTypes: new[] { this.csdlEntityType }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(csdlSchema); var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()); this.semanticSchema = new CsdlSemanticsSchema(semanticModel, csdlSchema); this.testLocation = new CsdlLocation(1, 3); }
public void EnsureActionImportActionPropertyIsUnresolvedAction() { var actionImport = new CsdlActionImport("Action", "FQ.NS.Action", null /*entitySet*/, null /*documentation*/, testLocation); var csdlEntityContainer = CsdlBuilder.EntityContainer("Container", operationImports: new CsdlOperationImport[] { actionImport }); var schema = CsdlBuilder.Schema("FQ.NS", csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty<IEdmModel>()), schema); CsdlSemanticsEntityContainer container = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var imports = container.OperationImports().ToList(); imports.Should().HaveCount(1); imports[0].Name.Should().Be("Action"); imports[0].Operation.GetType().Should().Be(typeof(UnresolvedAction)); var errors = imports[0].Operation.As<BadElement>().Errors.ToList(); errors.Should().HaveCount(1); errors.First().ErrorMessage.Should().Be(Strings.Bad_UnresolvedOperation("FQ.NS.Action")); imports[0].Container.Name.Should().Be("Container"); imports[0].Location().Should().Be(testLocation); imports[0].ContainerElementKind.Should().Be(EdmContainerElementKind.ActionImport); imports[0].EntitySet.Should().BeNull(); }
public CsdlSemanticsLabeledExpressionReferenceExpression(CsdlLabeledExpressionReferenceExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression) { this.expression = expression; this.bindingContext = bindingContext; }
protected CsdlSemanticsStructuredTypeDefinition(CsdlSemanticsSchema context, CsdlStructuredType type) : base(type) { this.context = context; }
public CsdlSemanticsFunction(CsdlSemanticsSchema context, CsdlFunction function) : base(context, function) { this.function = function; }
public CsdlSemanticsIsTypeExpression(CsdlIsTypeExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression) { this.expression = expression; this.bindingContext = bindingContext; }
public CsdlSemanticsOperation(CsdlSemanticsSchema context, CsdlOperation operation) : base(operation) { this.Context = context; this.operation = operation; }
public CsdlSemanticsValueTerm(CsdlSemanticsSchema context, CsdlValueTerm valueTerm) : base(valueTerm) { this.Context = context; this.valueTerm = valueTerm; }
public CsdlSemanticsComplexTypeDefinition(CsdlSemanticsSchema context, CsdlComplexType complex) : base(context, complex) { this.complex = complex; }
public CsdlSemanticsBooleanConstantExpression(CsdlConstantExpression expression, CsdlSemanticsSchema schema) : base(schema, expression) { this.valueCache = new Cache<CsdlSemanticsBooleanConstantExpression, bool>(); this.errorsCache = new Cache<CsdlSemanticsBooleanConstantExpression, IEnumerable<EdmError>>(); this.expression = expression; }
public CsdlSemanticsCollectionTypeDefinition(CsdlSemanticsSchema schema, CsdlCollectionType collection) : base(collection) { this.elementTypeCache = new Cache<CsdlSemanticsCollectionTypeDefinition, IEdmTypeReference>(); this.collection = collection; this.schema = schema; }
public CsdlSemanticsEntityContainer(CsdlSemanticsSchema context, CsdlEntityContainer entityContainer) : base(entityContainer) { this.elementsCache = new Cache<CsdlSemanticsEntityContainer, IEnumerable<IEdmEntityContainerElement>>(); this.associationSetsCache = new Cache<CsdlSemanticsEntityContainer, IEnumerable<CsdlSemanticsAssociationSet>>(); this.associationSetMappingsCache = new Cache<CsdlSemanticsEntityContainer, Dictionary<IEdmAssociation, IEnumerable<CsdlSemanticsAssociationSet>>>(); this.entitySetDictionaryCache = new Cache<CsdlSemanticsEntityContainer, Dictionary<string, IEdmEntitySet>>(); this.functionImportsDictionaryCache = new Cache<CsdlSemanticsEntityContainer, Dictionary<string, object>>(); this.errorsCache = new Cache<CsdlSemanticsEntityContainer, IEnumerable<EdmError>>(); this.extendsCache = new Cache<CsdlSemanticsEntityContainer, IEdmEntityContainer>(); this.context = context; this.entityContainer = entityContainer; }
public CsdlSemanticsNamedTypeReference(CsdlSemanticsSchema schema, CsdlNamedTypeReference reference) : base(reference) { this.schema = schema; this.reference = reference; }
/// <summary> /// Initializes a new instance of the <see cref="CsdlSemanticsAction"/> class. /// </summary> /// <param name="context">The context.</param> /// <param name="action">The action.</param> public CsdlSemanticsAction(CsdlSemanticsSchema context, CsdlAction action) : base(context, action) { }
public CsdlSemanticsTimeOfDayConstantExpression(CsdlConstantExpression expression, CsdlSemanticsSchema schema) : base(schema, expression) { this.expression = expression; }
public CsdlSemanticsFunctionReferenceExpression(CsdlFunctionReferenceExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(schema, expression) { this.referencedCache = new Cache<CsdlSemanticsFunctionReferenceExpression, IEdmFunction>(); this.expression = expression; this.bindingContext = bindingContext; }
protected CsdlSemanticsStructuredTypeDefinition(CsdlSemanticsSchema context, CsdlStructuredType type) : base(type) { this.declaredPropertiesCache = new Cache<CsdlSemanticsStructuredTypeDefinition, List<IEdmProperty>>(); this.propertiesDictionaryCache = new Cache<CsdlSemanticsStructuredTypeDefinition, IDictionary<string, IEdmProperty>>(); this.context = context; }
public CsdlSemanticsStringTypeReference(CsdlSemanticsSchema schema, CsdlStringTypeReference reference) : base(schema, reference) { }