コード例 #1
0
        public async Task When_generating_interface_contract_add_discriminator_string_literal()
        {
            //// Arrange
            var schema = JsonSchema.FromType<Nested>(new JsonSchemaGeneratorSettings
            {
                GenerateAbstractProperties = true,
            });
            var data = schema.ToJson();

            //// Act
            var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
            {
                TypeStyle = TypeScriptTypeStyle.Interface,
                TypeScriptVersion = 1.8m,
                EnumStyle = TypeScriptEnumStyle.StringLiteral,
            });
            var code = generator.GenerateFile("MyClass");

            //// Assert
            Assert.Contains("export interface Base {\n    Type: EBase;\n}", code);
        }
コード例 #2
0
        public async Task When_classes_have_extension_code_then_class_body_is_copied()
        {
            //// Arrange
            var schema = JsonSchema.FromType <Foo>();

            //// Act
            var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
            {
                ExtendedClasses = new[] { "Foo", "Bar" },
                ExtensionCode   = Code
            });
            var code = generator.GenerateFile();

            //// Assert
            Assert.DoesNotContain("FooBase", code);
            Assert.DoesNotContain("BarBase", code);
            Assert.DoesNotContain("generated.", code);

            Assert.Contains("return this.firstName + ' ' + this.lastName;", code);
            Assert.Contains("return this.bar ? this.bar.title : '';", code);
        }
コード例 #3
0
        public void FirstPersonTest()
        {
            var model = new glTF_VRM_Firstperson();

            var json = model.ToJson();

            Assert.AreEqual(
                @"{""firstPersonBone"":-1,""firstPersonBoneOffset"":{""x"":0,""y"":0,""z"":0},""meshAnnotations"":[],""lookAtTypeName"":""Bone"",""lookAtHorizontalInner"":{""xRange"":90,""yRange"":10},""lookAtHorizontalOuter"":{""xRange"":90,""yRange"":10},""lookAtVerticalDown"":{""xRange"":90,""yRange"":10},""lookAtVerticalUp"":{""xRange"":90,""yRange"":10}}",
                json);
            Debug.Log(json);

            var c = new JsonSchemaValidationContext("")
            {
                EnableDiagnosisForNotRequiredFields = true,
            };
            var json2 = JsonSchema.FromType <glTF_VRM_Firstperson>().Serialize(model, c);

            Assert.AreEqual(
                @"{""firstPersonBoneOffset"":{""x"":0,""y"":0,""z"":0},""meshAnnotations"":[],""lookAtTypeName"":""Bone"",""lookAtHorizontalInner"":{""xRange"":90,""yRange"":10},""lookAtHorizontalOuter"":{""xRange"":90,""yRange"":10},""lookAtVerticalDown"":{""xRange"":90,""yRange"":10},""lookAtVerticalUp"":{""xRange"":90,""yRange"":10}}",
                json2);
        }
コード例 #4
0
        public async Task When_name_of_JsonPropertyAttribute_is_set_then_it_is_used_as_json_property_name_even_with_contactresolver_that_has_nameing_strategy()
        {
            var settings = new NJsonSchema.Generation.JsonSchemaGeneratorSettings();

            settings.SerializerSettings = new JsonSerializerSettings
            {
                ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver
                {
                    NamingStrategy = new Newtonsoft.Json.Serialization.CamelCaseNamingStrategy()
                }
            };

            //// Arrange
            var schema = JsonSchema.FromType <JsonPropertyAttributeTests.MyJsonPropertyTestClass>(settings);

            //// Act
            var property = schema.Properties["NewName"];

            //// Assert
            Assert.Equal("NewName", property.Name);
        }
