static void Main(string[] args)
        {
            // Original delegate syntax required
              // initialization with a named method.
              TestDelegate testDelA = new TestDelegate(M);

              // C# 2.0: A delegate can be initialized with
              // inline code, called an "anonymous method." This
              // method takes a string as an input parameter.
              TestDelegate testDelB = delegate(string s) { Console.WriteLine(s); };

              // C# 3.0. A delegate can be initialized with
              // a lambda expression. The lambda also takes a string
              // as an input parameter (x). The type of x is inferred by the compiler.
              TestDelegate testDelC = (x) => { Console.WriteLine(x); };

              // Invoke the delegates.
              testDelA("Hello. My name is M and I write lines.");
              testDelB("That's nothing. I'm anonymous and ");
              testDelC("I'm a famous author.");

              // Initialize delegate with named method, anonymous method and lamba expression.
              TestDelegate testDel = new TestDelegate(M);
              testDel += delegate(string s) { Console.WriteLine(s); };
              testDel += (x) => { Console.WriteLine(x); };

              // Invoke the delegate.
              testDel("Delegate with multiple initialisations.");

              Console.ReadLine(); //wait for <ENTER>
        }

    public void addChildToThingThrowsException()
    {
      Thing thing = new Thing("lantern");

      var testDel = new TestDelegate(() => thing.AddChild(new Thing("fork")));
      Assert.That(testDel, Throws.TypeOf<NoChildrenForThingsException>());
    }

        public void TestArduinoStateToggles()
        {
            ArduinoCommsBase motorArduino = new MotorControllerArduino(mLogger);
            TestDelegate connectDel = new TestDelegate(delegate() { motorArduino.StartArduinoComms(); });

            Assert.AreEqual(motorArduino.ArduinoState, ProsthesisCore.Telemetry.ProsthesisTelemetry.DeviceState.Uninitialized);
            Assert.DoesNotThrow(connectDel);

            Assert.DoesNotThrow(delegate() { motorArduino.ToggleArduinoState(false); });
            //Wait 100ms for the message to cycle
            System.Threading.Thread.Sleep(100);

            Assert.AreEqual(motorArduino.ArduinoState, ProsthesisCore.Telemetry.ProsthesisTelemetry.DeviceState.Disabled);

            Assert.DoesNotThrow(delegate() { motorArduino.ToggleArduinoState(true); });
            //Wait 100ms for the message to cycle
            System.Threading.Thread.Sleep(100);
            Assert.AreEqual(motorArduino.ArduinoState, ProsthesisCore.Telemetry.ProsthesisTelemetry.DeviceState.Active);

            Assert.IsTrue(motorArduino.IsConnected);

            Assert.DoesNotThrow(delegate() { motorArduino.StopArduinoComms(true); });
            Assert.IsFalse(motorArduino.IsConnected);

            Assert.AreEqual(motorArduino.ArduinoState, ProsthesisCore.Telemetry.ProsthesisTelemetry.DeviceState.Disconnected);
        }

    static void Main(string[] args)
    {
        // Original delegate syntax required
                    // initialization with a named method.
                    TestDelegate testDelA = new TestDelegate(M);

                    // C# 2.0: A delegate can be initialized with
                    // inline code, called an "anonymous method." This
                    // method takes a string as an input parameter.
                    TestDelegate testDelB = delegate(string s) { Console.WriteLine(s); };

                    // C# 3.0. A delegate can be initialized with
                    // a lambda expression. The lambda also takes a string
                    // as an input parameter (x). The type of x is inferred by the compiler.
                    TestDelegate testDelC = (x) => { Console.WriteLine(x); };

                    // Invoke the delegates.
                    testDelA("Hello. My name is M and I write lines.");
                    testDelB("That's nothing. I'm anonymous and ");
                    testDelC("I'm a famous author.");

                    // Keep console window open in debug mode.
                    Console.WriteLine("Press any key to exit.");
                    Console.ReadKey();
    }

 /// <summary>
 /// Runs a code example in mocked mode.
 /// </summary>
 /// <param name="mockData">The mock data for mocking SOAP request and
 /// responses for API calls.</param>
 /// <param name="exampleDelegate">The delegate that initializes and runs the
 /// code example.</param>
 /// <param name="callback">The callback to be called before mocked responses
 /// are sent. You could use this callback to verify if the request was
 /// serialized correctly.</param>
 /// <remarks>This method is not thread safe, but since NUnit can run tests
 /// only in a single threaded mode, thread safety is not a requirement.
 /// </remarks>
 protected void RunMockedExample(ExamplesMockData mockData, TestDelegate exampleDelegate,
     WebRequestInterceptor.OnBeforeSendResponse callback) {
   TextWriter oldWriter = Console.Out;
   try {
     clientLoginInterceptor.Intercept = true;
     clientLoginInterceptor.RaiseException = false;
     awapiInterceptor.Intercept = true;
     AuthToken.Cache.Clear();
     awapiInterceptor.LoadMessages(mockData.MockMessages,
          delegate(Uri requestUri, WebHeaderCollection headers, String body) {
            VerifySoapHeaders(requestUri, body);
            callback(requestUri, headers, body);
          }
      );
     StringWriter newWriter = new StringWriter();
     Console.SetOut(newWriter);
     AdWordsAppConfig config = (user.Config as AdWordsAppConfig);
     exampleDelegate.Invoke();
     Assert.AreEqual(newWriter.ToString().Trim(), mockData.ExpectedOutput.Trim());
   } finally {
     Console.SetOut(oldWriter);
     clientLoginInterceptor.Intercept = false;
     awapiInterceptor.Intercept = false;
   }
 }

 public static ArgumentOutOfRangeException CatchArgumentOutOfRangeException(TestDelegate code, string paramName, string exceptionMessage, params object[] args)
 {
     var exception = Assert.Catch<ArgumentOutOfRangeException>(code);
     Assert.AreEqual(paramName, exception.ParamName);
     Assert.AreEqual(GetMessage(paramName, exceptionMessage, args), exception.Message);
     return exception;
 }

 public void func()
 {
     TestDelegate d1 = new TestDelegate(CallBackOne);
     d1 += new TestDelegate(CallBackTwo);
     cout(d1.Target);
     d1.BeginInvoke(null, null);
 }

        public void Repricing_InvalidTickets_ExceptionThrown()
        {
            var order = new Order();
            var callDelegate = new TestDelegate(() => _pricingManager.RepricingAsync(order).Wait());

            Assert.Throws<AggregateException>(callDelegate);
            Assert.Throws<AggregateException>(callDelegate).InnerExceptions.Any(exception => exception is TicketNotValidException);
        }

 public void GetParameters()
 {
     StringWriter sw = new StringWriter();
     string name = "MyName";
     Delegate hello = new TestDelegate(this.Hello);
     TestCase tc = new TestCase(name, hello, sw);
     ArrayAssert.AreEqual(new Object[] { sw }, tc.GetParameters());
 }

 public void GetTest()
 {
     StringWriter sw = new StringWriter();
     string name = "MyName";
     Delegate hello = new TestDelegate(this.Hello);
     TestCase tc = new TestCase(name, hello, sw);
     Assert.AreEqual(hello.Method, tc.TestDelegate.Method);
 }

        public void When_User_Id_Is_Not_Provided_It_Must_Throws_Exception()
        {
            TestDelegate createUserWithNullableId = new TestDelegate(() => { new User(null); });
            TestDelegate createUserWithEmptyId = new TestDelegate(() => { new User(String.Empty); });

            Assert.Throws<ArgumentNullException>(createUserWithNullableId, "User ID cannot be null.");
            Assert.Throws<ArgumentException>(createUserWithEmptyId, "User ID cannot be empty.");
        }

 void Start()
 {
     //use default when not be set value in Awake
     if (testDelegate == null)
         testDelegate = nullTestDelegate;
     if (setByfunction == null)
         setByfunction = nullTestDelegate;
 }

        public void when_balance_below_0_trader_should_go_bankrupt()
        {
            _trader.SetBalance(0);

            var methodUnderTest = new TestDelegate(_trader.CheckBankrupt);

            Assert.Throws<ApplicationException>(methodUnderTest);
        }

        public void GetConfigurationBeforeLoadingConfigurationMethods()
        {
            // Arrange
            // Action
            var testCase = new TestDelegate(() => Configure.Get<IMyTestConfiguration>());

            // Assert
            Assert.Throws(typeof(ConfigurationEnvironmentNotInitializedException), testCase);
        }

    public void ObjectWithBothMaleAndNeutralAttributesThrows()
    {
      var parser = new Parser();
      

      var testDel = new TestDelegate(() => parser.Parse("Jason [mp]"));
      Assert.That(testDel, Throws.TypeOf<PersonCannotBeTwoGenders>());

    }

 public void Invoke()
 {
     StringWriter sw = new StringWriter();
     string name = "MyName";
     Delegate hello = new TestDelegate(this.Hello);
     TestCase tc = new TestCase(name, hello, sw);
     tc.Invoke(this,new ArrayList());
     Assert.AreEqual("hello", sw.ToString());
 }

 public static void Execute() {
     TestDelegate d1 = new TestDelegate(Dowork);
     TestDelegate d2 = delegate(string s) { Console.WriteLine(s); };
     TestDelegate d3 = (x) => { Console.WriteLine(x); };
     d1("Hello World");
     d2("Hello World2");
     d3("Hello World3");
     TestLambda((x) => { Console.WriteLine(x); });
 }

        public static void Argument(TestDelegate code, string message, string paramName)
        {
            var constraint =
                Throws.ArgumentException
                    .With.Message.StartsWith(message)
                    .And
                    .With.Property("ParamName").EqualTo(paramName);

            Assert.That(code, constraint);
        }

 /// <summary>
 /// Validates whether an ArgumentNullException is called whenever a required
 /// property in targetObject is null, and testDelegate is invoked.
 /// </summary>
 /// <param name="targetObject">The target object.</param>
 /// <param name="propertyNames">The property names to be checked for null
 /// values.</param>
 /// <param name="testDelegate">The test delegate.</param>
 public static void ValidateRequiredParameters(object targetObject, string[] propertyNames,
     TestDelegate testDelegate) {
   foreach (string propertyName in propertyNames) {
     PropertyInfo propInfo = targetObject.GetType().GetProperty(propertyName);
     object oldValue = propInfo.GetValue(targetObject, null);
     propInfo.SetValue(targetObject, null, null);
     Assert.Throws<ArgumentNullException>(testDelegate);
     propInfo.SetValue(targetObject, oldValue, null);
   }
 }

        static void AssertMethodFailsWithSerializableException(TestDelegate intentionallyFailingMethod)
        {
            var original = Assert.Catch<Exception>(intentionallyFailingMethod);

            var formatter = new BinaryFormatter();
            var ms = new MemoryStream();
            formatter.Serialize(ms, original);
            object deserialized = formatter.Deserialize(new MemoryStream(ms.ToArray()));

            Assert.AreEqual(original.ToString(), deserialized.ToString());
        }