public void TestUnwrapObjectPassingInvalidObject() { StringSchema schema = new StringSchema(); IValueSchema<object> wrapper = schema.Wrap(); Assert.IsNotNull(wrapper); Assert.AreEqual(typeof(string), wrapper.Type); wrapper.UnwrapRefType<ArrayList>(); }
public void TestUnwrapStructPassingObjecSchema() { StringSchema schema = new StringSchema(); IValueSchema<object> wrapper = schema.Wrap(); Assert.IsNotNull(wrapper); Assert.AreEqual(typeof(string), wrapper.Type); wrapper.UnwrapValueType<int>(); }
public void NullableGuidValues(Guid value) { var schema = new StringSchema(); var deserializer = DeserializerBuilder.BuildDeserializer <Guid?>(schema); var serializer = SerializerBuilder.BuildSerializer <Guid>(schema); Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value))); }
public void NullableDateTimeValues(DateTime value) { var schema = new StringSchema(); var deserializer = DeserializerBuilder.BuildDeserializer <DateTime?>(schema); var serializer = SerializerBuilder.BuildSerializer <DateTime>(schema); Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value))); }
public void UriValues(Uri value) { var schema = new StringSchema(); var deserializer = DeserializerBuilder.BuildDeserializer <Uri>(schema); var serializer = SerializerBuilder.BuildSerializer <Uri>(schema); Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value))); }
public void NullableTimeSpanValues(TimeSpan value) { var schema = new StringSchema(); var deserializer = DeserializerBuilder.BuildDeserializer <TimeSpan?>(schema); var serializer = SerializerBuilder.BuildSerializer <TimeSpan>(schema); Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value))); }
private async void ShowComplexWindow(object sender, RoutedEventArgs e) { var nameSchema = new StringSchema(); var window = new MaterialWindow(new MaterialDialog { Title = "Demo material forms", Form = new MaterialForm { new CommandSchema { Name = "Login window", CommandHint = "SHOW", Callback = ShowLogin }, new CommandSchema { Name = "Settings window", CommandHint = "SHOW", Callback = ShowDemo(SettingsDialog) }, new CommandSchema { Name = "2x settings window (data binding)", CommandHint = "SHOW", Callback = ShowDemo(SettingsDialog, true) }, new CommandSchema { Name = "Dialog inside window", CommandHint = "SHOW", Callback = async args => { await((WindowSession)args.Session).ShowDialog(new MaterialDialog { Message = "Discard draft?", PositiveAction = "DISCARD" }, 250d); } }, new CommandSchema { Name = "E-mail window", CommandHint = "SHOW", Callback = ShowDemo(EmailDialog) }, new CommandSchema { Name = "Modal 2x schema (data binding)", CommandHint = "SHOW", Callback = async args => await((WindowSession)args.Session).ShowDialog(new MaterialDialog(nameSchema, nameSchema), 250d) } } }); await window.Show(); }
public void UseFirstChildOfUnionSchema() { var @int = new IntSchema(); var @string = new StringSchema(); var union = new UnionSchema(new Schema[] { @int, @string }); var defaultValue = new ObjectDefaultValue <int>(1, union); Assert.Equal(@int, defaultValue.Schema); }
public void TestStringSchemaMinMaxLengthValid() { StringSchema schema = new StringSchema { MinLength = 2, MaxLength = 5 }; schema.Validate("12"); schema.Validate("123"); schema.Validate("1234"); schema.Validate("12345"); }
public void TestUnwrapObject() { StringSchema schema = new StringSchema(); IValueSchema<object> wrapper = schema.Wrap(); Assert.IsNotNull(wrapper); Assert.AreEqual(typeof(string), wrapper.Type); IValueSchema<string> vs = wrapper.UnwrapRefType<string>(); Assert.IsNotNull(vs); StringSchema stringSchema = vs as StringSchema; Assert.IsNotNull(stringSchema); }
public void TestStringSchemaNoNullAllowed() { StringSchema schema = new StringSchema { AllowNull = false }; Assert.Throws <PropertyValidationException>(() => { schema.Validate(null); }); }
public void TestStringSchemaMinMaxLengthInvalidMax() { StringSchema schema = new StringSchema { MinLength = 2, MaxLength = 5 }; schema.Validate("12"); schema.Validate("123"); schema.Validate("1234"); schema.Validate("12345"); Assert.Throws <PropertyValidationException>(() => { schema.Validate("123456"); }); }
public void GuidValues(Guid value) { var schema = new StringSchema() { LogicalType = new UuidLogicalType() }; var deserializer = DeserializerBuilder.BuildDeserializer <Guid>(schema); var serializer = SerializerBuilder.BuildSerializer <Guid>(schema); Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value))); }
public void TestStringSchemaAllowedValuesInvalid() { StringSchema schema = new StringSchema { PossibleValues = new[] { "one", "two", "three", "four" } }; Assert.Throws <PropertyValidationException>(() => { schema.Validate("five"); }); }
public void TestUnwrapObjectPassingInvalidObject() { StringSchema schema = new StringSchema(); IValueSchema <object> wrapper = schema.Wrap(); Assert.IsNotNull(wrapper); Assert.AreEqual(typeof(string), wrapper.Type); Assert.Throws <InvalidCastException>(() => { wrapper.UnwrapRefType <ArrayList>(); }); }
public void NullableDateTimeOffsetValues(DateTimeOffset value) { var schema = new StringSchema(); var deserializer = DeserializerBuilder.BuildDeserializer <DateTimeOffset?>(schema); var serializer = SerializerBuilder.BuildSerializer <DateTimeOffset>(schema); var decoded = deserializer.Deserialize(serializer.Serialize(value)); // comparing two DateTimeOffsets doesn’t necessarily ensure that they’re identical: Assert.Equal(value.DateTime, decoded.Value.DateTime); Assert.Equal(value.Offset, decoded.Value.Offset); }
/// <summary> /// Builds a timestamp schema. /// </summary> /// <param name="resolution"> /// A type resolution. /// </param> /// <param name="cache"> /// A schema cache. /// </param> /// <returns> /// A <see cref="StringSchema" />. /// </returns> /// <exception cref="ArgumentException"> /// Thrown when the resolution is not a <see cref="TimestampResolution" />. /// </exception> public override Schema BuildSchema(TypeResolution resolution, IDictionary <Type, Schema> cache) { if (!(resolution is TimestampResolution timestamp)) { throw new ArgumentException("The timestamp case can only be applied to timestamp resolutions.", nameof(resolution)); } var schema = new StringSchema(); cache.Add(timestamp.Type, schema); return(schema); }
/// <summary> /// Builds a URI schema. /// </summary> /// <param name="resolution"> /// A type resolution. /// </param> /// <param name="cache"> /// A schema cache. /// </param> /// <returns> /// A <see cref="StringSchema" />. /// </returns> /// <exception cref="ArgumentException"> /// Thrown when the resolution is not a <see cref="UriResolution" />. /// </exception> public override Schema BuildSchema(TypeResolution resolution, IDictionary <Type, Schema> cache) { if (!(resolution is UriResolution uri)) { throw new ArgumentException("The URI case can only be applied to URI resolutions.", nameof(resolution)); } var schema = new StringSchema(); cache.Add(uri.Type, schema); return(schema); }
public void TestStringSchemaMaxLengthValid() { StringSchema schema = new StringSchema { MaxLength = 5 }; schema.Validate(string.Empty); schema.Validate("1"); schema.Validate("12"); schema.Validate("123"); schema.Validate("1234"); schema.Validate("12345"); }
private async void ShowInput(object sender, RoutedEventArgs e) { StringSchema schema = new StringSchema { Name = "Name", IconKind = PackIconKind.Account }; bool?result = await WindowFactory.FromSingleSchema("What is your name?", schema).Show(); if (result == true) { string name = schema.Value; await WindowFactory.Alert($"Hello {name}!").Show(); } }
public void UseFirstChildOfUnionSchema() { var document = JsonSerializer.Deserialize <JsonDocument>("1"); var element = document.RootElement; var @int = new IntSchema(); var @string = new StringSchema(); var union = new UnionSchema(new Schema[] { @int, @string }); var defaultValue = new JsonDefaultValue(element, union); Assert.Equal(@int, defaultValue.Schema); }
public void TestStringSerializeProperties() { JsonPropertySerializer serializer = new JsonPropertySerializer(new PropertySchemaFactory()); StringSchema schema = new StringSchema { MaxLength = 100, MinLength = 1, DefaultValue = "hello" }; PropertyElement element = serializer.Serialize("hello", schema.Wrap()); Assert.IsNotNull(element); Assert.AreEqual(typeof(StringSchema).FullName, element.Schema.SchemaType); Assert.AreEqual(SerializationTypeHint.String, element.SerializationHint); Assert.AreEqual("hello", element.Value); }
public void TestUnwrapObject() { StringSchema schema = new StringSchema(); IValueSchema <object> wrapper = schema.Wrap(); Assert.IsNotNull(wrapper); Assert.AreEqual(typeof(string), wrapper.Type); IValueSchema <string> vs = wrapper.UnwrapRefType <string>(); Assert.IsNotNull(vs); StringSchema stringSchema = vs as StringSchema; Assert.IsNotNull(stringSchema); }
public void TestWrapObject() { StringSchema schema=new StringSchema{AllowNull = true,DefaultValue = "Hello",PossibleValues = new[]{"one","two","Hello","Goodbye"}}; IValueSchema<object> wrapper = schema.Wrap(); Assert.IsNotNull(wrapper); Assert.AreEqual(typeof(string),wrapper.Type); Assert.IsTrue(wrapper.AllowNull); Assert.AreEqual("Hello",wrapper.DefaultValue); Assert.IsNotNull(wrapper.PossibleValues); Assert.AreEqual(4,wrapper.PossibleValues.Count()); Assert.AreEqual("one",wrapper.PossibleValues.ElementAt(0)); Assert.AreEqual("two", wrapper.PossibleValues.ElementAt(1)); Assert.AreEqual("Hello", wrapper.PossibleValues.ElementAt(2)); Assert.AreEqual("Goodbye", wrapper.PossibleValues.ElementAt(3)); }
public void TestSerializeStringSchema() { IValueSchema<string> schema = new StringSchema {AllowNull = true, DefaultValue = "abc", MaxLength = 100, MinLength = 2, PossibleValues = new[]{"abc","def"} }; JsonSchemaSerializationVisitor visitor=new JsonSchemaSerializationVisitor(); schema.Accept(visitor); Assert.AreEqual(typeof(string),visitor.ValueType); Assert.AreEqual(typeof(StringSchema),visitor.SchemaType); Assert.IsNotNull(visitor.JsonValue); Assert.AreNotEqual(0,visitor.JsonValue.Length); }
public void DynamicDateTimeValues(dynamic value) { var schema = new StringSchema(); var deserialize = deserializerBuilder.BuildDelegate <dynamic>(schema); var serialize = serializerBuilder.BuildDelegate <dynamic>(schema); using (stream) { serialize(value, new BinaryWriter(stream)); } var reader = new BinaryReader(stream.ToArray()); Assert.Equal(value.ToString("O"), deserialize(ref reader)); }
public void UriValues(Uri value) { var schema = new StringSchema(); var deserialize = deserializerBuilder.BuildDelegate <Uri>(schema); var serialize = serializerBuilder.BuildDelegate <Uri>(schema); using (stream) { serialize(value, new BinaryWriter(stream)); } var reader = new BinaryReader(stream.ToArray()); Assert.Equal(value, deserialize(ref reader)); }
public void NullableTimeSpanValues(TimeSpan value) { var schema = new StringSchema(); var deserialize = deserializerBuilder.BuildDelegate <TimeSpan?>(schema); var serialize = serializerBuilder.BuildDelegate <TimeSpan>(schema); using (stream) { serialize(value, new BinaryWriter(stream)); } var reader = new BinaryReader(stream.ToArray()); Assert.Equal(value, deserialize(ref reader)); }
/// <summary> /// Builds a UUID schema. /// </summary> /// <param name="resolution"> /// A type resolution. /// </param> /// <param name="cache"> /// A schema cache. /// </param> /// <returns> /// A <see cref="StringSchema" />. /// </returns> /// <exception cref="ArgumentException"> /// Thrown when the resolution is not a <see cref="UuidResolution" />. /// </exception> public override Schema BuildSchema(TypeResolution resolution, IDictionary <Type, Schema> cache) { if (!(resolution is UuidResolution uuid)) { throw new ArgumentException("The UUID case can only be applied to UUID resolutions.", nameof(resolution)); } var schema = new StringSchema() { LogicalType = new UuidLogicalType() }; cache.Add(uuid.Type, schema); return(schema); }
public void DateTimeValues(DateTime value) { var schema = new StringSchema(); var deserialize = deserializerBuilder.BuildDelegate <DateTime>(schema); var serialize = serializerBuilder.BuildDelegate <DateTime>(schema); using (stream) { serialize(value, new Utf8JsonWriter(stream)); } var reader = new Utf8JsonReader(stream.ToArray()); Assert.Equal(value, deserialize(ref reader)); }
/// <summary> /// Writes an <see cref="PrimitiveSchema" />. /// </summary> /// <inheritdoc /> public virtual JsonSchemaWriterCaseResult Write(Schema schema, Utf8JsonWriter json, bool canonical, JsonSchemaWriterContext context) { if (schema is PrimitiveSchema primitiveSchema) { json.WriteStringValue(primitiveSchema switch { BooleanSchema _ => JsonSchemaToken.Boolean, BytesSchema _ => JsonSchemaToken.Bytes, DoubleSchema _ => JsonSchemaToken.Double, FloatSchema _ => JsonSchemaToken.Float, IntSchema _ => JsonSchemaToken.Int, LongSchema _ => JsonSchemaToken.Long, NullSchema _ => JsonSchemaToken.Null, StringSchema _ => JsonSchemaToken.String, _ => throw new UnsupportedSchemaException(schema, $"Unknown primitive schema {schema}."), });
public void DynamicTimeSpanValues(TimeSpan value) { var schema = new StringSchema(); var deserialize = deserializerBuilder.BuildDelegate <dynamic>(schema); var serialize = serializerBuilder.BuildDelegate <dynamic>(schema); using (stream) { serialize(value, new Utf8JsonWriter(stream)); } var reader = new Utf8JsonReader(stream.ToArray()); Assert.Equal(XmlConvert.ToString(value), deserialize(ref reader)); }
public void TestStringSchemaEquality() { StringSchema s1 = new StringSchema(); StringSchema s2 = new StringSchema(); Assert.IsTrue(s1.Equals(s2)); Assert.IsTrue(s2.Equals(s1)); Assert.AreEqual(s1.GetHashCode(), s2.GetHashCode()); s1 = new StringSchema { DefaultValue = "two", MaxLength = 100, MinLength = 1, PossibleValues = new[] { "one", "two", "three", "four" } }; s2 = new StringSchema { DefaultValue = "two", MaxLength = 100, MinLength = 1, PossibleValues = new[] { "one", "two", "three", "four" } }; Assert.IsTrue(s1.Equals(s2)); Assert.IsTrue(s2.Equals(s1)); Assert.AreEqual(s1.GetHashCode(), s2.GetHashCode()); s2 = new StringSchema { DefaultValue = "two", MaxLength = 100, MinLength = 1, PossibleValues = new[] { "one", "2", "three", "four" } }; Assert.IsFalse(s1.Equals(s2)); Assert.IsFalse(s2.Equals(s1)); Assert.AreNotEqual(s1.GetHashCode(), s2.GetHashCode()); s2 = new StringSchema { AllowNull = true }; Assert.IsFalse(s1.Equals(s2)); Assert.IsFalse(s2.Equals(s1)); Assert.AreNotEqual(s1.GetHashCode(), s2.GetHashCode()); }
public void TestSerializeStringSchema() { IValueSchema <string> schema = new StringSchema { AllowNull = true, DefaultValue = "abc", MaxLength = 100, MinLength = 2, PossibleValues = new[] { "abc", "def" } }; SchemaJsonSerializationVisitor visitor = new SchemaJsonSerializationVisitor(); schema.Accept(visitor); Assert.AreEqual(typeof(string), visitor.ValueType); Assert.AreEqual(typeof(StringSchema), visitor.SchemaType); Assert.IsNotNull(visitor.JsonValue); Assert.AreNotEqual(0, visitor.JsonValue.Length); }
public void NonUnionReferenceToUnionTest() { var writerSchema = new StringSchema(); var readerSchema = new UnionSchema(new FloatSchema(), new StringSchema(), new BytesSchema()); var writer = new DatumWriter <string>(writerSchema); var reader = new DatumReader <object>(readerSchema, writerSchema); var expectedValue = "Test String"; using (var stream = new MemoryStream()) using (var encoder = new BinaryEncoder(stream)) using (var decoder = new BinaryDecoder(stream)) { writer.Write(encoder, expectedValue); stream.Seek(0, SeekOrigin.Begin); Assert.AreEqual(expectedValue, reader.Read(decoder)); } }
public void TestStringSerializeProperties() { JsonPropertySerializer serializer=new JsonPropertySerializer(new PropertySchemaFactory()); StringSchema schema=new StringSchema{MaxLength = 100,MinLength = 1, DefaultValue = "hello"}; PropertyElement element = serializer.Serialize("key", "hello", schema.Wrap()); Assert.IsNotNull(element); Assert.AreEqual(typeof(StringSchema).FullName,element.SchemaType); Assert.AreEqual(SerializationValueType.String,element.SerializationValueType); Assert.AreEqual("hello",element.ValString); }
public void TestStringDeSerializeProperties() { JsonPropertySerializer serializer = new JsonPropertySerializer(new PropertySchemaFactory()); StringSchema schema = new StringSchema { MaxLength = 100, MinLength = 1, DefaultValue = "hello" }; PropertyElement element = serializer.Serialize("key", "hello", schema.Wrap()); Assert.IsNotNull(element); Assert.AreEqual(typeof(StringSchema).FullName, element.SchemaType); Assert.AreEqual(SerializationValueType.String, element.SerializationValueType); Assert.AreEqual("hello", element.ValString); IValueSchema<object> vs; object value = serializer.Deserialize(element, out vs); Assert.IsNotNull(vs); Assert.IsNotNull(value); IValueSchema<string> strSchema = vs.UnwrapRefType<string>(); Assert.IsNotNull(strSchema); }