/// <summary>
        /// This method is used internally to trigger a failure indicating to the "programmer" that he is using the interface incorrectly.
        /// It is NEVER used to indicate failure of actual contracts at runtime.
        /// </summary>
#if FEATURE_UNTRUSTED_CALLERS
#endif
        static partial void AssertMustUseRewriter(ContractFailureKind kind, String contractKind)
        {
            //TODO: Implement CodeContract failure mechanics including enabling CCIRewrite

            if (t_assertingMustUseRewriter)
            {
                System.Diagnostics.Debug.Assert(false, "Asserting that we must use the rewriter went reentrant. Didn't rewrite this System.Private.CoreLib?");
                return;
            }
            t_assertingMustUseRewriter = true;

            //// For better diagnostics, report which assembly is at fault.  Walk up stack and
            //// find the first non-mscorlib assembly.
            //Assembly thisAssembly = typeof(Contract).Assembly;  // In case we refactor mscorlib, use Contract class instead of Object.
            //StackTrace stack = new StackTrace();
            //Assembly probablyNotRewritten = null;
            //for (int i = 0; i < stack.FrameCount; i++)
            //{
            //    Assembly caller = stack.GetFrame(i).GetMethod().DeclaringType.Assembly;
            //    if (caller != thisAssembly)
            //    {
            //        probablyNotRewritten = caller;
            //        break;
            //    }
            //}

            //if (probablyNotRewritten == null)
            //    probablyNotRewritten = thisAssembly;
            //String simpleName = probablyNotRewritten.GetName().Name;
            String simpleName = "System.Private.CoreLib";
            System.Runtime.CompilerServices.ContractHelper.TriggerFailure(kind, SR.Format(SR.MustUseCCRewrite, contractKind, simpleName), null, null, null);

            t_assertingMustUseRewriter = false;
        }

 public virtual bool OnContractFailure(String stackTrace, ContractFailureKind contractFailureKind, String displayMessage, String userMessage, String conditionText, Exception innerException)
 {
     Debug.WriteLine("Assertion failed: " + (displayMessage == null ? "" : displayMessage));
     if (Debugger.IsAttached)
         Debugger.Break();
     return false;
 }

 private static string KindToString(ContractFailureKind kind)
 {
   var kindString = "unknown";
   switch (kind)
   {
     case ContractFailureKind.Assert:
       kindString = "Contract.Assert";
       break;
     case ContractFailureKind.Assume:
       kindString = "Contract.Assume";
       break;
     case ContractFailureKind.Invariant:
       kindString = "Contract.Invariant";
       break;
     case ContractFailureKind.Postcondition:
       kindString = "Contract.Postcondition";
       break;
     case ContractFailureKind.PostconditionOnException:
       kindString = "Contract.PostconditionOnException";
       break;
     case ContractFailureKind.Precondition:
       kindString = "Contract.Precondition";
       break;
   }
   return kindString;
 }

        static partial void AssertMustUseRewriter(ContractFailureKind kind, String contractKind)
        {
            if (_assertingMustUseRewriter)
                System.Diagnostics.Assert.Fail("Asserting that we must use the rewriter went reentrant.", "Didn't rewrite this mscorlib?");
            _assertingMustUseRewriter = true;

            // For better diagnostics, report which assembly is at fault.  Walk up stack and
            // find the first non-mscorlib assembly.
            Assembly thisAssembly = typeof(Contract).Assembly;  // In case we refactor mscorlib, use Contract class instead of Object.
            StackTrace stack = new StackTrace();
            Assembly probablyNotRewritten = null;
            for (int i = 0; i < stack.FrameCount; i++)
            {
                Assembly caller = stack.GetFrame(i).GetMethod().DeclaringType.Assembly;
                if (caller != thisAssembly)
                {
                    probablyNotRewritten = caller;
                    break;
                }
            }

            if (probablyNotRewritten == null)
                probablyNotRewritten = thisAssembly;
            String simpleName = probablyNotRewritten.GetName().Name;
            System.Runtime.CompilerServices.ContractHelper.TriggerFailure(kind, Environment.GetResourceString("MustUseCCRewrite", contractKind, simpleName), null, null, null);

            _assertingMustUseRewriter = false;
        }

 private ContractException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
     : base(info, context)
 {
     _Kind = (ContractFailureKind)info.GetInt32("Kind");
     _UserMessage = info.GetString("UserMessage");
     _Condition = info.GetString("Condition");
 }

 public ContractFailedEventArgs(ContractFailureKind failureKind, string message, string condition, Exception originalException)
 {
     this._failureKind = failureKind;
     this._message = message;
     this._condition = condition;
     this._originalException = originalException;
 }

        // internal Exception thrownDuringHandler;

        public ContractFailedEventArgs(ContractFailureKind failureKind, String message, String condition, Exception originalException)
        {
            Contract.Requires(originalException == null || failureKind == ContractFailureKind.PostconditionOnException);
            _failureKind = failureKind;
            _message = message;
            _condition = condition;
            _originalException = originalException;
        }

		internal ContractException (string failure, ContractFailureKind kind, string condition, string userMessage, Exception innerException)
			: base (failure, innerException)
		{
			this.Failure = failure;
			this.Kind = kind;
			this.Condition = condition;
			this.UserMessage = userMessage;
		}

		public ContractFailedEventArgs (ContractFailureKind failureKind, string message, string condition, Exception originalException)
		{
			Condition = condition;
			FailureKind = failureKind;
			Handled = false;
			Unwind = true;
			Message = message;
			OriginalException = originalException;
		}

		public ContractFailedEventArgs (ContractFailureKind failureKind, string message, string condition, Exception originalException)
		{
			Condition = condition;
			FailureKind = failureKind;
			Handled = false;
			Unwind = false; // MS docs are incorrect - this should default to false.
			Message = message;
			OriginalException = originalException;
		}

        /// <summary> 
        /// This method is used internally to trigger a failure indicating to the "programmer" that he is using the interface incorrectly.
        /// It is NEVER used to indicate failure of actual contracts at runtime. 
        /// </summary> 
        static partial void AssertMustUseRewriter(ContractFailureKind kind, String contractKind)
        { 
            if (_assertingMustUseRewriter)
                System.Diagnostics.Assert.Fail("Asserting that we must use the rewriter went reentrant.", "Didn't rewrite this mscorlib?");
            _assertingMustUseRewriter = true;
 
            // @
            Internal.ContractHelper.TriggerFailure(kind, "Must use the rewriter when using Contract." + contractKind, null, null, null); 
 
            _assertingMustUseRewriter = false;
        } 

        private static string GetDisplayMessage(ContractFailureKind failureKind, string userMessage, string conditionText)
        {
            string key = null;
            switch (failureKind)
            {
                case ContractFailureKind.Precondition:
                    key = "PreconditionFailed";
                    break;

                case ContractFailureKind.Postcondition:
                    key = "PostconditionFailed";
                    break;

                case ContractFailureKind.PostconditionOnException:
                    key = "PostconditionOnExceptionFailed";
                    break;

                case ContractFailureKind.Invariant:
                    key = "InvariantFailed";
                    break;

                case ContractFailureKind.Assert:
                    key = "AssertionFailed";
                    break;

                case ContractFailureKind.Assume:
                    key = "AssumptionFailed";
                    break;

                default:
                    Contract.Assume(false, "Unreachable code");
                    key = "AssumptionFailed";
                    break;
            }
            if (!string.IsNullOrEmpty(conditionText))
            {
                key = key + "_Cnd";
            }
            string runtimeResourceString = Environment.GetRuntimeResourceString(key);
            if (!string.IsNullOrEmpty(conditionText))
            {
                if (!string.IsNullOrEmpty(userMessage))
                {
                    return (string.Format(CultureInfo.CurrentUICulture, runtimeResourceString, new object[] { conditionText }) + "  " + userMessage);
                }
                return string.Format(CultureInfo.CurrentUICulture, runtimeResourceString, new object[] { conditionText });
            }
            if (!string.IsNullOrEmpty(userMessage))
            {
                return (runtimeResourceString + "  " + userMessage);
            }
            return runtimeResourceString;
        }

 public ContractException(ContractFailureKind kind, string failure, string userMessage, string condition, Exception innerException)
   : base(failure, innerException) {
   this.m_data._Kind = kind;
   this.m_data._UserMessage = userMessage;
   this.m_data._Condition = condition;
   SerializeObjectState += delegate(object exception, SafeSerializationEventArgs eventArgs) {
     // This is fired when the exception is being serialized and asks
     // the exception to provide a serializable chunk of state to save
     // with the rest of the exception.
     eventArgs.AddSerializedState(m_data);
   };
 }

    public static string RaiseContractFailedEvent(ContractFailureKind kind, string userMessage, string conditionText, Exception innerException)
    {
      CountFailure(kind);
#if DEBUG
      var kindString = KindToString(kind);
      var message = String.Format("{0} failed: {1} {2}", kindString, conditionText, userMessage);
      Console.WriteLine(message);
      return message;
#else
      // handled
      return null;
#endif
    }

        static partial void ReportFailure(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException)
        {
            if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", failureKind), "failureKind"); 
            Contract.EndContractBlock();
 
            // displayMessage == null means: yes we handled it. Otherwise it is the localized failure message 
            var displayMessage = Internal.ContractHelper.RaiseContractFailedEvent(failureKind, userMessage, conditionText, innerException);
 
            if (displayMessage == null) return;

            Internal.ContractHelper.TriggerFailure(failureKind, displayMessage, userMessage, conditionText, innerException);
        } 

        private void AssertException(Action block, ContractFailureKind expectedKind, string expectedMessage, string expectedUserMessage, Exception expectedInnerException)
        {
            try
            {
                block();
            }
            catch (Exception ex)
            {
                var cex = ex as ContractException;
                if (cex == null)
                    Assert.Fail("Unexpected Exception");

                Assert.True(cex.Kind == expectedKind, "Kind");
                Assert.True(cex.Message == expectedMessage, "Message");
                Assert.True(cex.UserMessage == expectedUserMessage, "UserMessage");
                if (cex.InnerException != null)
                    Assert.True(cex.InnerException.Equals(expectedInnerException), "InnerException");
                else if (cex.InnerException == null && expectedInnerException != null)
                    Assert.Fail("InnerException");
            }
        }

		private void CheckAllMessages (ContractFailureKind kind, string messageStart, Action<string, Exception, string, ContractFailureKind, Func<string>> fnAssert)
		{

			foreach (Exception ex in new [] { null, new ArgumentNullException () }) {
				fnAssert (messageStart + ".", ex, null, kind, () => {
					return ContractHelper.RaiseContractFailedEvent (kind, null, null, ex);
				});

				fnAssert (messageStart + ".  Message", ex, null, kind, () => {
					return ContractHelper.RaiseContractFailedEvent (kind, "Message", null, ex);
				});

				fnAssert (messageStart + ": Condition", ex, "Condition", kind, () => {
					return ContractHelper.RaiseContractFailedEvent (kind, null, "Condition", ex);
				});

				fnAssert (messageStart + ": Condition  Message", ex, "Condition", kind, () => {
					return ContractHelper.RaiseContractFailedEvent (kind, "Message", "Condition", ex);
				});
			}

		}

		public static string RaiseContractFailedEvent (ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException)
		{

			StringBuilder msg = new StringBuilder (60);
			switch (failureKind) {
			case ContractFailureKind.Assert:
				msg.Append ("Assertion failed");
				break;
			case ContractFailureKind.Assume:
				msg.Append ("Assumption failed");
				break;
			case ContractFailureKind.Invariant:
				msg.Append ("Invariant failed");
				break;
			case ContractFailureKind.Postcondition:
				msg.Append ("Postcondition failed");
				break;
			case ContractFailureKind.PostconditionOnException:
				msg.Append ("Postcondition failed after throwing an exception");
				break;
			case ContractFailureKind.Precondition:
				msg.Append ("Precondition failed");
				break;
			default:
				throw new NotSupportedException ("Not supported: " + failureKind);
			}
			if (conditionText != null) {
				msg.Append (": ");
				msg.Append (conditionText);
			} else {
				msg.Append ('.');
			}
			if (userMessage != null) {
				msg.Append ("  ");
				msg.Append (userMessage);
			}
			string msgString = msg.ToString ();

			Exception handlerException = null;
			bool unwind = false, handled = false;

			var contractFailed = Contract.InternalContractFailedEvent;
			if (contractFailed != null) {
				// Execute all event handlers
				var handlers = contractFailed.GetInvocationList ();
				var e = new ContractFailedEventArgs (failureKind, msgString, conditionText, innerException);
				foreach (var handler in handlers) {
					try {
						handler.DynamicInvoke (null, e);
					} catch (Exception ex) {
						e.SetUnwind ();
						// If multiple handlers throw an exception then the specification states that it
						// is undetermined which one becomes the InnerException.
						handlerException = ex.InnerException;
					}
				}
				unwind = e.Unwind;
				handled = e.Handled;
			}

			if (unwind) {
				Exception ex = innerException ?? handlerException;
				throw new ContractException (msgString, failureKind, conditionText, userMessage, ex);
			}

			return handled ? null : msgString;
		}

		public static void TriggerFailure (ContractFailureKind kind, string displayMessage, string userMessage, string conditionText, Exception innerException)
		{
			StringBuilder msg = new StringBuilder (50);

			if (conditionText != null) {
				msg.Append ("Expression: ");
				msg.AppendLine (conditionText);
			}
			msg.Append ("Description: ");
			if (displayMessage != null) {
				msg.Append (displayMessage);
			}
#if MOONLIGHT
			// Silverlight shows a dialog that let you Abort (kill process/browser), Retry or Ignore
			// Moonlight will simply warn and ignore (at least until FailFast is implemented)
			// using reflection into System.Windows.Browser to popup an browser alert
			alert.Invoke (window, new object [] { msg.ToString () });
#else
			if (Environment.UserInteractive) {
				// FIXME: This should trigger an assertion.
				// But code will never get here at the moment, as Environment.UserInteractive currently
				// always returns false.
				throw new ContractShouldAssertException (msg.ToString ());
			} else {
				// Note that FailFast() currently throws a NotImplementedException()
				Environment.FailFast(msg.ToString()/*, new ExecutionEngineException()*/);
			}
#endif
		}

 public ContractException(ContractFailureKind kind, string failure, string userMessage, string condition, Exception innerException) : base(failure, innerException)
 {
     this._Kind = kind;
     this._UserMessage = userMessage;
     this._Condition = condition;
 }