public void ResetInstance_should_honor_options(ResetOptions resetOptions, bool shouldResetNoCleanField, bool shouldResetReadonlyField, bool shouldResetNoCleanProperty, bool shouldResetNoCleanReadonlyField, bool shouldResetField, bool shouldDispose)
{
var noCleanField = new Mock <IDisposable>();
var readonlyField = new Mock <IDisposable>();
var noCleanProperty = new Mock <IDisposable>();
var noCleanReadonlyField = new Mock <IDisposable>();
var field = new Mock <IDisposable>();
var current = new Options.Current(
noCleanField.Object,
readonlyField.Object,
noCleanProperty.Object,
noCleanReadonlyField.Object,
field.Object
);
StateCleaner.ResetInstance(current, HierarchyOptions.All, VisibilityOptions.All, resetOptions);
Assert.That(current.NoCleanField == null, Is.EqualTo(shouldResetNoCleanField));
noCleanField.Verify(d => d.Dispose(), Times.Exactly(shouldResetNoCleanField && shouldDispose ? 1 : 0));
Assert.That(current.ReadonlyField == null, Is.EqualTo(shouldResetReadonlyField));
readonlyField.Verify(d => d.Dispose(), Times.Exactly(shouldResetReadonlyField && shouldDispose ? 1 : 0));
Assert.That(current.NoCleanProperty == null, Is.EqualTo(shouldResetNoCleanProperty));
noCleanProperty.Verify(d => d.Dispose(), Times.Exactly(shouldResetNoCleanProperty && shouldDispose ? 1 : 0));
Assert.That(current.NoCleanReadonlyField == null, Is.EqualTo(shouldResetNoCleanReadonlyField));
noCleanReadonlyField.Verify(d => d.Dispose(), Times.Exactly(shouldResetNoCleanReadonlyField && shouldDispose ? 1 : 0));
Assert.That(current.Field == null, Is.EqualTo(shouldResetField));
field.Verify(d => d.Dispose(), Times.Exactly(shouldResetField && shouldDispose ? 1 : 0));
}
public void ResetInstance_should_handler_null_fields()
{
var current = new Options.Current(null, new Mock <IDisposable>().Object, null, null, new Mock <IDisposable>().Object);
Assert.DoesNotThrow(() => StateCleaner.ResetInstance(current, HierarchyOptions.All, VisibilityOptions.All, ResetOptions.OverruleNoAutoClean | ResetOptions.IncludeReadOnlyMembers));
Assert.That(current.ReadonlyField, Is.Null);
Assert.That(current.Field, Is.Null);
}
public void ResetInstance_should_honor_visibility_options(VisibilityOptions visibilityOptions, bool shouldResetPublic, bool shouldResetProtected, bool shouldResetPrivate, bool shouldResetInternal, bool shouldResetProtectedInternal)
{
var current = new Visibility.Current();
StateCleaner.ResetInstance(current, HierarchyOptions.All, visibilityOptions);
Assert.That(current.PublicField == null, Is.EqualTo(shouldResetPublic));
Assert.That(current.PublicPublicProperty == null, Is.EqualTo(shouldResetPublic));
Assert.That(current.GetProtectedField == null, Is.EqualTo(shouldResetProtected));
Assert.That(current.PublicProtectedProperty == null, Is.EqualTo(shouldResetProtected));
Assert.That(current.GetPrivateField == null, Is.EqualTo(shouldResetPrivate));
Assert.That(current.PublicPrivateProperty == null, Is.EqualTo(shouldResetPrivate));
Assert.That(current.InternalField == null, Is.EqualTo(shouldResetInternal));
Assert.That(current.ProtectedInternalField == null, Is.EqualTo(shouldResetProtectedInternal));
}
static void Main(string[] args)
{
Console.WriteLine("# Simple cleanup");
StateCleaner.ResetInstance <ChildClass>(new ChildClass());
Console.WriteLine("# Only self");
StateCleaner.ResetInstance <ChildClass>(new ChildClass(), HierarchyOptions.Declared);
Console.WriteLine("# Only parents");
StateCleaner.ResetInstance <ChildClass>(new ChildClass(), HierarchyOptions.Inherited);
Console.WriteLine("# Only self (referred as base class)");
StateCleaner.ResetInstance <MyClass>(new ChildClass(), HierarchyOptions.Declared);
Console.WriteLine("# Only parent (referred as base class)");
StateCleaner.ResetInstance <MyClass>(new ChildClass(), HierarchyOptions.Inherited);
Console.WriteLine("# Only children (referred as base class)");
StateCleaner.ResetInstance <MyClass>(new ChildClass(), HierarchyOptions.Descendant);
Console.ReadKey();
}
public void TearDown()
{
StateCleaner.ResetInstance(this, HierarchyOptions.Declared);
}
public void ResetInstance_should_do_nothing_if_target_is_null()
{
Assert.DoesNotThrow(() => StateCleaner.ResetInstance((Current)null, HierarchyOptions.All, VisibilityOptions.All));
}
public void ResetInstance_should_honor_hierarchy_options(HierarchyOptions hierarchyOptions, bool shouldResetChildren, bool shouldResetThis, bool shouldResetParent)
{
var text = "abc";
var guid = Guid.NewGuid();
var childDisposable = new Mock <IDisposable>();
var disposable = new Mock <IDisposable>();
var grandChildDisposable = new Mock <IDisposable>();
var grandDisposable = new Mock <IDisposable>();
var parentDisposable = new Mock <IDisposable>();
var instance = new GrandChild
{
ChildClass = text,
ChildDisposable = childDisposable.Object,
ChildStruct = guid,
Class = text,
Disposable = disposable.Object,
GrandChildClass = text,
GrandChildDisposable = grandChildDisposable.Object,
GrandChildStruct = guid,
GrandClass = text,
GrandDisposable = grandDisposable.Object,
GrandStruct = guid,
ParentClass = text,
ParentDisposable = parentDisposable.Object,
ParentStruct = guid,
Struct = guid,
AbstractProperty = text,
CurrentAbstractProperty = text,
GrandAbstractProperty = text
};
Current current = instance;
StateCleaner.ResetInstance(current, hierarchyOptions, VisibilityOptions.Public);
Assert.That(instance.GrandChildClass == null, Is.EqualTo(shouldResetChildren));
Assert.That(instance.AbstractProperty == null, Is.EqualTo(shouldResetChildren));
Assert.That(instance.GrandChildStruct == Guid.Empty, Is.EqualTo(shouldResetChildren));
Assert.That(instance.GrandChildDisposable == null, Is.EqualTo(shouldResetChildren));
grandChildDisposable.Verify(d => d.Dispose(), Times.Exactly(shouldResetChildren ? 1 : 0));
Assert.That(instance.ChildClass == null, Is.EqualTo(shouldResetChildren));
Assert.That(instance.ChildStruct == Guid.Empty, Is.EqualTo(shouldResetChildren));
Assert.That(instance.ChildDisposable == null, Is.EqualTo(shouldResetChildren));
childDisposable.Verify(d => d.Dispose(), Times.Exactly(shouldResetChildren ? 1 : 0));
Assert.That(instance.Class == null, Is.EqualTo(shouldResetThis));
Assert.That(instance.CurrentAbstractProperty == null, Is.EqualTo(shouldResetThis));
Assert.That(instance.Struct == Guid.Empty, Is.EqualTo(shouldResetThis));
Assert.That(instance.Disposable == null, Is.EqualTo(shouldResetThis));
disposable.Verify(d => d.Dispose(), Times.Exactly(shouldResetThis ? 1 : 0));
Assert.That(instance.ParentClass == null, Is.EqualTo(shouldResetParent));
Assert.That(instance.ParentStruct == Guid.Empty, Is.EqualTo(shouldResetParent));
Assert.That(instance.ParentDisposable == null, Is.EqualTo(shouldResetParent));
parentDisposable.Verify(d => d.Dispose(), Times.Exactly(shouldResetParent ? 1 : 0));
Assert.That(instance.GrandClass == null, Is.EqualTo(shouldResetParent));
Assert.That(instance.GrandAbstractProperty == null, Is.EqualTo(shouldResetParent));
Assert.That(instance.GrandStruct == Guid.Empty, Is.EqualTo(shouldResetParent));
Assert.That(instance.GrandDisposable == null, Is.EqualTo(shouldResetParent));
grandDisposable.Verify(d => d.Dispose(), Times.Exactly(shouldResetParent ? 1 : 0));
}
public void ResetInstance_should_throw_if_hierarchy_is_not_specified()
{
var ex = Assert.Throws <ArgumentException>(() => StateCleaner.ResetInstance(new Visibility.Current(), default(HierarchyOptions), VisibilityOptions.All));
Assert.That(ex.Message, Is.EqualTo("HierarchyOptions are not specified."));
}
