AssureUtilExtension.java

/**
 * Copyright (c) 2004-2025 Carnegie Mellon University and others. (see Contributors file).
 * All Rights Reserved.
 * 
 * NO WARRANTY. ALL MATERIAL IS FURNISHED ON AN "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY
 * KIND, EITHER EXPRESSED OR IMPLIED, AS TO ANY MATTER INCLUDING, BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR PURPOSE
 * OR MERCHANTABILITY, EXCLUSIVITY, OR RESULTS OBTAINED FROM USE OF THE MATERIAL. CARNEGIE MELLON UNIVERSITY DOES NOT
 * MAKE ANY WARRANTY OF ANY KIND WITH RESPECT TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT.
 * 
 * This program and the accompanying materials are made available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 * SPDX-License-Identifier: EPL-2.0
 * 
 * Created, in part, with funding and support from the United States Government. (see Acknowledgments file).
 * 
 * This program includes and/or can make use of certain third party source code, object code, documentation and other
 * files ("Third Party Software"). The Third Party Software that is used by this program is dependent upon your system
 * configuration. By using this program, You agree to comply with any and all relevant Third Party Software terms and
 * conditions contained in any such Third Party Software or separate license file distributed with such Third Party
 * Software. The parties who own the Third Party Software ("Third Party Licensors") are intended third party benefici-
 * aries to this license with respect to the terms applicable to their Third Party Software. Third Party Software li-
 * censes only apply to the Third Party Software and not any other portion of this program or this program as a whole.
 */
package org.osate.assure.util;

import com.google.common.base.Objects;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.xtext.EcoreUtil2;
import org.eclipse.xtext.resource.XtextResource;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.Conversions;
import org.eclipse.xtext.xbase.lib.Exceptions;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.junit.runner.notification.Failure;
import org.osate.aadl2.ComponentClassifier;
import org.osate.aadl2.ComponentImplementation;
import org.osate.aadl2.IntegerLiteral;
import org.osate.aadl2.NamedElement;
import org.osate.aadl2.NumberValue;
import org.osate.aadl2.RealLiteral;
import org.osate.aadl2.Subcomponent;
import org.osate.aadl2.UnitLiteral;
import org.osate.aadl2.instance.ComponentInstance;
import org.osate.aadl2.instance.ConnectionInstance;
import org.osate.aadl2.instance.InstanceObject;
import org.osate.aadl2.instance.SystemInstance;
import org.osate.aadl2.instantiation.InstantiateModel;
import org.osate.aadl2.modelsupport.AadlConstants;
import org.osate.aadl2.modelsupport.resources.OsateResourceUtil;
import org.osate.aadl2.util.Aadl2Util;
import org.osate.alisa.common.common.AVariableDeclaration;
import org.osate.alisa.common.common.AVariableReference;
import org.osate.alisa.common.common.ComputeDeclaration;
import org.osate.alisa.common.common.Description;
import org.osate.alisa.common.util.CommonUtilExtension;
import org.osate.alisa.workbench.alisa.AssurancePlan;
import org.osate.assure.assure.AssuranceCaseResult;
import org.osate.assure.assure.AssureResult;
import org.osate.assure.assure.ClaimResult;
import org.osate.assure.assure.ElseResult;
import org.osate.assure.assure.Metrics;
import org.osate.assure.assure.ModelResult;
import org.osate.assure.assure.NestedClaimReference;
import org.osate.assure.assure.PreconditionResult;
import org.osate.assure.assure.PredicateResult;
import org.osate.assure.assure.QualifiedClaimReference;
import org.osate.assure.assure.QualifiedVAReference;
import org.osate.assure.assure.QualifiedVerificationPlanElementReference;
import org.osate.assure.assure.SubsystemResult;
import org.osate.assure.assure.ThenResult;
import org.osate.assure.assure.ValidationResult;
import org.osate.assure.assure.VerificationActivityResult;
import org.osate.assure.assure.VerificationExpr;
import org.osate.assure.assure.VerificationResult;
import org.osate.categories.categories.CategoryFilter;
import org.osate.reqspec.reqSpec.ReqPredicate;
import org.osate.reqspec.reqSpec.Requirement;
import org.osate.reqspec.reqSpec.ValuePredicate;
import org.osate.result.AnalysisResult;
import org.osate.result.Diagnostic;
import org.osate.result.DiagnosticType;
import org.osate.result.Result;
import org.osate.result.ResultFactory;
import org.osate.result.ResultType;
import org.osate.result.util.ResultUtil;
import org.osate.verify.internal.util.VerifyUtilExtension;
import org.osate.verify.verify.Claim;
import org.osate.verify.verify.VerificationActivity;
import org.osate.verify.verify.VerificationMethod;
import org.osate.verify.verify.VerificationPlan;

@SuppressWarnings("all")
public class AssureUtilExtension {
  public static SubsystemResult getEnclosingSubsystemResult(final EObject assureObject) {
    EObject _eContainer = assureObject.eContainer();
    boolean _tripleEquals = (_eContainer == null);
    if (_tripleEquals) {
      return null;
    }
    EObject result = assureObject.eContainer();
    while (((result != null) && (!(result instanceof SubsystemResult)))) {
      result = result.eContainer();
    }
    if ((result == null)) {
      return null;
    }
    return ((SubsystemResult) result);
  }

  public static AssuranceCaseResult getAssuranceCaseResult(final EObject assureObject) {
    EObject result = assureObject;
    while ((result.eContainer() != null)) {
      result = result.eContainer();
    }
    return ((AssuranceCaseResult) result);
  }

  public static ModelResult getModelResult(final EObject assureObject) {
    EObject result = assureObject;
    while ((result != null)) {
      {
        if ((result instanceof ModelResult)) {
          return ((ModelResult)result);
        }
        result = result.eContainer();
      }
    }
    return null;
  }

  /**
   * return the component classifier associated with the ModelResult target, i.e., the AADL instance model being verified
   */
  public static ComponentClassifier getCaseTargetClassifier(final EObject assureObject) {
    EObject ac = assureObject;
    while ((ac != null)) {
      {
        ac = ac.eContainer();
        if ((ac instanceof ModelResult)) {
          ComponentImplementation _target = ((ModelResult)ac).getTarget();
          boolean _tripleNotEquals = (_target != null);
          if (_tripleNotEquals) {
            return ((ModelResult)ac).getTarget();
          }
        } else {
          if ((ac instanceof SubsystemResult)) {
            Subcomponent _targetSystem = ((SubsystemResult)ac).getTargetSystem();
            boolean _tripleNotEquals_1 = (_targetSystem != null);
            if (_tripleNotEquals_1) {
              return ((SubsystemResult)ac).getTargetSystem().getAllClassifier();
            }
          }
        }
      }
    }
    return null;
  }

  public static ClaimResult getClaimResult(final EObject assureObject) {
    EObject result = assureObject;
    while ((!(result instanceof ClaimResult))) {
      result = result.eContainer();
    }
    if ((result == null)) {
      return null;
    }
    return ((ClaimResult) result);
  }

  public static VerificationPlan findVerificationPlan(final NestedClaimReference refObject) {
    EObject result = refObject;
    while ((!(result instanceof QualifiedVerificationPlanElementReference))) {
      result = result.eContainer();
    }
    return ((QualifiedVerificationPlanElementReference) result).getVerificationPlan();
  }

  public static Claim findClaim(final QualifiedVAReference qva) {
    return AssureUtilExtension.getReferencedClaim(qva.getRequirement(), qva.getVerificationPlan().getClaim());
  }

  public static Claim getReferencedClaim(final NestedClaimReference cref, final Iterable<Claim> claims) {
    final String crefname = cref.getRequirement().getName();
    for (final Claim cl : claims) {
      if (((cl.getRequirement() != null) && (cl.getRequirement().getName() != null))) {
        boolean _equalsIgnoreCase = cl.getRequirement().getName().equalsIgnoreCase(crefname);
        if (_equalsIgnoreCase) {
          if (((cref.getSub() != null) && (!cl.getSubclaim().isEmpty()))) {
            return AssureUtilExtension.getReferencedClaim(cref.getSub(), cl.getSubclaim());
          }
          return cl;
        }
      }
    }
    return null;
  }

  public static Claim findClaim(final QualifiedClaimReference qc) {
    return AssureUtilExtension.getReferencedClaim(qc.getRequirement(), qc.getVerificationPlan().getClaim());
  }

  public static Requirement getTarget(final ClaimResult cr) {
    NestedClaimReference qualreqref = cr.getTargetReference().getRequirement();
    while ((qualreqref.getSub() != null)) {
      qualreqref = qualreqref.getSub();
    }
    return qualreqref.getRequirement();
  }

  public static ValuePredicate getPredicate(final PredicateResult pr) {
    NestedClaimReference qualreqref = pr.getTargetReference().getRequirement();
    while ((qualreqref.getSub() != null)) {
      qualreqref = qualreqref.getSub();
    }
    ReqPredicate _predicate = qualreqref.getRequirement().getPredicate();
    return ((ValuePredicate) _predicate);
  }

  /**
   * return the model element that is the target of verification
   */
  public static NamedElement getCaseTargetModelElement(final EObject assureObject) {
    NamedElement _xblockexpression = null;
    {
      final ClaimResult cr = AssureUtilExtension.getClaimResult(assureObject);
      final NamedElement res = cr.getModelElement();
      boolean _isNull = Aadl2Util.isNull(res);
      boolean _not = (!_isNull);
      if (_not) {
        return res;
      }
      final Requirement req = AssureUtilExtension.getTarget(cr);
      NamedElement _targetElement = null;
      if (req!=null) {
        _targetElement=req.getTargetElement();
      }
      _xblockexpression = _targetElement;
    }
    return _xblockexpression;
  }

  public static SystemInstance getAssuranceCaseInstanceModel(final AssureResult assureObject, final boolean save) {
    SystemInstance _xblockexpression = null;
    {
      ModelResult _modelResult = AssureUtilExtension.getModelResult(assureObject);
      ComponentImplementation _target = null;
      if (_modelResult!=null) {
        _target=_modelResult.getTarget();
      }
      final ComponentImplementation rac = _target;
      if ((rac == null)) {
        return null;
      }
      _xblockexpression = AssureUtilExtension.getInstanceModel(rac, save);
    }
    return _xblockexpression;
  }

