/// <summary> /// Test SemaphoreSlim Dispose /// </summary> /// <param name="initial">The initial semaphore count</param> /// <param name="maximum">The maximum semaphore count</param> /// <param name="action">SemaphoreSlim action to be called after Dispose</param> /// <param name="exceptionType">The type of the thrown exception in case of invalid cases, /// null for valid cases</param> /// <returns>True if the test succeeded, false otherwise</returns> private static void RunSemaphoreSlimTest4_Dispose(int initial, int maximum, SemaphoreSlimActions?action, Type exceptionType) { Exception exception = null; SemaphoreSlim semaphore = new SemaphoreSlim(initial, maximum); try { semaphore.Dispose(); CallSemaphoreAction(semaphore, action, null); } catch (Exception ex) { exception = ex; } // The code threw excption and it is not expected because the excyptionType param is null if (exceptionType == null && exception != null) { string methodFailed = "RunSemaphoreSlimTest4_Dispose(" + initial + "," + maximum + "," + action + "): FAILED. "; Assert.True(false, string.Format(methodFailed + "Dispose failed, the code threw an exception, and it is not supposed to.")); } // Compare both exception types in case of the code threw exception if (exception != null && !Type.Equals(exception.GetType(), exceptionType)) { string methodFailed = "RunSemaphoreSlimTest4_Dispose(" + initial + "," + maximum + "," + action + "): FAILED. "; Assert.True(false, string.Format(methodFailed + "Dispose failed, Excption types do not match")); } }
/// <summary> /// Test SemaphoreSlim AvailableWaitHandle property /// </summary> /// <param name="initial">The initial semaphore count</param> /// <param name="maximum">The maximum semaphore count</param> /// <param name="action">SemaphoreSlim action to be called before WaitHandle</param> /// <param name="state">The expected wait handle state</param> /// <returns>True if the test succeeded, false otherwise</returns> private static bool RunSemaphoreSlimTest7_AvailableWaitHandle (int initial, int maximum, SemaphoreSlimActions?action, bool state) { TestHarness.TestLog("AvailableWaitHandle(" + initial + "," + maximum + "," + action + ")"); SemaphoreSlim semaphore = new SemaphoreSlim(initial, maximum); try { CallSemaphoreAction(semaphore, action, null); if (semaphore.AvailableWaitHandle == null) { TestHarness.TestLog("AvailableWaitHandle failed, handle is null."); return(false); } if (semaphore.AvailableWaitHandle.WaitOne(0, false) != state) { TestHarness.TestLog("AvailableWaitHandle failed, expected " + state + " actual " + !state); return(false); } } catch (Exception ex) { TestHarness.TestLog("AvailableWaitHandle failed, the code threw exception " + ex); return(false); } TestHarness.TestLog("AvailableWaitHandle succeeded."); return(true); }
/// <summary> /// Test SemaphoreSlim Dispose /// </summary> /// <param name="initial">The initial semaphore count</param> /// <param name="maximum">The maximum semaphore count</param> /// <param name="action">SemaphoreSlim action to be called after Dispose</param> /// <param name="exceptionType">The type of the thrown exception in case of invalid cases, /// null for valid cases</param> /// <returns>True if the test succeeded, false otherwise</returns> private static bool RunSemaphoreSlimTest4_Dispose (int initial, int maximum, SemaphoreSlimActions?action, Type exceptionType) { TestHarness.TestLog("Dispose(" + initial + "," + maximum + "," + action + ")"); Exception exception = null; SemaphoreSlim semaphore = new SemaphoreSlim(initial, maximum); try { semaphore.Dispose(); CallSemaphoreAction(semaphore, action, null); } catch (Exception ex) { exception = ex; } // The code threw excption and it is not expected because the excyptionType param is null if (exceptionType == null && exception != null) { TestHarness.TestLog("Dispose failed, the code threw an exception, and it is not supposed to."); return(false); } // Compare both exception types in case of the code threw exception if (exception != null && !Type.Equals(exception.GetType(), exceptionType)) { TestHarness.TestLog("Dispose failed, Excption types do not match"); return(false); } TestHarness.TestLog("Dispose succeeded"); return(true); }
/// <summary> /// Call specific SemaphoreSlim method or property /// </summary> /// <param name="semaphore">The SemaphoreSlim instance</param> /// <param name="action">The action name</param> /// <param name="param">The action parameter, null if it takes no parameters</param> /// <returns>The action return value, null if the action returns void</returns> private static object CallSemaphoreAction (SemaphoreSlim semaphore, SemaphoreSlimActions?action, object param) { if (action == SemaphoreSlimActions.Wait) { if (param is TimeSpan) { return(semaphore.Wait((TimeSpan)param)); } else if (param is int) { return(semaphore.Wait((int)param)); } semaphore.Wait(); return(null); } else if (action == SemaphoreSlimActions.WaitAsync) { if (param is TimeSpan) { return(semaphore.WaitAsync((TimeSpan)param).Result); } else if (param is int) { return(semaphore.WaitAsync((int)param).Result); } semaphore.WaitAsync().Wait(); return(null); } else if (action == SemaphoreSlimActions.Release) { if (param != null) { return(semaphore.Release((int)param)); } return(semaphore.Release()); } else if (action == SemaphoreSlimActions.Dispose) { semaphore.Dispose(); return(null); } else if (action == SemaphoreSlimActions.CurrentCount) { return(semaphore.CurrentCount); } else if (action == SemaphoreSlimActions.AvailableWaitHandle) { return(semaphore.AvailableWaitHandle); } return(null); }
/// <summary> /// Call specific SemaphoreSlim method or property /// </summary> /// <param name="semaphore">The SemaphoreSlim instance</param> /// <param name="action">The action name</param> /// <param name="param">The action parameter, null if it takes no parameters</param> /// <returns>The action return value, null if the action returns void</returns> private static object CallSemaphoreAction (SemaphoreSlim semaphore, SemaphoreSlimActions?action, object param) { if (action == SemaphoreSlimActions.Wait) { if (param is TimeSpan timeSpan) { return(semaphore.Wait(timeSpan)); } if (param is int milliseconds) { return(semaphore.Wait(milliseconds)); } semaphore.Wait(); return(null); } if (action == SemaphoreSlimActions.WaitAsync) { if (param is TimeSpan timeSpan) { return(semaphore.WaitAsync(timeSpan).Result); } if (param is int milliseconds) { return(semaphore.WaitAsync(milliseconds).Result); } semaphore.WaitAsync().Wait(); return(null); } if (action == SemaphoreSlimActions.Release) { return(param != null?semaphore.Release((int)param) : semaphore.Release()); } if (action == SemaphoreSlimActions.Dispose) { semaphore.Dispose(); return(null); } if (action == SemaphoreSlimActions.CurrentCount) { return(semaphore.CurrentCount); } return(action == SemaphoreSlimActions.AvailableWaitHandle ? semaphore.AvailableWaitHandle : null); }
/// <summary> /// Test SemaphoreSlim Dispose /// </summary> /// <param name="initial">The initial semaphore count</param> /// <param name="maximum">The maximum semaphore count</param> /// <param name="action">SemaphoreSlim action to be called after Dispose</param> /// <param name="exceptionType">The type of the thrown exception in case of invalid cases, /// null for valid cases</param> /// <returns>True if the test succeeded, false otherwise</returns> private static void RunSemaphoreSlimTest4_Dispose(int initial, int maximum, SemaphoreSlimActions?action, Type exceptionType) { SemaphoreSlim semaphore = new SemaphoreSlim(initial, maximum); try { semaphore.Dispose(); CallSemaphoreAction(semaphore, action, null); } catch (Exception ex) { Assert.NotNull(exceptionType); Assert.IsType(exceptionType, ex); } }
/// <summary> /// Test SemaphoreSlim Dispose /// </summary> /// <param name="initial">The initial semaphore count</param> /// <param name="maximum">The maximum semaphore count</param> /// <param name="action">SemaphoreSlim action to be called after Dispose</param> /// <param name="exceptionType">The type of the thrown exception in case of invalid cases, /// null for valid cases</param> /// <returns>True if the test succeeded, false otherwise</returns> private static void RunSemaphoreSlimTest4_Dispose(int initial, int maximum, SemaphoreSlimActions?action, Type exceptionType) { var semaphore = new SemaphoreSlim(initial, maximum); try { semaphore.Dispose(); GC.KeepAlive(CallSemaphoreAction(semaphore, action, null)); } catch (Exception ex) { Assert.NotNull(exceptionType); Assert.IsTrue(exceptionType.IsInstanceOfType(ex)); } }
/// <summary> /// Test SemaphoreSlim CurrentCount property /// </summary> /// <param name="initial">The initial semaphore count</param> /// <param name="maximum">The maximum semaphore count</param> /// <param name="action">SemaphoreSlim action to be called before CurentCount</param> /// <returns>True if the test succeeded, false otherwise</returns> private static bool RunSemaphoreSlimTest5_CurrentCount (int initial, int maximum, SemaphoreSlimActions?action) { TestHarness.TestLog("CurrentCount(" + initial + "," + maximum + "," + action + ")"); SemaphoreSlim semaphore = new SemaphoreSlim(initial, maximum); try { CallSemaphoreAction(semaphore, action, null); if ((action == SemaphoreSlimActions.Wait && semaphore.CurrentCount != initial - 1) || (action == SemaphoreSlimActions.Release && semaphore.CurrentCount != initial + 1)) { TestHarness.TestLog("CurrentCount failed"); return(false); } } catch (Exception ex) { TestHarness.TestLog("CurrentCount failed, the code threw exception " + ex); return(false); } TestHarness.TestLog("CurrentCount succeeded"); return(true); }
/// <summary> /// Test SemaphoreSlim AvailableWaitHandle property /// </summary> /// <param name="initial">The initial semaphore count</param> /// <param name="maximum">The maximum semaphore count</param> /// <param name="action">SemaphoreSlim action to be called before WaitHandle</param> /// <param name="state">The expected wait handle state</param> /// <returns>True if the test succeeded, false otherwise</returns> private static void RunSemaphoreSlimTest7_AvailableWaitHandle(int initial, int maximum, SemaphoreSlimActions?action, bool state) { SemaphoreSlim semaphore = new SemaphoreSlim(initial, maximum); try { CallSemaphoreAction(semaphore, action, null); if (semaphore.AvailableWaitHandle == null) { string methodFailed = "RunSemaphoreSlimTest7_AvailableWaitHandle(" + initial + "," + maximum + "," + action + "): FAILED. "; Assert.True(false, string.Format(methodFailed + "AvailableWaitHandle failed, handle is null.")); } if (semaphore.AvailableWaitHandle.WaitOne(0) != state) { string methodFailed = "RunSemaphoreSlimTest7_AvailableWaitHandle(" + initial + "," + maximum + "," + action + "): FAILED. "; Assert.True(false, string.Format(methodFailed + "AvailableWaitHandle failed, expected " + state + " actual " + !state)); } } catch (Exception ex) { string methodFailed = "RunSemaphoreSlimTest7_AvailableWaitHandle(" + initial + "," + maximum + "," + action + "): FAILED. "; Assert.True(false, string.Format(methodFailed + "AvailableWaitHandle failed, the code threw exception " + ex)); } }
/// <summary> /// Test SemaphoreSlim CurrentCount property /// </summary> /// <param name="initial">The initial semaphore count</param> /// <param name="maximum">The maximum semaphore count</param> /// <param name="action">SemaphoreSlim action to be called before CurentCount</param> /// <returns>True if the test succeeded, false otherwise</returns> private static void RunSemaphoreSlimTest5_CurrentCount(int initial, int maximum, SemaphoreSlimActions?action) { SemaphoreSlim semaphore = new SemaphoreSlim(initial, maximum); try { CallSemaphoreAction(semaphore, action, null); if ((action == SemaphoreSlimActions.Wait && semaphore.CurrentCount != initial - 1) || (action == SemaphoreSlimActions.WaitAsync && semaphore.CurrentCount != initial - 1) || (action == SemaphoreSlimActions.Release && semaphore.CurrentCount != initial + 1)) { string methodFailed = "RunSemaphoreSlimTest5_CurrentCount(" + initial + "," + maximum + "," + action + "): FAILED. "; Assert.True(false, string.Format(methodFailed + "CurrentCount failed")); } } catch (Exception ex) { string methodFailed = "RunSemaphoreSlimTest5_CurrentCount(" + initial + "," + maximum + "," + action + "): FAILED. "; Assert.True(false, string.Format(methodFailed + "CurrentCount failed, the code threw exception " + ex)); } }
/// <summary> /// Test SemaphoreSlim AvailableWaitHandle property /// </summary> /// <param name="initial">The initial semaphore count</param> /// <param name="maximum">The maximum semaphore count</param> /// <param name="action">SemaphoreSlim action to be called before WaitHandle</param> /// <param name="state">The expected wait handle state</param> /// <returns>True if the test succeeded, false otherwise</returns> private static void RunSemaphoreSlimTest7_AvailableWaitHandle(int initial, int maximum, SemaphoreSlimActions?action, bool state) { SemaphoreSlim semaphore = new SemaphoreSlim(initial, maximum); CallSemaphoreAction(semaphore, action, null); Assert.NotNull(semaphore.AvailableWaitHandle); Assert.Equal(state, semaphore.AvailableWaitHandle.WaitOne(0)); }
/// <summary> /// Test SemaphoreSlim CurrentCount property /// </summary> /// <param name="initial">The initial semaphore count</param> /// <param name="maximum">The maximum semaphore count</param> /// <param name="action">SemaphoreSlim action to be called before CurrentCount</param> /// <returns>True if the test succeeded, false otherwise</returns> private static void RunSemaphoreSlimTest5_CurrentCount(int initial, int maximum, SemaphoreSlimActions?action) { SemaphoreSlim semaphore = new SemaphoreSlim(initial, maximum); CallSemaphoreAction(semaphore, action, null); if (action == null) { Assert.Equal(initial, semaphore.CurrentCount); } else { Assert.Equal(initial + (action == SemaphoreSlimActions.Release ? 1 : -1), semaphore.CurrentCount); } }