public void RemoveComponent()
{
var container = TestHierarchicalComponentContainer.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 DeserializeInvalidJson_DoesNotThrow()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
LogAssert.Expect(LogType.Exception, new Regex("InvalidJsonException: Input json was invalid.*"));
TestHierarchicalComponentContainer.DeserializeFromJson(container, "{\"Dependencies\": [], \"Components\": [{\"$type\": }, {\"$type\": }]}");
}
public void AddDependency_CannotAddSelfDependency()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
Assert.That(container.AddDependency(container), Is.False);
Assert.That(container.Dependencies.Count, Is.Zero);
}
public void CopyVisitor_DoesNotCopyCollectionReferences()
{
var list = new List <int> {
1, 2, 3
};
var component = new ComplexComponent {
ListInteger = list
};
var container = TestHierarchicalComponentContainer.CreateInstance(c => c.SetComponent(component));
var value = container.GetComponent <ComplexComponent>();
Assert.That(value, Is.Not.SameAs(component));
Assert.That(value, Is.EqualTo(component));
Assert.That(value.ListInteger, Is.Not.SameAs(list));
Assert.That(value.ListInteger, Is.EqualTo(list));
list.AddRange(new int[] { 4, 5, 6 });
Assert.That(value.ListInteger, Is.Not.SameAs(list));
Assert.That(value.ListInteger, Is.Not.EqualTo(list));
value = container.GetComponent <ComplexComponent>();
Assert.That(value.ListInteger, Is.Not.SameAs(list));
Assert.That(value.ListInteger, Is.Not.EqualTo(list));
container.SetComponent(component);
value = container.GetComponent <ComplexComponent>();
Assert.That(value.ListInteger, Is.Not.SameAs(list));
Assert.That(value.ListInteger, Is.EqualTo(list));
}
public void DeserializeInvalidJson_DoesNotThrow()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
LogAssert.Expect(LogType.Error, new Regex("Failed to deserialize memory container.*"));
TestHierarchicalComponentContainer.DeserializeFromJson(container, "{\"Dependencies\": [], \"Components\": [{\"$type\": }, {\"$type\": }]}");
}
public void DeserializeInvalidDependencies_ComponentsArePreserved()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
TestHierarchicalComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [123, \"abc\"], \"Components\": [{{\"$type\": {typeof(ComponentA).GetFullyQualifedAssemblyTypeName().DoubleQuotes()}}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
}
public void DeserializeInvalidComponents_OtherComponentsArePreserved()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
TestHierarchicalComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [], \"Components\": [{{\"$type\": {typeof(ComponentA).GetQualifedAssemblyTypeName().DoubleQuotes()}}}, {{\"$type\": \"Some.InvalidComponent.Name, Unknown.Assembly\"}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
}
public void DeserializeNullDependencies_DependenciesArePreserved()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
TestHierarchicalComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [null, \"GlobalObjectId_V1-0-00000000000000000000000000000000-0-0\"], \"Components\": []}}");
Assert.That(container.Dependencies, Is.EqualTo(new ITestComponent[] { null, null }));
}
public void DeserializeInvalidJson_DoesNotThrow()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
LogAssert.Expect(LogType.Error, $"Failed to deserialize memory container of type '{typeof(TestHierarchicalComponentContainer).FullName}':\nInput json was invalid. ExpectedType=[Value] ActualType=[EndObject] ActualChar=['}}'] at Line=[1] at Character=[47]");
TestHierarchicalComponentContainer.DeserializeFromJson(container, "{\"Dependencies\": [], \"Components\": [{\"$type\": }, {\"$type\": }]}");
}
public void ComponentOverrides_FromMultipleDependencies()
{
var containerA = TestHierarchicalComponentContainer.CreateInstance();
containerA.SetComponent(new ComponentA {
Integer = 1
});
var containerB = TestHierarchicalComponentContainer.CreateInstance();
containerB.AddDependency(containerA);
var componentA = containerB.GetComponent <ComponentA>();
componentA.Float = 123.456f;
containerB.SetComponent(componentA);
var containerC = TestHierarchicalComponentContainer.CreateInstance();
containerC.AddDependency(containerB);
componentA = containerC.GetComponent <ComponentA>();
componentA.String = "test";
containerC.SetComponent(componentA);
var containerD = TestHierarchicalComponentContainer.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 ComponentValues_AreValid()
{
var container = TestHierarchicalComponentContainer.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 GetComponents_WithType()
{
var containerA = TestHierarchicalComponentContainer.CreateInstance(c => c.SetComponent(new ComponentA()));
var containerB = TestHierarchicalComponentContainer.CreateInstance(c => c.SetComponent(new ComponentB()));
var complexContainer = TestHierarchicalComponentContainer.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 container = TestHierarchicalComponentContainer.CreateInstance();
var missingDependency = TestHierarchicalComponentContainer.CreateInstance();
UnityEngine.Object.DestroyImmediate(missingDependency);
Assert.Throws <ArgumentNullException>(() => container.AddDependency(missingDependency));
}
public void DeserializeInvalidComponents_OtherComponentsArePreserved()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
LogAssert.Expect(LogType.Error, $"Failed to deserialize memory container of type '{typeof(TestHierarchicalComponentContainer).FullName}':\nSystem.InvalidOperationException: PropertyContainer.Construct failed to construct DstType=[{typeof(ITestComponent).FullName}]. Could not resolve type from TypeName=[Some.InvalidComponent.Name, Unknown.Assembly].");
TestHierarchicalComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [], \"Components\": [{{\"$type\": {typeof(ComponentA).GetFullyQualifedAssemblyTypeName().DoubleQuotes()}}}, {{\"$type\": \"Some.InvalidComponent.Name, Unknown.Assembly\"}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
}
public void DeserializeInvalidDependencies_ComponentsArePreserved()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
LogAssert.Expect(LogType.Error, new Regex("While deserializing memory container of type.*"));
TestHierarchicalComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [123, \"abc\"], \"Components\": [{{\"$type\": {typeof(ComponentA).GetAssemblyQualifiedTypeName().DoubleQuotes()}}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
}
public void CannotSet_InterfaceType()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
Assert.Throws <InvalidOperationException>(() =>
{
container.SetComponent(typeof(ITestInterface), new ComponentA());
});
}
public void CannotSet_AbstractType()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
Assert.Throws <InvalidOperationException>(() =>
{
container.SetComponent(typeof(AbstractClass), new DerivedClass());
});
}
public void CannotSet_NullType()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
Assert.Throws <ArgumentNullException>(() =>
{
container.SetComponent(null, new ComponentA());
});
}
public void DeserializeInvalidDependencies_ComponentsArePreserved()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
#if UNITY_2020_1_OR_NEWER
LogAssert.Expect(LogType.Error, new Regex("Failed to deserialize memory container.*"));
#endif
TestHierarchicalComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [123, \"abc\"], \"Components\": [{{\"$type\": {typeof(ComponentA).GetQualifedAssemblyTypeName().DoubleQuotes()}}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
}
public void TryGetComponent()
{
var container = TestHierarchicalComponentContainer.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 AddDependency()
{
var containerA = TestHierarchicalComponentContainer.CreateInstance();
var containerB = TestHierarchicalComponentContainer.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 = TestHierarchicalComponentContainer.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 AsReadOnly_ReflectChanges()
{
var container = TestHierarchicalComponentContainer.CreateInstance(c => c.SetComponent <ComponentA>());
var containerRO = container.AsReadOnly();
Assert.That(containerRO.GetComponentTypes(), Is.EquivalentTo(new[] { typeof(ComponentA) }));
container.SetComponent <ComponentB>();
Assert.That(containerRO.GetComponentTypes(), Is.EquivalentTo(new[] { typeof(ComponentA), typeof(ComponentB) }));
}
public void GetComponent()
{
var container = TestHierarchicalComponentContainer.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 DeserializeNullDependencies_DependenciesArePreserved()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
TestHierarchicalComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [null, \"GlobalObjectId_V1-0-00000000000000000000000000000000-0-0\"], \"Components\": []}}");
#if UNITY_2020_1_OR_NEWER
Assert.That(container.Dependencies.Select(d => d.asset), Is.EqualTo(new TestHierarchicalComponentContainer[] { null, null }));
#else
Assert.That(container.Dependencies, Is.EqualTo(new TestHierarchicalComponentContainer[] { null, null }));
#endif
}
public void RemoveDependency()
{
var containerA = TestHierarchicalComponentContainer.CreateInstance();
var containerB = TestHierarchicalComponentContainer.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 GetDependencies()
{
var containerA = TestHierarchicalComponentContainer.CreateInstance();
var containerB = TestHierarchicalComponentContainer.CreateInstance();
var containerC = TestHierarchicalComponentContainer.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 GetComponentTypes()
{
var containerA = TestHierarchicalComponentContainer.CreateInstance(c => c.SetComponent(new ComponentA()));
var containerB = TestHierarchicalComponentContainer.CreateInstance(c => c.SetComponent(new ComponentB()));
var complexContainer = TestHierarchicalComponentContainer.CreateInstance(c => c.SetComponent(new ComplexComponent()));
containerA.AddDependency(containerB);
containerB.AddDependency(complexContainer);
Assert.That(containerA.GetComponentTypes(), Is.EquivalentTo(new[] { typeof(ComponentA), typeof(ComponentB), typeof(ComplexComponent) }));
Assert.That(containerB.GetComponentTypes(), Is.EquivalentTo(new[] { typeof(ComponentB), typeof(ComplexComponent) }));
Assert.That(complexContainer.GetComponentTypes(), Is.EquivalentTo(new[] { typeof(ComplexComponent) }));
}
public void DeserializeMultipleTimes_ShouldNotAppendData()
{
var container = TestHierarchicalComponentContainer.CreateInstance();
Assert.That(container.HasComponent <ComponentA>(), Is.False);
Assert.That(container.Components.Count, Is.Zero);
TestHierarchicalComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [], \"Components\": [{{\"$type\": {typeof(ComponentA).GetFullyQualifedAssemblyTypeName().DoubleQuotes()}}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
Assert.That(container.Components.Count, Is.EqualTo(1));
TestHierarchicalComponentContainer.DeserializeFromJson(container, $"{{\"Dependencies\": [], \"Components\": [{{\"$type\": {typeof(ComponentA).GetFullyQualifedAssemblyTypeName().DoubleQuotes()}}}]}}");
Assert.That(container.HasComponent <ComponentA>(), Is.True);
Assert.That(container.Components.Count, Is.EqualTo(1));
}
public void IsComponentOverridden()
{
var containerA = TestHierarchicalComponentContainer.CreateInstance(c => c.SetComponent(new ComponentA()));
var containerB = TestHierarchicalComponentContainer.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)));
}
