public void SerializeAndDeserialize_MultidimensionalArray()
{
var src = new ClassWithMultidimensionalArray
{
MultidimensionalArrayInt32 = new[, ]
{
{ 1, 2 },
{ 3, 4 }
}
};
var parameters = new JsonSerializationParameters
{
UserDefinedAdapters = new List <IJsonAdapter>
{
new Array2Adapter <int>()
}
};
var json = JsonSerialization.ToJson(src, parameters);
Assert.That(UnFormat(json), Is.EqualTo("{\"MultidimensionalArrayInt32\":[[1,2],[3,4]]}"));
var dst = default(ClassWithMultidimensionalArray);
JsonSerialization.FromJsonOverride(json, ref dst, parameters);
Assert.That(dst.MultidimensionalArrayInt32, Is.EqualTo(new [, ]
{
{ 1, 2 },
{ 3, 4 }
}));
}
public void SerializeAndDeserialize_WithUserDefinedAdapter_AdapterIsInvoked()
{
var jsonSerializationParameters = new JsonSerializationParameters
{
UserDefinedAdapters = new List <IJsonAdapter>
{
new DummyAdapter(),
new TestAdapter()
}
};
var src = new ClassWithAdaptedTypes
{
Value = new ClassWithAdapters {
A = 42
}
};
var json = JsonSerialization.ToJson(src, jsonSerializationParameters);
Assert.That(UnFormat(json), Is.EqualTo(@"{""Value"":42}"));
var dst = JsonSerialization.FromJson <ClassWithAdaptedTypes>(json, jsonSerializationParameters);
Assert.That(dst.Value.A, Is.EqualTo(src.Value.A));
}
public void ToJson_ScriptableObjectWithDisableRootAdapters_DoesNotThrow()
{
var src = ScriptableObject.CreateInstance <TestUnityObject>();
var dst = ScriptableObject.CreateInstance <TestUnityObject>();
src.Int32Value = 100;
try
{
var parameters = new JsonSerializationParameters
{
DisableRootAdapters = true
};
var json = JsonSerialization.ToJson(src, parameters);
Assert.That(UnFormat(json), Is.EqualTo("{\"Int32Value\":100}"));
JsonSerialization.FromJsonOverride(json, ref dst, parameters);
Assert.That(dst.Int32Value, Is.EqualTo(src.Int32Value));
/* @TODO uncomment when TypeConstruction lands
* var clone = JsonSerialization.FromJson<TestUnityObject>(json, parameters);
* Assert.That(clone.Int32Value, Is.EqualTo(src.Int32Value));
*/
}
finally
{
Object.DestroyImmediate(src);
}
}
public void SerializeAndDeserialize_WithMultipleUserDefinedAdapters_OnlyTheFirstAdapterIsInvoked()
{
var jsonSerializationParameters = new JsonSerializationParameters
{
UserDefinedAdapters = new List <IJsonAdapter>
{
// The order is important here.
new TestInverter(),
new TestAdapter(),
new TestDecorator()
}
};
var src = new ClassWithAdaptedTypes
{
Value = new ClassWithAdapters {
A = 42
}
};
var json = JsonSerialization.ToJson(src, jsonSerializationParameters);
Assert.That(UnFormat(json), Is.EqualTo(@"{""Value"":-42}"));
var dst = JsonSerialization.FromJson <ClassWithAdaptedTypes>(json, jsonSerializationParameters);
Assert.That(dst.Value.A, Is.EqualTo(src.Value.A));
}
public void SerializeAndDeserialize_WithContravariantUserDefinedAdapter_AdapterIsInvokedCorrectly()
{
var jsonSerializationParameters = new JsonSerializationParameters
{
UserDefinedAdapters = new List <IJsonAdapter>
{
new DummyAdapter(),
new ShapeAdapter(),
new AnimalAdapter()
}
};
var src = new ClassWithShapes
{
Shape = new Square(),
Square = new Square(),
Circle = new Circle(),
Animal = new Cat(),
Dog = new Dog(),
Cat = null
};
var json = JsonSerialization.ToJson(src, jsonSerializationParameters);
Assert.That(UnFormat(json), Is.EqualTo(@"{""Shape"":""a shape"",""Square"":""a shape"",""Circle"":""a shape"",""Animal"":""an animal"",""Dog"":""a dog"",""Cat"":""a cat""}"));
}
public SceneVisitor(Transform sceneRoot, UnsafeValueView view, List <DeserializationEvent> events,
JsonSerializationParameters parameters, SerializationMetadata metadata) : base(metadata)
{
SetView(view);
SetEvents(events);
m_Events = events;
m_SceneRoot = sceneRoot;
m_Parameters = parameters;
}
public GameObjectVisitor(UnsafeValueView view, List <DeserializationEvent> events, SerializationMetadata metadata,
Transform parent, GameObjectContainer prefabRoot, JsonSerializationParameters parameters) : base(metadata)
{
SetView(view);
SetEvents(events);
m_Events = events;
m_Parameters = parameters;
m_Parent = parent;
m_PrefabRoot = prefabRoot;
}
protected override T SerializeAndDeserialize <T>(T value, CommonSerializationParameters parameters = default)
{
var jsonSerializationParameters = new JsonSerializationParameters
{
DisableSerializedReferences = parameters.DisableSerializedReferences
};
var json = JsonSerialization.ToJson(value, jsonSerializationParameters);
return(JsonSerialization.FromJson <T>(json, jsonSerializationParameters));
}
/// <summary>
/// Alternative method to JsonSerialization.ToJson which uses JsonSceneWriter
/// Use this if you need to support `ISerializationCallbacks`
/// </summary>
/// <param name="value">The value to serialize</param>
/// <param name="metadata">SerializationMetadata for this call</param>
/// <typeparam name="T">The type of the value being serialized</typeparam>
/// <returns>A string containing the Json serialized representation of `value`</returns>
public static string ToJson <T>(T value, SerializationMetadata metadata = null)
{
var parameters = new JsonSerializationParameters
{
DisableRootAdapters = true,
DisableSerializedReferences = true
};
using (var writer = new JsonStringBuffer(parameters.InitialCapacity, Allocator.Temp))
{
var container = new PropertyWrapper <T>(value);
var visitor = new JsonSceneWriter(metadata);
visitor.SetStringWriter(writer);
visitor.SetSerializedType(parameters.SerializedType);
visitor.SetMinified(parameters.Minified);
visitor.SetSimplified(parameters.Simplified);
using (visitor.Lock()) PropertyContainer.Visit(ref container, visitor);
return(writer.ToString());
}
}
public void SerializeAndDeserialize_WithReEntranceAdapter_SerializedReferencesAreNotCleared()
{
var parameters = new JsonSerializationParameters
{
UserDefinedAdapters = new List <IJsonAdapter>
{
new FooAdapter()
}
};
var reference = new Dummy();
var src = new ClassWithObjectReferences
{
ObjectReference1 = reference,
ObjectReference2 = reference,
Foo = new Foo
{
A = 42,
// Despite being the same reference, the adapter triggers a re-entrance and handles serialization in it's own tree.
B = reference
}
};
var json = JsonSerialization.ToJson(src, parameters);
var dst = JsonSerialization.FromJson <ClassWithObjectReferences>(json, parameters);
Assert.That(dst, Is.Not.SameAs(src));
Assert.That(dst.ObjectReference1, Is.SameAs(dst.ObjectReference2));
Assert.That(dst.Foo.A, Is.EqualTo(42));
// Despite being the same reference in src, the adapter triggers a re-entrance and handles which should create a new instance.
Assert.That(dst.Foo.B, Is.Not.SameAs(dst.ObjectReference1));
}