コード例 #5
0
        public async Task When_dictionary_key_is_string_literal_then_typescript_has_string_literal_key_ts_2_1()
        {
            //// Arrange
            var schema = JsonSchema.FromType <EnumKeyDictionaryTest>();
            var data   = schema.ToJson();

            //// Act
            var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
            {
                TypeStyle         = TypeScriptTypeStyle.Interface,
                EnumNameGenerator = new DefaultEnumNameGenerator(),
                EnumStyle         = TypeScriptEnumStyle.StringLiteral,
                TypeScriptVersion = 2.1m,
            });
            var code = generator.GenerateFile("MyClass");

            //// Assert
            Assert.Contains("export type PropertyName = 0 | 1;", code);
            Assert.Contains("Mapping: { [key in PropertyName]?: string; } | undefined;", code);
            Assert.Contains("Mapping2: { [key in PropertyName]?: string; } | undefined;", code);
        }
コード例 #6
0
        public async Task When_property_is_required_then_required_attribute_is_rendered()
        {
            //// Arrange
            var schema     = JsonSchema.FromType <ClassWithRequiredObject>();
            var schemaData = schema.ToJson();

            //// Act
            var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
            {
                ClassStyle = CSharpClassStyle.Poco,
                SchemaType = SchemaType.JsonSchema
            });
            var code = generator.GenerateFile("MyClass");

            //// Assert
            Assert.Contains("[System.ComponentModel.DataAnnotations.Required]\n" +
                            "        public string Property { get; set; }\n", code);

            Assert.Contains("[System.ComponentModel.DataAnnotations.Required(AllowEmptyStrings = true)]\n" +
                            "        public string Property2 { get; set; }\n", code);
        }
コード例 #7
0
        public byte[] ToGlbBytes(bool UseUniJSONSerializer = false)
        {
            string json;

            if (UseUniJSONSerializer)
            {
                var c = new JsonSchemaValidationContext(this)
                {
                    EnableDiagnosisForNotRequiredFields = true,
                };
                json = JsonSchema.FromType(GetType()).Serialize(this, c);
            }
            else
            {
                json = ToJson();
            }

            RemoveUnusedExtensions(json);

            return(Glb.ToBytes(json, buffers[0].GetBytes()));
        }
コード例 #8
0
        public async Task When_property_is_not_required_then_required_attribute_is_not_rendered_in_Swagger_mode()
        {
            //// Arrange
            var schema = JsonSchema.FromType <ClassWithoutRequiredObject>(new JsonSchemaGeneratorSettings
            {
                SchemaType = SchemaType.Swagger2
            });
            var schemaData = schema.ToJson();

            //// Act
            var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
            {
                ClassStyle = CSharpClassStyle.Poco,
                SchemaType = SchemaType.Swagger2
            });
            var code = generator.GenerateFile("MyClass");

            //// Assert
            Assert.DoesNotContain("[Required]", code);
            Assert.Contains("public string Property { get; set; }", code);
        }
コード例 #9
0
ファイル: UniGLTFTests.cs プロジェクト: chittai/UniVRM
        public void MaterialTest()
        {
            var model = new glTFMaterial()
            {
                name           = "a",
                emissiveFactor = new float[] { 0.5f, 0.5f, 0.5f },
            };

            var json = model.ToJson();

            Assert.AreEqual(@"{""name"":""a"",""emissiveFactor"":[0.5,0.5,0.5],""doubleSided"":false}", json);
            Debug.Log(json);

            var c = new JsonSchemaValidationContext("")
            {
                EnableDiagnosisForNotRequiredFields = true,
            };
            var json2 = JsonSchema.FromType <glTFMaterial>().Serialize(model, c);

            Assert.AreEqual(@"{""name"":""a"",""emissiveFactor"":[0.5,0.5,0.5],""doubleSided"":false}", json2);
        }
