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