  public static SystemInstance getExistingAssuranceCaseInstanceModel(final AssureResult assureObject) {
    SystemInstance _xblockexpression = null;
    {
      ModelResult _modelResult = AssureUtilExtension.getModelResult(assureObject);
      ComponentImplementation _target = null;
      if (_modelResult!=null) {
        _target=_modelResult.getTarget();
      }
      final ComponentImplementation rac = _target;
      if ((rac == null)) {
        return null;
      }
      _xblockexpression = AssureUtilExtension.getExistingInstanceModel(rac);
    }
    return _xblockexpression;
  }

  public static ComponentInstance findTargetSystemComponentInstance(final SystemInstance si, final SubsystemResult ac) {
    ComponentInstance _xifexpression = null;
    if (((ac != null) && (ac.getTargetSystem() != null))) {
      ComponentInstance _xblockexpression = null;
      {
        final ComponentInstance ci = AssureUtilExtension.findTargetSystemComponentInstance(si, AssureUtilExtension.getEnclosingSubsystemResult(ac));
        InstanceObject _findElementInstance = CommonUtilExtension.findElementInstance(ci, ac.getTargetSystem());
        _xblockexpression = ((ComponentInstance) _findElementInstance);
      }
      _xifexpression = _xblockexpression;
    } else {
      _xifexpression = si;
    }
    return _xifexpression;
  }

  public static VerificationActivity getTarget(final VerificationActivityResult vares) {
    final QualifiedVAReference vaqref = vares.getTargetReference();
    return vaqref.getVerificationActivity();
  }

  public static VerificationMethod getMethod(final VerificationResult vr) {
    boolean _matched = false;
    if (vr instanceof VerificationActivityResult) {
      _matched=true;
      return AssureUtilExtension.getTarget(((VerificationActivityResult)vr)).getMethod();
    }
    if (!_matched) {
      if (vr instanceof PreconditionResult) {
        _matched=true;
        return ((PreconditionResult)vr).getTarget();
      }
    }
    if (!_matched) {
      if (vr instanceof ValidationResult) {
        _matched=true;
        return ((ValidationResult)vr).getTarget();
      }
    }
    return null;
  }

  /**
   * methods to process results from verification methods
   */
  public static void addMarkersAsResult(final VerificationResult verificationActivityResult, final InstanceObject instance, final String markertype, final VerificationMethod vm) {
    final Resource res = instance.eResource();
    final IFile irsrc = OsateResourceUtil.toIFile(res.getURI());
    IMarker[] markers = null;
    try {
      markers = irsrc.findMarkers(markertype, true, IResource.DEPTH_INFINITE);
    } catch (final Throwable _t) {
      if (_t instanceof CoreException) {
        AssureUtilExtension.setToError(verificationActivityResult, "Could not find Markers. Instance model was not saved.", instance);
        return;
      } else {
        throw Exceptions.sneakyThrow(_t);
      }
    }
    final String targetURI = EcoreUtil.getURI(instance).toString();
    final IMarker[] _converted_markers = (IMarker[])markers;
    final Function1<IMarker, Boolean> _function = (IMarker m) -> {
      try {
        Object _attribute = m.getAttribute(AadlConstants.AADLURI);
        return Boolean.valueOf(AssureUtilExtension.matchURI(((String) _attribute), targetURI));
      } catch (Throwable _e) {
        throw Exceptions.sneakyThrow(_e);
      }
    };
    Iterable<IMarker> targetmarkers = IterableExtensions.<IMarker>filter(((Iterable<IMarker>)Conversions.doWrapArray(_converted_markers)), _function);
    final String matchstr = AssureUtilExtension.matchMessage(vm);
    boolean _isEmpty = matchstr.isEmpty();
    boolean _not = (!_isEmpty);
    if (_not) {
      final Function1<IMarker, Boolean> _function_1 = (IMarker m) -> {
        try {
          boolean _xblockexpression = false;
          {
            Object _attribute = m.getAttribute(IMarker.MESSAGE);
            final String msg = ((String) _attribute);
            _xblockexpression = msg.contains(matchstr);
          }
          return Boolean.valueOf(_xblockexpression);
        } catch (Throwable _e) {
          throw Exceptions.sneakyThrow(_e);
        }
      };
      targetmarkers = IterableExtensions.<IMarker>filter(targetmarkers, _function_1);
    }
    final Consumer<IMarker> _function_2 = (IMarker em) -> {
      AssureUtilExtension.addMarkerIssue(verificationActivityResult, null, em);
    };
    targetmarkers.forEach(_function_2);
    final Function1<Result, Boolean> _function_3 = (Result ri) -> {
      ResultType _resultType = ri.getResultType();
      return Boolean.valueOf(Objects.equal(_resultType, ResultType.FAILURE));
    };
    boolean _exists = IterableExtensions.<Result>exists(verificationActivityResult.getResults(), _function_3);
    if (_exists) {
      AssureUtilExtension.setToFail(verificationActivityResult);
    } else {
      final Function1<Result, Boolean> _function_4 = (Result ri) -> {
        ResultType _resultType = ri.getResultType();
        return Boolean.valueOf(Objects.equal(_resultType, ResultType.ERROR));
      };
      boolean _exists_1 = IterableExtensions.<Result>exists(verificationActivityResult.getResults(), _function_4);
      if (_exists_1) {
        AssureUtilExtension.setToError(verificationActivityResult);
      } else {
        AssureUtilExtension.setToSuccess(verificationActivityResult);
      }
    }
  }

  private static boolean matchURI(final String uri1, final String uri2) {
    return Objects.equal(uri1, uri2);
  }

  private static String matchMessage(final VerificationMethod vm) {
    String _name = vm.getName();
    if (_name != null) {
      switch (_name) {
        case "MaxFlowLatencyAnalysis":
          return "Maximum actual latency";
        case "MinFlowLatencyAnalysis":
          return "Minimum actual latency";
        case "FlowLatencyJitterAnalysis":
          return "Jitter";
      }
    }
    return "";
  }