コード例 #10
0
ファイル: UniGLTFTests.cs プロジェクト: chittai/UniVRM
        public void SkinTest()
        {
            var model = new glTFSkin()
            {
                name   = "b",
                joints = new int[] { 1 },
            };

            var json = model.ToJson();

            Assert.AreEqual(@"{""inverseBindMatrices"":-1,""joints"":[1]}", json);
            Debug.Log(json);

            var c = new JsonSchemaValidationContext("")
            {
                EnableDiagnosisForNotRequiredFields = true,
            };
            var json2 = JsonSchema.FromType <glTFSkin>().Serialize(model, c);

            Assert.AreEqual(@"{""joints"":[1],""name"":""b""}", json2);
        }
        public void ProcessIncludesDefaultRuleNotNull()
        {
            // Arrange
            var jsonSchemaGeneratorSettings = CreateJsonSchemaGeneratorSettings();

            // Act
            var schema = JsonSchema.FromType <MockValidationTarget>(jsonSchemaGeneratorSettings);

            // Assert
            Assert.Contains("NotNull", schema.RequiredProperties);

            var test  = schema.Properties["NotNull"];
            var value = test.IsNullable(SchemaType.OpenApi3);

            Assert.False(value);

            var notNullChildProperty = schema.Properties["NotNullChild"];

            Assert.Empty(notNullChildProperty.OneOf);
            Assert.NotNull(notNullChildProperty.Reference);
        }
コード例 #12
0
        public async Task When_parameter_is_abstract_then_generate_union_class()
        {
            //// Arrange
            var schema = JsonSchema.FromType <Nested>();
            var data   = schema.ToJson();

            //// Act
            var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
            {
                UseLeafType       = true,
                TypeStyle         = TypeScriptTypeStyle.Class,
                TypeScriptVersion = 1.8m
            });
            var code = generator.GenerateFile("MyClass");

            //// Assert
            Assert.Contains("export class OneChild extends Base", code);
            Assert.Contains("export class SecondChild extends Base", code);
            Assert.Contains("child: OneChild | SecondChild;", code);
            Assert.Contains("children: OneChild[] | SecondChild[];", code);
        }
コード例 #13
0
        public byte[] ToGlbBytes(bool UseUniJSONSerializer = false)
        {
            string json;

            if (UseUniJSONSerializer)
            {
                json = JsonSchema.FromType(GetType()).Serialize(this);
            }
            else
            {
                json = ToJson();
            }

            var buffer = buffers[0];

            using (var s = new MemoryStream())
            {
                GlbHeader.WriteTo(s);

                var pos = s.Position;
                s.Position += 4; // skip total size

                int size = 12;

                {
                    var chunk = new GlbChunk(json);
                    size += chunk.WriteTo(s);
                }
                {
                    var chunk = new GlbChunk(buffer.GetBytes());
                    size += chunk.WriteTo(s);
                }

                s.Position = pos;
                var bytes = BitConverter.GetBytes(size);
                s.Write(bytes, 0, bytes.Length);

                return(s.ToArray());
            }
        }
コード例 #14
0
        public void ExtensionsTest()
        {
            var model = new glTF_VRM_extensions()
            {
                meta               = null,
                humanoid           = null,
                firstPerson        = null,
                blendShapeMaster   = null,
                secondaryAnimation = null,
                materialProperties = null,
            };

            var c = new JsonSchemaValidationContext("")
            {
                EnableDiagnosisForNotRequiredFields = true,
            };
            var json2    = JsonSchema.FromType <glTF_VRM_extensions>().Serialize(model, c);
            var expected =
                String.Format(@"{{""exporterVersion"":""{0}"",""specVersion"":""0.0""}}", VRMVersion.VRM_VERSION);

            Assert.AreEqual(expected, json2);
        }
