public override void Check(ArcChart chart) { // foreach (var h in chart.Holds) // { // foreach (var t in chart.Timings) // { // if (t.Timing > h.Timing && t.Timing < h.EndTiming) // { // Faults.Add(h); // } // } // } foreach (var a in chart.Arcs) { foreach (var t in chart.Timings) { if (t.Timing > a.Timing && t.Timing < a.EndTiming) { if (Mathf.Approximately(a.XStart, a.XEnd) && Mathf.Approximately(a.YStart, a.YEnd)) { continue; } Faults.Add(a); } } } Faults = Faults.Distinct().ToList(); }
public Jp2KrDesignVM() : base(null, null) { Ongoings.Add(new TestLabelProgressVM()); Ongoings.Add(new TestLabelProgressVM()); Faults.Add(new TestLabelProgressVM()); Progress = new TestLabelProgressVM(); }
private Task ParallelForEach(Func <TranslationUnit, Jp2KrWork> genViewModel) { List <TranslationUnit> transUnits = translations ?? FindTranslations().ToList(); int complete = 0; Progress.Value = 0; Progress.Label = $"{workKind}{complete} / {transUnits.Count}"; return(transUnits.ForEachPinnedAsync(coreCount, async t => { Jp2KrWork item = genViewModel(t); Ongoings.Add(item.Progress); try { await Task.Run(() => item.Process()); } catch (EhndNotFoundException) { Progress.Foreground = LabelProgressVM.FgError; throw; } catch (Exception e) { Progress.Foreground = LabelProgressVM.FgError; string msg = e is RegexMatchTimeoutException ? "정규식 검색이 너무 오래 걸립니다. 정규식을 점검해주세요." : e.Message; item.SetProgress(TranslationPhase.Error, 100, msg); Faults.Add(item.Progress); Exceptions.Add(e); } finally { _ = Ongoings.Remove(item.Progress); complete++; Progress.Value = (double)complete / transUnits.Count * 100; Progress.Label = $"{workKind}{complete} / {transUnits.Count}"; } })); }
public override void Check(ArcChart chart) { List <(ArcArcTap, float, float)> ats = new List <(ArcArcTap, float, float)>(); foreach (var arc in chart.Arcs) { foreach (var at in arc.ArcTaps) { float t = 1f * (at.Timing - arc.Timing) / (arc.EndTiming - arc.Timing); float x = ArcAlgorithm.X(arc.XStart, arc.XEnd, t, arc.LineType); float y = ArcAlgorithm.Y(arc.YStart, arc.YEnd, t, arc.LineType); ats.Add((at, x, y)); } } for (int i = 0; i < ats.Count - 1; ++i) { for (int k = i + 1; k < ats.Count; ++k) { if (ats[i].Item2 == ats[k].Item2 && ats[i].Item3 == ats[k].Item3 && ats[i].Item1.Timing == ats[k].Item1.Timing) { Faults.Add(ats[i].Item1); } } } Faults = Faults.Distinct().ToList(); }
public void SetAnalysisMode(AnalysisMode mode) { ObserverController.Mode = mode; var agents = ObserverController.Agents; switch (mode) { case AnalysisMode.TolerableFaults: agents.Select(agent => agent.ConfigurationUpdateFailed).SuppressActivations(); Workpieces.Select(workpiece => workpiece.IncorrectlyPositionedFault).SuppressActivations(); Workpieces.Select(workpiece => workpiece.ToolApplicationFailed).SuppressActivations(); Robots.Select(robot => robot.SwitchToWrongToolFault).SuppressActivations(); Carts.Select(cart => cart.Lost).SuppressActivations(); ObserverController.ReconfigurationFailure.SuppressActivation(); break; case AnalysisMode.IntolerableFaults: Faults.SuppressActivations(); agents.Select(agent => agent.ConfigurationUpdateFailed).MakeNondeterministic(); Workpieces.Select(workpiece => workpiece.IncorrectlyPositionedFault).MakeNondeterministic(); Workpieces.Select(workpiece => workpiece.ToolApplicationFailed).MakeNondeterministic(); Robots.Select(robot => robot.SwitchToWrongToolFault).MakeNondeterministic(); Carts.Select(cart => cart.Lost).MakeNondeterministic(); ObserverController.ReconfigurationFailure.MakeNondeterministic(); break; case AnalysisMode.AllFaults: return; default: throw new ArgumentOutOfRangeException(nameof(mode), mode, null); } }
/// <summary> /// Creates a counter example from the <paramref name="path" />. /// </summary> /// <param name="createModel">The factory function that can be used to create new instances of this model.</param> /// <param name="path"> /// The path the counter example should be generated from. A value of <c>null</c> indicates that no /// transitions could be generated for the model. /// </param> /// <param name="endsWithException">Indicates whether the counter example ends with an exception.</param> public CounterExample CreateCounterExample(CoupledExecutableModelCreator <TExecutableModel> createModel, byte[][] path, bool endsWithException) { Requires.NotNull(createModel, nameof(createModel)); // We have to create new model instances to generate and initialize the counter example, otherwise hidden // state variables might prevent us from doing so if they somehow influence the state var replayModel = createModel.Create(StateHeaderBytes); var choiceResolver = new NondeterministicChoiceResolver(true); replayModel.SetChoiceResolver(choiceResolver); CopyFaultActivationStates(replayModel); var faultActivations = Faults.Select(fault => fault.Activation).ToArray(); // Prepend the construction state to the path; if the path is null, at least one further state must be added // to enable counter example debugging. // Also, get the replay information, i.e., the nondeterministic choices that were made on the path; if the path is null, // we still have to get the choices that caused the problem. if (path == null) { path = new[] { new byte[StateVectorSize] } } ; path = new[] { ConstructionState }.Concat(path).ToArray(); var replayInfo = replayModel.GenerateReplayInformation(choiceResolver, path, endsWithException); return(new CounterExample(path, replayInfo, endsWithException, faultActivations)); }
public RpdChannelViewModel(IRpdChannel channel, RpdMeterViewModel meter) { _channel = channel; TrendChartType = TrendChartType.Rpd; Meter = meter; Faults.Add(meter.Fault); }
/// <summary> /// Updates the fault sets in accordance with the fault's actual activation states. /// </summary> public void UpdateFaultSets() { NondeterministicFaults = Faults.Where(fault => fault.Activation == Activation.Nondeterministic).ToArray(); ActivationSensitiveFaults = NondeterministicFaults.Where(fault => fault.RequiresActivationNotification).ToArray(); OnStartOfStepFaults = NondeterministicFaults.Where(fault => fault.DemandType == Fault.DemandTypes.OnStartOfStep).ToArray(); OnMethodCallFaults = NondeterministicFaults.Where(fault => fault.DemandType == Fault.DemandTypes.OnMethodCall).ToArray(); OnCustomFaults = NondeterministicFaults.Where(fault => fault.DemandType == Fault.DemandTypes.OnCustom).ToArray(); }
public IFaultablePort AppendFault(Exception e) { var fault = e.Message; Faults = Faults ?? new List <string>(); Faults.Add(fault); return(this); }
void FillFaults() { for (int i = 0; i < Section.Faults.Count; i++) { Faults.Add(new FaultViewModel(Section.Faults[i])); } _faultsLinker = new ObservableCollectionsConnector <IFaultLog, IFaultViewModel>(Section.Faults, Faults, ConstructNewFault, log => Faults.FirstOrDefault(e => e.Fault == log)); }
public override void Check(ArcChart chart) { foreach (var h in chart.Holds) { if (h.EndTiming <= h.Timing) { Faults.Add(h); } } Faults = Faults.Distinct().ToList(); }
private void GetData() { byte[] raw = new byte[4]; _device.Read(raw); Array.Reverse(raw); var data = BitConverter.ToInt32(raw, 0); //check for fault switch (data & 0x07) // first three bits are faults 0b111, if all are 0 then we have good data { case 0x0: _fault = Faults.OK; break; case 0x1: _fault = Faults.OPEN_CIRCUIT; break; case 0x2: _fault = Faults.SHORT_TO_GND; break; case 0x4: _fault = Faults.SHORT_TO_VCC; break; default: _fault = Faults.GENERAL_FAULT; break; } if (_fault != Faults.OK) { _temperature = double.NaN; _internal = double.NaN; } data >>= 4; // shift right 4 spaces (the fourth space is unused) _internal = (data & 0x7FF) * 0.0625; // 7FF = 0b11111111111, 11 bits for the temp + 1 for the sign bit (see below) if ((data & 0x800) != 0) //check negative sign bit 0b100000000000 { _internal += -128; } data >>= 14; //trim off everything except the thermocouple temperature, i.e. shift right the 14 bits of the internal temp bits _temperature = (data & 0x1FFF) * 0.25; // 1FFF = 0b1111111111111, 13 bits for the temp + 1 for the sign bit if ((data & 0x02000) != 0) //check negative sign bit (14th bit from the right) 0b10000000000000 { _temperature += -2048; } }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="serializedData">The serialized data describing the model.</param> /// <param name="stateHeaderBytes"> /// The number of bytes that should be reserved at the beginning of each state vector for the model checker tool. /// </param> internal RuntimeModel(SerializedRuntimeModel serializedData, int stateHeaderBytes = 0) { Requires.That(serializedData.Model != null, "Expected a valid model instance."); var buffer = serializedData.Buffer; var rootComponents = serializedData.Model.Roots; var objectTable = serializedData.ObjectTable; var formulas = serializedData.Formulas; Requires.NotNull(buffer, nameof(buffer)); Requires.NotNull(rootComponents, nameof(rootComponents)); Requires.NotNull(objectTable, nameof(objectTable)); Requires.NotNull(formulas, nameof(formulas)); Requires.That(stateHeaderBytes % 4 == 0, nameof(stateHeaderBytes), "Expected a multiple of 4."); Model = serializedData.Model; SerializedModel = buffer; RootComponents = rootComponents.Cast <Component>().ToArray(); Faults = objectTable.OfType <Fault>().Where(fault => fault.Activation == Activation.Nondeterministic && fault.IsUsed).ToArray(); ActivationSensitiveFaults = Faults.Where(fault => fault.RequiresActivationNotification).ToArray(); StateFormulas = objectTable.OfType <StateFormula>().ToArray(); Formulas = formulas; // Create a local object table just for the objects referenced by the model; only these objects // have to be serialized and deserialized. The local object table does not contain, for instance, // the closure types of the state formulas var objects = Model.ReferencedObjects; var deterministicFaults = objectTable.OfType <Fault>().Where(fault => fault.Activation != Activation.Nondeterministic); _serializedObjects = new ObjectTable(objects.Except(deterministicFaults, ReferenceEqualityComparer <object> .Default)); Objects = objectTable; StateVectorLayout = SerializationRegistry.Default.GetStateVectorLayout(Model, _serializedObjects, SerializationMode.Optimized); _deserialize = StateVectorLayout.CreateDeserializer(_serializedObjects); _serialize = StateVectorLayout.CreateSerializer(_serializedObjects); _restrictRanges = StateVectorLayout.CreateRangeRestrictor(_serializedObjects); _stateHeaderBytes = stateHeaderBytes; PortBinding.BindAll(objectTable); _choiceResolver = new ChoiceResolver(objectTable); ConstructionState = new byte[StateVectorSize]; fixed(byte *state = ConstructionState) { Serialize(state); _restrictRanges(); } FaultSet.CheckFaultCount(Faults.Length); StateFormulaSet.CheckFormulaCount(StateFormulas.Length); }
public void AddFault(Fault fault) { if (Faults == null) { Faults = new List <Fault> { fault }; } else { Faults.Add(fault); } }
public override void Check(ArcChart chart) { foreach (var h in chart.Holds) { foreach (var t in chart.Taps) { if (t.Timing >= h.Timing && t.Timing <= h.EndTiming && t.Track == h.Track) { Faults.Add(t); } } } Faults = Faults.Distinct().ToList(); }
public override void Check(ArcChart chart) { for (int i = 0; i < chart.Taps.Count - 1; ++i) { for (int k = i + 1; k < chart.Taps.Count; ++k) { if (chart.Taps[i].Timing == chart.Taps[k].Timing && chart.Taps[i].Track == chart.Taps[k].Track) { Faults.Add(chart.Taps[i]); } } } Faults = Faults.Distinct().ToList(); }
public override void Check(ArcChart chart) { foreach (var a in chart.Arcs) { if (a.EndTiming <= a.Timing) { if (a.XEnd == a.XStart) { if (a.YEnd == a.YStart) { Faults.Add(a); } } } } Faults = Faults.Distinct().ToList(); }
protected override async Task HandleCommand(UpdateProductCommand command) { Models.Product product = await _readOnlyProductRepository.GetProductAsync(command.ProductId).ConfigureAwait(false); if (product == null) { throw new NotFoundException(new Fault { Reason = "ResourceNotFound", Message = PRODUCT_NOT_FOUND }); } bool wasCodeChanged = product.Code != command.Code; if (wasCodeChanged) { var productByCode = await _readOnlyProductRepository.GetProductByCodeAsync(command.Code).ConfigureAwait(false); ProductValidator.ValidateProductCode(Faults, productByCode, command.Code); if (Faults.Any()) { var exception = new ValidationException(); exception.AddErrors(Faults); throw exception; } } product.LastUpdated = DateTime.Now; product.Name = command.Name; product.Code = command.Code; product.Price = command.Price; if (!string.IsNullOrEmpty(command.FileContent) && !string.IsNullOrEmpty(command.FileTitle)) { byte[] imageBytes = Convert.FromBase64String(command.FileContent); HandleProductImage(command, product, imageBytes); HandleProductImageThumbnail(command, product, imageBytes); } await _writeOnlyProductRepository.UpdateAsync().ConfigureAwait(false); }
public override void Check(ArcChart chart) { foreach (var h in chart.Holds) { foreach (var t in chart.Timings) { if (t.Timing > h.Timing && t.Timing < h.EndTiming) { Faults.Add(h); } } } foreach (var a in chart.Arcs) { foreach (var t in chart.Timings) { if (t.Timing > a.Timing && t.Timing < a.EndTiming) { Faults.Add(a); } } } Faults = Faults.Distinct().ToList(); }
public ErrorCode GetStickyFaults(Faults toFill) { return(_ll.GetStickyFaults(toFill)); }
/// <summary> /// Method to obtain all the faults as a result of the validation of the html /// </summary> /// <param name="htmlValid">Boolean that will indicate if the document is or not valid html.</param> /// <param name="urlDocument">Xml document that represents the result of the validation</param> /// <param name="envNamespace">Namespace using to obtain some data such as line, colum, etc.</param> /// <param name="mNamespace">Namespace using to obtain some data such as line, colum, etc.</param> private void HTMLFaults(XDocument urlDocument, XNamespace envNamespace, XNamespace mNamespace) { faults = new Faults(); //Obtaining the descendants of the elements labeled "Fault". With this we obtain all the faults var faultElement = from e in urlDocument.Descendants(envNamespace + "Fault") select e; //Obtaining the descendants of the elements labeled "Detail". With this we obtain the details of the fault var faultDetail = from e in faultElement.Descendants(envNamespace + "Detail") select e; //Obtaining the descendants of the elements labeled "Text". With this we obtain the reason text of the fault var faultReason = from e in faultElement.Descendants(envNamespace + "Text") select e; //Iterate over the fault elements foreach (var element in faultElement) { //Create a new instance of the class Fault Fault fault = new Fault(); //Iterate over the fault reason foreach (var reason in faultReason) { //Store the value of the reason into de instance of the fault fault.reason = reason.Value; } //Iterate over the fault detail foreach (var e in faultDetail) { //Store the value of the messageid and errordetail fault.messageid = e.Descendants(mNamespace + "messageid").First().Value; fault.errorDetail = e.Descendants(mNamespace + "errordetail").First().Value; } //Insert the fault in the list of faults faults.Add(fault); } }
/// <summary> /// get (the) local authority for... /// </summary> /// <param name="theTouchpoint">the touchpoint</param> /// <param name="theLADCode">the local adinistrative district code</param> /// <param name="inScope">in scope</param> /// <returns>the result of the operation</returns> public async Task <HttpResponseMessage> GetAuthorityFor(string theTouchpoint, string theLADCode, IScopeLoggingContext inScope) => await SafeOperations.Try(() => ProcessGetAuthorityFor(theTouchpoint, theLADCode, inScope), x => Faults.GetResponseFor(x, inScope));
/// <summary> /// delete an area routing detail using... /// </summary> /// <param name="theTouchpointID">the touchpoint id</param> /// <param name="inScope">in logging scope</param> /// <returns>the currently running task containing the response message (success or fail)</returns> public async Task <HttpResponseMessage> DeleteAreaRoutingDetailUsing(string theTouchpointID, IScopeLoggingContext inScope) => await SafeOperations.Try(() => ProcessDeleteAreaRoutingDetailUsing(theTouchpointID, inScope), x => Faults.GetResponseFor(x, TypeOfFunction.Delete, inScope));
public IEnumerator <ServiceFaultDetail> GetEnumerator() { return(Faults.GetEnumerator()); }
/// <summary> /// Updates the fault sets in accordance with the fault's actual activation states. /// </summary> public void UpdateFaultSets() { NondeterministicFaults = Faults.Where(fault => fault.Activation == Activation.Nondeterministic).ToArray(); ActivationSensitiveFaults = NondeterministicFaults.Where(fault => fault.RequiresActivationNotification).ToArray(); }
/// <summary> /// Constructor with parameters /// </summary> public HTMLValidate(string url) { errors = new Errors(); warnings = new Warnings(); warningPotentialIssues = new WarningPotentialIssues(); faults = new Faults(); this.URL = url; }
/// <summary> /// get (the) area routing detail by... /// excluded from coverage as moq doesn't support the lambda complexity for this routine /// </summary> /// <param name="theLocation">the location</param> /// <param name="inScope">in logging scope</param> /// <returns>the currently running task containing the response message (success or fail)</returns> public async Task <HttpResponseMessage> GetAreaRoutingDetailBy(string theLocation, IScopeLoggingContext inScope) => await SafeOperations.Try(() => ProcessGetAreaRoutingDetailBy(theLocation, inScope), x => Faults.GetResponseFor(x, TypeOfFunction.GetByLocation, inScope));
/// <summary> /// add new authority for... /// </summary> /// <param name="theTouchpoint">the touchpoint</param> /// <param name="usingContent">using content</param> /// <param name="inScope">in scope</param> /// <returns>the result of the operation</returns> public async Task <HttpResponseMessage> AddNewAuthorityFor(string theTouchpoint, string usingContent, IScopeLoggingContext inScope) => await SafeOperations.Try(() => ProcessAddNewAuthorityFor(theTouchpoint, usingContent, inScope), x => Faults.GetResponseFor(x, inScope));
/// <summary> /// get all route id's /// </summary> /// <param name="inScope">in logging scope</param> /// <returns>the currently running task containing the response message (success or fail)</returns> public async Task <HttpResponseMessage> GetAllRouteIDs(IScopeLoggingContext inScope) => await SafeOperations.Try(() => ProcessGetAllRouteIDs(inScope), x => Faults.GetResponseFor(x, TypeOfFunction.GetAll, inScope));
/// <summary> /// Returns a string representation of the minimal critical fault sets. /// </summary> public override string ToString() { var builder = new StringBuilder(); var percentage = CheckedSetCount / (double)(1L << Faults.Count()) * 100; var cardinalitySum = MinimalCriticalSets.Sum(set => set.Count); var minimalSetCardinalityAverage = cardinalitySum == 0 ? 0 : cardinalitySum / (double)MinimalCriticalSets.Count; builder.AppendLine(); builder.AppendLine("======================================================================="); builder.AppendLine("======= Deductive Cause Consequence Analysis: Results ======="); builder.AppendLine("======================================================================="); builder.AppendLine(); if (Exceptions.Any()) { builder.AppendLine("*** Warning: Unhandled exceptions have been thrown during the analysis. ***"); builder.AppendLine(); } if (!IsComplete) { builder.AppendLine("*** Warning: Analysis might be incomplete; not all fault sets have been checked. ***"); builder.AppendLine(); } Func <IEnumerable <Fault>, string> getFaultString = faults => String.Join(", ", faults.Select(fault => fault.Name).OrderBy(name => name)); builder.AppendLine($"Elapsed Time: {Time}"); builder.AppendLine($"Fault Count: {Faults.Count()}"); builder.AppendLine($"Faults: {getFaultString(Faults)}"); if (ForcedFaults.Any()) { builder.AppendLine($"Forced Faults: {getFaultString(ForcedFaults)}"); } if (SuppressedFaults.Any()) { builder.AppendLine($"Suppressed Faults: {getFaultString(SuppressedFaults)}"); } builder.AppendLine(); builder.AppendLine($"Checked Fault Sets: {CheckedSetCount} ({percentage:F0}% of all fault sets)"); builder.AppendLine($"Minimal Critical Sets: {MinimalCriticalSets.Count}"); builder.AppendLine($"Average Minimal Critical Set Cardinality: {minimalSetCardinalityAverage:F1}"); builder.AppendLine(); var i = 1; foreach (var criticalSet in MinimalCriticalSets) { builder.AppendFormat(" ({1}) {{ {0} }}", String.Join(", ", criticalSet.Select(fault => fault.Name).OrderBy(name => name)), i++); Exception e; if (Exceptions.TryGetValue(criticalSet, out e)) { builder.AppendLine(); builder.Append( $" An unhandled exception of type {e.GetType().FullName} was thrown while checking the fault set: {e.Message}"); } builder.AppendLine(); } var heuristicCount = Heuristics.Count(); if (heuristicCount != 0) { builder.AppendLine(); if (HeuristicSuggestionCount == 0) { builder.AppendLine("No suggestions were made by the heuristics."); } else { var nonTriviallyCritical = HeuristicSuggestionCount - HeuristicNonTrivialSafeCount - HeuristicTrivialCount; var percentageTrivial = HeuristicTrivialCount / (double)(HeuristicSuggestionCount) * 100; var percentageNonTrivialSafe = HeuristicNonTrivialSafeCount / (double)(HeuristicSuggestionCount) * 100; var percentageNonTrivialCritical = nonTriviallyCritical / (double)(HeuristicSuggestionCount) * 100; builder.AppendLine($"Of {HeuristicSuggestionCount} fault sets suggested by {heuristicCount} heuristics"); builder.AppendLine($" {HeuristicTrivialCount} ({percentageTrivial:F0}%) were trivially safe or trivially critical,"); builder.AppendLine($" {HeuristicNonTrivialSafeCount} ({percentageNonTrivialSafe:F0}%) were non-trivially safe, and"); builder.AppendLine($" {nonTriviallyCritical} ({percentageNonTrivialCritical:F0}%) were non-trivially critical."); builder.AppendLine($"In total, {TrivialChecksCount} trivial checks were performed."); } } return(builder.ToString()); }
/// <summary> /// Returns a string representation of the minimal critical fault sets. /// </summary> public override string ToString() { var builder = new StringBuilder(); var percentage = CheckedSets.Count / (float)(1 << Faults.Count()) * 100; builder.AppendLine(); builder.AppendLine("======================================================================="); builder.AppendLine("======= Deductive Cause Consequence Analysis: Results ======="); builder.AppendLine("======================================================================="); builder.AppendLine(); if (Exceptions.Any()) { builder.AppendLine("*** Warning: Unhandled exceptions have been thrown during the analysis. ***"); builder.AppendLine(); } if (!IsComplete) { builder.AppendLine("*** Warning: Analysis might be incomplete; not all fault sets have been checked. ***"); builder.AppendLine(); } Func <IEnumerable <Fault>, string> getFaultString = faults => String.Join(", ", faults.Select(fault => fault.Name).OrderBy(name => name)); builder.AppendFormat("Elapsed Time: {0}", Time); builder.AppendLine(); builder.AppendFormat("Fault Count: {0}", Faults.Count()); builder.AppendLine(); builder.AppendFormat("Faults: {0}", getFaultString(Faults)); builder.AppendLine(); if (ForcedFaults.Any()) { builder.AppendFormat("Forced Faults: {0}", getFaultString(ForcedFaults)); builder.AppendLine(); } if (SuppressedFaults.Any()) { builder.AppendFormat("Suppressed Faults: {0}", getFaultString(SuppressedFaults)); builder.AppendLine(); } builder.AppendLine(); builder.AppendFormat("Checked Fault Sets: {0} ({1:F0}% of all fault sets)", CheckedSets.Count, percentage); builder.AppendLine(); builder.AppendFormat("Minimal Critical Sets: {0}", MinimalCriticalSets.Count); builder.AppendLine(); builder.AppendLine(); var i = 1; foreach (var criticalSet in MinimalCriticalSets) { builder.AppendFormat(" ({1}) {{ {0} }}", String.Join(", ", criticalSet.Select(fault => fault.Name).OrderBy(name => name)), i++); Exception e; if (Exceptions.TryGetValue(criticalSet, out e)) { builder.AppendLine(); builder.AppendFormat( " An unhandled exception of type {0} was thrown while checking the fault set: {1}", e.GetType().FullName, e.Message); } builder.AppendLine(); } return(builder.ToString()); }
/// <summary> /// add new area routing detail /// excluded from coverage as moq doesn't support the lambda complexity for this routine /// </summary> /// <param name="theTouchpoint">the touchpoint</param> /// <param name="usingContent">using content</param> /// <param name="inScope">in scope</param> /// <returns>the result of the operation</returns> public async Task <HttpResponseMessage> AddAreaRoutingDetailUsing(string theContent, IScopeLoggingContext inScope) => await SafeOperations.Try(() => ProcessAddAreaRoutingDetailUsing(theContent, inScope), x => Faults.GetResponseFor(x, TypeOfFunction.Post, inScope));