public void TestSchemaEncodeDecodeFidelity()
{
var schema = BooleanSchema.Of();
Assert.Equal(new bool?(true), schema.Decode(schema.Encode(true)));
Assert.Equal(new bool?(false), schema.Decode(schema.Encode(false)));
}
public void RecordWithMissingFields()
{
var boolean = new BooleanSchema();
var array = new ArraySchema(boolean);
var map = new MapSchema(new IntSchema());
var @enum = new EnumSchema("Position", new[] { "First", "Last" });
var union = new UnionSchema(new Schema[]
{
new NullSchema(),
array
});
var schema = new RecordSchema("AllFields", new[]
{
new RecordField("First", union),
new RecordField("Second", union),
new RecordField("Third", array),
new RecordField("Fourth", array),
new RecordField("Fifth", map),
new RecordField("Sixth", map),
new RecordField("Seventh", @enum),
new RecordField("Eighth", @enum)
});
var deserializer = DeserializerBuilder.BuildDeserializer <WithoutEvenFields>(schema);
var serializer = SerializerBuilder.BuildSerializer <WithEvenFields>(schema);
var value = new WithEvenFields()
{
First = new List <bool>()
{
false
},
Second = new List <bool>()
{
false, false
},
Third = new List <bool>()
{
false, false, false
},
Fourth = new List <bool>()
{
false
},
Fifth = new Dictionary <string, int>()
{
{ "first", 1 }
},
Sixth = new Dictionary <string, int>()
{
{ "first", 1 }, { "second", 2 }
},
Seventh = Position.Last,
Eighth = Position.First
};
Assert.Equal(value.Seventh, deserializer.Deserialize(serializer.Serialize(value)).Seventh);
}
public void testBoolean()
{
BooleanSchema schema = new BooleanSchema();
Assert.AreEqual(schema, Schema.Parse("{\"type\":\"boolean\"}"));
Assert.AreEqual(schema, Schema.Parse("\"boolean\""));
check("\"boolean\"", "true", true);
}
public void RecordWithMissingFields()
{
var boolean = new BooleanSchema();
var array = new ArraySchema(boolean);
var map = new MapSchema(boolean);
var union = new UnionSchema(new Schema[]
{
new NullSchema(),
array
});
var schema = new RecordSchema("AllFields", new[]
{
new RecordField("First", union),
new RecordField("Second", union),
new RecordField("Third", array),
new RecordField("Fourth", array),
new RecordField("Fifth", map),
new RecordField("Sixth", map),
new RecordField("Seventh", boolean),
new RecordField("Eighth", boolean)
});
var deserializer = DeserializerBuilder.BuildDeserializer <WithoutEvenFields>(schema);
var serializer = SerializerBuilder.BuildSerializer <WithEvenFields>(schema);
var value = new WithEvenFields()
{
First = new List <bool>()
{
false
},
Second = new List <bool>()
{
false, false
},
Third = new List <bool>()
{
false, false, false
},
Fourth = new List <bool>()
{
false
},
Fifth = new Dictionary <string, bool>()
{
{ "first", false }
},
Sixth = new Dictionary <string, bool>()
{
{ "first", false }, { "second", false }
},
Seventh = true,
Eighth = false
};
Assert.True(deserializer.Deserialize(serializer.Serialize(value)).Seventh);
}
public void TestSchemaDecode()
{
var trueBytes = new byte[] { 1 };
var falseBytes = new byte[] { 0 };
var schema = BooleanSchema.Of();
Assert.Equal(new bool?(true), schema.Decode(trueBytes));
Assert.Equal(new bool?(false), schema.Decode(falseBytes));
}
public void TestSchemaEncode()
{
var schema = BooleanSchema.Of();
var expectedTrue = new byte[] { 1 };
var expectedFalse = new byte[] { 0 };
Assert.Equal(expectedTrue, schema.Encode(true));
Assert.Equal(expectedFalse, schema.Encode(false));
}
public void BooleanValues(bool value)
{
var schema = new BooleanSchema();
var deserializer = DeserializerBuilder.BuildDeserializer <bool>(schema);
var serializer = SerializerBuilder.BuildSerializer <bool>(schema);
Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value)));
}
/// <summary>
/// Builds a boolean schema.
/// </summary>
/// <param name="resolution">
/// A type resolution.
/// </param>
/// <param name="cache">
/// A schema cache.
/// </param>
/// <returns>
/// A <see cref="BooleanSchema" /> that matches the type resolution.
/// </returns>
/// <exception cref="ArgumentException">
/// Thrown when the resolution is not a <see cref="BooleanResolution" />.
/// </exception>
public override Schema BuildSchema(TypeResolution resolution, IDictionary <Type, Schema> cache)
{
if (!(resolution is BooleanResolution boolean))
{
throw new ArgumentException("The boolean case can only be applied to boolean resolutions.", nameof(resolution));
}
var schema = new BooleanSchema();
cache.Add(boolean.Type, schema);
return(schema);
}
static Schema()
{
ByteSequence = new ByteSequenceSchema();
ByteArray = new ByteArraySchema();
String = StringSchema.UTF8;
Boolean = new BooleanSchema();
Int8 = new ByteSchema();
Int16 = new ShortSchema();
Int32 = new IntegerSchema();
Int64 = new LongSchema();
Float = new FloatSchema();
TimeStamp = TimestampSchema.Timestamp;
Date = TimestampSchema.Date;
Time = new TimeSchema();
}
public void DynamicBooleanValues(bool value)
{
var schema = new BooleanSchema();
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(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}."),
});
/// <summary>
/// Builds a <see cref="BooleanSchema" />.
/// </summary>
/// <returns>
/// A successful <see cref="SchemaBuilderCaseResult" /> with a <see cref="BooleanSchema" />
/// if <paramref name="type" /> is <see cref="bool" />; an unsuccessful
/// <see cref="SchemaBuilderCaseResult" /> with an <see cref="UnsupportedTypeException" />
/// otherwise.
/// </returns>
/// <inheritdoc />
public virtual SchemaBuilderCaseResult BuildSchema(Type type, SchemaBuilderContext context)
{
if (type == typeof(bool))
{
var booleanSchema = new BooleanSchema();
try
{
context.Schemas.Add(type, booleanSchema);
}
catch (ArgumentException exception)
{
throw new InvalidOperationException($"A schema for {type} already exists on the schema builder context.", exception);
}
return(SchemaBuilderCaseResult.FromSchema(booleanSchema));
}
else
{
return(SchemaBuilderCaseResult.FromException(new UnsupportedTypeException(type, $"{nameof(BooleanSchemaBuilderCase)} can only be applied to the {typeof(bool)} type.")));
}
}
public void RecordWithMissingFields()
{
var boolean = new BooleanSchema();
var array = new ArraySchema(boolean);
var map = new MapSchema(new IntSchema());
var @enum = new EnumSchema("Ordinal", new[] { "None", "First", "Second", "Third", "Fourth" });
var union = new UnionSchema(new Schema[]
{
new NullSchema(),
array,
});
var schema = new RecordSchema("AllFields")
{
Fields = new[]
{
new RecordField("First", union),
new RecordField("Second", union),
new RecordField("Third", array),
new RecordField("Fourth", array),
new RecordField("Fifth", map),
new RecordField("Sixth", map),
new RecordField("Seventh", @enum),
new RecordField("Eighth", @enum),
},
};
var deserialize = deserializerBuilder.BuildDelegate <WithoutEvenFields>(schema);
var serialize = serializerBuilder.BuildDelegate <WithEvenFields>(schema);
var value = new WithEvenFields()
{
First = new List <bool>()
{
false
},
Second = new List <bool>()
{
false, false
},
Third = new List <bool>()
{
false, false, false
},
Fourth = new List <bool>()
{
false
},
Fifth = new Dictionary <string, int>()
{
{ "first", 1 }
},
Sixth = new Dictionary <string, int>()
{
{ "first", 1 }, { "second", 2 }
},
Seventh = ImplicitEnum.First,
Eighth = ImplicitEnum.None,
};
using (stream)
{
serialize(value, new Utf8JsonWriter(stream));
}
var reader = new Utf8JsonReader(stream.ToArray());
Assert.Equal(value.Seventh, deserialize(ref reader).Seventh);
}
private void VisitCore(BooleanSchema s)
{
s.Serializer = new BooleanSerializer(s);
}
