public bool PosTest4()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest4: Call set_Target on long weak reference to instance of an object before GC");
try
{
// Reclaim memories
GC.Collect();
GC.WaitForPendingFinalizers();
retVal = GenerateUnusedData2("004.1") && retVal;
object obj = new object();
string str = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LENGTH, c_MAX_STRING_LENGTH);
Byte[] randBytes = new Byte[c_MAX_STRING_LENGTH];
TestLibrary.Generator.GetBytes(-55, randBytes);
WeakReferenceTarget thisClass = new WeakReferenceTarget();
DisposableClass dc = new DisposableClass();
IntPtr ptr = new IntPtr(TestLibrary.Generator.GetInt32(-55));
Object[] objs = new object[] {
obj,
str,
randBytes,
thisClass,
dc,
ptr,
IntPtr.Zero
};
for (int i = 0; i < m_References.Length; ++i)
{
m_References[i].Target = objs[i];
if (!m_References[i].Target.Equals(objs[i]))
{
TestLibrary.TestFramework.LogError("004.2", "Target is not set correctly");
TestLibrary.TestFramework.LogInformation("WARNING: m_References[i].Target = " + m_References[i].Target.ToString() +
", objs = " + objs[i].ToString() +
", i = " + i.ToString());
retVal = false;
}
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("004.3", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
finally
{
m_References = null;
}
return(retVal);
}
void Start()
{
d = new DisposableClass(0);
Debug.Log(d.id + " before");
assignment();
Debug.Log(d.id + " after");
}
private void GenerateUnusedData1()
{
int intRandValue = TestLibrary.Generator.GetInt32(-55);
long longRandValue = TestLibrary.Generator.GetInt64(-55);
double doubleRandValue = TestLibrary.Generator.GetDouble(-55);
object obj = new object();
string str = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LENGTH, c_MAX_STRING_LENGTH);
Byte[] randBytes = new Byte[c_MAX_STRING_LENGTH];
TestLibrary.Generator.GetBytes(-55, randBytes);
WeakReferenceIsAlive thisClass = new WeakReferenceIsAlive();
DisposableClass dc = new DisposableClass();
IntPtr ptr = new IntPtr(TestLibrary.Generator.GetInt32(-55));
m_References = new WeakReference[] {
new WeakReference(obj, false),
new WeakReference(str, false),
new WeakReference(randBytes, false),
new WeakReference(thisClass, false),
new WeakReference(ptr, false),
new WeakReference(IntPtr.Zero, false),
new WeakReference(dc, false)
};
}
/// <summary>
///
/// </summary>
private void assignment()
{
DisposableClass temp = d;
temp.id = id++;
temp.Dispose(); // **
}
public static void DoSomething(Action <DisposableClass> doSomething)
{
using (var disposable = new DisposableClass())
{
doSomething(disposable);
}
}
public async Task Actor_Should_Return_Cancelled_Task_On_Any_Method_AfterCalling_IAsyncDisposable_DisposeAsync()
{
//arrange
var dispclass = new DisposableClass();
var intface = _TaskPoolActorFactory.Build <IDummyInterface1>(dispclass);
//act
var task = intface.DoAsync();
var disp = GetFiber(intface) as IAsyncDisposable;
await disp.DisposeAsync();
TaskCanceledException error = null;
Task canc = null;
try
{
canc = intface.DoAsync();
await canc;
}
catch (TaskCanceledException e)
{
error = e;
}
//assert
error.Should().NotBeNull();
task.IsCompleted.Should().BeTrue();
canc.IsCanceled.Should().BeTrue();
}
public void IsAssignableFrom_Interface()
{
var expected = new DisposableClass();
Assert.IsAssignableFrom(typeof(IDisposable), expected);
Assert.IsAssignableFrom <IDisposable>(expected);
}
public async Task Actor_IActorLifeCycle_Abort_Should_Cancel_Enqueued_Task()
{
//arrange
var dispclass = new DisposableClass();
var intface = _Factory.Build <IDummyInterface1>(dispclass);
Task Taskrunning = intface.DoAsync(), Takenqueued = intface.DoAsync();
Thread.Sleep(100);
//act
IActorCompleteLifeCycle disp = intface as IActorCompleteLifeCycle;
await disp.Abort();
//assert
TaskCanceledException error = null;
try
{
await Takenqueued;
}
catch (TaskCanceledException e)
{
error = e;
}
//assert
error.Should().NotBeNull();
Takenqueued.IsCanceled.Should().BeTrue();
}
public bool PosTest6()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest6: Call Ctor with IntPtr reference and set trackResurrection to true");
try
{
DisposableClass dc = new DisposableClass();
Object desiredValue = dc;
WeakReference reference = new WeakReference(desiredValue);
if ((reference.TrackResurrection != false) || (!reference.Target.Equals(desiredValue)))
{
TestLibrary.TestFramework.LogError("006.1", "Calling Ctor with valid target reference and set trackResurrection to false constructs wrong instance");
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] reference.TrackResurrection = " + reference.TrackResurrection.ToString() +
", reference.Target = " + reference.Target.ToString() +
", desiredValue = " + desiredValue.ToString());
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("006.7", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return(retVal);
}
public bool PosTest5()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest5: TrackResurrection will return correct value when construct the WeakReference for a disposable instance");
try
{
DisposableClass dc = new DisposableClass();
Object desiredValue = dc;
WeakReference reference = new WeakReference(desiredValue, true);
if (!reference.TrackResurrection)
{
TestLibrary.TestFramework.LogError("005.1", "TrackResurrection returns false when construct the WeakReference for a disposable instance");
retVal = false;
}
reference = new WeakReference(desiredValue, false);
if (reference.TrackResurrection)
{
TestLibrary.TestFramework.LogError("005.2", "TrackResurrection returns true when construct the WeakReference for a disposable instance");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("005.3", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return(retVal);
}
static void Main(string[] args)
{
List <string> DCNames = null;
string DCName = string.Empty;
int DCValue;
using (var disposableClass = new DisposableClass())
{
DCNames = disposableClass.Names;
DCName = disposableClass.Name;
DCValue = disposableClass.Value;
foreach (var name in DCNames)
{
Console.WriteLine(name);
}
Console.WriteLine(DCName);
Console.WriteLine(DCValue);
}
foreach (var name in DCNames)
{
Console.WriteLine(name);
}
Console.WriteLine(DCName);
Console.WriteLine(DCValue);
Console.Read();
}
/// <summary>
/// 还是要手动调用Dispose
/// </summary>
/// <param name="info"></param>
private void RefReturn(ref DisposableClass info)
{
//DisposableClass temp = info;
//temp.id = id++;
//info.Dispose();
info = new DisposableClass(id++);
//temp.Dispose();
}
public void DisposeAfter()
{
var d = new DisposableClass();
Assert.IsFalse(d.IsDisposed);
Assert.IsFalse(d.DisposeAfter(d2 => d2.IsDisposed));
Assert.IsTrue(d.IsDisposed);
}
public void DisposeDisposableObject()
{
var d = new DisposableClass();
DisposableClass?d2 = d;
DisposableUtility.DisposeObject(ref d2);
Assert.IsNull(d2);
Assert.IsTrue(d.IsDisposed);
}
public void Dispose()
{
DisposableClass?d = new DisposableClass();
var dCopy = d;
Assert.IsFalse(d.IsDisposed);
DisposableUtility.Dispose(ref d);
Assert.IsNull(d);
Assert.IsTrue(dCopy.IsDisposed);
}
public async Task Actor_IAsyncDisposable_DisposeAsync_Should_Call_Proxified_Class_On_IAsyncDisposable_Case_2()
{
//arrange
var dispclass = new DisposableClass();
var actor = _Factory.Build <IDummyInterface4>(dispclass);
await actor.DisposeAsync();
//assert
dispclass.IsDisposed.Should().BeTrue();
}
public void DisposeWeakEventSubscription_OnDisposedObject_DoesNotThrow()
{
var disposableClass = new DisposableClass();
var subscription = new MvxWeakEventSubscription <DisposableClass>(disposableClass, "TestEvent", (s, e) =>
{
});
disposableClass.Dispose();
subscription.Dispose();
}
static void IDisposable()
{
Console.WriteLine("IDisposable");
var o1 = new DisposableClass("DC1");
using (var o2 = new DisposableClass("DC in using"))
{
o2.f();
}
Console.WriteLine("IDisposable done");
}
public async Task DisposableTest()
{
var disposable = new DisposableClass();
Assert.False(disposable.IsDisposed);
var task = Disposable.Async(disposable);
Assert.False(disposable.IsDisposed);
await task.ConfigureAwait(false);
Assert.True(disposable.IsDisposed);
}
static void GCTest()
{
Debug.Log($"GC.MaxGeneration: {GC.MaxGeneration}");
// Disposing (deterministic) vs finalization (non-deterministic with possible multi-threaded issues)
Debug.Log("Running tests in: " + Thread.CurrentThread.ManagedThreadId);
using (var obj1 = new DisposableClass()) {
Debug.Log(obj1);
}
CreateOtherObject();
GC.Collect();
GC.WaitForPendingFinalizers();
}
public async Task Stop_Should_Call_Actor_IAsyncDisposable_DisposeAsync_Thread()
{
//arrange
var target1 = new DisposableClass();
var intface1 = _Factory.Build <IDummyInterface1>(target1);
//act
await intface1.DoAsync();
//assert
await _Factory.Stop();
target1.IsDisposed.Should().BeTrue();
}
public async Task Actor_IActorLifeCycle_Abort_Should_Call_Proxified_Class_On_IAsyncDisposable()
{
//arrange
var dispclass = new DisposableClass();
var intface = _Factory.Build <IDummyInterface1>(dispclass);
//act
IActorCompleteLifeCycle disp = intface as IActorCompleteLifeCycle;
await disp.Abort();
//assert
dispclass.IsDisposed.Should().BeTrue();
}
public async Task Actor_IActorLifeCycle_Stop_Should_Call_Proxified_Class_On_IAsyncDisposable()
{
//arrange
var dispclass = new DisposableClass();
var intface = _TaskPoolActorFactory.Build <IDummyInterface1>(dispclass);
//act
var disp = (IActorLifeCycle)intface;
await disp.Stop();
//assert
dispclass.IsDisposed.Should().BeTrue();
}
public void CanDisposeFactoryWhenDependentObjectCallsFactoryInDispose()
{
AbstractObjectFactory factory = CreateObjectFactory(false);
ConfigureObjectFactory(factory as IObjectDefinitionRegistry);
ParentClass parent = (ParentClass)factory.GetObject("Parent");
Assert.That(parent, Is.Not.Null);
DisposableClass innerObject = (DisposableClass)parent.InnerObject;
innerObject.ObjectFactory = factory;
factory.Dispose();
Assert.Pass("Test concluded successfully.");
}
private bool GenerateUnusedData2(string errorNo)
{
bool retVal = true;
object obj = new object();
string str = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LENGTH, c_MAX_STRING_LENGTH);
Byte[] randBytes = new Byte[c_MAX_STRING_LENGTH];
TestLibrary.Generator.GetBytes(-55, randBytes);
TestStruct ts = new TestStruct();
ts.IntValue = TestLibrary.Generator.GetInt32(-55);
WeakReferenceTarget thisClass = new WeakReferenceTarget();
DisposableClass dc = new DisposableClass();
IntPtr ptr = new IntPtr(TestLibrary.Generator.GetInt32(-55));
Object[] objs = new object[] {
obj,
str,
randBytes,
thisClass,
dc,
ptr,
IntPtr.Zero
};
m_References = new WeakReference[objs.Length];
for (int i = 0; i < objs.Length; ++i)
{
m_References[i] = new WeakReference(objs[i], true);
}
for (int i = 0; i < m_References.Length; ++i)
{
if (!m_References[i].Target.Equals(objs[i]))
{
TestLibrary.TestFramework.LogError(errorNo, "Target returns wrong value for weak references");
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] i = " + i.ToString() +
", m_References[i].Target = " + m_References[i].Target.ToString() +
", objs[i] = " + objs[i].ToString());
retVal = false;
}
}
return(retVal);
}
static void Main(string[] args)
{
#region Exceptions bad practices
try
{
var value = 0;
var otherValue = 10 / value; // throw DivideByZeroException;
}
catch (Exception e)
{
throw e;
}
#endregion
#region Extension methods
var str = "Hello Cap";
str.ExtensionMethod();
// NotExtensionMethod(str);
#endregion
#region Params
CountlessParameters();
CountlessParameters(1);
CountlessParameters(1, 2);
CountlessParameters(1, 2, 3, 4, 5, 6);
#endregion
#region Disposable Class
using (var disposableClass = new DisposableClass())
{
// use disposableClass
} // disposableClass.Dispose();
#endregion
#region Arrow function
string Method()
{
return("");
}
string Method2() => "";
#endregion
}
public async Task Actor_IActorLifeCycle_Stop_Should_Not_Cancel_Enqueued_Task()
{
//arrange
var dispclass = new DisposableClass();
var intface = _Factory.Build <IDummyInterface1>(dispclass);
Task Taskrunning = intface.DoAsync(), Takenqueued = intface.DoAsync();
Thread.Sleep(100);
//act
IActorCompleteLifeCycle disp = intface as IActorCompleteLifeCycle;
await disp.Stop();
await Takenqueued;
//assert
Takenqueued.IsCompleted.Should().BeTrue();
}
public void Print()
{
ConsoleColor currentBackground = Console.BackgroundColor;
ConsoleColor currentForeground = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"pre using declared");
using var disposableClass = new DisposableClass();
using var disposableStruct = new DisposableStruct();
// different from using (var d = new DisposableClass())
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"post using declared ");
Console.BackgroundColor = currentBackground;
Console.ForegroundColor = currentForeground;
Console.WriteLine($"After this line the objects dispose");
}
public async Task Actor_IAsyncDisposable_DisposeAsync_Should_Not_Cancel_Enqueued_Task()
{
//arrange
var dispclass = new DisposableClass();
var intface = _TaskPoolActorFactory.Build <IDummyInterface1>(dispclass);
Task taskrunning = intface.DoAsync();
var takenqueued = intface.DoAsync();
Thread.Sleep(100);
//act
var disp = GetFiber(intface) as IAsyncDisposable;
await disp.DisposeAsync();
await takenqueued;
//assert
takenqueued.IsCompleted.Should().BeTrue();
}
public async Task Actor_IAsyncDisposable_DisposeAsync_Should_Call_Proxified_Class_On_ActorThread_Case_2()
{
//arrange
var testThread = Thread.CurrentThread;
var dispclass = new DisposableClass();
var actor = _Factory.Build <IDummyInterface4>(dispclass);
await actor.DoAsync();
var thread = dispclass.LastCallingThread;
//act
await actor.DisposeAsync();
//assert
var disposableThread = dispclass.LastCallingThread;
disposableThread.Should().NotBe(testThread);
disposableThread.Should().Be(thread);
}
private void GenerateUnusedDisposableData()
{
DisposableClass dc = null;
m_References = new WeakReference[1];
try
{
dc = new DisposableClass();
m_References[0] = new WeakReference(dc);
}
finally
{
if (null != dc)
{
dc.Dispose();
}
}
GC.Collect();
}
public void IsAssignableFrom_Interface()
{
var expected = new DisposableClass();
Assert.IsAssignableFrom(typeof(IDisposable), expected);
Assert.IsAssignableFrom<IDisposable>(expected);
}
public bool PosTest4()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest4: Call set_Target on long weak reference to instance of an object before GC");
try
{
// Reclaim memories
GC.Collect();
GC.WaitForPendingFinalizers();
retVal = GenerateUnusedData2("004.1") && retVal;
object obj = new object();
string str = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LENGTH, c_MAX_STRING_LENGTH);
Byte[] randBytes = new Byte[c_MAX_STRING_LENGTH];
TestLibrary.Generator.GetBytes(-55, randBytes);
WeakReferenceTarget thisClass = new WeakReferenceTarget();
DisposableClass dc = new DisposableClass();
IntPtr ptr = new IntPtr(TestLibrary.Generator.GetInt32(-55));
Object[] objs = new object[] {
obj,
str,
randBytes,
thisClass,
dc,
ptr,
IntPtr.Zero
};
for (int i = 0; i < m_References.Length; ++i)
{
m_References[i].Target = objs[i];
if (!m_References[i].Target.Equals(objs[i]))
{
TestLibrary.TestFramework.LogError("004.2", "Target is not set correctly");
TestLibrary.TestFramework.LogInformation("WARNING: m_References[i].Target = " + m_References[i].Target.ToString() +
", objs = " + objs[i].ToString() +
", i = " + i.ToString());
retVal = false;
}
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("004.3", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
finally
{
m_References = null;
}
return retVal;
}
private bool GenerateUnusedData2(string errorNo)
{
bool retVal = true;
object obj = new object();
string str = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LENGTH, c_MAX_STRING_LENGTH);
Byte[] randBytes = new Byte[c_MAX_STRING_LENGTH];
TestLibrary.Generator.GetBytes(-55, randBytes);
TestStruct ts = new TestStruct();
ts.IntValue = TestLibrary.Generator.GetInt32(-55);
WeakReferenceTarget thisClass = new WeakReferenceTarget();
DisposableClass dc = new DisposableClass();
IntPtr ptr = new IntPtr(TestLibrary.Generator.GetInt32(-55));
Object[] objs = new object[] {
obj,
str,
randBytes,
thisClass,
dc,
ptr,
IntPtr.Zero
};
m_References = new WeakReference[objs.Length];
for (int i = 0; i < objs.Length; ++i)
{
m_References[i] = new WeakReference(objs[i], true);
}
for (int i = 0; i < m_References.Length; ++i)
{
if (!m_References[i].Target.Equals(objs[i]))
{
TestLibrary.TestFramework.LogError(errorNo, "Target returns wrong value for weak references");
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] i = " + i.ToString() +
", m_References[i].Target = " + m_References[i].Target.ToString() +
", objs[i] = " + objs[i].ToString());
retVal = false;
}
}
return retVal;
}
private void GenerateUnusedData1()
{
int intRandValue = TestLibrary.Generator.GetInt32(-55);
long longRandValue = TestLibrary.Generator.GetInt64(-55);
double doubleRandValue = TestLibrary.Generator.GetDouble(-55);
object obj = new object();
string str = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LENGTH, c_MAX_STRING_LENGTH);
Byte[] randBytes = new Byte[c_MAX_STRING_LENGTH];
TestLibrary.Generator.GetBytes(-55, randBytes);
WeakReferenceIsAlive thisClass = new WeakReferenceIsAlive();
DisposableClass dc = new DisposableClass();
IntPtr ptr = new IntPtr(TestLibrary.Generator.GetInt32(-55));
m_References = new WeakReference[] {
new WeakReference(obj, false),
new WeakReference(str, false),
new WeakReference(randBytes, false),
new WeakReference(thisClass, false),
new WeakReference(ptr, false),
new WeakReference(IntPtr.Zero, false),
new WeakReference(dc, false)
};
}
public bool PosTest5()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest5: TrackResurrection will return correct value when construct the WeakReference for a disposable instance");
try
{
DisposableClass dc = new DisposableClass();
Object desiredValue = dc;
WeakReference reference = new WeakReference(desiredValue, true);
if (!reference.TrackResurrection)
{
TestLibrary.TestFramework.LogError("005.1", "TrackResurrection returns false when construct the WeakReference for a disposable instance");
retVal = false;
}
reference = new WeakReference(desiredValue, false);
if (reference.TrackResurrection)
{
TestLibrary.TestFramework.LogError("005.2", "TrackResurrection returns true when construct the WeakReference for a disposable instance");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("005.3", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
private void GenerateUnusedData2()
{
object obj = new object();
string str = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LENGTH, c_MAX_STRING_LENGTH);
Byte[] randBytes = new Byte[c_MAX_STRING_LENGTH];
TestLibrary.Generator.GetBytes(-55, randBytes);
WeakReferenceIsAlive thisClass = new WeakReferenceIsAlive();
DisposableClass dc = new DisposableClass();
IntPtr ptr = new IntPtr(TestLibrary.Generator.GetInt32(-55));
m_References = new WeakReference[] {
new WeakReference(obj, true),
new WeakReference(str, true),
new WeakReference(randBytes, true),
new WeakReference(thisClass, true),
new WeakReference(ptr, true),
new WeakReference(IntPtr.Zero, true),
new WeakReference(dc, true)
};
}
public bool PosTest8()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest8: Call Ctor with IntPtr reference and set trackResurrection to true");
try
{
DisposableClass dc = new DisposableClass();
Object desiredValue = dc;
WeakReference reference = new WeakReference(desiredValue, true);
if ((reference.TrackResurrection != true) || (!reference.Target.Equals(desiredValue)))
{
TestLibrary.TestFramework.LogError("008.1", "Calling Ctor with valid target reference and set trackResurrection to false constructs wrong instance");
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] reference.TrackResurrection = " + reference.TrackResurrection.ToString() +
", reference.Target = " + reference.Target.ToString() +
", desiredValue = " + desiredValue.ToString());
retVal = false;
}
reference = new WeakReference(desiredValue, false);
if ((reference.TrackResurrection != false) || (!reference.Target.Equals(desiredValue)))
{
TestLibrary.TestFramework.LogError("008.2", "Calling Ctor with valid target reference and set trackResurrection to false constructs wrong instance");
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] reference.TrackResurrection = " + reference.TrackResurrection.ToString() +
", reference.Target = " + reference.Target.ToString() +
", desiredValue = " + desiredValue.ToString());
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("008.3", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
