Examples/test-suite/csharp/csharp_exceptions_runme.cs - third_party/swig - Git at Google

 using System;
 using System.Threading;
 using csharp_exceptionsNamespace;

 public class runme
 {
     static void Main()
     {
       // %exception tests
       try {
         csharp_exceptions.ThrowByValue();
         throw new Exception("ThrowByValue not working");
       } catch (DivideByZeroException) {
       }
       try {
         csharp_exceptions.ThrowByReference();
         throw new Exception("ThrowByReference not working");
       } catch (DivideByZeroException) {
       }

       // %csnothrowexception
       csharp_exceptions.NoThrowException();
       csharp_exceptions.NullReference(new Ex("should not throw"));

       // exception specifications
       bool testFailed = false;
       try {
         csharp_exceptions.ExceptionSpecificationValue();
         testFailed = true;
       } catch (ApplicationException) {
       }
       if (testFailed) throw new Exception("ExceptionSpecificationValue not working");
       try {
         csharp_exceptions.ExceptionSpecificationReference();
         testFailed = true;
       } catch (ApplicationException) {
       }
       if (testFailed) throw new Exception("ExceptionSpecificationReference not working");
       try {
         csharp_exceptions.ExceptionSpecificationString();
         testFailed = true;
       } catch (ApplicationException e) {
         if (e.Message != "ExceptionSpecificationString") throw new Exception("ExceptionSpecificationString unexpected message: " + e.Message);
       }
       if (testFailed) throw new Exception("ExceptionSpecificationString not working");
       try {
         csharp_exceptions.ExceptionSpecificationInteger();
         testFailed = true;
       } catch (ApplicationException) {
       }
       if (testFailed) throw new Exception("ExceptionSpecificationInteger not working");

       // null reference exceptions
       try {
         csharp_exceptions.NullReference(null);
         throw new Exception("NullReference not working");
       } catch (ArgumentNullException) {
       }
       try {
         csharp_exceptions.NullValue(null);
         throw new Exception("NullValue not working");
       } catch (ArgumentNullException) {
       }

       // enums
       try {
         csharp_exceptions.ExceptionSpecificationEnumValue();
         testFailed = true;
       } catch (ApplicationException) {
       }
       if (testFailed) throw new Exception("ExceptionSpecificationEnumValue not working");
       try {
         csharp_exceptions.ExceptionSpecificationEnumReference();
         testFailed = true;
       } catch (ApplicationException) {
       }
       if (testFailed) throw new Exception("ExceptionSpecificationEnumReference not working");

       // std::string
       try {
         csharp_exceptions.NullStdStringValue(null);
         throw new Exception("NullStdStringValue not working");
       } catch (ArgumentNullException) {
       }
       try {
         csharp_exceptions.NullStdStringReference(null);
         throw new Exception("NullStdStringReference not working");
       } catch (ArgumentNullException) {
       }
       try {
         csharp_exceptions.ExceptionSpecificationStdStringValue();
         testFailed = true;
       } catch (ApplicationException e) {
         if (e.Message != "ExceptionSpecificationStdStringValue") throw new Exception("ExceptionSpecificationStdStringValue unexpected message: " + e.Message);
       }
       if (testFailed) throw new Exception("ExceptionSpecificationStdStringValue not working");
       try {
         csharp_exceptions.ExceptionSpecificationStdStringReference();
         testFailed = true;
       } catch (ApplicationException e) {
         if (e.Message != "ExceptionSpecificationStdStringReference") throw new Exception("ExceptionSpecificationStdStringReference unexpected message: " + e.Message);
       }
       if (testFailed) throw new Exception("ExceptionSpecificationStdStringReference not working");

       // Memory leak check (The C++ exception stack was never unwound in the original approach to throwing exceptions from unmanaged code)
       try {
         csharp_exceptions.MemoryLeakCheck();
         throw new Exception("MemoryLeakCheck not working");
       } catch (DivideByZeroException) {
       }
       if (Counter.count != 0) throw new Exception("Memory leaks when throwing exception. count: " + Counter.count);

       // test exception pending in the csconstruct typemap
       try {
         new constructor(null);
         throw new Exception("constructor 1 not working");
       } catch (ArgumentNullException) {
       }
       try {
         new constructor();
         throw new Exception("constructor 2 not working");
       } catch (ApplicationException) {
       }

       // test exception pending in the csout typemaps
       try {
         csharp_exceptions.ushorttest();
         throw new Exception("csout not working");
       } catch (IndexOutOfRangeException) {
       }

       // test exception pending in the csvarout/csvarin typemaps and canthrow attribute in unmanaged code typemaps (1) global variables
       // 1) global variables
       int numberout = 0;
       try {
         csharp_exceptions.numberin = -1;
         throw new Exception("global csvarin not working");
       } catch (IndexOutOfRangeException) {
       }
       csharp_exceptions.numberin = 5;
       if (csharp_exceptions.numberin != 5)
         throw new Exception("global numberin not 5");
       csharp_exceptions.numberout = 20;
       try {
         numberout += csharp_exceptions.numberout;
         throw new Exception("global csvarout not working");
       } catch (IndexOutOfRangeException) {
       }
       // 2) static member variables
       try {
         InOutStruct.staticnumberin = -1;
         throw new Exception("static csvarin not working");
       } catch (IndexOutOfRangeException) {
       }
       InOutStruct.staticnumberin = 5;
       if (InOutStruct.staticnumberin != 5)
         throw new Exception("static staticnumberin not 5");
       InOutStruct.staticnumberout = 20;
       try {
         numberout += InOutStruct.staticnumberout;
         throw new Exception("static csvarout not working");
       } catch (IndexOutOfRangeException) {
       }
       // 3) member variables
       InOutStruct io = new InOutStruct();
       try {
         io.numberin = -1;
         throw new Exception("member csvarin not working");
       } catch (IndexOutOfRangeException) {
       }
       io.numberin = 5;
       if (io.numberin != 5)
         throw new Exception("member numberin not 5");
       io.numberout = 20;
       try {
         numberout += io.numberout;
         throw new Exception("member csvarout not working");
       } catch (IndexOutOfRangeException) {
       }
       // test SWIG_exception macro - it must return from unmanaged code without executing any further unmanaged code
       try {
         csharp_exceptions.exceptionmacrotest(-1);
         throw new Exception("exception macro not working");
       } catch (IndexOutOfRangeException) {
       }
       if (csharp_exceptions.exception_macro_run_flag)
         throw new Exception("exceptionmacrotest was executed");

       // test all the types of exceptions
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedApplicationException);
         throw new Exception("ApplicationException not caught");
       } catch (ApplicationException e) {
         if (e.Message != "msg") throw new Exception("ApplicationException msg incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedArithmeticException);
         throw new Exception("ArithmeticException not caught");
       } catch (ArithmeticException e) {
         if (e.Message != "msg") throw new Exception("ArithmeticException msg incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedDivideByZeroException);
         throw new Exception("DivideByZeroException not caught");
       } catch (DivideByZeroException e) {
         if (e.Message != "msg") throw new Exception("DivideByZeroException msg incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedIndexOutOfRangeException);
         throw new Exception("IndexOutOfRangeException not caught");
       } catch (IndexOutOfRangeException e) {
         if (e.Message != "msg") throw new Exception("IndexOutOfRangeException msg incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedInvalidOperationException);
         throw new Exception("InvalidOperationException not caught");
       } catch (InvalidOperationException e) {
         if (e.Message != "msg") throw new Exception("InvalidOperationException msg incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedIOException);
         throw new Exception("IOException not caught");
       } catch (System.IO.IOException e) {
         if (e.Message != "msg") throw new Exception("IOException msg incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedNullReferenceException);
         throw new Exception("NullReferenceException not caught");
       } catch (NullReferenceException e) {
         if (e.Message != "msg") throw new Exception("NullReferenceException msg incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedOutOfMemoryException);
         throw new Exception("OutOfMemoryException not caught");
       } catch (OutOfMemoryException e) {
         if (e.Message != "msg") throw new Exception("OutOfMemoryException msg incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedOverflowException);
         throw new Exception("OverflowException not caught");
       } catch (OverflowException e) {
         if (e.Message != "msg") throw new Exception("OverflowException msg incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedSystemException);
         throw new Exception("SystemException not caught");
       } catch (SystemException e) {
         if (e.Message != "msg") throw new Exception("SystemException msg incorrect");
       }

       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedArgumentException);
         throw new Exception("ArgumentException not caught");
       } catch (ArgumentException e) {
         if (e.Message.Replace(CRLF,"\n") != "msg\nParameter name: parm") throw new Exception("ArgumentException msg incorrect");
         if (e.ParamName != "parm") throw new Exception("ArgumentException parm incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedArgumentNullException);
         throw new Exception("ArgumentNullException not caught");
       } catch (ArgumentNullException e) {
         if (e.Message.Replace(CRLF,"\n") != "msg\nParameter name: parm") throw new Exception("ArgumentNullException msg incorrect");
         if (e.ParamName != "parm") throw new Exception("ArgumentNullException parm incorrect");
       }
       try {
         csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedArgumentOutOfRangeException);
         throw new Exception("ArgumentOutOfRangeException not caught");
       } catch (ArgumentOutOfRangeException e) {
         if (e.Message.Replace(CRLF,"\n") != "msg\nParameter name: parm") throw new Exception("ArgumentOutOfRangeException msg incorrect");
         if (e.ParamName != "parm") throw new Exception("ArgumentOutOfRangeException parm incorrect");
       }


       // exceptions in multiple threads test
       {
         ThrowsClass throwsClass = new ThrowsClass(1234.5678);
         const int NUM_THREADS = 8;
         Thread[] threads = new Thread[NUM_THREADS];
         TestThread[] testThreads = new TestThread[NUM_THREADS];
         // invoke the threads
         for (int i=0; i<NUM_THREADS; i++) {
             testThreads[i] = new TestThread(throwsClass, i);
             threads[i] = new Thread(new ThreadStart(testThreads[i].Run));
             threads[i].Start();
         }
         // wait for the threads to finish
         for (int i=0; i<NUM_THREADS; i++) {
             threads[i].Join();
         }
         for (int i=0; i<NUM_THREADS; i++) {
             if (testThreads[i].Failed) throw new Exception("Test Failed");
         }
       }


       // test inner exceptions
       try {
         csharp_exceptions.InnerExceptionTest();
         throw new Exception("InnerExceptionTest exception not caught");
       } catch (InvalidOperationException e) {
         if (e.Message != "My OuterException message") throw new Exception("OuterException msg incorrect");
         if (e.InnerException.Message != "My InnerException message") throw new Exception("InnerException msg incorrect");
       }
     }
     public static string CRLF = "\r\n"; // Some CLR implementations use a CRLF instead of just CR
 }

 public class TestThread {
    private int threadId;
    private ThrowsClass throwsClass;
    public bool Failed;
    public TestThread(ThrowsClass t, int id) {
        throwsClass = t;
        threadId = id;
    }
    public void Run() {
      Failed = false;
      try {
        for (int i=0; i<6000; i++) { // run test for about 10 seconds on a 1GHz machine (Mono)
          try {
            throwsClass.ThrowException(i);
            throw new Exception("No exception thrown");
          } catch (ArgumentOutOfRangeException e) {
            String expectedMessage = "caught:" + i + "\n" + "Parameter name: input";
            if (e.Message.Replace(runme.CRLF,"\n") != expectedMessage)
              throw new Exception("Exception message incorrect. Expected:\n[" +
                  expectedMessage + "]\n" + "Received:\n[" +
                  e.Message + "]");
            if (e.ParamName != "input")
              throw new Exception("Exception ParamName incorrect. Expected:\n[input]\n" + "Received:\n[" + e.ParamName + "]");
            if (e.InnerException != null)
              throw new Exception("Unexpected inner exception");
          }
          if (throwsClass.dub != 1234.5678) // simple check which attempts to catch memory corruption
            throw new Exception("throwsException.dub = " + throwsClass.dub + " expected: 1234.5678");
        }
      } catch (Exception e) {
        Console.Error.WriteLine("Test failed (thread " + threadId + "): " + e.Message + "\n  TestThread Inner stack trace: " + e.StackTrace);
        Failed = true;
      }
    }
 }
	using System;
	using System.Threading;
	using csharp_exceptionsNamespace;

	public class runme
	{
	static void Main()
	{
	// %exception tests
	try {
	csharp_exceptions.ThrowByValue();
	throw new Exception("ThrowByValue not working");
	} catch (DivideByZeroException) {
	}
	try {
	csharp_exceptions.ThrowByReference();
	throw new Exception("ThrowByReference not working");
	} catch (DivideByZeroException) {
	}

	// %csnothrowexception
	csharp_exceptions.NoThrowException();
	csharp_exceptions.NullReference(new Ex("should not throw"));

	// exception specifications
	bool testFailed = false;
	try {
	csharp_exceptions.ExceptionSpecificationValue();
	testFailed = true;
	} catch (ApplicationException) {
	}
	if (testFailed) throw new Exception("ExceptionSpecificationValue not working");
	try {
	csharp_exceptions.ExceptionSpecificationReference();
	testFailed = true;
	} catch (ApplicationException) {
	}
	if (testFailed) throw new Exception("ExceptionSpecificationReference not working");
	try {
	csharp_exceptions.ExceptionSpecificationString();
	testFailed = true;
	} catch (ApplicationException e) {
	if (e.Message != "ExceptionSpecificationString") throw new Exception("ExceptionSpecificationString unexpected message: " + e.Message);
	}
	if (testFailed) throw new Exception("ExceptionSpecificationString not working");
	try {
	csharp_exceptions.ExceptionSpecificationInteger();
	testFailed = true;
	} catch (ApplicationException) {
	}
	if (testFailed) throw new Exception("ExceptionSpecificationInteger not working");

	// null reference exceptions
	try {
	csharp_exceptions.NullReference(null);
	throw new Exception("NullReference not working");
	} catch (ArgumentNullException) {
	}
	try {
	csharp_exceptions.NullValue(null);
	throw new Exception("NullValue not working");
	} catch (ArgumentNullException) {
	}

	// enums
	try {
	csharp_exceptions.ExceptionSpecificationEnumValue();
	testFailed = true;
	} catch (ApplicationException) {
	}
	if (testFailed) throw new Exception("ExceptionSpecificationEnumValue not working");
	try {
	csharp_exceptions.ExceptionSpecificationEnumReference();
	testFailed = true;
	} catch (ApplicationException) {
	}
	if (testFailed) throw new Exception("ExceptionSpecificationEnumReference not working");

	// std::string
	try {
	csharp_exceptions.NullStdStringValue(null);
	throw new Exception("NullStdStringValue not working");
	} catch (ArgumentNullException) {
	}
	try {
	csharp_exceptions.NullStdStringReference(null);
	throw new Exception("NullStdStringReference not working");
	} catch (ArgumentNullException) {
	}
	try {
	csharp_exceptions.ExceptionSpecificationStdStringValue();
	testFailed = true;
	} catch (ApplicationException e) {
	if (e.Message != "ExceptionSpecificationStdStringValue") throw new Exception("ExceptionSpecificationStdStringValue unexpected message: " + e.Message);
	}
	if (testFailed) throw new Exception("ExceptionSpecificationStdStringValue not working");
	try {
	csharp_exceptions.ExceptionSpecificationStdStringReference();
	testFailed = true;
	} catch (ApplicationException e) {
	if (e.Message != "ExceptionSpecificationStdStringReference") throw new Exception("ExceptionSpecificationStdStringReference unexpected message: " + e.Message);
	}
	if (testFailed) throw new Exception("ExceptionSpecificationStdStringReference not working");

	// Memory leak check (The C++ exception stack was never unwound in the original approach to throwing exceptions from unmanaged code)
	try {
	csharp_exceptions.MemoryLeakCheck();
	throw new Exception("MemoryLeakCheck not working");
	} catch (DivideByZeroException) {
	}
	if (Counter.count != 0) throw new Exception("Memory leaks when throwing exception. count: " + Counter.count);

	// test exception pending in the csconstruct typemap
	try {
	new constructor(null);
	throw new Exception("constructor 1 not working");
	} catch (ArgumentNullException) {
	}
	try {
	new constructor();
	throw new Exception("constructor 2 not working");
	} catch (ApplicationException) {
	}

	// test exception pending in the csout typemaps
	try {
	csharp_exceptions.ushorttest();
	throw new Exception("csout not working");
	} catch (IndexOutOfRangeException) {
	}

	// test exception pending in the csvarout/csvarin typemaps and canthrow attribute in unmanaged code typemaps (1) global variables
	// 1) global variables
	int numberout = 0;
	try {
	csharp_exceptions.numberin = -1;
	throw new Exception("global csvarin not working");
	} catch (IndexOutOfRangeException) {
	}
	csharp_exceptions.numberin = 5;
	if (csharp_exceptions.numberin != 5)
	throw new Exception("global numberin not 5");
	csharp_exceptions.numberout = 20;
	try {
	numberout += csharp_exceptions.numberout;
	throw new Exception("global csvarout not working");
	} catch (IndexOutOfRangeException) {
	}
	// 2) static member variables
	try {
	InOutStruct.staticnumberin = -1;
	throw new Exception("static csvarin not working");
	} catch (IndexOutOfRangeException) {
	}
	InOutStruct.staticnumberin = 5;
	if (InOutStruct.staticnumberin != 5)
	throw new Exception("static staticnumberin not 5");
	InOutStruct.staticnumberout = 20;
	try {
	numberout += InOutStruct.staticnumberout;
	throw new Exception("static csvarout not working");
	} catch (IndexOutOfRangeException) {
	}
	// 3) member variables
	InOutStruct io = new InOutStruct();
	try {
	io.numberin = -1;
	throw new Exception("member csvarin not working");
	} catch (IndexOutOfRangeException) {
	}
	io.numberin = 5;
	if (io.numberin != 5)
	throw new Exception("member numberin not 5");
	io.numberout = 20;
	try {
	numberout += io.numberout;
	throw new Exception("member csvarout not working");
	} catch (IndexOutOfRangeException) {
	}
	// test SWIG_exception macro - it must return from unmanaged code without executing any further unmanaged code
	try {
	csharp_exceptions.exceptionmacrotest(-1);
	throw new Exception("exception macro not working");
	} catch (IndexOutOfRangeException) {
	}
	if (csharp_exceptions.exception_macro_run_flag)
	throw new Exception("exceptionmacrotest was executed");

	// test all the types of exceptions
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedApplicationException);
	throw new Exception("ApplicationException not caught");
	} catch (ApplicationException e) {
	if (e.Message != "msg") throw new Exception("ApplicationException msg incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedArithmeticException);
	throw new Exception("ArithmeticException not caught");
	} catch (ArithmeticException e) {
	if (e.Message != "msg") throw new Exception("ArithmeticException msg incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedDivideByZeroException);
	throw new Exception("DivideByZeroException not caught");
	} catch (DivideByZeroException e) {
	if (e.Message != "msg") throw new Exception("DivideByZeroException msg incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedIndexOutOfRangeException);
	throw new Exception("IndexOutOfRangeException not caught");
	} catch (IndexOutOfRangeException e) {
	if (e.Message != "msg") throw new Exception("IndexOutOfRangeException msg incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedInvalidOperationException);
	throw new Exception("InvalidOperationException not caught");
	} catch (InvalidOperationException e) {
	if (e.Message != "msg") throw new Exception("InvalidOperationException msg incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedIOException);
	throw new Exception("IOException not caught");
	} catch (System.IO.IOException e) {
	if (e.Message != "msg") throw new Exception("IOException msg incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedNullReferenceException);
	throw new Exception("NullReferenceException not caught");
	} catch (NullReferenceException e) {
	if (e.Message != "msg") throw new Exception("NullReferenceException msg incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedOutOfMemoryException);
	throw new Exception("OutOfMemoryException not caught");
	} catch (OutOfMemoryException e) {
	if (e.Message != "msg") throw new Exception("OutOfMemoryException msg incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedOverflowException);
	throw new Exception("OverflowException not caught");
	} catch (OverflowException e) {
	if (e.Message != "msg") throw new Exception("OverflowException msg incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedSystemException);
	throw new Exception("SystemException not caught");
	} catch (SystemException e) {
	if (e.Message != "msg") throw new Exception("SystemException msg incorrect");
	}

	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedArgumentException);
	throw new Exception("ArgumentException not caught");
	} catch (ArgumentException e) {
	if (e.Message.Replace(CRLF,"\n") != "msg\nParameter name: parm") throw new Exception("ArgumentException msg incorrect");
	if (e.ParamName != "parm") throw new Exception("ArgumentException parm incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedArgumentNullException);
	throw new Exception("ArgumentNullException not caught");
	} catch (ArgumentNullException e) {
	if (e.Message.Replace(CRLF,"\n") != "msg\nParameter name: parm") throw new Exception("ArgumentNullException msg incorrect");
	if (e.ParamName != "parm") throw new Exception("ArgumentNullException parm incorrect");
	}
	try {
	csharp_exceptions.check_exception(UnmanagedExceptions.UnmanagedArgumentOutOfRangeException);
	throw new Exception("ArgumentOutOfRangeException not caught");
	} catch (ArgumentOutOfRangeException e) {
	if (e.Message.Replace(CRLF,"\n") != "msg\nParameter name: parm") throw new Exception("ArgumentOutOfRangeException msg incorrect");
	if (e.ParamName != "parm") throw new Exception("ArgumentOutOfRangeException parm incorrect");
	}


	// exceptions in multiple threads test
	{
	ThrowsClass throwsClass = new ThrowsClass(1234.5678);
	const int NUM_THREADS = 8;
	Thread[] threads = new Thread[NUM_THREADS];
	TestThread[] testThreads = new TestThread[NUM_THREADS];
	// invoke the threads
	for (int i=0; i<NUM_THREADS; i++) {
	testThreads[i] = new TestThread(throwsClass, i);
	threads[i] = new Thread(new ThreadStart(testThreads[i].Run));
	threads[i].Start();
	}
	// wait for the threads to finish
	for (int i=0; i<NUM_THREADS; i++) {
	threads[i].Join();
	}
	for (int i=0; i<NUM_THREADS; i++) {
	if (testThreads[i].Failed) throw new Exception("Test Failed");
	}
	}


	// test inner exceptions
	try {
	csharp_exceptions.InnerExceptionTest();
	throw new Exception("InnerExceptionTest exception not caught");
	} catch (InvalidOperationException e) {
	if (e.Message != "My OuterException message") throw new Exception("OuterException msg incorrect");
	if (e.InnerException.Message != "My InnerException message") throw new Exception("InnerException msg incorrect");
	}
	}
	public static string CRLF = "\r\n"; // Some CLR implementations use a CRLF instead of just CR
	}

	public class TestThread {
	private int threadId;
	private ThrowsClass throwsClass;
	public bool Failed;
	public TestThread(ThrowsClass t, int id) {
	throwsClass = t;
	threadId = id;
	}
	public void Run() {
	Failed = false;
	try {
	for (int i=0; i<6000; i++) { // run test for about 10 seconds on a 1GHz machine (Mono)
	try {
	throwsClass.ThrowException(i);
	throw new Exception("No exception thrown");
	} catch (ArgumentOutOfRangeException e) {
	String expectedMessage = "caught:" + i + "\n" + "Parameter name: input";
	if (e.Message.Replace(runme.CRLF,"\n") != expectedMessage)
	throw new Exception("Exception message incorrect. Expected:\n[" +
	expectedMessage + "]\n" + "Received:\n[" +
	e.Message + "]");
	if (e.ParamName != "input")
	throw new Exception("Exception ParamName incorrect. Expected:\n[input]\n" + "Received:\n[" + e.ParamName + "]");
	if (e.InnerException != null)
	throw new Exception("Unexpected inner exception");
	}
	if (throwsClass.dub != 1234.5678) // simple check which attempts to catch memory corruption
	throw new Exception("throwsException.dub = " + throwsClass.dub + " expected: 1234.5678");
	}
	} catch (Exception e) {
	Console.Error.WriteLine("Test failed (thread " + threadId + "): " + e.Message + "\n TestThread Inner stack trace: " + e.StackTrace);
	Failed = true;
	}
	}
	}