コード例 #15
0
        private static JsonSchema CreateAddonAdapter(JsonSchema docSchema, IProviderProcessorAdapter inputOutputAdapter)
        {
            var connectionParameterSchema = JsonSchema
                                            .FromType(inputOutputAdapter.ConnectionParametersType)
                                            .AddAsDefinition(docSchema);

            var adapterSchema = JsonSchemaEx
                                .CreateObject($"Adapter_{inputOutputAdapter.Name}")
                                .AddProperty("Type", new JsonSchemaProperty {
                Pattern = $"^{inputOutputAdapter.Name}$"
            }, true)
                                .AddProperty("Connection", connectionParameterSchema, false);

            if (inputOutputAdapter.ProviderParametersType != null)
            {
                var providerParameterSchema = JsonSchema
                                              .FromType(inputOutputAdapter.ProviderParametersType)
                                              .AddStringProperty("Name", false);
                var providersSchema = JsonSchemaEx
                                      .CreateDictionary($"Sources_{inputOutputAdapter.Name}", providerParameterSchema)
                                      .AddAsDefinition(docSchema);
                adapterSchema
                .AddProperty("Providers", providersSchema, false);
            }

            if (inputOutputAdapter.ProcessorParametersType != null)
            {
                var processorParameterSchema = JsonSchema
                                               .FromType(inputOutputAdapter.ProcessorParametersType)
                                               .AddStringProperty("Name", false);
                var processorsSchema = JsonSchemaEx
                                       .CreateDictionary($"Processes_{inputOutputAdapter.Name}", processorParameterSchema)
                                       .AddAsDefinition(docSchema);
                adapterSchema
                .AddProperty("Processors", processorsSchema, false);
            }

            return(adapterSchema.AddAsDefinition(docSchema));
        }
        public void ProcessIncludesDefaultRuleNotEmpty()
        {
            // Arrange
            var jsonSchemaGeneratorSettings = CreateJsonSchemaGeneratorSettings();

            // Act
            var schema = JsonSchema.FromType <MockValidationTarget>(jsonSchemaGeneratorSettings);

            // Assert
            Assert.Equal(1, schema.Properties["NotEmpty"].MinLength);
            Assert.False(schema.Properties["NotEmpty"].IsNullable(SchemaType.OpenApi3));

            var notEmptyChildProperty = schema.Properties["NotEmptyChild"];

            Assert.Empty(notEmptyChildProperty.OneOf);
            Assert.NotNull(notEmptyChildProperty.Reference);

            // Unable to get this to work right now
            // var notEmptyChildPropertyEnum = schema.Properties["NotEmptyChildEnum"];
            // Assert.Empty(notEmptyChildPropertyEnum.OneOf);
            // Assert.NotNull(notEmptyChildPropertyEnum.Reference);
        }
コード例 #17
0
        public void GetByCEPAsync_ResponseSchema_Test(string cep)
        {
            var httpClientMock = "https://viacep.com.br/ws/";

            string schema = JsonSchema.FromType <ViaCEP>(new JsonSchemaGeneratorSettings()
            {
                AlwaysAllowAdditionalObjectProperties = true
            }).ToJson();

            new RestAssured()
            .Given()
            .Name("VIA Cep Teste")
            .Header("Content-Type", "text/html; charset=utf-8")
            .Header("Accept-Encoding", "gzip,deflate")
            .When()
            .Get($"{httpClientMock}{cep}/json/")
            .Then()
            //.Debug()
            .Schema(schema)
            .WriteAssertions()
            .AssertSchema();
        }
コード例 #18
0
        public void NodeTest()
        {
            var model = new glTFNode()
            {
                name   = "a",
                skin   = 0,
                camera = -1,
            };

            var json = model.ToJson();

            Assert.AreEqual(@"{""name"":""a"",""skin"":0}", json);
            Debug.Log(json);

            var c = new JsonSchemaValidationContext("")
            {
                EnableDiagnosisForNotRequiredFields = true,
            };
            var json2 = JsonSchema.FromType <glTFNode>().Serialize(model, c);

            Assert.AreEqual(@"{""name"":""a"",""extras"":{}}", json2);
        }
