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; }
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; }