  public static Diagnostic addMarkerIssue(final VerificationResult vr, final EObject target, final IMarker marker) {
    try {
      Diagnostic _xblockexpression = null;
      {
        Object _attribute = marker.getAttribute(IMarker.MESSAGE);
        final String msg = ((String) _attribute);
        Diagnostic _switchResult = null;
        Object _attribute_1 = marker.getAttribute(IMarker.SEVERITY);
        boolean _matched = false;
        if (Objects.equal(_attribute_1, IMarker.SEVERITY_ERROR)) {
          _matched=true;
          _switchResult = AssureUtilExtension.addErrorIssue(vr, target, msg);
        }
        if (!_matched) {
          if (Objects.equal(_attribute_1, IMarker.SEVERITY_WARNING)) {
            _matched=true;
            _switchResult = AssureUtilExtension.addWarningIssue(vr, target, msg);
          }
        }
        if (!_matched) {
          if (Objects.equal(_attribute_1, IMarker.SEVERITY_INFO)) {
            _matched=true;
            _switchResult = AssureUtilExtension.addInfoIssue(vr, target, msg);
          }
        }
        _xblockexpression = _switchResult;
      }
      return _xblockexpression;
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }

  public static Diagnostic addErrorIssue(final VerificationResult vr, final EObject target, final String message) {
    return AssureUtilExtension.addIssue(vr, DiagnosticType.ERROR, target, message);
  }

  public static Diagnostic addIssue(final VerificationResult vr, final DiagnosticType type, final EObject target, final String message) {
    Diagnostic _xblockexpression = null;
    {
      final Diagnostic issue = ResultFactory.eINSTANCE.createDiagnostic();
      String _elvis = null;
      if (message != null) {
        _elvis = message;
      } else {
        _elvis = "no message";
      }
      issue.setMessage(_elvis);
      issue.setDiagnosticType(type);
      issue.setModelElement(target);
      vr.getIssues().add(issue);
      _xblockexpression = issue;
    }
    return _xblockexpression;
  }

  public static Diagnostic addInfoIssue(final VerificationResult vr, final EObject target, final String message) {
    return AssureUtilExtension.addIssue(vr, DiagnosticType.INFO, target, message);
  }

  public static Diagnostic addWarningIssue(final VerificationResult vr, final EObject target, final String message) {
    return AssureUtilExtension.addIssue(vr, DiagnosticType.WARNING, target, message);
  }

  public static void doJUnitResults(final org.junit.runner.Result rr, final Result ri) {
    final List<Failure> failist = rr.getFailures();
    final Consumer<Failure> _function = (Failure failed) -> {
      final Result issue = ResultUtil.createFailureResult(failed.getMessage(), null);
      ri.getSubResults().add(issue);
    };
    failist.forEach(_function);
  }

  public static int getTotalCount(final AssureResult ar) {
    int _xblockexpression = (int) 0;
    {
      final Metrics counts = ar.getMetrics();
      int _errorCount = counts.getErrorCount();
      int _failCount = counts.getFailCount();
      int _plus = (_errorCount + _failCount);
      int _successCount = counts.getSuccessCount();
      int _plus_1 = (_plus + _successCount);
      int _tbdCount = counts.getTbdCount();
      int _plus_2 = (_plus_1 + _tbdCount);
      int _didelseCount = counts.getDidelseCount();
      int _plus_3 = (_plus_2 + _didelseCount);
      int _thenskipCount = counts.getThenskipCount();
      _xblockexpression = (_plus_3 + _thenskipCount);
    }
    return _xblockexpression;
  }

  public static boolean isSuccessful(final AssureResult ar) {
    boolean _xblockexpression = false;
    {
      final Metrics counts = ar.getMetrics();
      _xblockexpression = ((((counts.getFailCount() == 0) && (counts.getErrorCount() == 0)) && (counts.getTbdCount() == 0)) && 
        (counts.getSuccessCount() > 0));
    }
    return _xblockexpression;
  }

  public static boolean isNoSuccess(final AssureResult ar) {
    boolean _xblockexpression = false;
    {
      final Metrics counts = ar.getMetrics();
      _xblockexpression = ((counts.getFailCount() != 0) || (counts.getErrorCount() != 0));
    }
    return _xblockexpression;
  }

  public static boolean isFail(final AssureResult ar) {
    boolean _xblockexpression = false;
    {
      final Metrics counts = ar.getMetrics();
      int _failCount = counts.getFailCount();
      _xblockexpression = (_failCount != 0);
    }
    return _xblockexpression;
  }

  public static boolean isError(final AssureResult ar) {
    boolean _xblockexpression = false;
    {
      final Metrics counts = ar.getMetrics();
      int _errorCount = counts.getErrorCount();
      _xblockexpression = (_errorCount != 0);
    }
    return _xblockexpression;
  }

  public static boolean isTBD(final AssureResult ar) {
    boolean _xblockexpression = false;
    {
      final Metrics counts = ar.getMetrics();
      _xblockexpression = (((counts.getFailCount() == 0) && (counts.getErrorCount() == 0)) && (counts.getTbdCount() > 0));
    }
    return _xblockexpression;
  }

  public static boolean isZeroCount(final AssureResult ar) {
    boolean _xblockexpression = false;
    {
      final Metrics counts = ar.getMetrics();
      _xblockexpression = (((counts.getFailCount() == 0) && (counts.getErrorCount() == 0)) && (counts.getTbdCount() == 0));
    }
    return _xblockexpression;
  }

  public static boolean isZeroTotalCount(final AssureResult ar) {
    boolean _xblockexpression = false;
    {
      final Metrics counts = ar.getMetrics();
      _xblockexpression = ((((counts.getFailCount() == 0) && (counts.getErrorCount() == 0)) && (counts.getTbdCount() == 0)) && 
        (counts.getSuccessCount() == 0));
    }
    return _xblockexpression;
  }

  /**
   * state of VerificationResult
   */
  public static boolean isSuccess(final VerificationResult vr) {
    ResultType _type = vr.getType();
    return Objects.equal(_type, ResultType.SUCCESS);
  }

  public static boolean isError(final VerificationResult vr) {
    ResultType _type = vr.getType();
    return Objects.equal(_type, ResultType.ERROR);
  }

  public static boolean isFailed(final VerificationResult vr) {
    ResultType _type = vr.getType();
    return Objects.equal(_type, ResultType.FAILURE);
  }

  /**
   * true at least one element is TBD
   */
  public static boolean isTBD(final EList<VerificationExpr> vel) {
    for (final VerificationExpr ar : vel) {
      boolean _isTBD = AssureUtilExtension.isTBD(ar);
      if (_isTBD) {
        return true;
      }
    }
    return false;
  }

  /**
   * true iff none of the elements have a fail or error
   */
  public static boolean isSuccess(final EList<VerificationExpr> vel) {
    for (final VerificationExpr ar : vel) {
      boolean _isNoSuccess = AssureUtilExtension.isNoSuccess(ar);
      if (_isNoSuccess) {
        return false;
      }
    }
    return true;
  }

  /**
   * true iff none of the elements have a fail or error
   */
  public static boolean isSuccessFul(final EList<VerificationResult> vel) {
    for (final VerificationResult ar : vel) {
      boolean _isNoSuccess = AssureUtilExtension.isNoSuccess(ar);
      if (_isNoSuccess) {
        return false;
      }
    }
    return true;
  }

  /**
   * true iff at least one has a non-zero fail or unknown count
   */
  public static boolean isNoSuccess(final EList<VerificationExpr> vel) {
    for (final VerificationExpr ar : vel) {
      boolean _isNoSuccess = AssureUtilExtension.isNoSuccess(ar);
      if (_isNoSuccess) {
        return true;
      }
    }
    return false;
  }

  public static boolean hasError(final EList<VerificationExpr> vel) {
    if (((vel.size() == 1) && (IterableExtensions.<VerificationExpr>head(vel) instanceof VerificationActivityResult))) {
      VerificationExpr _head = IterableExtensions.<VerificationExpr>head(vel);
      return AssureUtilExtension.isError(((VerificationActivityResult) _head));
    } else {
      return AssureUtilExtension.isNoSuccess(vel);
    }
  }

  public static boolean isFailed(final EList<VerificationExpr> vel) {
    if (((vel.size() == 1) && (IterableExtensions.<VerificationExpr>head(vel) instanceof VerificationActivityResult))) {
      VerificationExpr _head = IterableExtensions.<VerificationExpr>head(vel);
      return AssureUtilExtension.isFailed(((VerificationActivityResult) _head));
    } else {
      return false;
    }
  }

  public static String constructLabel(final EObject obj) {
    String _xblockexpression = null;
    {
      boolean _matched = false;
      if (obj instanceof SystemInstance) {
        _matched=true;
        String _name = ((SystemInstance)obj).getComponentImplementation().getName();
        return ("top " + _name);
      }
      if (!_matched) {
        if (obj instanceof ComponentInstance) {
          _matched=true;
          String _name = ((ComponentInstance)obj).getCategory().getName();
          String _plus = (_name + " ");
          String _name_1 = ((ComponentInstance)obj).getName();
          return (_plus + _name_1);
        }
      }
      if (!_matched) {
        if (obj instanceof ConnectionInstance) {
          _matched=true;
          return ((ConnectionInstance)obj).getName();
        }
      }
      if (!_matched) {
        if (obj instanceof NamedElement) {
          _matched=true;
          return ((NamedElement)obj).getName();
        }
      }
      _xblockexpression = "";
    }
    return _xblockexpression;
  }

  public static String getNamePath(final AssureResult ar) {
    EObject _eContainer = ar.eContainer();
    boolean _tripleEquals = (_eContainer == null);
    if (_tripleEquals) {
      return AssureUtilExtension.getPrintableName(ar);
    } else {
      EObject _eContainer_1 = ar.eContainer();
      String _namePath = AssureUtilExtension.getNamePath(((AssureResult) _eContainer_1));
      String _plus = (_namePath + ".");
      String _printableName = AssureUtilExtension.getPrintableName(ar);
      return (_plus + _printableName);
    }
  }

  public static String getPrintableName(final AssureResult ar) {
    boolean _matched = false;
    if (ar instanceof AssuranceCaseResult) {
      _matched=true;
      String _name = ((AssuranceCaseResult)ar).getName();
      return ("case " + _name);
    }
    if (!_matched) {
      if (ar instanceof ModelResult) {
        _matched=true;
        String _name = AssureUtilExtension.getName(((ModelResult)ar));
        return ("plan " + _name);
      }
    }
    if (!_matched) {
      if (ar instanceof SubsystemResult) {
        _matched=true;
        String _name = AssureUtilExtension.getName(((SubsystemResult)ar));
        return ("subsystem " + _name);
      }
    }
    if (!_matched) {
      if (ar instanceof ClaimResult) {
        _matched=true;
        String _name = AssureUtilExtension.getName(((ClaimResult)ar));
        return ("claim " + _name);
      }
    }
    if (!_matched) {
      if (ar instanceof ValidationResult) {
        _matched=true;
        String _name = AssureUtilExtension.getName(((ValidationResult)ar));
        return ("validation " + _name);
      }
    }
    if (!_matched) {
      if (ar instanceof PreconditionResult) {
        _matched=true;
        String _name = AssureUtilExtension.getName(((PreconditionResult)ar));
        return ("precondition " + _name);
      }
    }
    if (!_matched) {
      if (ar instanceof VerificationActivityResult) {
        _matched=true;
        String _name = AssureUtilExtension.getName(((VerificationActivityResult)ar));
        return ("evidence " + _name);
      }
    }
    if (!_matched) {
      if (ar instanceof ElseResult) {
        _matched=true;
        return "Else";
      }
    }
    if (!_matched) {
      if (ar instanceof ThenResult) {
        _matched=true;
        return "Then";
      }
    }
    if (!_matched) {
      if (ar instanceof PredicateResult) {
        _matched=true;
        return "Predicate";
      }
    }
    return "";
  }

  public static String getName(final AssureResult ar) {
    boolean _matched = false;
    if (ar instanceof AssuranceCaseResult) {
      _matched=true;
      return ((AssuranceCaseResult)ar).getName();
    }
    if (!_matched) {
      if (ar instanceof ModelResult) {
        _matched=true;
        return AssureUtilExtension.getName(((ModelResult)ar));
      }
    }
    if (!_matched) {
      if (ar instanceof SubsystemResult) {
        _matched=true;
        return AssureUtilExtension.getName(((SubsystemResult)ar));
      }
    }
    if (!_matched) {
      if (ar instanceof ClaimResult) {
        _matched=true;
        return AssureUtilExtension.getName(((ClaimResult)ar));
      }
    }
    if (!_matched) {
      if (ar instanceof ValidationResult) {
        _matched=true;
        return AssureUtilExtension.getName(((ValidationResult)ar));
      }
    }
    if (!_matched) {
      if (ar instanceof PreconditionResult) {
        _matched=true;
        return AssureUtilExtension.getName(((PreconditionResult)ar));
      }
    }
    if (!_matched) {
      if (ar instanceof VerificationActivityResult) {
        _matched=true;
        return AssureUtilExtension.getName(((VerificationActivityResult)ar));
      }
    }
    return "";
  }

  /**
   * this method resets the execution state of all verification activities to TBD
   */
  public static void resetToTBD(final AssuranceCaseResult root, final CategoryFilter filter) {
    final List<VerificationResult> vrlist = EcoreUtil2.<VerificationResult>eAllOfType(root, VerificationResult.class);
    final Consumer<VerificationResult> _function = (VerificationResult vr) -> {
      if ((filter == null)) {
        vr.setType(ResultType.TBD);
        vr.getIssues().clear();
      } else {
        boolean _matched = false;
        if (vr instanceof VerificationActivityResult) {
          _matched=true;
          final VerificationActivity verificationActivity = ((VerificationActivityResult)vr).getTargetReference().getVerificationActivity();
          if ((VerifyUtilExtension.evaluateVerificationMethodFilter(verificationActivity, filter) && 
            VerifyUtilExtension.evaluateVerificationActivityFilter(verificationActivity, filter))) {
            ((VerificationActivityResult)vr).setType(ResultType.TBD);
            ((VerificationActivityResult)vr).getIssues().clear();
          }
        }
      }
    };
    vrlist.forEach(_function);
  }

  /**
   * Helper methods
   */
  private static void resetCounts(final AssureResult result) {
    final Metrics counts = result.getMetrics();
    counts.setFailCount(0);
    counts.setSuccessCount(0);
    counts.setErrorCount(0);
    counts.setThenskipCount(0);
    counts.setDidelseCount(0);
    counts.setTbdCount(0);
    counts.setPreconditionfailCount(0);
    counts.setValidationfailCount(0);
    counts.setFeaturesCount(0);
    counts.setFeaturesRequirementsCount(0);
    counts.setExecutionTime(0);
  }

  /**
   * update the counts to reflect existing own status
   * Used by complete process and set result
   */
  private static VerificationResult addOwnResultStateToCount(final VerificationResult ar) {
    VerificationResult _xblockexpression = null;
    {
      final Metrics counts = ar.getMetrics();
      ResultType _type = ar.getType();
      if (_type != null) {
        switch (_type) {
          case SUCCESS:
            int _successCount = counts.getSuccessCount();
            int _plus = (_successCount + 1);
            counts.setSuccessCount(_plus);
            break;
          case FAILURE:
            int _failCount = counts.getFailCount();
            int _plus_1 = (_failCount + 1);
            counts.setFailCount(_plus_1);
            break;
          case ERROR:
            int _errorCount = counts.getErrorCount();
            int _plus_2 = (_errorCount + 1);
            counts.setErrorCount(_plus_2);
            break;
          case TBD:
            int _tbdCount = counts.getTbdCount();
            int _plus_3 = (_tbdCount + 1);
            counts.setTbdCount(_plus_3);
            break;
          default:
            break;
        }
      }
      _xblockexpression = ar;
    }
    return _xblockexpression;
  }

  /**
   * add all but the total count to the result object
   * This method is used in the process and set result methods
   */
  private static void addTo(final AssureResult subresult, final AssureResult result) {
    if ((subresult == null)) {
      return;
    }
    final Metrics counts = result.getMetrics();
    final Metrics subcounts = subresult.getMetrics();
    int _failCount = counts.getFailCount();
    int _failCount_1 = subcounts.getFailCount();
    int _plus = (_failCount + _failCount_1);
    counts.setFailCount(_plus);
    int _successCount = counts.getSuccessCount();
    int _successCount_1 = subcounts.getSuccessCount();
    int _plus_1 = (_successCount + _successCount_1);
    counts.setSuccessCount(_plus_1);
    int _errorCount = counts.getErrorCount();
    int _errorCount_1 = subcounts.getErrorCount();
    int _plus_2 = (_errorCount + _errorCount_1);
    counts.setErrorCount(_plus_2);
    int _thenskipCount = counts.getThenskipCount();
    int _thenskipCount_1 = subcounts.getThenskipCount();
    int _plus_3 = (_thenskipCount + _thenskipCount_1);
    counts.setThenskipCount(_plus_3);
    int _didelseCount = counts.getDidelseCount();
    int _didelseCount_1 = subcounts.getDidelseCount();
    int _plus_4 = (_didelseCount + _didelseCount_1);
    counts.setDidelseCount(_plus_4);
    int _tbdCount = counts.getTbdCount();
    int _tbdCount_1 = subcounts.getTbdCount();
    int _plus_5 = (_tbdCount + _tbdCount_1);
    counts.setTbdCount(_plus_5);
    int _preconditionfailCount = counts.getPreconditionfailCount();
    int _preconditionfailCount_1 = subcounts.getPreconditionfailCount();
    int _plus_6 = (_preconditionfailCount + _preconditionfailCount_1);
    counts.setPreconditionfailCount(_plus_6);
    int _validationfailCount = counts.getValidationfailCount();
    int _validationfailCount_1 = subcounts.getValidationfailCount();
    int _plus_7 = (_validationfailCount + _validationfailCount_1);
    counts.setValidationfailCount(_plus_7);
    int _featuresCount = counts.getFeaturesCount();
    int _featuresCount_1 = subcounts.getFeaturesCount();
    int _plus_8 = (_featuresCount + _featuresCount_1);
    counts.setFeaturesCount(_plus_8);
    int _featuresRequirementsCount = counts.getFeaturesRequirementsCount();
    int _featuresRequirementsCount_1 = subcounts.getFeaturesRequirementsCount();
    int _plus_9 = (_featuresRequirementsCount + _featuresRequirementsCount_1);
    counts.setFeaturesRequirementsCount(_plus_9);
  }

  /**
   * recompute and add the counts of the parts list to the result
   */
  private static void recomputeAllCounts(final AssureResult result, final List<? extends AssureResult> parts, final CategoryFilter filter) {
    final Consumer<AssureResult> _function = (AssureResult e) -> {
      boolean _matched = false;
      if (e instanceof ClaimResult) {
        _matched=true;
        boolean _evaluateRequirementFilter = VerifyUtilExtension.evaluateRequirementFilter(AssureUtilExtension.findClaim(((ClaimResult)e).getTargetReference()), filter);
        if (_evaluateRequirementFilter) {
          AssureUtilExtension.addTo(AssureUtilExtension.recomputeAllCounts(((ClaimResult)e), filter), result);
        }
      }
      if (!_matched) {
        if (e instanceof VerificationActivityResult) {
          _matched=true;
          final VerificationActivity verificationActivity = ((VerificationActivityResult)e).getTargetReference().getVerificationActivity();
          if ((VerifyUtilExtension.evaluateVerificationMethodFilter(verificationActivity, filter) && 
            VerifyUtilExtension.evaluateVerificationActivityFilter(verificationActivity, filter))) {
            AssureUtilExtension.addTo(AssureUtilExtension.recomputeAllCounts(((VerificationActivityResult)e), filter), result);
          }
        }
      }
      if (!_matched) {
        AssureUtilExtension.addTo(AssureUtilExtension.recomputeAllCounts(e, filter), result);
      }
    };
    parts.forEach(_function);
  }

  private static void setAllCountstoZero(final AssuranceCaseResult caseResult) {
    final Consumer<AssureResult> _function = (AssureResult ao) -> {
      AssureUtilExtension.resetCounts(ao);
    };
    EcoreUtil2.<AssureResult>eAllOfType(caseResult, AssureResult.class).forEach(_function);
  }

  public static AssuranceCaseResult recomputeAllCounts(final AssuranceCaseResult caseResult, final CategoryFilter filter) {
    AssuranceCaseResult _xblockexpression = null;
    {
      AssureUtilExtension.setAllCountstoZero(caseResult);
      AssureUtilExtension.recomputeAllCounts(caseResult, caseResult.getModelResult(), filter);
      _xblockexpression = caseResult;
    }
    return _xblockexpression;
  }

  private static ModelResult recomputeAllCounts(final ModelResult modelResult, final CategoryFilter filter) {
    ModelResult _xblockexpression = null;
    {
      AssureUtilExtension.recomputeAllCounts(modelResult, modelResult.getClaimResult(), filter);
      AssureUtilExtension.recomputeAllCounts(modelResult, modelResult.getSubsystemResult(), filter);
      _xblockexpression = modelResult;
    }
    return _xblockexpression;
  }

  private static SubsystemResult recomputeAllCounts(final SubsystemResult subsystemResult, final CategoryFilter filter) {
    SubsystemResult _xblockexpression = null;
    {
      AssureUtilExtension.recomputeAllCounts(subsystemResult, subsystemResult.getClaimResult(), filter);
      AssureUtilExtension.recomputeAllCounts(subsystemResult, subsystemResult.getSubsystemResult(), filter);
      _xblockexpression = subsystemResult;
    }
    return _xblockexpression;
  }

  private static ClaimResult recomputeAllCounts(final ClaimResult claimResult, final CategoryFilter filter) {
    ClaimResult _xblockexpression = null;
    {
      AssureUtilExtension.recomputeAllCounts(claimResult, claimResult.getVerificationActivityResult(), filter);
      AssureUtilExtension.recomputeAllCounts(claimResult, claimResult.getSubClaimResult(), filter);
      VerificationResult _predicateResult = claimResult.getPredicateResult();
      AssureUtilExtension.recomputeAllCounts(claimResult, Collections.<AssureResult>unmodifiableList(CollectionLiterals.<AssureResult>newArrayList(_predicateResult)), filter);
      _xblockexpression = claimResult;
    }
    return _xblockexpression;
  }

  private static VerificationActivityResult recomputeAllCounts(final VerificationActivityResult vaResult, final CategoryFilter filter) {
    VerificationActivityResult _xblockexpression = null;
    {
      VerificationResult _preconditionResult = vaResult.getPreconditionResult();
      boolean _tripleNotEquals = (_preconditionResult != null);
      if (_tripleNotEquals) {
        AssureUtilExtension.addTo(AssureUtilExtension.recomputeAllCounts(vaResult.getPreconditionResult(), filter), vaResult);
      }
      AssureUtilExtension.addOwnResultStateToCount(vaResult);
      VerificationResult _validationResult = vaResult.getValidationResult();
      boolean _tripleNotEquals_1 = (_validationResult != null);
      if (_tripleNotEquals_1) {
        AssureUtilExtension.addTo(AssureUtilExtension.recomputeAllCounts(vaResult.getValidationResult(), filter), vaResult);
      }
      _xblockexpression = vaResult;
    }
    return _xblockexpression;
  }

  private static ElseResult recomputeAllCounts(final ElseResult vaResult, final CategoryFilter filter) {
    ElseResult _xblockexpression = null;
    {
      vaResult.setDidFail(ResultType.SUCCESS);
      AssureUtilExtension.recomputeAllCounts(vaResult, vaResult.getFirst(), filter);
      boolean _isTBD = AssureUtilExtension.isTBD(vaResult.getFirst());
      boolean _not = (!_isTBD);
      if (_not) {
        boolean _isSuccess = AssureUtilExtension.isSuccess(vaResult.getFirst());
        if (_isSuccess) {
          AssureUtilExtension.recordNoElse(vaResult);
        } else {
          boolean _isFailed = AssureUtilExtension.isFailed(vaResult.getFirst());
          if (_isFailed) {
            AssureUtilExtension.recordElse(vaResult, ResultType.FAILURE);
            AssureUtilExtension.recomputeAllCounts(vaResult, vaResult.getFail(), filter);
          } else {
            boolean _isEmpty = vaResult.getFirst().isEmpty();
            if (_isEmpty) {
              AssureUtilExtension.recordElse(vaResult, ResultType.ERROR);
              AssureUtilExtension.recomputeAllCounts(vaResult, vaResult.getError(), filter);
            }
          }
        }
      } else {
      }
      _xblockexpression = vaResult;
    }
    return _xblockexpression;
  }

  private static ThenResult recomputeAllCounts(final ThenResult vaResult, final CategoryFilter filter) {
    ThenResult _xblockexpression = null;
    {
      vaResult.setDidThenFail(false);
      AssureUtilExtension.recomputeAllCounts(vaResult, vaResult.getFirst(), filter);
      boolean _isTBD = AssureUtilExtension.isTBD(vaResult.getFirst());
      boolean _not = (!_isTBD);
      if (_not) {
        boolean _isSuccess = AssureUtilExtension.isSuccess(vaResult.getFirst());
        if (_isSuccess) {
          AssureUtilExtension.recordNoSkip(vaResult);
          AssureUtilExtension.recomputeAllCounts(vaResult, vaResult.getSecond(), filter);
        } else {
          AssureUtilExtension.recordSkip(vaResult);
        }
      } else {
        AssureUtilExtension.recomputeAllCounts(vaResult, vaResult.getSecond(), filter);
      }
      _xblockexpression = vaResult;
    }
    return _xblockexpression;
  }

  private static ValidationResult recomputeAllCounts(final ValidationResult validationResult, final CategoryFilter filter) {
    ValidationResult _xblockexpression = null;
    {
      AssureUtilExtension.addOwnResultStateToCount(validationResult);
      _xblockexpression = validationResult;
    }
    return _xblockexpression;
  }

  private static PreconditionResult recomputeAllCounts(final PreconditionResult preconditionResult, final CategoryFilter filter) {
    PreconditionResult _xblockexpression = null;
    {
      AssureUtilExtension.addOwnResultStateToCount(preconditionResult);
      _xblockexpression = preconditionResult;
    }
    return _xblockexpression;
  }

  private static PredicateResult recomputeAllCounts(final PredicateResult predicateResult, final CategoryFilter filter) {
    PredicateResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(predicateResult);
      AssureUtilExtension.addOwnResultStateToCount(predicateResult);
      _xblockexpression = predicateResult;
    }
    return _xblockexpression;
  }