コード例 #19
0
        public async Task When_string_and_integer_enum_used_then_one_enum_is_generated_in_CSharp()
        {
            //// Arrange
            var schema = JsonSchema.FromType <StringAndIntegerEnumTestClass>(new JsonSchemaGeneratorSettings
            {
                DefaultEnumHandling = EnumHandling.Integer
            });
            var data = schema.ToJson();

            //// Act
            var generator = new CSharpGenerator(schema);
            var code      = generator.GenerateFile("MyClass").Replace("\r", "");

            //// Assert
            Assert.DoesNotContain("Ref_", code);
            Assert.Contains("public enum Bar\n", code);
            Assert.Contains("public enum Bar2\n", code);

            Assert.Contains(" B = 5,", code);                                                                                                                                  // B must be 5 even if B = 1 is first defined
            Assert.Equal(3, code.Split(new[] { "public enum " }, StringSplitOptions.None).Count());                                                                            // two found (one string and one integer based enum)
            Assert.Equal(3, code.Split(new[] { "[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]" }, StringSplitOptions.None).Count()); // two found
        }
コード例 #20
0
        public async Task When_GenerateConstructorInterface_is_disabled_then_data_is_not_checked_and_default_initialization_is_always_exectued()
        {
            // Assert
            var schema = JsonSchema.FromType(
                typeof(MyDerivedClass),
                new JsonSchemaGeneratorSettings
            {
                GenerateAbstractProperties = true
            });

            var generator = new TypeScriptGenerator(schema);

            generator.Settings.GenerateConstructorInterface = false;
            generator.Settings.MarkOptionalProperties       = true;
            generator.Settings.TypeStyle = TypeScriptTypeStyle.Class;

            // Act
            var output = generator.GenerateFile();

            // Assert
            Assert.DoesNotContain("if (!data) {", output);
        }
コード例 #21
0
        public void SecondaryAnimationColliderTest()
        {
            var model = new glTF_VRM_SecondaryAnimationCollider()
            {
                offset = new Vector3(1, 2, 3),
                radius = 42,
            };

            var json = model.ToJson();

            Assert.AreEqual(@"{""offset"":{""x"":1,""y"":2,""z"":3},""radius"":42}", json);
            Debug.Log(json);

            var c = new JsonSchemaValidationContext("")
            {
                EnableDiagnosisForNotRequiredFields = true,
            };
            var json2 = JsonSchema.FromType <glTF_VRM_SecondaryAnimationCollider>().Serialize(model, c);

            // NOTE: New serializer outputs values which will not be used...
            Assert.AreEqual(json, json2);
        }
コード例 #22
0
        public async Task When_property_is_optional_and_GenerateNullableOptionalProperties_is_set_then_CSharp_property_is_nullable()
        {
            //// Arrange
            var schema = JsonSchema.FromType <ClassWithRequiredObject>(new JsonSchemaGeneratorSettings
            {
                SchemaType = SchemaType.OpenApi3
            });
            var schemaData = schema.ToJson();

            //// Act
            var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
            {
                ClassStyle = CSharpClassStyle.Poco,
                SchemaType = SchemaType.OpenApi3,
                GenerateNullableReferenceTypes = true
            });
            var code = generator.GenerateFile("MyClass");

            //// Assert
            Assert.Contains("public object? Property { get; set; }= default!;", code);
            Assert.Contains("public object Property2 { get; set; }= default!;", code);
        }
コード例 #23
0
        public void BlendShapeBindTest()
        {
            var model = new glTF_VRM_BlendShapeBind()
            {
                mesh   = 1,
                weight = 2,
                index  = 3,
            };

            var json = model.ToJson();

            Assert.AreEqual(@"{""mesh"":1,""index"":3,""weight"":2}", json);
            Debug.Log(json);

            var c = new JsonSchemaValidationContext("")
            {
                EnableDiagnosisForNotRequiredFields = true,
            };
            var json2 = JsonSchema.FromType <glTF_VRM_BlendShapeBind>().Serialize(model, c);

            Assert.AreEqual(json, json2);
        }
