public void TestRaiseRTMINPlusOneSignal() { if (!TestHelper.CanUseRealTimeSignals()) { return; } /*this number is a guestimate, but it's ok*/ for (int i = 1; i < 10; ++i) { RealTimeSignum rts = new RealTimeSignum(i); UnixSignal signal; try { signal = new UnixSignal(rts); } catch (ArgumentException) { /*skip the ones that are unavailable*/ continue; } using (signal) { MultiThreadTest(signal, 5000, delegate() { Thread.Sleep(1000); Stdlib.raise(rts); }); } return; } Assert.IsTrue(false, "#1 No available RT signal"); }
public void TestCanRegisterRTSignalMultipleTimes() { if (!TestHelper.CanUseRealTimeSignals()) { return; } /*this number is a guestimate, but it's ok*/ for (int i = 1; i < 10; ++i) { RealTimeSignum rts = new RealTimeSignum(i); UnixSignal signal; try { signal = new UnixSignal(rts); } catch (ArgumentException) { /*skip the ones that are unavailable*/ continue; } try { using (UnixSignal signal2 = new UnixSignal(rts)) { //ok return; } } catch (ArgumentException) { /*skip the ones that are unavailable*/ Assert.IsTrue(false, "#1 Could not register second signal handler"); } } Assert.IsTrue(false, "#2 No available RT signal"); }
public void TestRTSignalGetHashCodeInequality() { RealTimeSignum rts1 = new RealTimeSignum(0); RealTimeSignum rts2 = new RealTimeSignum(1); Assert.That(rts1.GetHashCode(), Is.Not.EqualTo(rts2.GetHashCode())); }
public void TestRealTimeSignumProperty() { RealTimeSignum rts = new RealTimeSignum(0); UnixSignal signal1 = new UnixSignal(rts); Assert.That(signal1.RealTimeSignum, Is.EqualTo(rts)); }
public void TestRTSignalInequality () { RealTimeSignum rts1 = new RealTimeSignum (0); RealTimeSignum rts2 = new RealTimeSignum (1); Assert.That (rts1 == rts2, Is.False); Assert.That (rts1 != rts2, Is.True); }
// convert a realtime signal to os signal public static int FromRealTimeSignum (RealTimeSignum sig) { int sigNum; if (FromRealTimeSignum (sig.Offset, out sigNum) == -1) ThrowArgumentException (sig.Offset); return sigNum; }
public void TestRTSignalInequality() { RealTimeSignum rts1 = new RealTimeSignum(0); RealTimeSignum rts2 = new RealTimeSignum(1); Assert.That(rts1 == rts2, Is.False); Assert.That(rts1 != rts2, Is.True); }
public void TestRTSignalGetHashCodeInequality () { if (!TestHelper.CanUseRealTimeSignals ()) return; RealTimeSignum rts1 = new RealTimeSignum (0); RealTimeSignum rts2 = new RealTimeSignum (1); Assert.That (rts1.GetHashCode (), Is.Not.EqualTo(rts2.GetHashCode ())); }
public void TestRealTimeSignumNegativeOffset() { if (!TestHelper.CanUseRealTimeSignals()) { return; } RealTimeSignum rts1 = new RealTimeSignum(-1); }
public void TestRealTimeOutOfRange() { if (!TestHelper.CanUseRealTimeSignals()) { return; } RealTimeSignum rts = new RealTimeSignum(int.MaxValue); }
public void TestRTSignalInequality () { if (!TestHelper.CanUseRealTimeSignals ()) return; RealTimeSignum rts1 = new RealTimeSignum (0); RealTimeSignum rts2 = new RealTimeSignum (1); Assert.That (rts1 == rts2, Is.False); Assert.That (rts1 != rts2, Is.True); }
public void TestRealTimePropertyThrows() { if (!TestHelper.CanUseRealTimeSignals()) { return; } UnixSignal signal1 = new UnixSignal(Signum.SIGSEGV); RealTimeSignum s = signal1.RealTimeSignum; }
public static int FromRealTimeSignum(RealTimeSignum sig) { int result; if (UnsafeNativeMethods.FromRealTimeSignum(sig.Offset, out result) == -1) { throw new ArgumentException("sig.Offset " + sig.Offset + " is not an acceptable offset"); } return result; }
public void TestRealTimeCstor() { RealTimeSignum rts = new RealTimeSignum(0); using (UnixSignal s = new UnixSignal(rts)) { Assert.That(s.IsRealTimeSignal); Assert.That(s.RealTimeSignum, Is.EqualTo(rts)); } }
public void TestRTSignalGetHashCodeInequality() { if (!TestHelper.CanUseRealTimeSignals()) { return; } RealTimeSignum rts1 = new RealTimeSignum(0); RealTimeSignum rts2 = new RealTimeSignum(1); Assert.That(rts1.GetHashCode(), Is.Not.EqualTo(rts2.GetHashCode())); }
public void TestRealTimeSignumNegativeOffset() { if (!TestHelper.CanUseRealTimeSignals()) { return; } Assert.Throws <ArgumentOutOfRangeException> (() => { RealTimeSignum rts1 = new RealTimeSignum(-1); }); }
public void TestRealTimeSignumProperty() { if (!TestHelper.CanUseRealTimeSignals()) { return; } RealTimeSignum rts = new RealTimeSignum(0); UnixSignal signal1 = new UnixSignal(rts); Assert.That(signal1.RealTimeSignum, Is.EqualTo(rts)); }
public void TestRealTimeOutOfRange() { if (!TestHelper.CanUseRealTimeSignals()) { return; } Assert.Throws <ArgumentOutOfRangeException> (() => { RealTimeSignum rts = new RealTimeSignum(int.MaxValue); }); }
public void TestRealTimePropertyThrows() { if (!TestHelper.CanUseRealTimeSignals()) { return; } Assert.Throws <InvalidOperationException> (() => { UnixSignal signal1 = new UnixSignal(Signum.SIGSEGV); RealTimeSignum s = signal1.RealTimeSignum; }); }
public void TestRTSignalInequality() { if (!TestHelper.CanUseRealTimeSignals()) { return; } RealTimeSignum rts1 = new RealTimeSignum(0); RealTimeSignum rts2 = new RealTimeSignum(1); Assert.That(rts1 == rts2, Is.False); Assert.That(rts1 != rts2, Is.True); }
public void TestRaiseRTMINSignal() { RealTimeSignum rts = new RealTimeSignum(0); using (UnixSignal signal = new UnixSignal(rts)) { MultiThreadTest(signal, 5000, delegate() { Thread.Sleep(1000); Stdlib.raise(rts); }); } }
public void TestRealTimeCstor() { if (!TestHelper.CanUseRealTimeSignals()) { return; } RealTimeSignum rts = new RealTimeSignum(0); using (UnixSignal s = new UnixSignal(rts)) { Assert.That(s.IsRealTimeSignal); Assert.That(s.RealTimeSignum, Is.EqualTo(rts)); } }
public void TestRaiseRTMINSignal() { if (!TestHelper.CanUseRealTimeSignals()) { return; } RealTimeSignum rts = new RealTimeSignum(0); using (UnixSignal signal = new UnixSignal(rts)) { MultiThreadTest(signal, 5000, delegate() { Thread.Sleep(1000); Stdlib.raise(rts); }); } }
public void TestRealTimeSignumProperty() { if (!TestHelper.CanUseRealTimeSignals()) { return; } int rtsigOffset = Utilities.FindFirstFreeRTSignal(); Assert.That(rtsigOffset, Is.GreaterThan(-1), "No available RT signals"); RealTimeSignum rts = new RealTimeSignum(rtsigOffset); UnixSignal signal1 = new UnixSignal(rts); Assert.That(signal1.RealTimeSignum, Is.EqualTo(rts)); }
public void TestRaiseRTMINSignal() { if (!TestHelper.CanUseRealTimeSignals()) { return; } int rtsigOffset = Utilities.FindFirstFreeRTSignal(); Assert.That(rtsigOffset, Is.GreaterThan(-1), "No available RT signals"); RealTimeSignum rts = new RealTimeSignum(rtsigOffset); using (UnixSignal signal = new UnixSignal(rts)) { MultiThreadTest(signal, 5000, delegate() { Thread.Sleep(1000); Stdlib.raise(rts); }); } }
public void TestRealTimePropertyThrows() { UnixSignal signal1 = new UnixSignal(Signum.SIGSEGV); RealTimeSignum s = signal1.RealTimeSignum; }
public void TestRealTimeOutOfRange () { RealTimeSignum rts = new RealTimeSignum (int.MaxValue); }
public void TestCanRegisterRTSignalMultipleTimes () { /*this number is a guestimate, but it's ok*/ for (int i = 1; i < 10; ++i) { RealTimeSignum rts = new RealTimeSignum (i); UnixSignal signal; try { signal = new UnixSignal (rts); } catch (ArgumentException) { /*skip the ones that are unavailable*/ continue; } try { using (UnixSignal signal2 = new UnixSignal (rts)) { //ok return; } } catch (ArgumentException) { /*skip the ones that are unavailable*/ Assert.IsTrue (false, "#1 Could not register second signal handler"); } } Assert.IsTrue (false, "#2 No available RT signal"); }
public void TestRaiseRTMINSignal () { RealTimeSignum rts = new RealTimeSignum (0); using (UnixSignal signal = new UnixSignal (rts)) { MultiThreadTest (signal, 5000, delegate() { Thread.Sleep (1000); Stdlib.raise (rts); }); } }
public void TestRealTimeSignumProperty () { RealTimeSignum rts = new RealTimeSignum (0); UnixSignal signal1 = new UnixSignal (rts); Assert.That (signal1.RealTimeSignum, Is.EqualTo (rts)); }
public void TestRealTimeCstor () { RealTimeSignum rts = new RealTimeSignum (0); using (UnixSignal s = new UnixSignal (rts)) { Assert.That(s.IsRealTimeSignal); Assert.That(s.RealTimeSignum, Is.EqualTo (rts)); } }
public void TestRealTimeCstor () { if (!TestHelper.CanUseRealTimeSignals ()) return; RealTimeSignum rts = new RealTimeSignum (0); using (UnixSignal s = new UnixSignal (rts)) { Assert.That(s.IsRealTimeSignal); Assert.That(s.RealTimeSignum, Is.EqualTo (rts)); } }
public void TestRealTimeSignumProperty () { if (!TestHelper.CanUseRealTimeSignals ()) return; RealTimeSignum rts = new RealTimeSignum (0); UnixSignal signal1 = new UnixSignal (rts); Assert.That (signal1.RealTimeSignum, Is.EqualTo (rts)); }
public void TestRTSignalGetHashCodeInequality () { RealTimeSignum rts1 = new RealTimeSignum (0); RealTimeSignum rts2 = new RealTimeSignum (1); Assert.That (rts1.GetHashCode (), Is.Not.EqualTo(rts2.GetHashCode ())); }
public void TestRealTimeOutOfRange() { RealTimeSignum rts = new RealTimeSignum(int.MaxValue); }
public void TestRaiseRTMINPlusOneSignal () { /*this number is a guestimate, but it's ok*/ for (int i = 1; i < 10; ++i) { RealTimeSignum rts = new RealTimeSignum (i); UnixSignal signal; try { signal = new UnixSignal (rts); } catch (ArgumentException) { /*skip the ones that are unavailable*/ continue; } using (signal) { MultiThreadTest (signal, 5000, delegate() { Thread.Sleep(1000); Stdlib.raise(rts); }); } return; } Assert.IsTrue (false, "#1 No available RT signal"); }
public void TestRealTimeOutOfRange () { if (!TestHelper.CanUseRealTimeSignals ()) return; RealTimeSignum rts = new RealTimeSignum (int.MaxValue); }
public void TestRealTimeSignumNegativeOffset() { RealTimeSignum rts1 = new RealTimeSignum(-1); }
public void TestRealTimeSignumNegativeOffset () { if (!TestHelper.CanUseRealTimeSignals ()) return; RealTimeSignum rts1 = new RealTimeSignum (-1); }
public void TestRealTimeSignumNegativeOffset () { RealTimeSignum rts1 = new RealTimeSignum (-1); }