  private static AssureResult recomputeAllCounts(final AssureResult assureResult, final CategoryFilter filter) {
    AssureResult _switchResult = null;
    boolean _matched = false;
    if (assureResult instanceof AssuranceCaseResult) {
      _matched=true;
      _switchResult = AssureUtilExtension.recomputeAllCounts(((AssuranceCaseResult)assureResult), filter);
    }
    if (!_matched) {
      if (assureResult instanceof ModelResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.recomputeAllCounts(((ModelResult)assureResult), filter);
      }
    }
    if (!_matched) {
      if (assureResult instanceof SubsystemResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.recomputeAllCounts(((SubsystemResult)assureResult), filter);
      }
    }
    if (!_matched) {
      if (assureResult instanceof ClaimResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.recomputeAllCounts(((ClaimResult)assureResult), filter);
      }
    }
    if (!_matched) {
      if (assureResult instanceof PredicateResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.recomputeAllCounts(((PredicateResult)assureResult), filter);
      }
    }
    if (!_matched) {
      if (assureResult instanceof ValidationResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.recomputeAllCounts(((ValidationResult)assureResult), filter);
      }
    }
    if (!_matched) {
      if (assureResult instanceof PreconditionResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.recomputeAllCounts(((PreconditionResult)assureResult), filter);
      }
    }
    if (!_matched) {
      if (assureResult instanceof VerificationActivityResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.recomputeAllCounts(((VerificationActivityResult)assureResult), filter);
      }
    }
    if (!_matched) {
      if (assureResult instanceof ElseResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.recomputeAllCounts(((ElseResult)assureResult), filter);
      }
    }
    if (!_matched) {
      if (assureResult instanceof ThenResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.recomputeAllCounts(((ThenResult)assureResult), filter);
      }
    }
    return _switchResult;
  }