コード例 #24
0
        public SchemaDefinition GetSchema(Type type, Func <Type, string> topicResolver)
        {
            if (topicResolver == null)
            {
                throw new ArgumentException("topicResolver", "TopicResolver must be specified");
            }

            if (type == null)
            {
                throw new ArgumentException("type", "Type must be specified");
            }

            var schema     = JsonSchema.FromType(type);
            var jsonSchema = schema.ToJson();
            var topic      = topicResolver(type);

            var sampleBuilder = new SampleBuilder();
            var obj           = sampleBuilder.GetSampleFromType(type);
            var sample        = obj != null?JsonConvert.SerializeObject(obj) : string.Empty;

            return(new SchemaDefinition(type.Name, type.FullName, jsonSchema, topic, sample));
        }
コード例 #25
0
        public JsonSchema GetSchema(Type t, HttpDataSerializerOptions options, bool useStringEnums, bool requireReferenceTypes)
        {
            var        settings = GetSchemaSerializationSettings(useStringEnums);
            JsonSchema schema   = JsonSchema.FromType(t, new JsonSchemaGeneratorSettings
            {
                FlattenInheritanceHierarchy           = true,
                AlwaysAllowAdditionalObjectProperties = AllowAdditionalPropertiesForJsonSchemaValidation(options),
                GenerateEnumMappingDescription        = true,
                DefaultReferenceTypeNullHandling      = requireReferenceTypes ? ReferenceTypeNullHandling.NotNull : ReferenceTypeNullHandling.Null,
                SerializerSettings = settings,
                ReflectionService  = new CustomReflectionService(),
                TypeMappers        = new List <ITypeMapper>
                {
                    new TokenStringTypeMapper(),
                    new TokenDateTypeMapper(),
                    new ClientTokenStringTypeMapper(),
                    new ClientTokenDateTypeMapper()
                }
            });

            return(schema);
        }
コード例 #26
0
        public async Task When_property_is_string_enum_then_schema_has_enum()
        {
            //// Arrange


            //// Act
            var schema = JsonSchema.FromType <Foo>(new JsonSchemaGeneratorSettings
            {
                DefaultEnumHandling            = EnumHandling.String,
                GenerateEnumMappingDescription = true
            });
            var data = schema.ToJson();

            //// Assert
            Assert.Equal(JsonObjectType.String, schema.Properties["Bar"].ActualTypeSchema.Type);
            Assert.Equal(3, schema.Properties["Bar"].ActualTypeSchema.Enumeration.Count);
            Assert.Equal("A", schema.Properties["Bar"].ActualTypeSchema.Enumeration.ElementAt(0));
            Assert.Equal("B", schema.Properties["Bar"].ActualTypeSchema.Enumeration.ElementAt(1));
            Assert.Equal("C", schema.Properties["Bar"].ActualTypeSchema.Enumeration.ElementAt(2));

            Assert.DoesNotContain("=", schema.Properties["Bar"].ActualTypeSchema.Description); // string enums do not have mapping in description
        }
コード例 #27
0
        public async Task When_constructor_interface_and_conversion_code_is_generated_then_it_is_correct()
        {
            //// Arrange
            var schema = JsonSchema.FromType <Person>(new JsonSchemaGeneratorSettings());
            var json   = schema.ToJson();

            //// Act
            var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
            {
                GenerateConstructorInterface    = true,
                ConvertConstructorInterfaceData = true,
                TypeScriptVersion = 1.8m
            });

            var output = generator.GenerateFile("MyClass");

            //// Assert

            Assert.DoesNotContain("new MyClass(", output);
            // address property is converted:
            Assert.Contains("this.address = data.address && !(<any>data.address).toJSON ? new Address(data.address) : <Address>this.address;", output);
            // cars items are converted:
            Assert.Contains("this.cars[i] = item && !(<any>item).toJSON ? new Car(item) : <Car>item;", output);
            // skills values are converted:
            Assert.Contains("this.skills[key] = item && !(<any>item).toJSON ? new Skill(item) : <Skill>item;", output);
            // student car is converted:
            Assert.Contains("this.car = data.car && !(<any>data.car).toJSON ? new Car(data.car) : <Car>this.car;", output);

            // interface is correct
            Assert.Contains(@"export interface IMyClass {
    supervisor: MyClass;
    address: IAddress;
    cars: ICar[];
    skills: { [key: string] : ISkill; };
    foo: Car[][];
    bar: { [key: string] : Skill[]; };
}".Replace("\r", "").Replace("\n", ""), output.Replace("\r", "").Replace("\n", ""));
        }
