public void WhenConstructorFailsVersionIsNotIncremented() { bool firstConstructorInvocation = true; var reloader = new Reloader <int>( constructor: () => { if (!firstConstructorInvocation) { throw new NotImplementedException(); } firstConstructorInvocation = false; return(42); }); // constructor not called yet --> current version 0 XAssert.AreEqual(0, reloader.CurrentVersion); // constructor called the first time --> doesn't throw --> version incremented reloader.Reload(0); XAssert.AreEqual(1, reloader.CurrentVersion); // constructor called the second time --> throws --> version stays the same Assert.Throws <NotImplementedException>(() => reloader.Reload(1)); XAssert.AreEqual(1, reloader.CurrentVersion); }
public void DestructorNotCalledBeforeReloaderIsDisposed() { int constructorCnt = 0; int destructorCnt = 0; // create reloader and assert constructor was called var reloader = new Reloader <int>( constructor: () => Interlocked.Increment(ref constructorCnt), destructor: (i) => Interlocked.Increment(ref destructorCnt)); XAssert.AreEqual(0, constructorCnt, "Constructor should not be called as soon as Reloader is created"); XAssert.AreEqual(0, destructorCnt, "Destructor should not be called before Reloader is disposed."); // reload and assert constructor was called again, but no destructor reloader.Reload(reloader.CurrentVersion); XAssert.AreEqual(1, constructorCnt); XAssert.AreEqual(0, destructorCnt, "Destructor should not be called before Reloader is disposed."); // reload and assert constructor was called again, but no destructor reloader.Reload(reloader.CurrentVersion); XAssert.AreEqual(2, constructorCnt); XAssert.AreEqual(0, destructorCnt, "Destructor should not be called before Reloader is disposed."); // dispose and assert that destructor was called twice (once for each reloaded value) reloader.Dispose(); XAssert.AreEqual(2, destructorCnt, "Destructor wasn't called for each created value."); }
public void TestConcurrentReloadsOfSameVersionCreateOnlyOneNewValue() { int cnt = 0; using (var reloader = new Reloader <string>(() => "hi" + Interlocked.Increment(ref cnt))) { // call 'Reload(startVersion)' concurrently from multiple threads var startVersion = reloader.CurrentVersion; var range = Enumerable.Range(0, 100).ToList(); var threads = range.Select(_ => new Thread(() => { reloader.Reload(startVersion); var instance = reloader.CurrentVersionedValue; // assert each thread gets the same instance XAssert.AreEqual(startVersion + 1, instance.Version); XAssert.AreEqual("hi1", instance.Value); })).ToList(); ConcurrencyTest.Start(threads); ConcurrencyTest.Join(threads); // assert only 1 new value was created XAssert.AreEqual(startVersion + 1, reloader.CurrentVersion); XAssert.AreEqual(startVersion + 1, reloader.CurrentVersionedValue.Version); XAssert.AreEqual("hi1", reloader.CurrentVersionedValue.Value); } }
public void Reload() { if (reloader == null) { return; } reloader.Reload(); }