  /**
   * methods to incrementally set the state of a verification activity and propagate the state change
   * up the hierarchy
   */
  public static void setToSuccess(final VerificationResult verificationActivityResult) {
    boolean _updateOwnResultState = AssureUtilExtension.updateOwnResultState(verificationActivityResult, ResultType.SUCCESS);
    if (_updateOwnResultState) {
      AssureUtilExtension.propagateCountChangeUp(verificationActivityResult);
    }
  }

  public static void setToSuccess(final VerificationResult verificationActivityResult, final List<Diagnostic> rl) {
    verificationActivityResult.getIssues().addAll(rl);
    boolean _updateOwnResultState = AssureUtilExtension.updateOwnResultState(verificationActivityResult, ResultType.SUCCESS);
    if (_updateOwnResultState) {
      AssureUtilExtension.propagateCountChangeUp(verificationActivityResult);
    }
  }

  public static void setToTBD(final VerificationResult verificationActivityResult) {
    boolean _updateOwnResultState = AssureUtilExtension.updateOwnResultState(verificationActivityResult, ResultType.TBD);
    if (_updateOwnResultState) {
      AssureUtilExtension.propagateCountChangeUp(verificationActivityResult);
    }
  }

  public static void setToError(final VerificationResult verificationActivityResult) {
    boolean _updateOwnResultState = AssureUtilExtension.updateOwnResultState(verificationActivityResult, ResultType.ERROR);
    if (_updateOwnResultState) {
      AssureUtilExtension.propagateCountChangeUp(verificationActivityResult);
    }
  }

  public static void setToError(final VerificationResult verificationActivityResult, final String message, final EObject target) {
    AssureUtilExtension.addErrorIssue(verificationActivityResult, target, message);
    AssureUtilExtension.setToError(verificationActivityResult);
  }

  public static void setToFail(final VerificationResult verificationActivityResult) {
    boolean _updateOwnResultState = AssureUtilExtension.updateOwnResultState(verificationActivityResult, ResultType.FAILURE);
    if (_updateOwnResultState) {
      AssureUtilExtension.propagateCountChangeUp(verificationActivityResult);
    }
  }

  public static void setToFail(final VerificationResult verificationActivityResult, final List<Diagnostic> rl) {
    verificationActivityResult.getIssues().addAll(rl);
    AssureUtilExtension.setToFail(verificationActivityResult);
  }

  public static void setToFail(final VerificationResult verificationActivityResult, final Throwable e) {
    String _elvis = null;
    String _message = e.getMessage();
    if (_message != null) {
      _elvis = _message;
    } else {
      String _string = e.toString();
      _elvis = _string;
    }
    AssureUtilExtension.addErrorIssue(verificationActivityResult, null, _elvis);
    AssureUtilExtension.setToFail(verificationActivityResult);
  }

  public static void setToError(final VerificationResult verificationActivityResult, final Throwable e) {
    String _elvis = null;
    String _message = e.getMessage();
    if (_message != null) {
      _elvis = _message;
    } else {
      String _string = e.toString();
      _elvis = _string;
    }
    AssureUtilExtension.addErrorIssue(verificationActivityResult, null, _elvis);
    AssureUtilExtension.setToError(verificationActivityResult);
  }

  public static void setToError(final VerificationResult verificationActivityResult, final String message) {
    AssureUtilExtension.addErrorIssue(verificationActivityResult, null, message);
    AssureUtilExtension.setToError(verificationActivityResult);
  }

  /**
   * the next methods update the counts for FailThen and AndThen
   */
  public static void recordElse(final ElseResult result, final ResultType et) {
    ResultType _didFail = result.getDidFail();
    boolean _notEquals = (!Objects.equal(_didFail, ResultType.SUCCESS));
    if (_notEquals) {
    } else {
      result.setDidFail(et);
      Metrics _metrics = result.getMetrics();
      int _didelseCount = result.getMetrics().getDidelseCount();
      int _plus = (_didelseCount + 1);
      _metrics.setDidelseCount(_plus);
    }
  }

  /**
   * the next methods update the counts for FailThen and AndThen
   * Initial didFail is false
   */
  public static void recordNoElse(final ElseResult result) {
    ResultType _didFail = result.getDidFail();
    boolean _notEquals = (!Objects.equal(_didFail, ResultType.SUCCESS));
    if (_notEquals) {
      result.setDidFail(ResultType.SUCCESS);
      Metrics _metrics = result.getMetrics();
      int _didelseCount = result.getMetrics().getDidelseCount();
      int _minus = (_didelseCount - 1);
      _metrics.setDidelseCount(_minus);
    } else {
    }
  }

  /**
   * the next methods update the counts for FailThen and AndThen
   * returns true if change of state
   */
  public static void recordSkip(final ThenResult result) {
    boolean _isDidThenFail = result.isDidThenFail();
    if (_isDidThenFail) {
    } else {
      result.setDidThenFail(true);
      Metrics _metrics = result.getMetrics();
      int _thenskipCount = result.getMetrics().getThenskipCount();
      int _plus = (_thenskipCount + 1);
      _metrics.setThenskipCount(_plus);
    }
  }

  /**
   * the next methods update the counts for FailThen and AndThen
   */
  public static void recordNoSkip(final ThenResult result) {
    boolean _isDidThenFail = result.isDidThenFail();
    if (_isDidThenFail) {
      result.setDidThenFail(false);
      Metrics _metrics = result.getMetrics();
      int _thenskipCount = result.getMetrics().getThenskipCount();
      int _minus = (_thenskipCount - 1);
      _metrics.setThenskipCount(_minus);
    } else {
    }
  }

  /**
   * set the status and update the counts
   * true if state changed
   */
  private static boolean updateOwnResultState(final VerificationResult ar, final ResultType newState) {
    boolean _xblockexpression = false;
    {
      final Metrics counts = ar.getMetrics();
      ResultType _type = ar.getType();
      boolean _equals = Objects.equal(_type, newState);
      if (_equals) {
        return false;
      }
      if ((Objects.equal(ar.getType(), ResultType.FAILURE) && (!Objects.equal(newState, ResultType.TBD)))) {
        return true;
      }
      if ((Objects.equal(ar.getType(), ResultType.ERROR) && 
        Objects.equal(newState, ResultType.SUCCESS))) {
        return true;
      }
      ResultType _type_1 = ar.getType();
      if (_type_1 != null) {
        switch (_type_1) {
          case SUCCESS:
            int _successCount = counts.getSuccessCount();
            int _minus = (_successCount - 1);
            counts.setSuccessCount(_minus);
            break;
          case FAILURE:
            int _failCount = counts.getFailCount();
            int _minus_1 = (_failCount - 1);
            counts.setFailCount(_minus_1);
            break;
          case ERROR:
            int _errorCount = counts.getErrorCount();
            int _minus_2 = (_errorCount - 1);
            counts.setErrorCount(_minus_2);
            break;
          case TBD:
            int _tbdCount = counts.getTbdCount();
            int _minus_3 = (_tbdCount - 1);
            counts.setTbdCount(_minus_3);
            break;
          default:
            break;
        }
      }
      if (newState != null) {
        switch (newState) {
          case SUCCESS:
            int _successCount_1 = counts.getSuccessCount();
            int _plus = (_successCount_1 + 1);
            counts.setSuccessCount(_plus);
            break;
          case FAILURE:
            int _failCount_1 = counts.getFailCount();
            int _plus_1 = (_failCount_1 + 1);
            counts.setFailCount(_plus_1);
            break;
          case ERROR:
            int _errorCount_1 = counts.getErrorCount();
            int _plus_2 = (_errorCount_1 + 1);
            counts.setErrorCount(_plus_2);
            break;
          case TBD:
            int _tbdCount_1 = counts.getTbdCount();
            int _plus_3 = (_tbdCount_1 + 1);
            counts.setTbdCount(_plus_3);
            break;
          default:
            break;
        }
      }
      ar.setType(newState);
      _xblockexpression = true;
    }
    return _xblockexpression;
  }