コード例 #28
0
ファイル: InheritanceTests.cs プロジェクト: xumix/NJsonSchema
        public async Task When_empty_class_inherits_from_dictionary_then_allOf_inheritance_still_works()
        {
            //// Arrange
            var schema = JsonSchema.FromType <MyContainer>();
            var data   = schema.ToJson();

            var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings());

            //// Act
            var code = generator.GenerateFile();

            //// Assert
            var dschema = schema.Definitions["EmptyClassInheritingDictionary"];

            Assert.Equal(0, dschema.AllOf.Count);
            Assert.True(dschema.IsDictionary);
            Assert.Contains("Foobar.", data);
            Assert.Contains("Foobar.", code);

            Assert.DoesNotContain("class CustomDictionary :", code);
            Assert.Contains("public EmptyClassInheritingDictionary CustomDictionary", code);
            Assert.Contains("public partial class EmptyClassInheritingDictionary : System.Collections.Generic.Dictionary<string, object>", code);
        }
コード例 #29
0
        public void HumanoidBoneTest()
        {
            var model = new glTF_VRM_HumanoidBone()
            {
                bone = "hips", // NOTE: This field must not be null?
            };

            var json = model.ToJson();

            Assert.AreEqual(@"{""bone"":""hips"",""node"":-1,""useDefaultValues"":true}", json);
            Debug.Log(json);

            var c = new JsonSchemaValidationContext("")
            {
                EnableDiagnosisForNotRequiredFields = true,
            };
            var json2 = JsonSchema.FromType <glTF_VRM_HumanoidBone>().Serialize(model, c);

            // NOTE: New serializer outputs values which will not be used...
            Assert.AreEqual(
                @"{""bone"":""hips"",""node"":-1,""useDefaultValues"":true,""min"":{""x"":0,""y"":0,""z"":0},""max"":{""x"":0,""y"":0,""z"":0},""center"":{""x"":0,""y"":0,""z"":0},""axisLength"":0}",
                json2);
        }
コード例 #30
0
        public async Task When_property_is_integer_enum_then_schema_has_enum()
        {
            //// Arrange


            //// Act
            var schema = JsonSchema.FromType <Foo>(new JsonSchemaGeneratorSettings
            {
                DefaultEnumHandling            = EnumHandling.Integer,
                GenerateEnumMappingDescription = true
            });
            var data = schema.ToJson();

            //// Assert
            Assert.Equal(JsonObjectType.Integer, schema.Properties["Bar"].ActualTypeSchema.Type);
            Assert.Equal(3, schema.Properties["Bar"].ActualTypeSchema.Enumeration.Count);
            Assert.Equal(0, schema.Properties["Bar"].ActualTypeSchema.Enumeration.ElementAt(0));
            Assert.Equal(5, schema.Properties["Bar"].ActualTypeSchema.Enumeration.ElementAt(1));
            Assert.Equal(6, schema.Properties["Bar"].ActualTypeSchema.Enumeration.ElementAt(2));

            Assert.Contains("Foo bar.", schema.Properties["Bar"].ActualTypeSchema.Description); // option is enabled
            Assert.Contains("5 = B", schema.Properties["Bar"].ActualTypeSchema.Description);    // option is enabled
        }