public ContractFailedEventArgs(ContractFailureKind failureKind, string message, string condition, Exception originalException) { this._failureKind = failureKind; this._message = message; this._condition = condition; this._originalException = originalException; }
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 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; }
/// <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; }
// 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; }
public ContractException(ContractFailureKind kind, string failure, string userMessage, string condition, Exception innerException) : base(failure, innerException) { HResult = Runtime.CompilerServices.ContractHelper.COR_E_CODECONTRACTFAILED; _Kind = kind; _UserMessage = userMessage; _Condition = condition; }
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; }
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); }; }
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 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 static void ReportFailure(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException) { if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume) { throw new ArgumentException(string.Format("Invalid enum value: {0}", failureKind), "failureKind"); } EndContractBlock(); // displayMessage == null means: yes we handled it. Otherwise it is the localized failure message var displayMessage = ContractHelper.RaiseContractFailedEvent(failureKind, userMessage, conditionText, innerException); if (displayMessage == null) { return; } ContractHelper.TriggerFailure(failureKind, displayMessage, userMessage, conditionText, innerException); }
private static String GetDisplayMessage(ContractFailureKind failureKind, String userMessage, String conditionText) { // Well-formatted English messages will take one of four forms. A sentence ending in // either a period or a colon, the condition string, then the message tacked // on to the end with two spaces in front. // Note that both the conditionText and userMessage may be null. Also, // on Silverlight we may not be able to look up a friendly string for the // error message. Let's leverage Silverlight's default error message there. String failureMessage = GetFailureMessage(failureKind, conditionText); // Now add in the user message, if present. if (!String.IsNullOrEmpty(userMessage)) { return(failureMessage + " " + userMessage); } else { return(failureMessage); } }
private static void AssertMustUseRewriter(ContractFailureKind kind, string contractKind) { if (_assertingMustUseRewriter) { ContractHelperEx.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. var thisAssembly = typeof(Contract).Assembly; // In case we refactor mscorlib, use Contract class instead of Object. var stack = new StackTrace(); Assembly probablyNotRewritten = null; for (var i = 0; i < stack.FrameCount; i++) { var declaringType = stack.GetFrame(i).GetMethod().DeclaringType; if (declaringType == null) { // Not standard method info - ignoring continue; } var caller = declaringType.Assembly; if (thisAssembly.Equals(caller)) { continue; } probablyNotRewritten = caller; break; } if (probablyNotRewritten == null) { probablyNotRewritten = thisAssembly; } var simpleName = probablyNotRewritten.GetName().Name; ContractHelper.TriggerFailure(kind, string.Format("The code has not been rewriten. ContractKind: {0} - Source: {1}", contractKind, simpleName), null, null, null); _assertingMustUseRewriter = false; }
static partial void TriggerFailureImplementation(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException) { // If we're here, our intent is to pop up a dialog box (if we can). For developers // interacting live with a debugger, this is a good experience. For Silverlight // hosted in Internet Explorer, the assert window is great. If we cannot // pop up a dialog box, throw an exception (consider a library compiled with // "Assert On Failure" but used in a process that can't pop up asserts, like an // NT Service). For the CLR hosted by server apps like SQL or Exchange, we should // trigger escalation policy. //#if !FEATURE_CORECLR // if (Environment.IsCLRHosted) // { // TriggerCodeContractEscalationPolicy(kind, displayMessage, conditionText, innerException); // // Hosts like SQL may choose to abort the thread, so we will not get here in all cases. // // But if the host's chosen action was to throw an exception, we should throw an exception // // here (which is easier to do in managed code with the right parameters). // throw new ContractException(kind, displayMessage, userMessage, conditionText, innerException); // } //#endif // !FEATURE_CORECLR //TODO: Implement CodeContract failure mechanics including enabling CCIRewrite String stackTrace = null; //@todo: Any reasonable way to get a stack trace here? bool userSelectedIgnore = DeveloperExperience.Default.OnContractFailure(stackTrace, kind, displayMessage, userMessage, conditionText, innerException); if (userSelectedIgnore) { return; } //if (!Environment.UserInteractive) { throw new ContractException(kind, displayMessage, userMessage, conditionText, innerException); //} //// May need to rethink Assert.Fail w/ TaskDialogIndirect as a model. Window title. Main instruction. Content. Expanded info. //// Optional info like string for collapsed text vs. expanded text. //String windowTitle = SR.Format(GetResourceNameForFailure(kind)); //const int numStackFramesToSkip = 2; // To make stack traces easier to read //System.Diagnostics.Debug.Assert(conditionText, displayMessage, windowTitle, COR_E_CODECONTRACTFAILED, StackTrace.TraceFormat.Normal, numStackFramesToSkip); // If we got here, the user selected Ignore. Continue. }
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)); }); } }
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"); } }
static partial void TriggerFailureImplementation(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException) { // If we're here, our intent is to pop up a dialog box (if we can). For developers // interacting live with a debugger, this is a good experience. For Silverlight // hosted in Internet Explorer, the assert window is great. If we cannot // pop up a dialog box, throw an exception (consider a library compiled with // "Assert On Failure" but used in a process that can't pop up asserts, like an // NT Service). if (!Environment.UserInteractive) { throw new ContractException(kind, displayMessage, userMessage, conditionText, innerException); } // May need to rethink Assert.Fail w/ TaskDialogIndirect as a model. Window title. Main instruction. Content. Expanded info. // Optional info like string for collapsed text vs. expanded text. String windowTitle = SR.GetResourceString(GetResourceNameForFailure(kind)); const int numStackFramesToSkip = 2; // To make stack traces easier to read System.Diagnostics.Assert.Fail(conditionText, displayMessage, windowTitle, COR_E_CODECONTRACTFAILED, StackTrace.TraceFormat.Normal, numStackFramesToSkip); // If we got here, the user selected Ignore. Continue. }
internal static string GetFailureMessage(ContractFailureKind failureKind, string?conditionText) { string result; var withCondition = !string.IsNullOrEmpty(conditionText); switch (failureKind) { case ContractFailureKind.Assert: result = withCondition ? $"Assertion failed: {conditionText}" : "Assertion failed."; break; case ContractFailureKind.Assume: result = withCondition ? $"Assumption failed: {conditionText}" : "Assumption failed."; break; case ContractFailureKind.Precondition: result = withCondition ? $"Precondition failed: {conditionText}" : "Precondition failed."; break; case ContractFailureKind.Postcondition: result = withCondition ? $"Postcondition failed: {conditionText}" : "Postcondition failed."; break; case ContractFailureKind.Invariant: result = withCondition ? $"Invariant failed: {conditionText}" : "Invariant failed."; break; case ContractFailureKind.PostconditionOnException: result = withCondition ? $"Postcondition failed after throwing an exception: {conditionText}" : "Postcondition failed after throwing an exception."; break; default: result = "Assumption failed."; Contract.Assume(false, "Unreachable code"); break; } return(result); }
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); }); } }
private static string GetDisplayMessage(ContractFailureKind failureKind, string userMessage, string conditionText) { string text = ContractHelper.GetResourceNameForFailure(failureKind); string resourceString; if (!string.IsNullOrEmpty(conditionText)) { text += "_Cnd"; resourceString = Environment.GetResourceString(text, new object[] { conditionText }); } else { resourceString = Environment.GetResourceString(text); } if (!string.IsNullOrEmpty(userMessage)) { return(resourceString + " " + userMessage); } return(resourceString); }
private static String GetResourceNameForFailure(ContractFailureKind failureKind) { String resourceName = null; switch (failureKind) { case ContractFailureKind.Assert: resourceName = "AssertionFailed"; break; case ContractFailureKind.Assume: resourceName = "AssumptionFailed"; break; case ContractFailureKind.Precondition: resourceName = "PreconditionFailed"; break; case ContractFailureKind.Postcondition: resourceName = "PostconditionFailed"; break; case ContractFailureKind.Invariant: resourceName = "InvariantFailed"; break; case ContractFailureKind.PostconditionOnException: resourceName = "PostconditionOnExceptionFailed"; break; default: Contract.Assume(false, "Unreachable code"); resourceName = "AssumptionFailed"; break; } return(resourceName); }
public void TestRaiseContractFailedEventHandled() { string expectedMsg = null; Exception originalException = null; string expectedCondition = null; ContractFailureKind expectedKind = ContractFailureKind.Assert; Contract.ContractFailed += (sender, e) => { Assert.AreEqual(expectedMsg, e.Message, "TestRaiseContractFailedEventHandled() event message wrong"); Assert.AreSame(originalException, e.OriginalException, "TestRaiseContractFailedEventHandled() event exception wrong"); Assert.AreEqual(expectedCondition, e.Condition, "TestRaiseContractFailedEventHandled() event condition wrong"); Assert.AreEqual(expectedKind, e.FailureKind, "TestRaiseContractFailedEventHandled() event failure kind wrong"); e.SetHandled(); }; this.CheckAllKinds((expected, ex, condition, kind, fnTest) => { expectedMsg = expected; originalException = ex; expectedCondition = condition; expectedKind = kind; string msg = fnTest(); Assert.IsNull(msg, "TestRaiseContractFailedEventHandled() expected null message"); }); }
public static string RaiseContractFailedEvent(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException) { throw new NotImplementedException(); }
private static void TriggerFailureImplementation(ContractFailureKind kind, string displayMessage, string userMessage, string conditionText, Exception innerException) { if (Environment.IsCLRHosted) { TriggerCodeContractEscalationPolicy(kind, displayMessage, conditionText, innerException); } if (!Environment.UserInteractive) { Environment.FailFast(displayMessage); } Assert.Check(false, conditionText, displayMessage); }
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 string RaiseContractFailedEvent(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException) { return(System.Runtime.CompilerServices.ContractHelper.RaiseContractFailedEvent(failureKind, userMessage, conditionText, innerException)); }
public static void TriggerFailure(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException) { TriggerFailureImplementation(kind, displayMessage, userMessage, conditionText, innerException); }
/// <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) { // @TODO: localize this Internal.ContractHelper.TriggerFailure(kind, "Must use the rewriter when using Contract." + contractKind, null, null, null); }
internal static void TriggerCodeContractFailure(ContractFailureKind failureKind, String message, String condition, String exceptionAsString) { }
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); }
/// <summary> /// Implements the default failure behavior of the platform. Under the BCL, it triggers an Assert box. /// </summary> static partial void TriggerFailureImplementation(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException);
private static void TriggerCodeContractEscalationPolicy(ContractFailureKind failureKind, string message, string conditionText, Exception innerException) { string exceptionAsString = null; if (innerException != null) { exceptionAsString = innerException.ToString(); } Environment.TriggerCodeContractFailure(failureKind, message, conditionText, exceptionAsString); }
private static void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException, ref string resultFailureMessage) { string str2; if ((failureKind < ContractFailureKind.Precondition) || (failureKind > ContractFailureKind.Assume)) { throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { failureKind }), "failureKind"); } string message = "contract failed."; ContractFailedEventArgs e = null; RuntimeHelpers.PrepareConstrainedRegions(); try { message = GetDisplayMessage(failureKind, userMessage, conditionText); if (contractFailedEvent != null) { e = new ContractFailedEventArgs(failureKind, message, conditionText, innerException); foreach (EventHandler<ContractFailedEventArgs> handler in contractFailedEvent.GetInvocationList()) { try { handler(null, e); } catch (Exception exception) { e.thrownDuringHandler = exception; e.SetUnwind(); } } if (e.Unwind) { if (Environment.IsCLRHosted) { TriggerCodeContractEscalationPolicy(failureKind, message, conditionText, innerException); } if (innerException == null) { innerException = e.thrownDuringHandler; } throw new ContractException(failureKind, message, userMessage, conditionText, innerException); } } } finally { if ((e != null) && e.Handled) { str2 = null; } else { str2 = message; } } resultFailureMessage = str2; }
public static string RaiseContractFailedEvent(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException) { string resultFailureMessage = "Contract failed"; RaiseContractFailedEventImplementation(failureKind, userMessage, conditionText, innerException, ref resultFailureMessage); return resultFailureMessage; }
public ContractException(string msg) : base(msg) { _Kind = ContractFailureKind.Precondition; }
public ContractFailedEventArgs(ContractFailureKind failureKind, string message, string condition, Exception 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);
private Literal TranslateKindForBackwardCompatibility(ContractFailureKind kind) { switch (kind) { case ContractFailureKind.Assert: { var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Assert")); Contract.Assume(field != null); return field.DefaultValue; } case ContractFailureKind.Assume: { var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Assume")); Contract.Assume(field != null); return field.DefaultValue; } case ContractFailureKind.Invariant: { var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Invariant")); Contract.Assume(field != null); return field.DefaultValue; } case ContractFailureKind.Postcondition: { var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Postcondition")); Contract.Assume(field != null); return field.DefaultValue; } case ContractFailureKind.PostconditionOnException: { var pe = this.contractNodes.ContractFailureKind.GetField(Identifier.For("PostconditionOnException")); // hack if (pe == null) { // Old CLR 4.0 beta var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Postcondition")); Contract.Assume(field != null); return field.DefaultValue; } return pe.DefaultValue; } case ContractFailureKind.Precondition: { var field = this.contractNodes.ContractFailureKind.GetField(Identifier.For("Precondition")); Contract.Assume(field != null); return field.DefaultValue; } default: { throw new ApplicationException(String.Format("Unexpected failure kind {0}", kind.ToString())); } } }
public static void TriggerFailure(ContractFailureKind kind, string displayMessage, string userMessage, string conditionText, Exception innerException) { throw new NotImplementedException(); }
private static String GetDisplayMessage(ContractFailureKind failureKind, String userMessage, String conditionText) { String resourceName = null; switch (failureKind) { case ContractFailureKind.Assert: resourceName = "AssertionFailed"; break; case ContractFailureKind.Assume: resourceName = "AssumptionFailed"; break; case ContractFailureKind.Precondition: resourceName = "PreconditionFailed"; break; case ContractFailureKind.Postcondition: resourceName = "PostconditionFailed"; break; case ContractFailureKind.Invariant: resourceName = "InvariantFailed"; break; case ContractFailureKind.PostconditionOnException: resourceName = "PostconditionOnExceptionFailed"; break; default: Contract.Assume(false, "Unreachable code"); resourceName = "AssumptionFailed"; break; } var failureMessage = myResourceManager.GetString(resourceName); if (failureMessage == null) { // Hack for pre-V4 CLR�s failureMessage = String.Format(System.Globalization.CultureInfo.CurrentUICulture, "{0} failed", failureKind); } // Now format based on presence of condition/userProvidedMessage if (!String.IsNullOrEmpty(conditionText)) { if (!String.IsNullOrEmpty(userMessage)) { // both != null return(String.Format(System.Globalization.CultureInfo.CurrentUICulture, "{0}: {1} {2}", failureMessage, conditionText, userMessage)); } else { // condition != null, userProvidedMessage == null return(String.Format(System.Globalization.CultureInfo.CurrentUICulture, "{0}: {1}", failureMessage, conditionText)); } } else { if (!String.IsNullOrEmpty(userMessage)) { // condition null, userProvidedMessage != null return(String.Format(System.Globalization.CultureInfo.CurrentUICulture, "{0}: {1}", failureMessage, userMessage)); } else { // both null return(failureMessage); } } }
internal static string GetFailureMessage(ContractFailureKind failureKind) { return(GetFailureMessage(failureKind, "")); }
public static void TriggerFailure(ContractFailureKind kind, String displayMessage, String userMessage, String conditionText, Exception innerException) { System.Runtime.CompilerServices.ContractHelper.TriggerFailure(kind, displayMessage, userMessage, conditionText, innerException); }
public ContractException(ContractFailureKind kind, string failure, string userMessage, string condition, Exception innerException) : base(failure, innerException) { this._Kind = kind; this._UserMessage = userMessage; this._Condition = condition; }
public extern ContractException(ContractFailureKind kind, string failure, string userMessage, string condition, Exception innerException);
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 }
/// <summary> /// Rewriter will call this method on a contract failure to allow listeners to be notified. /// The method should not perform any failure (assert/throw) itself. /// This method has 3 functions: /// 1. Call any contract hooks (such as listeners to Contract failed events) /// 2. Determine if the listeneres deem the failure as handled (then resultFailureMessage should be set to null) /// 3. Produce a localized resultFailureMessage used in advertising the failure subsequently. /// </summary> /// <param name="resultFailureMessage">Should really be out (or the return value), but partial methods are not flexible enough. /// On exit: null if the event was handled and should not trigger a failure. /// Otherwise, returns the localized failure message</param> static partial void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException, ref string resultFailureMessage);
public static void TriggerFailure(ContractFailureKind kind, string displayMessage, string userMessage, string conditionText, Exception innerException) { TriggerFailureImplementation(kind, displayMessage, userMessage, conditionText, innerException); }
/// <summary> /// Without contract rewriting, failing Assert/Assumes end up calling this method. /// Code going through the contract rewriter never calls this method. Instead, the rewriter produced failures call /// System.Runtime.CompilerServices.ContractHelper.RaiseContractFailedEvent, followed by /// System.Runtime.CompilerServices.ContractHelper.TriggerFailure. /// </summary> static partial void ReportFailure(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException);
public static void TriggerFailure(ContractFailureKind kind, string msg, string userMessage, string conditionTxt) { throw new ContractException(kind, msg, userMessage, conditionTxt); }
static partial void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, String userMessage, String conditionText, Exception innerException, ref string resultFailureMessage) { if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume) { throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, failureKind), "failureKind"); } Contract.EndContractBlock(); string returnValue; String displayMessage = "contract failed."; // Incomplete, but in case of OOM during resource lookup... #if !FEATURE_CORECLR ContractFailedEventArgs eventArgs = null; // In case of OOM. #endif // !FEATURE_CORECLR #if FEATURE_RELIABILITY_CONTRACTS System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions(); #endif try { displayMessage = GetDisplayMessage(failureKind, userMessage, conditionText); #if !FEATURE_CORECLR if (s_contractFailedEvent != null) { eventArgs = new ContractFailedEventArgs(failureKind, displayMessage, conditionText, innerException); foreach (EventHandler <ContractFailedEventArgs> handler in s_contractFailedEvent.GetInvocationList()) { try { handler(null, eventArgs); } catch (Exception e) { eventArgs.thrownDuringHandler = e; eventArgs.SetUnwind(); } } if (eventArgs.Unwind) { //if (Environment.IsCLRHosted) // TriggerCodeContractEscalationPolicy(failureKind, displayMessage, conditionText, innerException); // unwind if (innerException == null) { innerException = eventArgs.thrownDuringHandler; } throw new ContractException(failureKind, displayMessage, userMessage, conditionText, innerException); } } #endif // !FEATURE_CORECLR } finally { #if !FEATURE_CORECLR if (eventArgs != null && eventArgs.Handled) { returnValue = null; // handled } else #endif // !FEATURE_CORECLR { returnValue = displayMessage; } } resultFailureMessage = returnValue; }
private ContractException(SerializationInfo info, StreamingContext context) : base(info, context) { this._Kind = (ContractFailureKind) info.GetInt32("Kind"); this._UserMessage = info.GetString("UserMessage"); this._Condition = info.GetString("Condition"); }
private static string GetFailureMessage(ContractFailureKind failureKind, string conditionText, Provenance provenence) { return(string.IsNullOrEmpty(conditionText) ? string.Format(CultureInfo.InvariantCulture, "{0}", failureKind.ToDisplayString()) : string.Format(CultureInfo.InvariantCulture, "{0}: {1}", failureKind.ToDisplayString(), conditionText)); }
static void RaiseContractFailedEventImplementation(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException, ref string resultFailureMessage) { if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume) { throw new ArgumentException(string.Format("Invalid enum value: {0}", failureKind), "failureKind"); } Contract.EndContractBlock(); string returnValue; var displayMessage = "contract failed."; // Incomplete, but in case of OOM during resource lookup... ContractFailedEventArgs eventArgs = null; // In case of OOM. RuntimeHelpers.PrepareConstrainedRegions(); try { displayMessage = GetDisplayMessage(failureKind, userMessage, conditionText); var contractFailedEventLocal = _contractFailedEvent; if (contractFailedEventLocal != null) { eventArgs = new ContractFailedEventArgs(failureKind, displayMessage, conditionText, innerException); foreach (var @delegate in contractFailedEventLocal.GetInvocationList()) { var handler = (EventHandler <ContractFailedEventArgs>)@delegate; try { handler(null, eventArgs); } catch (Exception e) { #if NET35 eventArgs.ThrownDuringHandler = e; #else GC.KeepAlive(e); #endif eventArgs.SetUnwind(); } } if (eventArgs.Unwind) { #if NET35 // unwind if (innerException == null) { innerException = eventArgs.ThrownDuringHandler; } #endif throw new ContractException(failureKind, displayMessage, userMessage, conditionText, innerException); } } } finally { if (eventArgs != null && eventArgs.Handled) { returnValue = null; // handled } else { returnValue = displayMessage; } } resultFailureMessage = returnValue; }