Beispiel #1
0
        public void ParseCastExpressionWorksAsExpected()
        {
            string json = @" {
  ""$Cast"": {
    ""$Path"": ""Average""
  },
  ""$Type"": ""Edm.Decimal"",
  ""$Precision"": 42
}";

            CsdlExpressionBase expressionBase = ParseExpression(json);

            Assert.NotNull(expressionBase);
            CsdlCastExpression castExp = Assert.IsType <CsdlCastExpression>(expressionBase);

            Assert.NotNull(castExp.Operand);
            CsdlPathExpression pathExp = Assert.IsType <CsdlPathExpression>(castExp.Operand);

            Assert.Equal("Average", pathExp.Path);

            Assert.NotNull(castExp.Type);
            CsdlDecimalTypeReference decimalType = Assert.IsType <CsdlDecimalTypeReference>(castExp.Type);

            Assert.NotNull(decimalType.Precision);
            Assert.Equal(42, decimalType.Precision.Value);
            Assert.Null(decimalType.Scale);
        }
 public CsdlSemanticsDecimalTypeReference(CsdlSemanticsSchema schema, CsdlDecimalTypeReference reference)
     : base(schema, reference)
 {
 }
Beispiel #3
0
        public void ParseCsdlOperationWithActionAndFunctionWorksAsExpected()
        {
            string json = @"""Approval"": [
    {
        ""$Kind"": ""Action"",
        ""$IsBound"": true,
        ""$Parameter"": [
            {
                ""$Name"": ""binding"",
                ""$Type"": ""self.Order"",
                ""$Nullable"": true
            }
        ]
    },
    {
        ""$Kind"": ""Function"",
        ""$Parameter"": [
            {
                ""$Name"": ""Rating"",
                ""$Type"": ""Edm.Decimal"",
                ""$Precision"": 4,
                ""$Scale"": 1
            }
        ],
        ""$ReturnType"": {
            ""$Type"": ""self.Product""
         }
    }
]";

            IList <CsdlOperation> operations = ParseCsdlSchemaElement(json, SchemaJsonParser.TryParseCsdlOperationOverload);

            Assert.NotNull(operations);
            Assert.Equal(2, operations.Count);

            // #1 CsdlAction
            CsdlAction action = Assert.IsType <CsdlAction>(operations.First());

            Assert.Equal("Approval", action.Name);
            Assert.True(action.IsBound);
            Assert.Null(action.EntitySetPath);

            CsdlOperationParameter parameter = Assert.Single(action.Parameters);

            Assert.Equal("binding", parameter.Name);
            Assert.False(parameter.IsOptional);
            Assert.Null(parameter.DefaultValue);
            CsdlNamedTypeReference namedType = Assert.IsType <CsdlNamedTypeReference>(parameter.Type);

            Assert.True(namedType.IsNullable);
            Assert.Equal("self.Order", namedType.FullName);
            Assert.Null(action.Return);

            // #2 CsdlFunction
            CsdlFunction function = Assert.IsType <CsdlFunction>(operations.Last());

            Assert.Equal("Approval", function.Name);
            Assert.False(function.IsBound);
            Assert.Null(function.EntitySetPath);

            parameter = Assert.Single(function.Parameters);
            Assert.Equal("Rating", parameter.Name);
            Assert.False(parameter.IsOptional);
            Assert.Null(parameter.DefaultValue);
            CsdlDecimalTypeReference decimalType = Assert.IsType <CsdlDecimalTypeReference>(parameter.Type);

            Assert.False(decimalType.IsNullable);
            Assert.Equal(4, decimalType.Precision.Value);
            Assert.Equal(1, decimalType.Scale.Value);

            Assert.NotNull(function.Return);
            namedType = Assert.IsType <CsdlNamedTypeReference>(function.Return.ReturnType);
            Assert.False(namedType.IsNullable);
            Assert.Equal("self.Product", namedType.FullName);
        }