private void executeBehavior(IJsonReader reader)
{
var behavior = new DeserializeJsonBehavior<Message>(reader, request);
var next = MockRepository.GenerateMock<IActionBehavior>();
behavior.InsideBehavior = next;
behavior.Invoke();
next.AssertWasCalled(x => x.Invoke());
}
public void setup()
{
// sub the file reader
file_reader = Substitute.For<IFileReader>();
file_reader.Read( "foo_path" ).Returns( "foo_json" );
// sub the json reader
json_reader = Substitute.For<IJsonReader>();
json_reader.Serialize<TestAsset>( "foo_json" ).Returns( new TestAsset() { TestString = "Bar" } );
}
private static PointComplex ParseJson(IJsonReader r)
{
if (r.GetLiteralKind() == LiteralKind.String)
{
var parts = ((string)r.GetLiteralString()).Split(',');
if (parts.Length == 2)
{
var pt = new PointComplex()
{
X = int.Parse(parts[0], CultureInfo.InvariantCulture),
Y = int.Parse(parts[0], CultureInfo.InvariantCulture),
};
r.NextToken();
return pt;
}
}
throw new InvalidDataException("Invalid point");
}
/// <summary>
/// Read list of specific type.
/// </summary>
/// <typeparam name="TItem">The item type.</typeparam>
/// <param name="reader">The json reader.</param>
/// <param name="itemDecoder">The item decoder.</param>
/// <returns>The decoded list.</returns>
protected static List <TItem> ReadList <TItem>(IJsonReader reader, IDecoder <TItem> itemDecoder)
{
return(ListDecoder <TItem> .Decode(reader, itemDecoder));
}
/// <summary>
/// The decode.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>The value.</returns>
public byte[] Decode(IJsonReader reader)
{
return(reader.ReadBytes());
}
/// <summary>
/// The decode.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>The value.</returns>
public bool Decode(IJsonReader reader)
{
return(reader.ReadBoolean());
}
/// <summary>
/// The decode.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>The value.</returns>
public float Decode(IJsonReader reader)
{
return(reader.ReadSingle());
}
/// <summary>
/// Writes raw JSON where a value is expected and updates the writer's state.
/// </summary>
/// <param name="json">The raw JSON to write.</param>
public override void WriteRawValue(string json)
{
IJsonReader jsonReader = JsonReader.Create(Encoding.UTF8.GetBytes(json));
this.jsonWriter.WriteAll(jsonReader);
}
private void DeserializeClassProperty(object obj, PdClassBase pd, IJsonReader jsonReader)
{
var instance = pd.PropertyFabric.CreateInstance(obj);
Deserialize(instance, jsonReader);
}
bool IJsonLoadField.OnJsonField(IJsonReader r, string key)
{
fieldLoaded = true;
return false;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="innerReader">The inner JSON reader.</param>
/// <param name="maxInnerErrorDepth">The maximum number of recursive internalexception objects to allow when reading in-stream errors.</param>
internal ReorderingJsonReader(IJsonReader innerReader, int maxInnerErrorDepth)
: base(innerReader, JsonLightConstants.ODataErrorPropertyName, maxInnerErrorDepth)
{
Debug.Assert(innerReader != null, "innerReader != null");
}
private static bool IsLiteralTerminator(char ch, bool quoted, char quoteCh, bool escaped, bool eos, IJsonReader reader)
{
if (!escaped && quoted && ch == quoteCh)
{
return(true);
}
else if (quoted && (ch == INSIGNIFICANT_NEWLINE || ch == INSIGNIFICANT_RETURN))
{
throw JsonSerializationException.UnterminatedStringLiteral(reader);
}
else if (eos)
{
if (quoted)
{
throw JsonSerializationException.UnexpectedEndOfStream(reader);
}
else
{
return(true);
}
}
else if (!quoted &&
(ch == SIGNIFICANT_BEGIN_ARRAY || ch == SIGNIFICANT_BEGIN_OBJECT || ch == SIGNIFICANT_END_ARRAY ||
ch == SIGNIFICANT_END_OBJECT || ch == INSIGNIFICANT_VALUE_SEPARATOR || ch == INSIGNIFICANT_NAME_SEPARATOR))
{
return(true);
}
else if (!quoted && IsInsignificantWhitespace(ch))
{
return(true);
}
return(false);
}
/// <summary>
/// Writes current token from a json reader to the internal buffer.
/// </summary>
/// <param name="jsonReader">The JsonReader to the get the current token from.</param>
public void WriteCurrentToken(IJsonReader jsonReader)
{
if (jsonReader == null)
{
throw new ArgumentNullException("jsonReader can not be null");
}
// For now we don't optimize for text, since the reader could be UTF-8 and the writer could be UTF-16.
// We need to add more enums for the different serialization formats.
bool sameFormat = jsonReader.SerializationFormat == this.SerializationFormat && (this.SerializationFormat == JsonSerializationFormat.Binary || this.SerializationFormat == JsonSerializationFormat.HybridRow);
JsonTokenType jsonTokenType = jsonReader.CurrentTokenType;
switch (jsonTokenType)
{
case JsonTokenType.NotStarted:
break;
case JsonTokenType.BeginArray:
this.WriteArrayStart();
break;
case JsonTokenType.EndArray:
this.WriteArrayEnd();
break;
case JsonTokenType.BeginObject:
this.WriteObjectStart();
break;
case JsonTokenType.EndObject:
this.WriteObjectEnd();
break;
case JsonTokenType.True:
this.WriteBoolValue(true);
break;
case JsonTokenType.False:
this.WriteBoolValue(false);
break;
case JsonTokenType.Null:
this.WriteNullValue();
break;
case JsonTokenType.String:
case JsonTokenType.Number:
case JsonTokenType.FieldName:
{
if (sameFormat)
{
IReadOnlyList <byte> bufferedRawJson = jsonReader.GetBufferedRawJsonToken();
this.WriteRawJsonToken(jsonTokenType, bufferedRawJson);
}
else
{
if (jsonTokenType == JsonTokenType.Number)
{
double number = jsonReader.GetNumberValue();
this.WriteNumberValue(number);
}
else
{
string value = jsonReader.GetStringValue();
if (jsonTokenType == JsonTokenType.FieldName)
{
this.WriteFieldName(value);
}
else
{
this.WriteStringValue(value);
}
}
}
break;
}
default:
throw new ArgumentException($"Unexpected JsonTokenType: {jsonTokenType}");
}
}
void IJsonLoading.OnJsonLoading(IJsonReader r)
{
loading = true;
}
/// <summary> /// Decode based on given tag. /// </summary> /// <param name="tag">The tag.</param> /// <param name="reader">The reader.</param> /// <returns>The decoded object.</returns> protected abstract T Decode(string tag, IJsonReader reader);
public override object Deserialize(IJsonReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
var container = new List <DictionaryEntry>();
reader.Context.Hierarchy.Push(container);
try
{
if (reader.Token == JsonToken.BeginArray)
{
while (reader.NextToken() && reader.Token != JsonToken.EndOfArray)
{
if (reader.Token != JsonToken.BeginArray || !reader.NextToken())
{
throw new UnexpectedToken(reader, JsonToken.BeginArray);
}
object key = null;
object value = null;
try
{
key = reader.ReadValue(keyType, false);
}
catch (Exception e)
{
throw new SerializationException(string.Format("Failed to read '{0}' key of dictionary: {1}\r\nMore detailed information in inner exception.", keyType.Name, e.Message), e);
}
if (!reader.NextToken())
{
throw new UnexpectedToken(reader, JsonToken.Boolean, JsonToken.DateTime, JsonToken.Number,
JsonToken.StringLiteral);
}
try
{
value = reader.ReadValue(valueType, false);
}
catch (Exception e)
{
throw new SerializationException(string.Format("Failed to read '{0}' value for key '{1}' in dictionary: {2}\r\nMore detailed information in inner exception.", valueType.Name, key, e.Message), e);
}
container.Add(new DictionaryEntry(key, value));
if (!reader.NextToken() || reader.Token != JsonToken.EndOfArray)
{
throw new UnexpectedToken(reader, JsonToken.EndOfArray);
}
}
}
else if (reader.Token == JsonToken.BeginObject)
{
while (reader.NextToken() && reader.Token != JsonToken.EndOfObject)
{
if (reader.Token != JsonToken.Member)
{
throw new UnexpectedToken(reader, JsonToken.Member);
}
string key = null;
object value = null;
try
{
key = reader.Value.AsString;
}
catch (Exception e)
{
throw new SerializationException(string.Format("Failed to read '{0}' key of dictionary: {1}\r\nMore detailed information in inner exception.", keyType.Name, e.Message), e);
}
if (!reader.NextToken())
{
throw new UnexpectedToken(reader, JsonToken.Boolean, JsonToken.DateTime, JsonToken.Number,
JsonToken.StringLiteral);
}
try
{
value = reader.ReadValue(valueType, false);
}
catch (Exception e)
{
throw new SerializationException(string.Format("Failed to read '{0}' value for key '{1}' in dictionary: {2}\r\nMore detailed information in inner exception.", valueType.Name, key, e.Message), e);
}
container.Add(new DictionaryEntry(key, value));
}
}
else
{
throw new UnexpectedToken(reader, JsonToken.BeginObject, JsonToken.BeginArray);
}
var dictionary = (IDictionary)Activator.CreateInstance(this.dictionaryType);
foreach (var kv in container)
{
var key = kv.Key;
var value = kv.Value;
if (this.keyType.IsEnum)
{
key = Enum.Parse(this.keyType, Convert.ToString(key));
}
else if (this.keyType != typeof(string) && this.keyType != typeof(object))
{
key = Convert.ChangeType(key, this.keyType);
}
if (dictionary.Contains(key))
{
dictionary.Remove(key);
}
dictionary.Add(key, value);
}
return(dictionary);
}
finally
{
reader.Context.Hierarchy.Pop();
}
}
/// <summary>
/// The decode.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>The value.</returns>
public List <T> Decode(IJsonReader reader)
{
return(Decode(reader, this.itemDecoder));
}
public void FromJson(IJsonReader reader)
{
reader.Read();
reader.Read();
}
public override JsonNull FromJson(IJsonContext context, IJsonReader reader)
{
return(reader.GetNextToken() == JsonToken.Null
? JsonNull.Null
: ExceptionHelper.ThrowInvalidJsonException <JsonNull>());
}
private void MultiSerializationRoundTrip(string json)
{
// Normalize the json to get rid of any formatting issues
json = this.NewtonsoftFormat(json);
foreach (SerializationFormat sourceFormat in Enum.GetValues(typeof(SerializationFormat)))
{
foreach (SerializationFormat destinationFormat in Enum.GetValues(typeof(SerializationFormat)))
{
IJsonReader reader;
switch (sourceFormat)
{
case SerializationFormat.Text:
reader = JsonReader.Create(Encoding.UTF8.GetBytes(json));
break;
case SerializationFormat.Binary:
reader = JsonReader.Create(JsonTestUtils.ConvertTextToBinary(json));
break;
case SerializationFormat.NewtonsoftText:
reader = new JsonNewtonsoftNewtonsoftTextReader(json);
break;
default:
throw new ArgumentException($"Unexpected {nameof(sourceFormat)} of type: {sourceFormat}");
}
IJsonNavigator navigator;
switch (sourceFormat)
{
case SerializationFormat.Text:
navigator = JsonNavigator.Create(Encoding.UTF8.GetBytes(json));
break;
case SerializationFormat.Binary:
navigator = JsonNavigator.Create(JsonTestUtils.ConvertTextToBinary(json));
break;
case SerializationFormat.NewtonsoftText:
navigator = new JsonNewtonsoftNavigator(json);
break;
default:
throw new ArgumentException($"Unexpected {nameof(sourceFormat)} of type: {sourceFormat}");
}
object[] sources = new object[] { reader, navigator };
foreach (object source in sources)
{
IJsonWriter writer;
switch (destinationFormat)
{
case SerializationFormat.Text:
writer = JsonWriter.Create(JsonSerializationFormat.Text);
break;
case SerializationFormat.Binary:
writer = JsonWriter.Create(JsonSerializationFormat.Binary);
break;
case SerializationFormat.NewtonsoftText:
writer = new JsonNewtonsoftNewtonsoftTextWriter();
break;
default:
throw new ArgumentException($"Unexpected {nameof(destinationFormat)} of type: {destinationFormat}");
}
Stopwatch stopwatch = Stopwatch.StartNew();
if (source is IJsonReader)
{
IJsonReader sourceReader = source as IJsonReader;
writer.WriteAll(sourceReader);
}
else if (source is IJsonNavigator)
{
IJsonNavigator sourceNavigator = source as IJsonNavigator;
writer.WriteJsonNode(sourceNavigator, sourceNavigator.GetRootNode());
}
stopwatch.Stop();
string result;
switch (writer.SerializationFormat)
{
case JsonSerializationFormat.Text:
result = Encoding.UTF8.GetString(writer.GetResult());
break;
case JsonSerializationFormat.Binary:
result = JsonTestUtils.ConvertBinaryToText(writer.GetResult());
break;
default:
throw new ArgumentException();
}
result = this.NewtonsoftFormat(result);
Assert.AreEqual(json, result);
string sourceType = (source is IJsonReader) ? "Reader" : "Navigator";
Console.WriteLine($"{sourceFormat} {sourceType} to {destinationFormat} Writer took {stopwatch.ElapsedMilliseconds}ms");
}
}
}
}
private static JsonToken[] GetTokensWithReader(IJsonReader jsonReader)
{
List <JsonToken> tokens = new List <JsonToken>();
while (jsonReader.Read())
{
JsonToken token;
switch (jsonReader.CurrentTokenType)
{
case JsonTokenType.NotStarted:
throw new InvalidOperationException();
case JsonTokenType.BeginArray:
token = JsonToken.ArrayStart();
break;
case JsonTokenType.EndArray:
token = JsonToken.ArrayEnd();
break;
case JsonTokenType.BeginObject:
token = JsonToken.ObjectStart();
break;
case JsonTokenType.EndObject:
token = JsonToken.ObjectEnd();
break;
case JsonTokenType.String:
token = JsonToken.String(jsonReader.GetStringValue());
break;
case JsonTokenType.Number:
token = JsonToken.Number(jsonReader.GetNumberValue());
break;
case JsonTokenType.True:
token = JsonToken.Boolean(true);
break;
case JsonTokenType.False:
token = JsonToken.Boolean(false);
break;
case JsonTokenType.Null:
token = JsonToken.Null();
break;
case JsonTokenType.FieldName:
token = JsonToken.FieldName(jsonReader.GetStringValue());
break;
case JsonTokenType.Int8:
token = JsonToken.Int8(jsonReader.GetInt8Value());
break;
case JsonTokenType.Int16:
token = JsonToken.Int16(jsonReader.GetInt16Value());
break;
case JsonTokenType.Int32:
token = JsonToken.Int32(jsonReader.GetInt32Value());
break;
case JsonTokenType.Int64:
token = JsonToken.Int64(jsonReader.GetInt64Value());
break;
case JsonTokenType.UInt32:
token = JsonToken.UInt32(jsonReader.GetUInt32Value());
break;
case JsonTokenType.Float32:
token = JsonToken.Float32(jsonReader.GetFloat32Value());
break;
case JsonTokenType.Float64:
token = JsonToken.Float64(jsonReader.GetFloat64Value());
break;
case JsonTokenType.Guid:
token = JsonToken.Guid(jsonReader.GetGuidValue());
break;
case JsonTokenType.Binary:
token = JsonToken.Binary(jsonReader.GetBinaryValue());
break;
default:
throw new ArgumentException($"Unknown {nameof(JsonTokenType)}: {jsonReader.CurrentTokenType}");
}
tokens.Add(token);
}
return(tokens.ToArray());
}
public EmptyMemberName(IJsonReader reader)
: base("Empty member name.", ErrorCode.EmptyMemberName, reader)
{
}
/// <summary>
/// The decode.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>The value.</returns>
public ulong Decode(IJsonReader reader)
{
return(reader.ReadUInt64());
}
public ConferenceVideosSource(IJsonReader repository)
{
_repository = repository;
}
/// <summary>
/// The decode.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>The value.</returns>
public double Decode(IJsonReader reader)
{
return(reader.ReadDouble());
}
public HjsonReader(TextReader reader, IJsonReader jsonReader)
: base(reader, jsonReader)
{
}
/// <summary>
/// The decode.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>The value.</returns>
public DateTime Decode(IJsonReader reader)
{
return(reader.ReadDateTime());
}
T IJsonSerializer.Deserialize <T>(IJsonReader reader)
{
return(Deserialize <T>((BlittableJsonReader)reader));
}
/// <summary>
/// The decode.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>The value.</returns>
public string Decode(IJsonReader reader)
{
return(reader.ReadString());
}
object IJsonSerializer.Deserialize(IJsonReader reader, Type type)
{
return(Deserialize((BlittableJsonReader)reader, type));
}
/// <summary>
/// Set given field.
/// </summary>
/// <param name="value">The field value.</param>
/// <param name="fieldName">The field name.</param>
/// <param name="reader">The json reader.</param>
protected virtual void SetField(T value, string fieldName, IJsonReader reader)
{
throw new NotImplementedException();
}
private static void PerformRoundTrip(
SerializationFormat sourceFormat,
SerializationFormat destinationFormat,
string json,
bool writeAsRootNode)
{
IJsonReader reader = sourceFormat switch
{
SerializationFormat.Text => JsonReader.Create(Encoding.UTF8.GetBytes(json)),
SerializationFormat.Binary => JsonReader.Create(JsonTestUtils.ConvertTextToBinary(json)),
SerializationFormat.NewtonsoftText => NewtonsoftToCosmosDBReader.CreateFromString(json),
_ => throw new ArgumentException($"Unexpected {nameof(sourceFormat)} of type: {sourceFormat}"),
};
IJsonNavigator navigator = sourceFormat switch
{
SerializationFormat.Text => JsonNavigator.Create(Encoding.UTF8.GetBytes(json)),
SerializationFormat.Binary => JsonNavigator.Create(JsonTestUtils.ConvertTextToBinary(json)),
SerializationFormat.NewtonsoftText => new JsonNewtonsoftNavigator(json),
_ => throw new ArgumentException($"Unexpected {nameof(sourceFormat)} of type: {sourceFormat}"),
};
foreach (object source in new object[] { reader, navigator })
{
IJsonWriter writer = destinationFormat switch
{
SerializationFormat.Text => JsonWriter.Create(JsonSerializationFormat.Text),
SerializationFormat.Binary => JsonWriter.Create(JsonSerializationFormat.Binary),
SerializationFormat.NewtonsoftText => NewtonsoftToCosmosDBWriter.CreateTextWriter(),
_ => throw new ArgumentException($"Unexpected {nameof(destinationFormat)} of type: {destinationFormat}"),
};
switch (source)
{
case IJsonReader sourceReader:
sourceReader.WriteAll(writer);
break;
case IJsonNavigator sourceNavigator:
if (writeAsRootNode)
{
sourceNavigator.WriteNode(sourceNavigator.GetRootNode(), writer);
}
else
{
IJsonNavigatorNode rootNode = sourceNavigator.GetRootNode();
JsonNodeType jsonNodeType = sourceNavigator.GetNodeType(rootNode);
switch (jsonNodeType)
{
case JsonNodeType.Array:
writer.WriteArrayStart();
foreach (IJsonNavigatorNode arrayItem in sourceNavigator.GetArrayItems(rootNode))
{
sourceNavigator.WriteNode(arrayItem, writer);
}
writer.WriteArrayEnd();
break;
case JsonNodeType.Object:
writer.WriteObjectStart();
foreach (ObjectProperty objectProperty in sourceNavigator.GetObjectProperties(rootNode))
{
sourceNavigator.WriteNode(objectProperty.NameNode, writer);
sourceNavigator.WriteNode(objectProperty.ValueNode, writer);
}
writer.WriteObjectEnd();
break;
default:
sourceNavigator.WriteNode(sourceNavigator.GetRootNode(), writer);
break;
}
}
break;
default:
Assert.Fail("Failed to downcast source type.");
break;
}
string result = writer.SerializationFormat switch
{
JsonSerializationFormat.Text => Utf8String.UnsafeFromUtf8BytesNoValidation(writer.GetResult()).ToString(),
JsonSerializationFormat.Binary => JsonTestUtils.ConvertBinaryToText(writer.GetResult()),
_ => throw new ArgumentException(),
};
string normalizedResult = JsonRoundTripsTests.NewtonsoftFormat(result);
string normalizedJson = JsonRoundTripsTests.NewtonsoftFormat(json);
Assert.AreEqual(normalizedJson, normalizedResult);
}
}
/// <summary>
/// Decoder for struct type.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>The empty instance.</returns>
public Empty Decode(IJsonReader reader)
{
reader.Skip();
return(Empty.Instance);
}
public static void DrainReader(IJsonReader jsonReader, bool materializeValue)
{
if (jsonReader == null)
{
throw new ArgumentNullException(nameof(jsonReader));
}
while (jsonReader.Read())
{
// Materialize the value
switch (jsonReader.CurrentTokenType)
{
case JsonTokenType.BeginArray:
case JsonTokenType.EndArray:
case JsonTokenType.BeginObject:
case JsonTokenType.EndObject:
case JsonTokenType.Null:
case JsonTokenType.True:
case JsonTokenType.False:
// Single byte tokens
break;
case JsonTokenType.String:
case JsonTokenType.FieldName:
if (materializeValue)
{
string stringValue = jsonReader.GetStringValue();
}
break;
case JsonTokenType.Number:
if (materializeValue)
{
Number64 number64Value = jsonReader.GetNumberValue();
}
break;
case JsonTokenType.Int8:
if (materializeValue)
{
sbyte int8Value = jsonReader.GetInt8Value();
}
break;
case JsonTokenType.Int16:
if (materializeValue)
{
short int16Value = jsonReader.GetInt16Value();
}
break;
case JsonTokenType.Int32:
if (materializeValue)
{
int int32Value = jsonReader.GetInt32Value();
}
break;
case JsonTokenType.Int64:
if (materializeValue)
{
long int64Value = jsonReader.GetInt64Value();
}
break;
case JsonTokenType.UInt32:
if (materializeValue)
{
uint uInt32Value = jsonReader.GetUInt32Value();
}
break;
case JsonTokenType.Float32:
if (materializeValue)
{
float float32Value = jsonReader.GetFloat32Value();
}
break;
case JsonTokenType.Float64:
if (materializeValue)
{
double doubleValue = jsonReader.GetFloat64Value();
}
break;
case JsonTokenType.Guid:
if (materializeValue)
{
Guid guidValue = jsonReader.GetGuidValue();
}
break;
case JsonTokenType.Binary:
if (materializeValue)
{
ReadOnlyMemory <byte> binaryValue = jsonReader.GetBinaryValue();
}
break;
default:
throw new ArgumentException("$Unknown token type.");
}
}
}
/// <summary>
/// The decode.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>The value.</returns>
public int Decode(IJsonReader reader)
{
return(reader.ReadInt32());
}
void IJsonLoaded.OnJsonLoaded(IJsonReader r)
{
loaded = true;
}