  /**
   * Given the state (and count) change to ar, propagate the counts up the hierarchy
   */
  private static void propagateCountChangeUp(final AssureResult ar) {
    EObject parent = ar.eContainer();
    while (((parent != null) && (parent instanceof AssureResult))) {
      {
        final AssureResult parentResult = ((AssureResult) parent);
        AssureUtilExtension.addAllSubCounts(parentResult);
        parent = parent.eContainer();
      }
    }
  }

  /**
   * recompute the result count from the part list counts without recursing
   */
  private static AssuranceCaseResult addAllSubCounts(final AssuranceCaseResult caseResult) {
    AssuranceCaseResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(caseResult);
      final Consumer<ModelResult> _function = (ModelResult e) -> {
        AssureUtilExtension.addTo(e, caseResult);
      };
      caseResult.getModelResult().forEach(_function);
      _xblockexpression = caseResult;
    }
    return _xblockexpression;
  }

  private static ModelResult addAllSubCounts(final ModelResult modelResult) {
    ModelResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(modelResult);
      final Consumer<ClaimResult> _function = (ClaimResult e) -> {
        AssureUtilExtension.addTo(e, modelResult);
      };
      modelResult.getClaimResult().forEach(_function);
      final Consumer<SubsystemResult> _function_1 = (SubsystemResult e) -> {
        AssureUtilExtension.addTo(e, modelResult);
      };
      modelResult.getSubsystemResult().forEach(_function_1);
      _xblockexpression = modelResult;
    }
    return _xblockexpression;
  }

  private static SubsystemResult addAllSubCounts(final SubsystemResult subsystemResult) {
    SubsystemResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(subsystemResult);
      final Consumer<ClaimResult> _function = (ClaimResult e) -> {
        AssureUtilExtension.addTo(e, subsystemResult);
      };
      subsystemResult.getClaimResult().forEach(_function);
      final Consumer<SubsystemResult> _function_1 = (SubsystemResult e) -> {
        AssureUtilExtension.addTo(e, subsystemResult);
      };
      subsystemResult.getSubsystemResult().forEach(_function_1);
      _xblockexpression = subsystemResult;
    }
    return _xblockexpression;
  }

  private static ClaimResult addAllSubCounts(final ClaimResult claimResult) {
    ClaimResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(claimResult);
      final Consumer<VerificationExpr> _function = (VerificationExpr e) -> {
        AssureUtilExtension.addTo(e, claimResult);
      };
      claimResult.getVerificationActivityResult().forEach(_function);
      final Consumer<ClaimResult> _function_1 = (ClaimResult e) -> {
        AssureUtilExtension.addTo(e, claimResult);
      };
      claimResult.getSubClaimResult().forEach(_function_1);
      AssureUtilExtension.addTo(claimResult.getPredicateResult(), claimResult);
      _xblockexpression = claimResult;
    }
    return _xblockexpression;
  }

  private static VerificationActivityResult addAllSubCounts(final VerificationActivityResult vaResult) {
    VerificationActivityResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(vaResult);
      AssureUtilExtension.addTo(vaResult.getPreconditionResult(), vaResult);
      AssureUtilExtension.addPreFailCount(vaResult, vaResult.getPreconditionResult());
      AssureUtilExtension.addOwnResultStateToCount(vaResult);
      AssureUtilExtension.addTo(vaResult.getValidationResult(), vaResult);
      AssureUtilExtension.addValidationFailCount(vaResult, vaResult.getValidationResult());
      _xblockexpression = vaResult;
    }
    return _xblockexpression;
  }

  private static VerificationActivityResult addPreFailCount(final VerificationActivityResult ar, final VerificationResult pre) {
    VerificationActivityResult _xblockexpression = null;
    {
      if ((pre == null)) {
        return ar;
      }
      final Metrics counts = ar.getMetrics();
      ResultType _type = pre.getType();
      if (_type != null) {
        switch (_type) {
          case FAILURE:
            int _preconditionfailCount = counts.getPreconditionfailCount();
            int _plus = (_preconditionfailCount + 1);
            counts.setPreconditionfailCount(_plus);
            break;
          case ERROR:
            int _preconditionfailCount_1 = counts.getPreconditionfailCount();
            int _plus_1 = (_preconditionfailCount_1 + 1);
            counts.setPreconditionfailCount(_plus_1);
            break;
          default:
            break;
        }
      } else {
      }
      _xblockexpression = ar;
    }
    return _xblockexpression;
  }

  private static VerificationActivityResult addValidationFailCount(final VerificationActivityResult ar, final VerificationResult pre) {
    VerificationActivityResult _xblockexpression = null;
    {
      if ((pre == null)) {
        return ar;
      }
      final Metrics counts = ar.getMetrics();
      ResultType _type = pre.getType();
      if (_type != null) {
        switch (_type) {
          case FAILURE:
            int _validationfailCount = counts.getValidationfailCount();
            int _plus = (_validationfailCount + 1);
            counts.setValidationfailCount(_plus);
            break;
          case ERROR:
            int _validationfailCount_1 = counts.getValidationfailCount();
            int _plus_1 = (_validationfailCount_1 + 1);
            counts.setValidationfailCount(_plus_1);
            break;
          default:
            break;
        }
      } else {
      }
      _xblockexpression = ar;
    }
    return _xblockexpression;
  }

  private static ElseResult addAllSubCounts(final ElseResult vaResult) {
    ElseResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(vaResult);
      vaResult.setDidFail(ResultType.SUCCESS);
      final Consumer<VerificationExpr> _function = (VerificationExpr e) -> {
        AssureUtilExtension.addTo(e, vaResult);
      };
      vaResult.getFirst().forEach(_function);
      boolean _isTBD = AssureUtilExtension.isTBD(vaResult.getFirst());
      boolean _not = (!_isTBD);
      if (_not) {
        boolean _isSuccess = AssureUtilExtension.isSuccess(vaResult.getFirst());
        if (_isSuccess) {
          AssureUtilExtension.recordNoElse(vaResult);
        } else {
          boolean _isFailed = AssureUtilExtension.isFailed(vaResult.getFirst());
          if (_isFailed) {
            AssureUtilExtension.recordElse(vaResult, ResultType.FAILURE);
          } else {
            AssureUtilExtension.recordElse(vaResult, ResultType.ERROR);
          }
          final Consumer<VerificationExpr> _function_1 = (VerificationExpr e) -> {
            AssureUtilExtension.addTo(e, vaResult);
          };
          vaResult.getError().forEach(_function_1);
          final Consumer<VerificationExpr> _function_2 = (VerificationExpr e) -> {
            AssureUtilExtension.addTo(e, vaResult);
          };
          vaResult.getFail().forEach(_function_2);
          final Consumer<VerificationExpr> _function_3 = (VerificationExpr e) -> {
            AssureUtilExtension.addTo(e, vaResult);
          };
          vaResult.getTimeout().forEach(_function_3);
        }
      }
      _xblockexpression = vaResult;
    }
    return _xblockexpression;
  }

  private static ThenResult addAllSubCounts(final ThenResult vaResult) {
    ThenResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(vaResult);
      vaResult.setDidThenFail(false);
      final Consumer<VerificationExpr> _function = (VerificationExpr e) -> {
        AssureUtilExtension.addTo(e, vaResult);
      };
      vaResult.getFirst().forEach(_function);
      boolean _isTBD = AssureUtilExtension.isTBD(vaResult.getFirst());
      boolean _not = (!_isTBD);
      if (_not) {
        boolean _isSuccess = AssureUtilExtension.isSuccess(vaResult.getFirst());
        if (_isSuccess) {
          AssureUtilExtension.recordSkip(vaResult);
          final Consumer<VerificationExpr> _function_1 = (VerificationExpr e) -> {
            AssureUtilExtension.addTo(e, vaResult);
          };
          vaResult.getSecond().forEach(_function_1);
        } else {
          AssureUtilExtension.recordNoSkip(vaResult);
        }
      }
      _xblockexpression = vaResult;
    }
    return _xblockexpression;
  }

  private static ValidationResult addAllSubCounts(final ValidationResult validationResult) {
    ValidationResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(validationResult);
      AssureUtilExtension.addOwnResultStateToCount(validationResult);
      _xblockexpression = validationResult;
    }
    return _xblockexpression;
  }

  private static PreconditionResult addAllSubCounts(final PreconditionResult preconditionResult) {
    PreconditionResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(preconditionResult);
      AssureUtilExtension.addOwnResultStateToCount(preconditionResult);
      _xblockexpression = preconditionResult;
    }
    return _xblockexpression;
  }

  private static PredicateResult addAllSubCounts(final PredicateResult predicateResult) {
    PredicateResult _xblockexpression = null;
    {
      AssureUtilExtension.resetCounts(predicateResult);
      AssureUtilExtension.addOwnResultStateToCount(predicateResult);
      _xblockexpression = predicateResult;
    }
    return _xblockexpression;
  }

  private static AssureResult addAllSubCounts(final AssureResult assureResult) {
    AssureResult _switchResult = null;
    boolean _matched = false;
    if (assureResult instanceof AssuranceCaseResult) {
      _matched=true;
      _switchResult = AssureUtilExtension.addAllSubCounts(((AssuranceCaseResult)assureResult));
    }
    if (!_matched) {
      if (assureResult instanceof ModelResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.addAllSubCounts(((ModelResult)assureResult));
      }
    }
    if (!_matched) {
      if (assureResult instanceof SubsystemResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.addAllSubCounts(((SubsystemResult)assureResult));
      }
    }
    if (!_matched) {
      if (assureResult instanceof ClaimResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.addAllSubCounts(((ClaimResult)assureResult));
      }
    }
    if (!_matched) {
      if (assureResult instanceof ValidationResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.addAllSubCounts(((ValidationResult)assureResult));
      }
    }
    if (!_matched) {
      if (assureResult instanceof PreconditionResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.addAllSubCounts(((PreconditionResult)assureResult));
      }
    }
    if (!_matched) {
      if (assureResult instanceof PredicateResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.addAllSubCounts(((PredicateResult)assureResult));
      }
    }
    if (!_matched) {
      if (assureResult instanceof VerificationActivityResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.addAllSubCounts(((VerificationActivityResult)assureResult));
      }
    }
    if (!_matched) {
      if (assureResult instanceof ElseResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.addAllSubCounts(((ElseResult)assureResult));
      }
    }
    if (!_matched) {
      if (assureResult instanceof ThenResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.addAllSubCounts(((ThenResult)assureResult));
      }
    }
    return _switchResult;
  }

  public static String constructLabel(final AssureResult ar) {
    boolean _matched = false;
    if (ar instanceof AssuranceCaseResult) {
      _matched=true;
      return ((AssuranceCaseResult)ar).getName();
    }
    if (!_matched) {
      if (ar instanceof ModelResult) {
        _matched=true;
        return AssureUtilExtension.getName(((ModelResult)ar));
      }
    }
    if (!_matched) {
      if (ar instanceof SubsystemResult) {
        _matched=true;
        return AssureUtilExtension.getName(((SubsystemResult)ar));
      }
    }
    if (!_matched) {
      if (ar instanceof ClaimResult) {
        _matched=true;
        String _elvis = null;
        Requirement _target = AssureUtilExtension.getTarget(((ClaimResult)ar));
        String _title = null;
        if (_target!=null) {
          _title=_target.getTitle();
        }
        if (_title != null) {
          _elvis = _title;
        } else {
          String _name = AssureUtilExtension.getTarget(((ClaimResult)ar)).getName();
          _elvis = _name;
        }
        return _elvis;
      }
    }
    if (!_matched) {
      if (ar instanceof ValidationResult) {
        _matched=true;
        String _elvis = null;
        VerificationMethod _target = ((ValidationResult)ar).getTarget();
        String _title = null;
        if (_target!=null) {
          _title=_target.getTitle();
        }
        if (_title != null) {
          _elvis = _title;
        } else {
          String _name = ((ValidationResult)ar).getTarget().getName();
          _elvis = _name;
        }
        return _elvis;
      }
    }
    if (!_matched) {
      if (ar instanceof PreconditionResult) {
        _matched=true;
        String _elvis = null;
        VerificationMethod _target = ((PreconditionResult)ar).getTarget();
        String _title = null;
        if (_target!=null) {
          _title=_target.getTitle();
        }
        if (_title != null) {
          _elvis = _title;
        } else {
          String _name = ((PreconditionResult)ar).getTarget().getName();
          _elvis = _name;
        }
        return _elvis;
      }
    }
    if (!_matched) {
      if (ar instanceof VerificationActivityResult) {
        _matched=true;
        return AssureUtilExtension.getTarget(((VerificationActivityResult)ar)).getName();
      }
    }
    return "unknown assure result type";
  }

  public static String constructMessage(final VerificationActivityResult vr) {
    String _message = vr.getMessage();
    boolean _tripleNotEquals = (_message != null);
    if (_tripleNotEquals) {
      return vr.getMessage();
    }
    return AssureUtilExtension.constructDescription(vr);
  }

  public static String constructDescription(final VerificationActivityResult vr) {
    final VerificationActivity va = AssureUtilExtension.getTarget(vr);
    if ((va == null)) {
      return "";
    }
    String _title = va.getTitle();
    boolean _tripleNotEquals = (_title != null);
    if (_tripleNotEquals) {
      return va.getTitle();
    }
    final VerificationMethod vm = va.getMethod();
    if ((vm == null)) {
      return "";
    }
    Description _description = vm.getDescription();
    boolean _tripleNotEquals_1 = (_description != null);
    if (_tripleNotEquals_1) {
      return CommonUtilExtension.toText(vm.getDescription(), AssureUtilExtension.getCaseTargetModelElement(vr));
    }
    String _title_1 = vm.getTitle();
    boolean _tripleNotEquals_2 = (_title_1 != null);
    if (_tripleNotEquals_2) {
      return vm.getTitle();
    }
    return "";
  }

  public static String constructMessage(final AssuranceCaseResult ce) {
    String _message = ce.getMessage();
    boolean _tripleNotEquals = (_message != null);
    if (_tripleNotEquals) {
      return ce.getMessage();
    }
    return "";
  }

  public static String constructMessage(final ModelResult ce) {
    String _message = ce.getMessage();
    boolean _tripleNotEquals = (_message != null);
    if (_tripleNotEquals) {
      return ce.getMessage();
    }
    return "";
  }

  public static String constructMessage(final SubsystemResult ce) {
    String _message = ce.getMessage();
    boolean _tripleNotEquals = (_message != null);
    if (_tripleNotEquals) {
      return ce.getMessage();
    }
    return "";
  }

  public static String constructDescription(final ModelResult ar) {
    String _xblockexpression = null;
    {
      final AssurancePlan plan = ar.getPlan();
      if ((plan == null)) {
        return "";
      }
      Description _description = null;
      if (plan!=null) {
        _description=plan.getDescription();
      }
      boolean _tripleNotEquals = (_description != null);
      if (_tripleNotEquals) {
        return CommonUtilExtension.toText(plan.getDescription(), plan.getTarget());
      }
      String _title = plan.getTitle();
      boolean _tripleNotEquals_1 = (_title != null);
      if (_tripleNotEquals_1) {
        return plan.getTitle();
      }
      ComponentImplementation _target = plan.getTarget();
      boolean _tripleEquals = (_target == null);
      if (_tripleEquals) {
        return "";
      }
      String _qualifiedName = plan.getTarget().getQualifiedName();
      _xblockexpression = ("Verified component implementation " + _qualifiedName);
    }
    return _xblockexpression;
  }

  public static String successToString(final AssureResult ar) {
    final int cnt = ar.getMetrics().getSuccessCount();
    if ((cnt == 0)) {
      return "";
    }
    return Integer.valueOf(cnt).toString();
  }

  public static String failToString(final AssureResult ar) {
    final int cnt = ar.getMetrics().getFailCount();
    if ((cnt == 0)) {
      return "";
    }
    return Integer.valueOf(cnt).toString();
  }

  public static String errorToString(final AssureResult ar) {
    final int cnt = ar.getMetrics().getErrorCount();
    if ((cnt == 0)) {
      return "";
    }
    return Integer.valueOf(cnt).toString();
  }

  public static String tbdToString(final AssureResult ar) {
    final int cnt = ar.getMetrics().getTbdCount();
    if ((cnt == 0)) {
      return "";
    }
    return Integer.valueOf(cnt).toString();
  }

  public static String getName(final VerificationActivityResult cr) {
    boolean _isNull = Aadl2Util.isNull(AssureUtilExtension.getTarget(cr));
    boolean _not = (!_isNull);
    if (_not) {
      VerificationActivity _target = AssureUtilExtension.getTarget(cr);
      String _name = null;
      if (_target!=null) {
        _name=_target.getName();
      }
      return _name;
    }
    String _string = AssureUtilExtension.getTarget(cr).toString();
    String _plus = ("[unresolved:" + _string);
    return (_plus + "]");
  }

  public static String getName(final ValidationResult cr) {
    boolean _isNull = Aadl2Util.isNull(cr.getTarget());
    boolean _not = (!_isNull);
    if (_not) {
      VerificationMethod _target = cr.getTarget();
      String _name = null;
      if (_target!=null) {
        _name=_target.getName();
      }
      return _name;
    }
    String _string = cr.getTarget().toString();
    String _plus = ("[unresolved:" + _string);
    return (_plus + "]");
  }

  public static String getName(final PreconditionResult cr) {
    boolean _isNull = Aadl2Util.isNull(cr.getTarget());
    boolean _not = (!_isNull);
    if (_not) {
      VerificationMethod _target = cr.getTarget();
      String _name = null;
      if (_target!=null) {
        _name=_target.getName();
      }
      return _name;
    }
    String _string = cr.getTarget().toString();
    String _plus = ("[unresolved:" + _string);
    return (_plus + "]");
  }

  public static String getName(final AssuranceCaseResult ce) {
    return ce.getName();
  }

  public static String getName(final ModelResult ce) {
    String _name = AssureUtilExtension.getAssuranceCaseResult(ce).getName();
    String _plus = (_name + ".");
    String _name_1 = ce.getPlan().getName();
    String _plus_1 = (_plus + _name_1);
    String _plus_2 = (_plus_1 + "(");
    String _name_2 = ce.getTarget().getName();
    String _plus_3 = (_plus_2 + _name_2);
    return (_plus_3 + ")");
  }

  public static String getName(final SubsystemResult ce) {
    return ce.getTargetSystem().getName();
  }

  public static String getName(final ClaimResult cr) {
    final NamedElement me = AssureUtilExtension.getCaseTargetModelElement(cr);
    String _xifexpression = null;
    if ((me != null)) {
      String _name = me.getName();
      String _plus = ("(" + _name);
      _xifexpression = (_plus + ")");
    } else {
      _xifexpression = "";
    }
    final String targetElementLabel = _xifexpression;
    boolean _isNull = Aadl2Util.isNull(AssureUtilExtension.getTarget(cr));
    boolean _not = (!_isNull);
    if (_not) {
      Requirement _target = AssureUtilExtension.getTarget(cr);
      String _name_1 = null;
      if (_target!=null) {
        _name_1=_target.getName();
      }
      return (_name_1 + targetElementLabel);
    }
    String _string = AssureUtilExtension.getTarget(cr).toString();
    String _plus_1 = ("[unresolved:" + _string);
    String _plus_2 = (_plus_1 + "]");
    return (_plus_2 + targetElementLabel);
  }

  public static String constructDescription(final ClaimResult cr) {
    String _xblockexpression = null;
    {
      final Requirement r = AssureUtilExtension.getTarget(cr);
      if ((r == null)) {
        return "";
      }
      SystemInstance instanceroot = AssureUtilExtension.getExistingAssuranceCaseInstanceModel(cr);
      final NamedElement targetElement = AssureUtilExtension.getCaseTargetModelElement(cr);
      NamedElement target = targetElement;
      if ((instanceroot != null)) {
        final ComponentInstance targetComponent = AssureUtilExtension.findTargetSystemComponentInstance(instanceroot, AssureUtilExtension.getEnclosingSubsystemResult(cr));
        if ((targetComponent != null)) {
          if (((targetElement != null) && (targetElement.getName() != null))) {
            target = CommonUtilExtension.findElementInstance(targetComponent, targetElement);
          } else {
            target = targetComponent;
          }
        }
      } else {
        if (((targetElement != null) && (targetElement.getName() != null))) {
          target = targetElement;
        } else {
          ModelResult _modelResult = AssureUtilExtension.getModelResult(cr);
          ComponentImplementation _target = null;
          if (_modelResult!=null) {
            _target=_modelResult.getTarget();
          }
          target = _target;
        }
      }
      if (((r.getDescription() != null) && (target != null))) {
        return CommonUtilExtension.toText(r.getDescription(), target);
      }
      String _title = r.getTitle();
      boolean _tripleNotEquals = (_title != null);
      if (_tripleNotEquals) {
        return r.getTitle();
      }
      _xblockexpression = "";
    }
    return _xblockexpression;
  }

  public static String constructMessage(final ClaimResult cr) {
    String _xblockexpression = null;
    {
      String _message = cr.getMessage();
      boolean _tripleNotEquals = (_message != null);
      if (_tripleNotEquals) {
        return cr.getMessage();
      }
      _xblockexpression = AssureUtilExtension.constructDescription(cr);
    }
    return _xblockexpression;
  }

  public static String constructMessage(final ValidationResult cr) {
    String _xblockexpression = null;
    {
      String _message = cr.getMessage();
      boolean _tripleNotEquals = (_message != null);
      if (_tripleNotEquals) {
        return cr.getMessage();
      }
      _xblockexpression = "";
    }
    return _xblockexpression;
  }

  public static String constructMessage(final PreconditionResult cr) {
    String _xblockexpression = null;
    {
      String _message = cr.getMessage();
      boolean _tripleNotEquals = (_message != null);
      if (_tripleNotEquals) {
        return cr.getMessage();
      }
      _xblockexpression = "";
    }
    return _xblockexpression;
  }

  public static String constructMessage(final Diagnostic ri) {
    String _xblockexpression = null;
    {
      String _message = ri.getMessage();
      boolean _tripleNotEquals = (_message != null);
      if (_tripleNotEquals) {
        return ri.getMessage();
      }
      _xblockexpression = "";
    }
    return _xblockexpression;
  }

  public static String constructMessage(final Result ri) {
    String _xblockexpression = null;
    {
      String _message = ri.getMessage();
      boolean _tripleNotEquals = (_message != null);
      if (_tripleNotEquals) {
        return ri.getMessage();
      }
      _xblockexpression = "";
    }
    return _xblockexpression;
  }

  /**
   * @since 2.0
   */
  public static String constructMessage(final AnalysisResult ri) {
    String _analysis = ri.getAnalysis();
    String _plus = (_analysis + ": ");
    String _xifexpression = null;
    String _message = ri.getMessage();
    boolean _tripleNotEquals = (_message != null);
    if (_tripleNotEquals) {
      _xifexpression = ri.getMessage();
    } else {
      _xifexpression = "";
    }
    String _plus_1 = (_plus + _xifexpression);
    String _plus_2 = (_plus_1 + " for ");
    EObject _modelElement = ri.getModelElement();
    String _name = ((NamedElement) _modelElement).getName();
    return (_plus_2 + _name);
  }

  public static String constructMessage(final PredicateResult pr) {
    final ValuePredicate pred = AssureUtilExtension.getPredicate(pr);
    if ((pred != null)) {
      String _xtrycatchfinallyexpression = null;
      try {
        Resource _eResource = pred.eResource();
        _xtrycatchfinallyexpression = ((XtextResource) _eResource).getSerializer().serialize(pred.getXpression());
      } catch (final Throwable _t) {
        if (_t instanceof NullPointerException) {
          _xtrycatchfinallyexpression = "<none>";
        } else {
          throw Exceptions.sneakyThrow(_t);
        }
      }
      final String predstring = _xtrycatchfinallyexpression;
      return predstring;
    }
    return "";
  }

  public static String assureExecutionTime(final AssureResult ele) {
    String _xblockexpression = null;
    {
      final Metrics elec = ele.getMetrics();
      long _executionTime = elec.getExecutionTime();
      String _plus = ("(" + Long.valueOf(_executionTime));
      _xblockexpression = (_plus + " ms)");
    }
    return _xblockexpression;
  }

  public static String buildCaseModelElementPath(final AssureResult ar) {
    String _switchResult = null;
    boolean _matched = false;
    if (ar instanceof SubsystemResult) {
      _matched=true;
      EObject _eContainer = ((SubsystemResult)ar).eContainer();
      String _buildCaseModelElementPath = AssureUtilExtension.buildCaseModelElementPath(((AssureResult) _eContainer));
      String _plus = (_buildCaseModelElementPath + ".");
      Subcomponent _targetSystem = ((SubsystemResult)ar).getTargetSystem();
      String _name = null;
      if (_targetSystem!=null) {
        _name=_targetSystem.getName();
      }
      _switchResult = (_plus + _name);
    }
    if (!_matched) {
      if (ar instanceof ModelResult) {
        _matched=true;
        _switchResult = ((ModelResult)ar).getTarget().getQualifiedName();
      }
    }
    if (!_matched) {
      if (ar instanceof ClaimResult) {
        _matched=true;
        String _xblockexpression = null;
        {
          EObject _eContainer = ((ClaimResult)ar).eContainer();
          final String res = AssureUtilExtension.buildCaseModelElementPath(((AssureResult) _eContainer));
          String _xifexpression = null;
          EObject _eContainer_1 = ((ClaimResult)ar).eContainer();
          if ((_eContainer_1 instanceof ClaimResult)) {
            _xifexpression = res;
          } else {
            String _xifexpression_1 = null;
            NamedElement _modelElement = ((ClaimResult)ar).getModelElement();
            boolean _tripleNotEquals = (_modelElement != null);
            if (_tripleNotEquals) {
              String _name = ((ClaimResult)ar).getModelElement().getName();
              _xifexpression_1 = ((res + ".") + _name);
            } else {
              _xifexpression_1 = res;
            }
            _xifexpression = _xifexpression_1;
          }
          _xblockexpression = _xifexpression;
        }
        _switchResult = _xblockexpression;
      }
    }
    if (!_matched) {
      if (ar instanceof VerificationResult) {
        _matched=true;
        _switchResult = AssureUtilExtension.buildCaseModelElementPath(AssureUtilExtension.getClaimResult(ar));
      }
    }
    if (!_matched) {
      if (ar instanceof AssuranceCaseResult) {
        _matched=true;
        _switchResult = "";
      }
    }
    return _switchResult;
  }

  private static final Map<Object, Object> instanceModelRecord = Collections.<Object, Object>synchronizedMap(CollectionLiterals.<Object, Object>newHashMap());

  public static void setInstanceModel(final ComponentImplementation key, final SystemInstance target) {
    AssureUtilExtension.instanceModelRecord.put(key.getName(), target);
  }

  public static void clearAllInstanceModels() {
    AssureUtilExtension.instanceModelRecord.clear();
  }

  public static SystemInstance getInstanceModel(final ComponentImplementation cimpl, final boolean save) {
    try {
      boolean _isNull = Aadl2Util.isNull(cimpl);
      if (_isNull) {
        return null;
      }
      Object _get = AssureUtilExtension.instanceModelRecord.get(cimpl.getName());
      SystemInstance si = ((SystemInstance) _get);
      if ((si == null)) {
        si = InstantiateModel.instantiate(cimpl);
        if ((save && (si.eResource() != null))) {
          si.eResource().save(null);
        }
        AssureUtilExtension.setInstanceModel(cimpl, si);
      }
      return si;
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }

  public static SystemInstance getExistingInstanceModel(final ComponentImplementation cimpl) {
    boolean _isNull = Aadl2Util.isNull(cimpl);
    if (_isNull) {
      return null;
    }
    Object _get = AssureUtilExtension.instanceModelRecord.get(cimpl.getName());
    return ((SystemInstance) _get);
  }

  public static int numberVerificationResults(final AssuranceCaseResult ac) {
    return EcoreUtil2.<VerificationActivityResult>eAllOfType(ac, VerificationActivityResult.class).size();
  }

  /**
   * convert to target unit. If target unit is null or number value has no unit return the original
   */
  public static NumberValue convertValueToUnit(final NumberValue numberValue, final UnitLiteral target) {
    final UnitLiteral unit = numberValue.getUnit();
    if (((unit == null) || (target == null))) {
      return numberValue;
    }
    final double value = AssureUtilExtension.getValue(numberValue);
    final double factor = unit.getAbsoluteFactor(target);
    final double result = (value * factor);
    final NumberValue resultValue = numberValue.cloneNumber();
    resultValue.setUnit(target);
    AssureUtilExtension.setValue(resultValue, result);
    return resultValue;
  }

  public static void setValue(final NumberValue numberValue, final double value) {
    boolean _matched = false;
    if (numberValue instanceof RealLiteral) {
      _matched=true;
      ((RealLiteral)numberValue).setValue(value);
    }
    if (!_matched) {
      if (numberValue instanceof IntegerLiteral) {
        _matched=true;
        ((IntegerLiteral)numberValue).setValue(((long) value));
      }
    }
  }

  public static double getValue(final NumberValue numberValue) {
    double _switchResult = (double) 0;
    boolean _matched = false;
    if (numberValue instanceof RealLiteral) {
      _matched=true;
      _switchResult = ((RealLiteral)numberValue).getValue();
    }
    if (!_matched) {
      if (numberValue instanceof IntegerLiteral) {
        _matched=true;
        _switchResult = ((IntegerLiteral)numberValue).getValue();
      }
    }
    return _switchResult;
  }

  public static boolean containsComputeVariables(final ValuePredicate predicate) {
    boolean _xblockexpression = false;
    {
      final List<AVariableReference> varrefs = EcoreUtil2.<AVariableReference>getAllContentsOfType(predicate, AVariableReference.class);
      for (final AVariableReference varref : varrefs) {
        AVariableDeclaration _variable = varref.getVariable();
        if ((_variable instanceof ComputeDeclaration)) {
          return true;
        }
      }
      _xblockexpression = false;
    }
    return _xblockexpression;
  }
}