Examples/test-suite/csharp/csharp_exceptions_runme.cs

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 exception pending in %exceptionvar code
      try {
        csharp_exceptions.exceptionvar_number = -1;
        throw new Exception("global %exceptionvar set not working");
      } catch (IndexOutOfRangeException e) {
        if (e.Message != "exceptionvar_number negative") throw new Exception("global %exceptionvar set msg incorrect");
      }
      try {
        numberout += csharp_exceptions.exceptionvar_number;
        throw new Exception("global %exceptionvar get not working");
      } catch (IndexOutOfRangeException) {
      }
      csharp_exceptions.exceptionvar_number = 5;
      if (csharp_exceptions.exceptionvar_number != 5)
        throw new Exception("global exceptionvar_number not 5");
      try {
        ExceptionVarStruct.staticnumber = -1;
        throw new Exception("static %exceptionvar set not working");
      } catch (IndexOutOfRangeException e) {
        if (e.Message != "staticnumber negative") throw new Exception("static %exceptionvar set msg incorrect");
      }
      try {
        numberout += ExceptionVarStruct.staticnumber;
        throw new Exception("static %exceptionvar get not working");
      } catch (IndexOutOfRangeException) {
      }
      ExceptionVarStruct.staticnumber = 5;
      if (ExceptionVarStruct.staticnumber != 5)
        throw new Exception("static staticnumber not 5");

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