Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/Mono.Posix/Test/Mono.Unix.Native/ChangeLog

@@ -0,0 +1,15 @@
+2009-02-19  Jonathan Pryor  <jonpryor@vt.edu>
+
+	* RealTimeSignumTest.cs: Disable the tests on Mac OS X, as OS X
+	  doesn't support real-time signals.
+
+2008-12-19  Jonathan Pryor  <jonpryor@vt.edu>
+
+	* RealTimeSignumTest.cs: Added; unit tests for RealTimeSignum.
+	  Patch thanks to tim.jenks@realtimeworlds.com.
+
+2005-11-28  Jonathan Pryor  <jonpryor@vt.edu>
+
+	* ChangeLog: Started.
+	* StdlibTest.cs: Moved from ../Mono.Unix.  Test Mono.Unix.Native namespace.
+

mcs/class/Mono.Posix/Test/Mono.Unix.Native/RealTimeSignumTests.cs

@@ -0,0 +1,87 @@
+//
+// RealTimeSignumTests.cs - NUnit Test Cases for Mono.Unix.Native.RealTimeSignum
+//
+// Authors:
+//	Tim Jenks  <tim.jenks@realtimeworlds.com>
+//
+// (C) 2008 Realtime Worlds Ltd
+//
+
+using NUnit.Framework;
+using NUnit.Framework.SyntaxHelpers;
+using System;
+using System.Text;
+using System.Threading;
+using Mono.Unix;
+using Mono.Unix.Native;
+
+namespace MonoTests.Mono.Unix.Native {
+
+	[TestFixture]
+	[Category ("NotOnMac")]
+	public class RealTimeSignumTest 
+	{
+		[Test]
+		[ExpectedException (typeof (ArgumentOutOfRangeException))]
+		public void TestRealTimeOutOfRange ()
+		{
+			RealTimeSignum rts = new RealTimeSignum (int.MaxValue);
+		}
+
+		[Test]
+		[ExpectedException (typeof (ArgumentOutOfRangeException))]
+		public void TestRealTimeSignumNegativeOffset ()
+		{
+			RealTimeSignum rts1 = new RealTimeSignum (-1);
+		}
+
+		[Test]
+		public void TestRTSignalEquality ()
+		{
+			RealTimeSignum rts1 = new RealTimeSignum (0);
+			RealTimeSignum rts2 = new RealTimeSignum (0);
+			Assert.That (rts1 == rts2, Is.True);
+			Assert.That (rts1 != rts2, Is.False);
+		}
+
+		[Test]
+		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);
+		}
+
+		[Test]
+		public void TestRTSignalGetHashCodeEquality ()
+		{
+			RealTimeSignum rts1 = new RealTimeSignum (0);
+			RealTimeSignum rts2 = new RealTimeSignum (0);
+			Assert.That (rts1.GetHashCode (), Is.EqualTo(rts2.GetHashCode ()));
+		}
+
+		[Test]
+		public void TestRTSignalGetHashCodeInequality ()
+		{
+			RealTimeSignum rts1 = new RealTimeSignum (0);
+			RealTimeSignum rts2 = new RealTimeSignum (1);
+			Assert.That (rts1.GetHashCode (), Is.Not.EqualTo(rts2.GetHashCode ()));
+		}
+
+		[Test]
+		public void TestIsRTSignalPropertyForRTSignum ()
+		{
+			UnixSignal signal1 = new UnixSignal(new RealTimeSignum (0));
+			Assert.That (signal1.IsRealTimeSignal, Is.True);
+		}
+
+		[Test]
+		public void TestIsRTSignalPropertyForSignum ()
+		{
+			UnixSignal signal1 = new UnixSignal (Signum.SIGSEGV);
+			Assert.That (signal1.IsRealTimeSignal, Is.False);
+		}
+
+	}
+}

mcs/class/Mono.Posix/Test/Mono.Unix.Native/StdlibTest.cs

@@ -0,0 +1,105 @@
+//
+// StdlibTest.cs:
+// 	NUnit Test Cases for Mono.Unix.Native.Stdlib
+//
+// Authors:
+//   Jonathan Pryor (jonpryor@vt.edu)
+//
+// (C) 2004-2005 Jonathan Pryor
+// 
+
+using System;
+using System.Text;
+
+using NUnit.Framework;
+
+using Mono.Unix.Native;
+
+namespace MonoTests.Mono.Unix.Native {
+
+	[TestFixture]
+	public class StdlibTest
+	{
+		private class SignalTest {
+			public int signalReceived;
+
+			public void Handler (int sn)
+			{
+				signalReceived = sn;
+			}
+		}
+
+		// [Test]
+#if !NET_2_0
+		// .NET 1.1 marshals delegates as Stdcall functions, while signal(3)
+		// expects a Cdecl function.  Result: stack corruption.
+		// DO NOT USE Stdlib.signal under .NET 1.1!
+		// .NET 2.0 allows us to specify how delegates should be marshaled, so
+		// this isn't an issue there.
+		[Category ("NotDotNet")]
+#endif
+		public void Signal ()
+		{
+			SignalTest st = new SignalTest ();
+
+			// Insert handler
+			SignalHandler oh = Stdlib.signal (Signum.SIGURG, 
+					new SignalHandler (st.Handler));
+
+			st.signalReceived = ~NativeConvert.FromSignum (Signum.SIGURG);
+
+			// Send signal
+			Stdlib.raise (Signum.SIGURG);
+
+			Assert.IsTrue (
+				NativeConvert.ToSignum (st.signalReceived) == Signum.SIGURG,
+					"#IH: Signal handler not invoked for SIGURG");
+
+			// Reset old signal
+			Stdlib.signal (Signum.SIGURG, oh);
+
+			st.signalReceived = NativeConvert.FromSignum (Signum.SIGUSR1);
+			Stdlib.raise (Signum.SIGURG);
+
+			Assert.IsFalse (NativeConvert.ToSignum (st.signalReceived) == Signum.SIGURG,
+					"#IH: Signal Handler invoked when it should have been removed!");
+		}
+
+		[Test]
+		// MSVCRT.DLL doesn't export snprintf(3).
+		[Category ("NotDotNet")]
+		[Category ("NotWorking")]
+		public void Snprintf ()
+		{
+			StringBuilder s = new StringBuilder (1000);
+			Stdlib.snprintf (s, "hello, %s world!\n");
+			Assert.AreEqual (s.ToString(), "hello, %s world!\n", 
+					"#SNPF: string not echoed");
+			s = new StringBuilder (1000);
+			Stdlib.snprintf (s, "yet another %s test", "simple");
+			Assert.AreEqual (s.ToString(), "yet another simple test",
+					"#SNPF: string argument not printed");
+			s = new StringBuilder (1000);
+			string fmt = 
+@"this is another test:
+	  char: '%c'
+	 short: %i
+	   int: %i
+	  long: %li
+	 float: %g
+	double: %g" + "\n";
+		Stdlib.snprintf (s, fmt, 'a', (short) 16, 32, (long) 64, (double) 32.23, 64.46);
+			string expected = 
+@"this is another test:
+	  char: 'a'
+	 short: 16
+	   int: 32
+	  long: 64
+	 float: 32.23
+	double: 64.46" + "\n";
+			Assert.AreEqual (s.ToString(), expected,
+					"#SNPF: printf of many builtin types failed");
+		}
+	}
+}
+