public void ComponentValues_AreValid()
{
var container = TestComponentContainer.CreateInstance();
var component = new ComplexComponent
{
Integer = 1,
Float = 123.456f,
String = "test",
Nested = new ComponentA
{
Integer = 42
},
ListInteger = new List <int> {
1, 1, 2, 3, 5, 8, 13
}
};
container.SetComponent(component);
var value = container.GetComponent <ComplexComponent>();
Assert.That(value.Integer, Is.EqualTo(1));
Assert.That(value.Float, Is.EqualTo(123.456f));
Assert.That(value.String, Is.EqualTo("test"));
Assert.That(value.Nested.Integer, Is.EqualTo(42));
Assert.That(value.ListInteger, Is.EquivalentTo(new List <int> {
1, 1, 2, 3, 5, 8, 13
}));
}
public void DeserializeInvalidJson_ShouldNotThrowException()
{
var container = TestComponentContainer.CreateInstance();
LogAssert.Expect(LogType.Error, $"Failed to deserialize memory container of type '{typeof(TestComponentContainer).FullName}':\nInput json was invalid. ExpectedType=[Value] ActualType=[EndObject] ActualChar=['}}'] at Line=[1] at Character=[47]");
TestComponentContainer.DeserializeFromJson(container, "{\"Dependencies\": [], \"Components\": [{\"$type\": }, {\"$type\": }]}");
}
public void RemoveComponent()
{
var container = TestComponentContainer.CreateInstance();
container.SetComponent(new ComponentA());
container.SetComponent(new ComponentB());
container.SetComponent(new ComplexComponent());
Assert.That(container.HasComponent <ComponentA>(), Is.True);
Assert.That(container.HasComponent <ComponentB>(), Is.True);
Assert.That(container.HasComponent <ComplexComponent>(), Is.True);
Assert.That(container.Components.Count, Is.EqualTo(3));
Assert.That(container.RemoveComponent <ComplexComponent>(), Is.True);
Assert.That(container.Components.Count, Is.EqualTo(2));
Assert.That(container.RemoveComponent <DerivedClass>(), Is.False);
Assert.That(container.Components.Count, Is.EqualTo(2));
Assert.That(container.RemoveComponent <ITestInterface>(), Is.True);
Assert.That(container.Components.Count, Is.EqualTo(0));
Assert.Throws <ArgumentNullException>(() => container.RemoveComponent(null));
Assert.Throws <InvalidOperationException>(() => container.RemoveComponent(typeof(object)));
Assert.Throws <InvalidOperationException>(() => container.RemoveComponent(typeof(InvalidComponent)));
}
public void ComponentOverrides_FromMultipleDependencies()
{
var containerA = TestComponentContainer.CreateInstance();
containerA.SetComponent(new ComponentA {
Integer = 1
});
var containerB = TestComponentContainer.CreateInstance();
containerB.AddDependency(containerA);
var componentA = containerB.GetComponent <ComponentA>();
componentA.Float = 123.456f;
containerB.SetComponent(componentA);
var containerC = TestComponentContainer.CreateInstance();
containerC.AddDependency(containerB);
componentA = containerC.GetComponent <ComponentA>();
componentA.String = "test";
containerC.SetComponent(componentA);
var containerD = TestComponentContainer.CreateInstance();
containerD.AddDependency(containerC);
var value = containerD.GetComponent <ComponentA>();
Assert.That(value.Integer, Is.EqualTo(1));
Assert.That(value.Float, Is.EqualTo(123.456f));
Assert.That(value.String, Is.EqualTo("test"));
}
public void AddDependency_CannotAddSelfDependency()
{
var container = TestComponentContainer.CreateInstance();
Assert.That(container.AddDependency(container), Is.False);
Assert.That(container.Dependencies.Count, Is.Zero);
}
public void GetComponents_WithType()
{
var containerA = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComponentA()));
var containerB = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComponentB()));
var complexContainer = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComplexComponent()));
containerA.AddDependency(containerB);
containerB.AddDependency(complexContainer);
Assert.That(containerA.GetComponents <ComponentA>().Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComponentA) }));
Assert.That(containerA.GetComponents <ComponentB>().Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComponentB) }));
Assert.That(containerA.GetComponents <ComplexComponent>().Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComplexComponent) }));
Assert.That(containerB.GetComponents <ComponentA>(), Is.Empty);
Assert.That(containerB.GetComponents <ComponentB>().Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComponentB) }));
Assert.That(containerB.GetComponents <ComplexComponent>().Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComplexComponent) }));
Assert.That(complexContainer.GetComponents <ComponentA>(), Is.Empty);
Assert.That(complexContainer.GetComponents <ComponentB>(), Is.Empty);
Assert.That(complexContainer.GetComponents <ComplexComponent>().Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComplexComponent) }));
Assert.That(containerA.GetComponents <ITestInterface>().Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComponentA), typeof(ComponentB) }));
Assert.That(containerB.GetComponents <ITestInterface>().Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComponentB) }));
Assert.That(complexContainer.GetComponents <ITestInterface>(), Is.Empty);
}
public void AddingDestoyedDependency_Throws()
{
var settings = TestComponentContainer.CreateInstance();
var missingDependency = TestComponentContainer.CreateInstance();
UnityEngine.Object.DestroyImmediate(missingDependency);
Assert.Throws <ArgumentNullException>(() => settings.AddDependency(missingDependency));
}
public void DeserializeInvalidDependency_ShouldNotResetEntireBuildSettings()
{
var container = TestComponentContainer.CreateInstance();
TestComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [null, \"\", \"bleh\"], \"Components\": [{{\"$type\": \"{typeof(ComponentA).FullName}, {typeof(ComponentA).Assembly.GetName().Name}\"}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
Assert.That(container.Dependencies.Count, Is.Zero);
}
public void DeserializeInvalidComponent_ShouldNotResetEntireBuildSettings()
{
var container = TestComponentContainer.CreateInstance();
LogAssert.Expect(LogType.Error, $"Failed to deserialize memory container of type '{typeof(TestComponentContainer).FullName}':\nSystem.InvalidOperationException: PropertyContainer.Construct failed to construct DstType=[{typeof(ITestComponent).FullName}]. Could not resolve type from TypeName=[Some.InvalidComponent.Name, Unknown.Assembly].");
TestComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [], \"Components\": [{{\"$type\": \"{typeof(ComponentA).FullName}, {typeof(ComponentA).Assembly.GetName().Name}\"}}, {{\"$type\": \"Some.InvalidComponent.Name, Unknown.Assembly\"}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
}
public void CannotSet_NullType()
{
var container = TestComponentContainer.CreateInstance();
Assert.Throws <ArgumentNullException>(() =>
{
container.SetComponent(null, new ComponentA());
});
}
public void CannotSet_AbstractType()
{
var container = TestComponentContainer.CreateInstance();
Assert.Throws <InvalidOperationException>(() =>
{
container.SetComponent(typeof(AbstractClass), new DerivedClass());
});
}
public void CannotSet_InterfaceType()
{
var container = TestComponentContainer.CreateInstance();
Assert.Throws <InvalidOperationException>(() =>
{
container.SetComponent(typeof(ITestInterface), new ComponentA());
});
}
public void TryGetComponent()
{
var container = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComponentA()));
Assert.That(container.TryGetComponent <ComponentA>(out var _), Is.True);
Assert.That(container.TryGetComponent <ComponentB>(out var _), Is.False);
Assert.That(container.TryGetComponent(null, out var _), Is.False);
Assert.That(container.TryGetComponent(typeof(object), out var _), Is.False);
Assert.That(container.TryGetComponent(typeof(InvalidComponent), out var _), Is.False);
}
public void GetComponent()
{
var container = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComponentA()));
Assert.That(container.GetComponent <ComponentA>(), Is.Not.Null);
Assert.Throws <InvalidOperationException>(() => container.GetComponent <ComponentB>());
Assert.Throws <ArgumentNullException>(() => container.GetComponent(null));
Assert.Throws <InvalidOperationException>(() => container.GetComponent(typeof(object)));
Assert.Throws <InvalidOperationException>(() => container.GetComponent(typeof(InvalidComponent)));
}
public void AddDependency()
{
var containerA = TestComponentContainer.CreateInstance();
var containerB = TestComponentContainer.CreateInstance();
Assert.That(containerA.AddDependency(containerB), Is.True);
Assert.That(containerA.AddDependency(containerB), Is.False);
Assert.That(containerA.Dependencies, Is.EqualTo(new[] { containerB }));
Assert.Throws <ArgumentNullException>(() => containerA.AddDependency(null));
}
public void SetComponent()
{
var container = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComponentA()));
Assert.That(container.Components.Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComponentA) }));
Assert.Throws <ArgumentNullException>(() => container.SetComponent(null, default));
Assert.Throws <InvalidOperationException>(() => container.SetComponent(typeof(object), default));
Assert.Throws <InvalidOperationException>(() => container.SetComponent(typeof(InvalidComponent), default));
Assert.Throws <InvalidOperationException>(() => container.SetComponent(typeof(ITestInterface), default));
}
public void RemoveDependency()
{
var containerA = TestComponentContainer.CreateInstance();
var containerB = TestComponentContainer.CreateInstance();
containerA.AddDependency(containerB);
Assert.That(containerA.RemoveDependency(containerB), Is.True);
Assert.That(containerA.RemoveDependency(containerB), Is.False);
Assert.That(containerB.RemoveDependency(containerA), Is.False);
Assert.Throws <ArgumentNullException>(() => containerA.RemoveDependency(null));
}
public void DeserializeMultipleTimes_ShouldNotAppendData()
{
var container = TestComponentContainer.CreateInstance();
Assert.That(container.HasComponent <ComponentA>(), Is.False);
Assert.That(container.Components.Count, Is.Zero);
TestComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [], \"Components\": [{{\"$type\": \"{typeof(ComponentA).FullName}, {typeof(ComponentA).Assembly.GetName().Name}\"}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
Assert.That(container.Components.Count, Is.EqualTo(1));
TestComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [], \"Components\": [{{\"$type\": \"{typeof(ComponentA).FullName}, {typeof(ComponentA).Assembly.GetName().Name}\"}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
Assert.That(container.Components.Count, Is.EqualTo(1));
}
public void GetDependencies()
{
var containerA = TestComponentContainer.CreateInstance();
var containerB = TestComponentContainer.CreateInstance();
var containerC = TestComponentContainer.CreateInstance();
containerA.AddDependency(containerB);
containerB.AddDependency(containerC);
Assert.That(containerA.GetDependencies(), Is.EqualTo(new[] { containerB, containerC }));
Assert.That(containerB.GetDependencies(), Is.EqualTo(new[] { containerC }));
Assert.That(containerC.GetDependencies(), Is.Empty);
}
public void IsComponentOverridden()
{
var containerA = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComponentA()));
var containerB = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComponentA()));
containerA.AddDependency(containerB);
Assert.That(containerA.IsComponentOverridden <ComponentA>(), Is.True);
Assert.That(containerB.IsComponentOverridden <ComponentA>(), Is.False);
Assert.Throws <ArgumentNullException>(() => containerA.IsComponentOverridden(null));
Assert.Throws <InvalidOperationException>(() => containerA.IsComponentOverridden(typeof(object)));
Assert.Throws <InvalidOperationException>(() => containerA.IsComponentOverridden(typeof(InvalidComponent)));
}
public void CanQuery_InterfaceType()
{
var container = TestComponentContainer.CreateInstance();
container.SetComponent(new ComponentA {
Float = 123.456f, Integer = 42, String = "foo"
});
Assert.That(container.HasComponent(typeof(ITestInterface)));
Assert.That(container.TryGetComponent(typeof(ITestInterface), out var value), Is.True);
Assert.That(value, Is.EqualTo(new ComponentA {
Float = 123.456f, Integer = 42, String = "foo"
}));
Assert.That(container.RemoveComponent(typeof(ITestInterface)), Is.True);
}
public void ClearDependencies()
{
var containerA = TestComponentContainer.CreateInstance();
var containerB = TestComponentContainer.CreateInstance();
var containerC = TestComponentContainer.CreateInstance();
containerA.AddDependency(containerB);
containerA.AddDependency(containerC);
Assert.That(containerA.Dependencies.Count, Is.EqualTo(2));
Assert.DoesNotThrow(() => containerA.ClearDependencies());
Assert.That(containerA.Dependencies, Is.Empty);
Assert.DoesNotThrow(() => containerA.ClearDependencies());
Assert.That(containerA.Dependencies, Is.Empty);
}
public void AddDependency_CannotAddCircularDependency()
{
var containerA = TestComponentContainer.CreateInstance();
var containerB = TestComponentContainer.CreateInstance();
var containerC = TestComponentContainer.CreateInstance();
Assert.That(containerA.AddDependency(containerB), Is.True);
Assert.That(containerB.AddDependency(containerA), Is.False);
Assert.That(containerB.AddDependency(containerC), Is.True);
Assert.That(containerC.AddDependency(containerA), Is.False);
Assert.That(containerC.AddDependency(containerB), Is.False);
Assert.That(containerA.GetDependencies().Count, Is.EqualTo(2));
Assert.That(containerB.GetDependencies().Count, Is.EqualTo(1));
Assert.That(containerC.GetDependencies().Count, Is.Zero);
}
public void CanQuery_AbstractType()
{
var container = TestComponentContainer.CreateInstance();
container.SetComponent(new DerivedClass {
Integer = 2, Float = 654.321f
});
Assert.That(container.HasComponent(typeof(AbstractClass)));
Assert.That(container.TryGetComponent(typeof(AbstractClass), out var value), Is.True);
var instance = value as DerivedClass;
Assert.That(instance, Is.Not.Null);
Assert.That(instance.Integer, Is.EqualTo(2));
Assert.That(instance.Float, Is.EqualTo(654.321f));
Assert.That(container.RemoveComponent(typeof(AbstractClass)), Is.True);
}
public void ComponentOverrides()
{
var containerA = TestComponentContainer.CreateInstance();
containerA.SetComponent(new ComponentA
{
Integer = 1,
Float = 123.456f,
String = "test"
});
var containerB = TestComponentContainer.CreateInstance();
containerB.AddDependency(containerA);
containerB.SetComponent(new ComponentB
{
Byte = 255,
Double = 3.14159265358979323846,
Short = 32767
});
var component = containerB.GetComponent <ComponentA>();
component.Integer = 2;
containerB.SetComponent(component);
Assert.That(containerB.IsComponentOverridden <ComponentA>(), Is.True);
Assert.That(containerB.GetComponent <ComponentA>(), Is.EqualTo(new ComponentA
{
Integer = 2,
Float = 123.456f,
String = "test"
}));
Assert.That(containerB.IsComponentOverridden <ComponentB>(), Is.False);
Assert.That(containerB.GetComponent <ComponentB>(), Is.EqualTo(new ComponentB
{
Byte = 255,
Double = 3.14159265358979323846,
Short = 32767
}));
}
public void MissingDependencies_DoesNotThrow()
{
var settings = TestComponentContainer.CreateInstance();
settings.SetComponent(new ComplexComponent());
// We cannot directly add `null` using AddDependency, so we add it to the underlying list to simulate a
// missing dependency (either added through UI or missing asset).
settings.Dependencies.Add(null);
var missingDependency = TestComponentContainer.CreateInstance();
missingDependency.SetComponent(new ComplexComponent());
settings.AddDependency(missingDependency);
UnityEngine.Object.DestroyImmediate(missingDependency);
Assert.DoesNotThrow(() => settings.TryGetComponent <ComplexComponent>(out _));
Assert.DoesNotThrow(() => settings.GetComponent <ComplexComponent>());
Assert.DoesNotThrow(() => settings.GetDependencies());
Assert.DoesNotThrow(() => settings.HasComponent <ComplexComponent>());
}
public void ComponentSerialization()
{
var container = TestComponentContainer.CreateInstance();
container.SetComponent(new ComplexComponent
{
Integer = 1,
Float = 123.456f,
String = "test",
Nested = new ComponentA
{
Integer = 42
},
ListInteger = new List <int> {
1, 1, 2, 3, 5, 8, 13
}
});
var json = container.SerializeToJson();
Assert.That(json.Length, Is.GreaterThan(3));
var deserializedContainer = TestComponentContainer.CreateInstance();
TestComponentContainer.DeserializeFromJson(deserializedContainer, json);
var component = deserializedContainer.GetComponent <ComplexComponent>();
Assert.That(component.Integer, Is.EqualTo(1));
Assert.That(component.Float, Is.EqualTo(123.456f));
Assert.That(component.String, Is.EqualTo("test"));
Assert.That(component.Nested.Integer, Is.EqualTo(42));
Assert.That(component.ListInteger, Is.EquivalentTo(new List <int> {
1, 1, 2, 3, 5, 8, 13
}));
var reserializedJson = deserializedContainer.SerializeToJson();
Assert.That(reserializedJson, Is.EqualTo(json));
}
public void HasDependency()
{
var containerA = TestComponentContainer.CreateInstance();
var containerB = TestComponentContainer.CreateInstance();
var containerC = TestComponentContainer.CreateInstance();
containerA.AddDependency(containerB);
containerB.AddDependency(containerC);
Assert.That(containerA.HasDependency(containerA), Is.False);
Assert.That(containerA.HasDependency(containerB), Is.True);
Assert.That(containerA.HasDependency(containerC), Is.True);
Assert.That(containerB.HasDependency(containerA), Is.False);
Assert.That(containerB.HasDependency(containerB), Is.False);
Assert.That(containerB.HasDependency(containerC), Is.True);
Assert.That(containerC.HasDependency(containerA), Is.False);
Assert.That(containerC.HasDependency(containerB), Is.False);
Assert.That(containerC.HasDependency(containerC), Is.False);
Assert.That(containerA.HasDependency(null), Is.False);
}
public void GetComponents()
{
var containerA = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComponentA()));
var containerB = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComponentB()));
var complexContainer = TestComponentContainer.CreateInstance(c => c.SetComponent(new ComplexComponent()));
containerA.AddDependency(containerB);
containerB.AddDependency(complexContainer);
var containerAComponents = containerA.GetComponents();
Assert.That(containerAComponents.Count, Is.EqualTo(3));
Assert.That(containerAComponents.Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComponentA), typeof(ComponentB), typeof(ComplexComponent) }));
var containerBComponents = containerB.GetComponents();
Assert.That(containerBComponents.Count, Is.EqualTo(2));
Assert.That(containerBComponents.Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComponentB), typeof(ComplexComponent) }));
var complexContainerComponents = complexContainer.GetComponents();
Assert.That(complexContainerComponents.Count, Is.EqualTo(1));
Assert.That(complexContainerComponents.Select(c => c.GetType()), Is.EquivalentTo(new[] { typeof(ComplexComponent) }));
}
public void ComponentInheritance_FromMultipleDependencies()
{
var containerA = TestComponentContainer.CreateInstance();
containerA.SetComponent(new ComponentA
{
Integer = 1,
Float = 123.456f,
String = "test"
});
var containerB = TestComponentContainer.CreateInstance();
containerB.AddDependency(containerA);
containerB.SetComponent(new ComponentB
{
Byte = 255,
Double = 3.14159265358979323846,
Short = 32767
});
var containerC = TestComponentContainer.CreateInstance();
containerC.SetComponent(new ComplexComponent
{
Integer = 1,
Float = 123.456f,
String = "test",
Nested = new ComponentA
{
Integer = 42
},
ListInteger = new List <int> {
1, 1, 2, 3, 5, 8, 13
}
});
var containerD = TestComponentContainer.CreateInstance();
containerD.AddDependency(containerB);
containerD.AddDependency(containerC);
Assert.That(containerD.IsComponentInherited <ComponentA>(), Is.True);
Assert.That(containerD.GetComponent <ComponentA>(), Is.EqualTo(new ComponentA
{
Integer = 1,
Float = 123.456f,
String = "test"
}));
Assert.That(containerD.IsComponentInherited <ComponentB>(), Is.True);
Assert.That(containerD.GetComponent <ComponentB>(), Is.EqualTo(new ComponentB
{
Byte = 255,
Double = 3.14159265358979323846,
Short = 32767
}));
Assert.That(containerD.IsComponentInherited <ComplexComponent>(), Is.True);
var complexComponent = containerD.GetComponent <ComplexComponent>();
Assert.That(complexComponent.Integer, Is.EqualTo(1));
Assert.That(complexComponent.Float, Is.EqualTo(123.456f));
Assert.That(complexComponent.String, Is.EqualTo("test"));
Assert.That(complexComponent.Nested.Integer, Is.EqualTo(42));
Assert.That(complexComponent.ListInteger, Is.EquivalentTo(new List <int> {
1, 1, 2, 3, 5, 8, 13
}));
}