AssureProcessor.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.evaluator;
import com.google.common.base.Objects;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.xsemantics.runtime.Result;
import org.eclipse.xsemantics.runtime.RuleEnvironment;
import org.eclipse.xtend.lib.annotations.AccessorType;
import org.eclipse.xtend.lib.annotations.Accessors;
import org.eclipse.xtext.resource.IResourceServiceProvider;
import org.eclipse.xtext.xbase.lib.Conversions;
import org.eclipse.xtext.xbase.lib.Exceptions;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure0;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.junit.runner.JUnitCore;
import org.osate.aadl2.Aadl2Factory;
import org.osate.aadl2.AadlBoolean;
import org.osate.aadl2.AadlInteger;
import org.osate.aadl2.AadlReal;
import org.osate.aadl2.AadlString;
import org.osate.aadl2.BooleanLiteral;
import org.osate.aadl2.IntegerLiteral;
import org.osate.aadl2.ModalPropertyValue;
import org.osate.aadl2.NamedElement;
import org.osate.aadl2.NumberValue;
import org.osate.aadl2.Property;
import org.osate.aadl2.PropertyAssociation;
import org.osate.aadl2.PropertyExpression;
import org.osate.aadl2.PropertyType;
import org.osate.aadl2.PropertyValue;
import org.osate.aadl2.RealLiteral;
import org.osate.aadl2.StringLiteral;
import org.osate.aadl2.UnitLiteral;
import org.osate.aadl2.instance.ComponentInstance;
import org.osate.aadl2.instance.ConnectionInstance;
import org.osate.aadl2.instance.EndToEndFlowInstance;
import org.osate.aadl2.instance.InstanceObject;
import org.osate.aadl2.instance.InstanceReferenceValue;
import org.osate.aadl2.instance.SystemInstance;
import org.osate.aadl2.properties.PropertyNotPresentException;
import org.osate.alisa.common.common.AModelReference;
import org.osate.alisa.common.common.CommonFactory;
import org.osate.alisa.common.common.TargetType;
import org.osate.alisa.common.common.TypeRef;
import org.osate.alisa.common.typing.CommonInterpreter;
import org.osate.alisa.common.util.CommonUtilExtension;
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.PreconditionResult;
import org.osate.assure.assure.PredicateResult;
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.assure.util.AssureUtilExtension;
import org.osate.categories.categories.CategoryFilter;
import org.osate.pluginsupport.ExecuteJavaUtil;
import org.osate.reqspec.reqSpec.ReqPredicate;
import org.osate.reqspec.reqSpec.ValuePredicate;
import org.osate.resolute.ResoluteUtil;
import org.osate.result.AnalysisResult;
import org.osate.result.BooleanValue;
import org.osate.result.Diagnostic;
import org.osate.result.DiagnosticType;
import org.osate.result.IntegerValue;
import org.osate.result.RealValue;
import org.osate.result.ResultFactory;
import org.osate.result.ResultType;
import org.osate.result.StringValue;
import org.osate.result.Value;
import org.osate.result.util.ResultUtil;
import org.osate.verify.internal.util.VerificationMethodDispatchers;
import org.osate.verify.internal.util.VerifyJavaUtil;
import org.osate.verify.internal.util.VerifyUtilExtension;
import org.osate.verify.verify.AgreeMethod;
import org.osate.verify.verify.ComputeRef;
import org.osate.verify.verify.FormalParameter;
import org.osate.verify.verify.JUnit4Method;
import org.osate.verify.verify.JavaMethod;
import org.osate.verify.verify.ManualMethod;
import org.osate.verify.verify.MethodKind;
import org.osate.verify.verify.PluginMethod;
import org.osate.verify.verify.PythonMethod;
import org.osate.verify.verify.ResoluteMethod;
import org.osate.verify.verify.VerificationMethod;
import org.osate.xtext.aadl2.properties.util.PropertyUtils;
/**
* performs the processing of verification activities
* records the result propagating up the counts
* Will process only those that are TBD
* It assumes the counts are ok
*/
@SuppressWarnings("all")
public class AssureProcessor implements IAssureProcessor {
private CommonInterpreter interpreter = IResourceServiceProvider.Registry.INSTANCE.getResourceServiceProvider(
URI.createFileURI("dummy.___common___")).<CommonInterpreter>get(CommonInterpreter.class);
private IProgressMonitor progressmonitor = new NullProgressMonitor();
@Accessors(AccessorType.PUBLIC_SETTER)
private Procedure1<? super URI> progressUpdater;
@Accessors(AccessorType.PUBLIC_SETTER)
private Procedure0 requirementsCoverageUpdater;
private final RuleEnvironment env = new RuleEnvironment();
private final HashMap<String, PropertyExpression> computes = new HashMap<String, PropertyExpression>();
private final HashMap<String, Object> vals = new HashMap<String, Object>();
private long start = 0;
private CategoryFilter filter;
private boolean save = true;
public AssureProcessor() {
this.env.add("vals", this.vals);
this.env.add("computes", this.computes);
}
public void startSubTask(final VerificationActivityResult vaResult) {
this.progressmonitor.subTask(AssureUtilExtension.getTarget(vaResult).getName());
this.start = System.currentTimeMillis();
}
public void doneSubTask(final VerificationActivityResult vaResult) {
this.progressmonitor.worked(1);
final long stop = System.currentTimeMillis();
Metrics _metrics = vaResult.getMetrics();
_metrics.setExecutionTime((stop - this.start));
}
@Override
public void processCase(final AssuranceCaseResult assureResult, final CategoryFilter filter, final IProgressMonitor monitor, final boolean save) {
this.progressmonitor = monitor;
this.filter = filter;
this.save = save;
final int count = AssureUtilExtension.numberVerificationResults(assureResult);
try {
this.progressmonitor.beginTask(assureResult.getName(), count);
this.process(assureResult);
} finally {
this.saveAssureResult(assureResult);
this.progressmonitor.done();
}
this.updateRequirementsCoverage();
}
public void saveAssureResult(final AssureResult assureResult) {
try {
if ((this.save && (assureResult.eResource() != null))) {
assureResult.eResource().save(null);
}
} catch (Throwable _e) {
throw Exceptions.sneakyThrow(_e);
}
}
protected void _process(final AssuranceCaseResult caseResult) {
final Consumer<ModelResult> _function = (ModelResult modelResult) -> {
this.process(modelResult);
};
caseResult.getModelResult().forEach(_function);
}
protected void _process(final ModelResult modelResult) {
final Consumer<ClaimResult> _function = (ClaimResult claimResult) -> {
this.process(claimResult);
};
modelResult.getClaimResult().forEach(_function);
final Consumer<SubsystemResult> _function_1 = (SubsystemResult claimResult) -> {
this.process(claimResult);
};
modelResult.getSubsystemResult().forEach(_function_1);
final Consumer<AssuranceCaseResult> _function_2 = (AssuranceCaseResult subcaseResult) -> {
this.process(subcaseResult);
};
modelResult.getSubAssuranceCase().forEach(_function_2);
}
protected void _process(final SubsystemResult caseResult) {
final Consumer<ClaimResult> _function = (ClaimResult claimResult) -> {
this.process(claimResult);
};
caseResult.getClaimResult().forEach(_function);
final Consumer<SubsystemResult> _function_1 = (SubsystemResult subcaseResult) -> {
this.process(subcaseResult);
};
caseResult.getSubsystemResult().forEach(_function_1);
}
protected void _process(final ClaimResult claimResult) {
boolean _evaluateRequirementFilter = VerifyUtilExtension.evaluateRequirementFilter(claimResult.getTargetReference().getRequirement().getRequirement(), this.filter);
if (_evaluateRequirementFilter) {
this.vals.clear();
this.computes.clear();
final Consumer<VerificationExpr> _function = (VerificationExpr vaResult) -> {
this.process(vaResult);
};
claimResult.getVerificationActivityResult().forEach(_function);
VerificationResult _predicateResult = claimResult.getPredicateResult();
if (_predicateResult!=null) {
this.process(_predicateResult);
}
final Consumer<ClaimResult> _function_1 = (ClaimResult subclaimResult) -> {
this.process(subclaimResult);
};
claimResult.getSubClaimResult().forEach(_function_1);
}
}
protected void _process(final VerificationActivityResult vaResult) {
if ((VerifyUtilExtension.evaluateVerificationActivityFilter(vaResult.getTargetReference().getVerificationActivity(), this.filter) &&
VerifyUtilExtension.evaluateVerificationMethodFilter(vaResult.getTargetReference().getVerificationActivity(), this.filter))) {
this.startSubTask(vaResult);
VerificationResult _preconditionResult = vaResult.getPreconditionResult();
boolean _tripleNotEquals = (_preconditionResult != null);
if (_tripleNotEquals) {
this.process(vaResult.getPreconditionResult());
boolean _isSuccess = AssureUtilExtension.isSuccess(vaResult.getPreconditionResult());
boolean _not = (!_isSuccess);
if (_not) {
this.doneSubTask(vaResult);
return;
}
}
this.runVerificationMethod(vaResult);
VerificationResult _validationResult = vaResult.getValidationResult();
boolean _tripleNotEquals_1 = (_validationResult != null);
if (_tripleNotEquals_1) {
this.process(vaResult.getValidationResult());
}
this.doneSubTask(vaResult);
}
}
protected void _process(final ElseResult vaResult) {
final Consumer<VerificationExpr> _function = (VerificationExpr expr) -> {
this.process(expr);
};
vaResult.getFirst().forEach(_function);
boolean _hasError = AssureUtilExtension.hasError(vaResult.getFirst());
if (_hasError) {
AssureUtilExtension.recordElse(vaResult, ResultType.ERROR);
final Consumer<VerificationExpr> _function_1 = (VerificationExpr expr) -> {
this.process(expr);
};
vaResult.getError().forEach(_function_1);
} else {
boolean _isFailed = AssureUtilExtension.isFailed(vaResult.getFirst());
if (_isFailed) {
AssureUtilExtension.recordElse(vaResult, ResultType.FAILURE);
final Consumer<VerificationExpr> _function_2 = (VerificationExpr expr) -> {
this.process(expr);
};
vaResult.getFail().forEach(_function_2);
} else {
AssureUtilExtension.recordNoElse(vaResult);
}
}
}
protected void _process(final ThenResult vaResult) {
final Consumer<VerificationExpr> _function = (VerificationExpr expr) -> {
this.process(expr);
};
vaResult.getFirst().forEach(_function);
boolean _isSuccess = AssureUtilExtension.isSuccess(vaResult.getFirst());
if (_isSuccess) {
AssureUtilExtension.recordNoSkip(vaResult);
final Consumer<VerificationExpr> _function_1 = (VerificationExpr expr) -> {
this.process(expr);
};
vaResult.getSecond().forEach(_function_1);
} else {
AssureUtilExtension.recordSkip(vaResult);
}
}
protected void _process(final ValidationResult validationResult) {
this.runVerificationMethod(validationResult);
}
protected void _process(final PreconditionResult preconditionResult) {
this.runVerificationMethod(preconditionResult);
}
protected void _process(final PredicateResult predicateResult) {
this.runVerificationMethod(predicateResult);
}
/**
* who needs to understand the method types?
* the runVerificationMethod dispatcher may do different catch methods
* The dispatchVerificationMethod may know from its label what type it is.
* The methods are expected to return boolean for predicate,
* null or bool for analysis with results in marker/diagnostic, or the result report object
*/
public void runVerificationMethod(final VerificationResult verificationResult) {
boolean _isCanceled = this.progressmonitor.isCanceled();
if (_isCanceled) {
throw new OperationCanceledException();
}
VerificationMethod method = AssureUtilExtension.getMethod(verificationResult);
SystemInstance instanceroot = AssureUtilExtension.getAssuranceCaseInstanceModel(verificationResult, this.save);
if ((instanceroot == null)) {
AssureUtilExtension.setToError(verificationResult, "Could not find instance model", null);
this.saveAssureResult(verificationResult);
this.updateProgress(verificationResult);
return;
}
ComponentInstance targetComponent = instanceroot;
targetComponent = AssureUtilExtension.findTargetSystemComponentInstance(instanceroot, AssureUtilExtension.getEnclosingSubsystemResult(verificationResult));
if ((targetComponent == null)) {
AssureUtilExtension.setToError(verificationResult, "Unresolved target system for claim", null);
this.saveAssureResult(verificationResult);
this.updateProgress(verificationResult);
return;
}
final NamedElement targetElement = AssureUtilExtension.getCaseTargetModelElement(verificationResult);
InstanceObject target = targetComponent;
if (((targetElement != null) && (targetElement.getName() != null))) {
target = CommonUtilExtension.findElementInstance(targetComponent, targetElement);
if ((target == null)) {
AssureUtilExtension.setToError(verificationResult, "Unresolved target model element in instance for claim", targetElement);
this.saveAssureResult(verificationResult);
this.updateProgress(verificationResult);
return;
}
}
this.env.add("target", target);
if ((verificationResult instanceof PredicateResult)) {
this.evaluatePredicate(((PredicateResult)verificationResult));
this.saveAssureResult(verificationResult);
this.updateProgress(verificationResult);
return;
}
Iterable<? extends EObject> parameters = null;
if ((verificationResult instanceof VerificationActivityResult)) {
parameters = AssureUtilExtension.getTarget(((VerificationActivityResult)verificationResult)).getActuals();
} else {
if ((verificationResult instanceof ValidationResult)) {
parameters = method.getValidation().getParameters();
method = method.getValidation().getMethod();
} else {
if ((verificationResult instanceof PreconditionResult)) {
parameters = method.getPrecondition().getParameters();
method = method.getPrecondition().getMethod();
}
}
}
int _size = IterableExtensions.size(parameters);
int _size_1 = method.getFormals().size();
boolean _lessThan = (_size < _size_1);
if (_lessThan) {
AssureUtilExtension.setToError(verificationResult, "Fewer actual parameters than formal parameters for verification activity",
null);
this.saveAssureResult(verificationResult);
this.updateProgress(verificationResult);
return;
}
final int nbParams = method.getFormals().size();
int i = 0;
int _size_2 = IterableExtensions.size(parameters);
List<PropertyExpression> parameterObjects = new ArrayList<PropertyExpression>(_size_2);
for (final EObject p : parameters) {
{
PropertyExpression exp = null;
if ((p instanceof FormalParameter)) {
EObject _eContainer = verificationResult.eContainer();
final VerificationActivityResult varesult = ((VerificationActivityResult) _eContainer);
final EList<PropertyExpression> aps = AssureUtilExtension.getTarget(varesult).getActuals();
final int idx = method.getFormals().indexOf(p);
if ((idx >= 0)) {
exp = aps.get(idx);
} else {
String _name = ((FormalParameter)p).getName();
String _plus = ("Referenced formal parameter " + _name);
String _plus_1 = (_plus + " of method ");
String _name_1 = method.getName();
String _plus_2 = (_plus_1 + _name_1);
String _plus_3 = (_plus_2 +
" does not have an actual value");
AssureUtilExtension.setToError(verificationResult, _plus_3, null);
this.saveAssureResult(verificationResult);
this.updateProgress(verificationResult);
return;
}
} else {
if ((p instanceof PropertyExpression)) {
exp = ((PropertyExpression)p);
} else {
FormalParameter formalParam = method.getFormals().get(i);
String _name_2 = formalParam.getName();
String _plus_4 = ("Actual parameter for " + _name_2);
String _plus_5 = (_plus_4 + " of method ");
String _name_3 = method.getName();
String _plus_6 = (_plus_5 + _name_3);
String _plus_7 = (_plus_6 +
" does not have an actual value");
AssureUtilExtension.setToError(verificationResult, _plus_7, null);
this.saveAssureResult(verificationResult);
this.updateProgress(verificationResult);
return;
}
}
final Result<PropertyValue> result = this.interpreter.interpretExpression(this.env, exp);
boolean _failed = result.failed();
if (_failed) {
FormalParameter formalParam_1 = method.getFormals().get(i);
String _name_4 = formalParam_1.getName();
String _plus_8 = ("Could not evaluate expression for " + _name_4);
String _plus_9 = (_plus_8 + " of method ");
String _name_5 = method.getName();
String _plus_10 = (_plus_9 + _name_5);
String _plus_11 = (_plus_10 + ": ");
String _failedMsg = CommonUtilExtension.getFailedMsg(result.getRuleFailedException());
String _plus_12 = (_plus_11 + _failedMsg);
AssureUtilExtension.setToError(verificationResult, _plus_12, null);
this.saveAssureResult(verificationResult);
this.updateProgress(verificationResult);
return;
}
PropertyValue actual = result.getValue();
if ((i < nbParams)) {
FormalParameter formalParam_2 = method.getFormals().get(i);
i = (i + 1);
if ((actual instanceof NumberValue)) {
if ((((formalParam_2.getUnit() != null) && (((NumberValue)actual).getUnit() != null)) &&
(!formalParam_2.getUnit().getName().equals(((NumberValue)actual).getUnit().getName())))) {
actual = AssureUtilExtension.convertValueToUnit(((NumberValue)actual), formalParam_2.getUnit());
}
}
parameterObjects.add(actual);
}
}
}
try {
final MethodKind methodtype = method.getMethodKind();
boolean _matched = false;
if (methodtype instanceof PluginMethod) {
_matched=true;
final Object res = VerificationMethodDispatchers.eInstance.dispatchVerificationMethod(((PluginMethod)methodtype), instanceroot, parameterObjects);
if ((res instanceof String)) {
final String result = ((String)res);
if ((target instanceof ConnectionInstance)) {
final Collection<ConnectionInstance> conns = CommonUtilExtension.findConnectionInstances(targetComponent.getConnectionInstances(), ((ConnectionInstance)target));
for (final ConnectionInstance conni : conns) {
AssureUtilExtension.addMarkersAsResult(verificationResult, conni, result, method);
}
} else {
if ((target instanceof EndToEndFlowInstance)) {
final Collection<EndToEndFlowInstance> etefis = CommonUtilExtension.findETEFInstances(targetComponent.getEndToEndFlows(), ((EndToEndFlowInstance)target));
for (final EndToEndFlowInstance etefi : etefis) {
AssureUtilExtension.addMarkersAsResult(verificationResult, etefi, result, method);
}
} else {
AssureUtilExtension.addMarkersAsResult(verificationResult, target, result, method);
}
}
} else {
if ((res instanceof AnalysisResult)) {
boolean foundResult = false;
EList<org.osate.result.Result> _results = ((AnalysisResult)res).getResults();
for (final org.osate.result.Result r : _results) {
if (((r.getModelElement() == target) || this.matchEnclosingComponentInstance(r, target))) {
foundResult = true;
final EList<Diagnostic> issues = r.getDiagnostics();
boolean _isError = AssureUtilExtension.isError(verificationResult);
if (_isError) {
} else {
boolean _isResultError = ResultUtil.isResultError(r);
if (_isResultError) {
AssureUtilExtension.setToError(verificationResult);
} else {
boolean _isResultFailure = ResultUtil.isResultFailure(r);
if (_isResultFailure) {
AssureUtilExtension.setToFail(verificationResult);
} else {
AssureUtilExtension.setToSuccess(verificationResult);
}
}
}
for (final Diagnostic issue : issues) {
{
final Diagnostic c = EcoreUtil.<Diagnostic>copy(issue);
verificationResult.getIssues().add(c);
}
}
}
}
EList<Diagnostic> _diagnostics = ((AnalysisResult)res).getDiagnostics();
for (final Diagnostic issue_1 : _diagnostics) {
{
final Diagnostic c = EcoreUtil.<Diagnostic>copy(issue_1);
verificationResult.getIssues().add(c);
}
}
if ((!foundResult)) {
String _name = target.getName();
String _plus = ("No Result found for requirement verification target " + _name);
AssureUtilExtension.setToError(verificationResult, _plus, target);
}
} else {
if ((res instanceof org.osate.result.Result)) {
EObject _modelElement = ((org.osate.result.Result)res).getModelElement();
boolean _tripleEquals = (_modelElement == target);
if (_tripleEquals) {
final EList<Diagnostic> issues_1 = ((org.osate.result.Result)res).getDiagnostics();
boolean _isResultError_1 = ResultUtil.isResultError(((org.osate.result.Result)res));
if (_isResultError_1) {
AssureUtilExtension.setToError(verificationResult);
} else {
boolean _isResultFailure_1 = ResultUtil.isResultFailure(((org.osate.result.Result)res));
if (_isResultFailure_1) {
AssureUtilExtension.setToFail(verificationResult);
} else {
AssureUtilExtension.setToSuccess(verificationResult);
}
}
for (final Diagnostic issue_2 : issues_1) {
{
final Diagnostic c = EcoreUtil.<Diagnostic>copy(issue_2);
verificationResult.getIssues().add(c);
}
}
} else {
String _name_1 = target.getName();
String _plus_1 = ("Result is not for requirement verification target " + _name_1);
AssureUtilExtension.setToError(verificationResult, _plus_1, target);
}
} else {
AssureUtilExtension.setToError(verificationResult,
"Analysis return type is not a string, Result, or AnalysisResult", targetComponent);
}
}
}
}
if (!_matched) {
if (methodtype instanceof AgreeMethod) {
_matched=true;
AssureUtilExtension.setToError(verificationResult, "Execution of AGREE methods is not supported");
}
}
if (!_matched) {
if (methodtype instanceof JUnit4Method) {
_matched=true;
final Class<?> test = ExecuteJavaUtil.getJavaClass(((JUnit4Method)methodtype).getClassPath());
final JUnitCore junit = new JUnitCore();
final org.junit.runner.Result result = junit.run(test);
int _failureCount = result.getFailureCount();
boolean _equals = (_failureCount == 0);
if (_equals) {
AssureUtilExtension.setToSuccess(verificationResult);
} else {
final org.osate.result.Result proveri = ResultFactory.eINSTANCE.createResult();
AssureUtilExtension.doJUnitResults(result, proveri);
AssureUtilExtension.setToFail(verificationResult, proveri.getDiagnostics());
}
}
}
if (!_matched) {
if (methodtype instanceof ManualMethod) {
_matched=true;
}
}
if (!_matched) {
this.executeVerificationMethod(verificationResult, method, targetComponent, target, parameterObjects);
}
} catch (final Throwable _t) {
if (_t instanceof AssertionError) {
final AssertionError e = (AssertionError)_t;
AssureUtilExtension.setToFail(verificationResult, e);
} else if (_t instanceof ThreadDeath) {
final ThreadDeath e_1 = (ThreadDeath)_t;
throw e_1;
} else if (_t instanceof Throwable) {
final Throwable e_2 = (Throwable)_t;
AssureUtilExtension.setToError(verificationResult, e_2);
} else {
throw Exceptions.sneakyThrow(_t);
}
}
this.saveAssureResult(verificationResult);
this.updateProgress(verificationResult);
}
public boolean matchEnclosingComponentInstance(final org.osate.result.Result r, final EObject target) {
EObject _modelElement = r.getModelElement();
if ((_modelElement instanceof InstanceObject)) {
EObject _modelElement_1 = r.getModelElement();
ComponentInstance _componentInstance = ((InstanceObject) _modelElement_1).getComponentInstance();
return (_componentInstance == target);
}
return false;
}
public void updateRequirementsCoverage() {
if ((this.requirementsCoverageUpdater != null)) {
this.requirementsCoverageUpdater.apply();
}
}
public Object getType(final FormalParameter fp) {
final PropertyType pt = fp.getType();
return this.getType(pt);
}
public Object getType(final PropertyType pt) {
boolean _matched = false;
if (pt instanceof AadlBoolean) {
_matched=true;
return Boolean.class;
}
if (!_matched) {
if (pt instanceof AadlInteger) {
_matched=true;
return Integer.class;
}
}
if (!_matched) {
if (pt instanceof AadlReal) {
_matched=true;
return Double.class;
}
}
if (!_matched) {
if (pt instanceof AadlString) {
_matched=true;
return String.class;
}
}
if (!_matched) {
if (pt instanceof TypeRef) {
_matched=true;
return this.getType(((TypeRef)pt).getRef());
}
}
return null;
}
public PropertyExpression toLiteral(final Object data, final FormalParameter fp) {
PropertyExpression _xblockexpression = null;
{
UnitLiteral _unit = null;
if (fp!=null) {
_unit=fp.getUnit();
}
final UnitLiteral unit = _unit;
final Object expectedType = this.getType(fp);
PropertyExpression _switchResult = null;
boolean _matched = false;
if (data instanceof Boolean) {
_matched=true;
BooleanLiteral _xblockexpression_1 = null;
{
final BooleanLiteral b = Aadl2Factory.eINSTANCE.createBooleanLiteral();
b.setValue(((Boolean) data).booleanValue());
_xblockexpression_1 = b;
}
_switchResult = _xblockexpression_1;
}
if (!_matched) {
if (data instanceof Integer) {
_matched=true;
NumberValue _xifexpression = null;
if ((expectedType == Integer.class)) {
IntegerLiteral _xblockexpression_1 = null;
{
final IntegerLiteral i = Aadl2Factory.eINSTANCE.createIntegerLiteral();
i.setValue(((Integer) data).intValue());
if ((unit != null)) {
i.setUnit(unit);
}
_xblockexpression_1 = i;
}
_xifexpression = _xblockexpression_1;
} else {
RealLiteral _xblockexpression_2 = null;
{
final RealLiteral r = Aadl2Factory.eINSTANCE.createRealLiteral();
r.setValue(((Integer) data).intValue());
if ((unit != null)) {
r.setUnit(unit);
}
_xblockexpression_2 = r;
}
_xifexpression = _xblockexpression_2;
}
_switchResult = _xifexpression;
}
}
if (!_matched) {
if (data instanceof Double) {
_matched=true;
NumberValue _xifexpression = null;
if ((expectedType == Integer.class)) {
IntegerLiteral _xblockexpression_1 = null;
{
final IntegerLiteral i = Aadl2Factory.eINSTANCE.createIntegerLiteral();
AssureUtilExtension.setValue(i, ((Double) data).doubleValue());
if ((unit != null)) {
i.setUnit(unit);
}
_xblockexpression_1 = i;
}
_xifexpression = _xblockexpression_1;
} else {
RealLiteral _xblockexpression_2 = null;
{
final RealLiteral r = Aadl2Factory.eINSTANCE.createRealLiteral();
r.setValue(((Double) data).doubleValue());
if ((unit != null)) {
r.setUnit(unit);
}
_xblockexpression_2 = r;
}
_xifexpression = _xblockexpression_2;
}
_switchResult = _xifexpression;
}
}
if (!_matched) {
if (data instanceof String) {
_matched=true;
StringLiteral _xblockexpression_1 = null;
{
final StringLiteral str = Aadl2Factory.eINSTANCE.createStringLiteral();
str.setValue(((String)data));
_xblockexpression_1 = str;
}
_switchResult = _xblockexpression_1;
}
}
if (!_matched) {
if (data instanceof BooleanValue) {
_matched=true;
BooleanLiteral _xblockexpression_1 = null;
{
final BooleanLiteral b = Aadl2Factory.eINSTANCE.createBooleanLiteral();
b.setValue(((BooleanValue)data).isValue());
_xblockexpression_1 = b;
}
_switchResult = _xblockexpression_1;
}
}
if (!_matched) {
if (data instanceof IntegerValue) {
_matched=true;
NumberValue _xifexpression = null;
if ((expectedType == Integer.class)) {
IntegerLiteral _xblockexpression_1 = null;
{
final IntegerLiteral i = Aadl2Factory.eINSTANCE.createIntegerLiteral();
i.setValue(((IntegerValue)data).getValue());
if ((unit != null)) {
i.setUnit(unit);
}
_xblockexpression_1 = i;
}
_xifexpression = _xblockexpression_1;
} else {
RealLiteral _xblockexpression_2 = null;
{
final RealLiteral r = Aadl2Factory.eINSTANCE.createRealLiteral();
r.setValue(((IntegerValue)data).getValue());
if ((unit != null)) {
r.setUnit(unit);
}
_xblockexpression_2 = r;
}
_xifexpression = _xblockexpression_2;
}
_switchResult = _xifexpression;
}
}
if (!_matched) {
if (data instanceof RealValue) {
_matched=true;
NumberValue _xifexpression = null;
if ((expectedType == Integer.class)) {
IntegerLiteral _xblockexpression_1 = null;
{
final IntegerLiteral i = Aadl2Factory.eINSTANCE.createIntegerLiteral();
AssureUtilExtension.setValue(i, ((RealValue)data).getValue());
if ((unit != null)) {
i.setUnit(unit);
}
_xblockexpression_1 = i;
}
_xifexpression = _xblockexpression_1;
} else {
RealLiteral _xblockexpression_2 = null;
{
final RealLiteral r = Aadl2Factory.eINSTANCE.createRealLiteral();
r.setValue(((RealValue)data).getValue());
if ((unit != null)) {
r.setUnit(unit);
}
_xblockexpression_2 = r;
}
_xifexpression = _xblockexpression_2;
}
_switchResult = _xifexpression;
}
}
if (!_matched) {
if (data instanceof StringValue) {
_matched=true;
StringLiteral _xblockexpression_1 = null;
{
final StringLiteral str = Aadl2Factory.eINSTANCE.createStringLiteral();
str.setValue(((StringValue)data).getValue());
_xblockexpression_1 = str;
}
_switchResult = _xblockexpression_1;
}
}
if (!_matched) {
if (data instanceof InstanceObject) {
_matched=true;
AModelReference _xblockexpression_1 = null;
{
final AModelReference objref = CommonFactory.eINSTANCE.createAModelReference();
objref.setModelElement(((NamedElement)data));
_xblockexpression_1 = objref;
}
_switchResult = _xblockexpression_1;
}
}
if (!_matched) {
if (data instanceof InstanceReferenceValue) {
_matched=true;
AModelReference _xblockexpression_1 = null;
{
final AModelReference objref = CommonFactory.eINSTANCE.createAModelReference();
objref.setModelElement(((InstanceReferenceValue)data).getReferencedInstanceObject());
_xblockexpression_1 = objref;
}
_switchResult = _xblockexpression_1;
}
}
if (!_matched) {
_switchResult = ((PropertyExpression) data);
}
_xblockexpression = _switchResult;
}
return _xblockexpression;
}
public void updateProgress(final VerificationResult result) {
if ((this.progressUpdater != null)) {
this.progressUpdater.apply(EcoreUtil.getURI(result));
}
}
public void evaluatePredicate(final PredicateResult predicateResult) {
final ValuePredicate predicate = AssureUtilExtension.getPredicate(predicateResult);
this.computes.clear();
this.evaluatePredicate(predicateResult, predicate);
}
public void evaluatePredicate(final VerificationResult vResult, final ValuePredicate predicate) {
try {
final Result<PropertyValue> result = this.interpreter.interpretExpression(this.env, predicate.getXpression());
boolean _failed = result.failed();
if (_failed) {
String _failedMsg = CommonUtilExtension.getFailedMsg(result.getRuleFailedException());
String _plus = ("Could not evaluate value predicate: " + _failedMsg);
AssureUtilExtension.setToError(vResult, _plus, null);
} else {
PropertyValue _value = result.getValue();
final boolean success = ((BooleanLiteral) _value).getValue();
if (success) {
AssureUtilExtension.setToSuccess(vResult);
} else {
AssureUtilExtension.setToFail(vResult);
}
}
} catch (final Throwable _t) {
if (_t instanceof AssertionError) {
final AssertionError e = (AssertionError)_t;
AssureUtilExtension.setToFail(vResult, e);
} else if (_t instanceof ThreadDeath) {
final ThreadDeath e_1 = (ThreadDeath)_t;
throw e_1;
} else if (_t instanceof Throwable) {
final Throwable e_2 = (Throwable)_t;
AssureUtilExtension.setToError(vResult, e_2);
} else {
throw Exceptions.sneakyThrow(_t);
}
}
}
public void evaluateComputePredicate(final org.osate.result.Result pResult, final ValuePredicate predicate) {
try {
final Result<PropertyValue> result = this.interpreter.interpretExpression(this.env, predicate.getXpression());
boolean _failed = result.failed();
if (_failed) {
String _failedMsg = CommonUtilExtension.getFailedMsg(result.getRuleFailedException());
String _plus = ("Could not evaluate value predicate: " + _failedMsg);
ResultUtil.setToError(pResult, _plus);
} else {
PropertyValue _value = result.getValue();
final boolean success = ((BooleanLiteral) _value).getValue();
if (success) {
pResult.setResultType(ResultType.SUCCESS);
} else {
pResult.setResultType(ResultType.FAILURE);
}
}
} catch (final Throwable _t) {
if (_t instanceof AssertionError) {
final AssertionError e = (AssertionError)_t;
pResult.setResultType(ResultType.FAILURE);
String _message = pResult.getMessage();
boolean _tripleEquals = (_message == null);
if (_tripleEquals) {
pResult.setMessage(e.getMessage());
} else {
pResult.getDiagnostics().add(
ResultUtil.createErrorDiagnostic(
e.getMessage(), null));
}
} else if (_t instanceof ThreadDeath) {
final ThreadDeath e_1 = (ThreadDeath)_t;
throw e_1;
} else if (_t instanceof Throwable) {
final Throwable e_2 = (Throwable)_t;
ResultUtil.setToError(pResult, e_2.getMessage());
} else {
throw Exceptions.sneakyThrow(_t);
}
}
}
/**
* lookup targetElement and handle connection instances
* check on properties
* Then call on ExecuteMethodOnce, which handles Java and Resolute
*/
public void executeVerificationMethod(final VerificationResult verificationResult, final VerificationMethod method, final ComponentInstance targetComponent, final InstanceObject target, final List<PropertyExpression> parameters) {
if ((target instanceof ConnectionInstance)) {
final Collection<ConnectionInstance> conns = CommonUtilExtension.findConnectionInstances(targetComponent.getConnectionInstances(), ((ConnectionInstance)target));
for (final ConnectionInstance conni : conns) {
boolean _checkPropertyValues = this.checkPropertyValues(verificationResult, conni);
if (_checkPropertyValues) {
this.executeMethodOnce(verificationResult, method, targetComponent, conni, parameters);
}
}
boolean _hasResultErrors = ResultUtil.hasResultErrors(verificationResult.getResults());
if (_hasResultErrors) {
AssureUtilExtension.setToError(verificationResult);
} else {
boolean _hasResultFailures = ResultUtil.hasResultFailures(verificationResult.getResults());
if (_hasResultFailures) {
AssureUtilExtension.setToFail(verificationResult);
}
}
} else {
if ((target instanceof EndToEndFlowInstance)) {
final Collection<EndToEndFlowInstance> etefis = CommonUtilExtension.findETEFInstances(targetComponent.getEndToEndFlows(), ((EndToEndFlowInstance)target));
for (final EndToEndFlowInstance etefi : etefis) {
boolean _checkPropertyValues_1 = this.checkPropertyValues(verificationResult, etefi);
if (_checkPropertyValues_1) {
this.executeMethodOnce(verificationResult, method, targetComponent, etefi, parameters);
}
}
boolean _hasResultErrors_1 = ResultUtil.hasResultErrors(verificationResult.getResults());
if (_hasResultErrors_1) {
AssureUtilExtension.setToError(verificationResult);
} else {
boolean _hasResultFailures_1 = ResultUtil.hasResultFailures(verificationResult.getResults());
if (_hasResultFailures_1) {
AssureUtilExtension.setToFail(verificationResult);
}
}
} else {
if ((target != null)) {
boolean _checkPropertyValues_2 = this.checkPropertyValues(verificationResult, target);
if (_checkPropertyValues_2) {
this.executeMethodOnce(verificationResult, method, targetComponent, target, parameters);
}
} else {
String _name = target.getName();
String _plus = ("Could not find target element instance " + _name);
AssureUtilExtension.setToError(verificationResult, _plus, targetComponent);
}
}
}
}
public void executeMethodOnce(final VerificationResult verificationResult, final VerificationMethod method, final ComponentInstance targetComponent, final InstanceObject target, final List<PropertyExpression> parameters) {
final MethodKind methodtype = method.getMethodKind();
boolean _matched = false;
if (methodtype instanceof JavaMethod) {
_matched=true;
this.executeJavaMethodOnce(verificationResult, method, target, parameters);
}
if (!_matched) {
if (methodtype instanceof ResoluteMethod) {
_matched=true;
this.executeResoluteMethodOnce(verificationResult, method, targetComponent, target, parameters);
}
}
if (!_matched) {
if (methodtype instanceof PythonMethod) {
_matched=true;
AssureUtilExtension.setToError(verificationResult, "Python script execution not supported", null);
}
}
}
public void executeResoluteMethodOnce(final VerificationResult verificationResult, final VerificationMethod method, final ComponentInstance targetComponent, final InstanceObject target, final List<PropertyExpression> parameters) {
boolean _isResoluteInstalled = ResoluteUtil.isResoluteInstalled();
if (_isResoluteInstalled) {
MethodKind _methodKind = method.getMethodKind();
final ResoluteMethod methodtype = ((ResoluteMethod) _methodKind);
final EObject fundef = methodtype.getMethodReference();
final EObject returned = ResoluteUtil.getResolute().executeResoluteFunctionOnce(fundef, targetComponent, target, parameters);
this.processExecutionResult(verificationResult, method, target, returned);
} else {
AssureUtilExtension.setToError(verificationResult, "Resolute not installed");
}
}
public void executeJavaMethodOnce(final VerificationResult verificationResult, final VerificationMethod method, final InstanceObject target, final List<PropertyExpression> parameters) {
MethodKind _methodKind = method.getMethodKind();
final JavaMethod methodtype = ((JavaMethod) _methodKind);
final ArrayList<Class<?>> newClasses = VerifyJavaUtil.getParameterClasses(methodtype);
final List<Object> objects = VerifyJavaUtil.getActualJavaObjects(methodtype, target, parameters);
Object returned = ExecuteJavaUtil.invokeJavaMethod(methodtype.getMethodPath(), ((Class<?>[])Conversions.unwrapArray(newClasses, Class.class)), ((Object[])Conversions.unwrapArray(objects, Object.class)));
if (((returned == null) || (returned instanceof Exception))) {
TargetType _targetType = method.getTargetType();
boolean _tripleEquals = (_targetType == null);
if (_tripleEquals) {
newClasses.remove(0);
objects.remove(0);
returned = ExecuteJavaUtil.invokeJavaMethod(methodtype.getMethodPath(), ((Class<?>[])Conversions.unwrapArray(newClasses, Class.class)), ((Object[])Conversions.unwrapArray(objects, Object.class)));
}
}
this.processExecutionResult(verificationResult, method, target, returned);
}
/**
* process execution results
* We interpret boolean, Diagnostic, Result, AnalysisResult. We also interpret any returned object other than the previous as compute variable
*/
public void processExecutionResult(final VerificationResult verificationResult, final VerificationMethod method, final InstanceObject target, final Object returned) {
if ((returned != null)) {
if (((returned instanceof Boolean) && method.getResults().isEmpty())) {
boolean _notEquals = (!Objects.equal(returned, Boolean.valueOf(true)));
if (_notEquals) {
AssureUtilExtension.setToFail(verificationResult);
} else {
AssureUtilExtension.setToSuccess(verificationResult);
}
} else {
if ((returned instanceof org.osate.result.Result)) {
verificationResult.getResults().add(((org.osate.result.Result)returned));
if ((verificationResult instanceof VerificationActivityResult)) {
this.evaluateComputePredicate(((VerificationActivityResult)verificationResult), method, target, ((org.osate.result.Result)returned));
}
boolean _isError = AssureUtilExtension.isError(verificationResult);
if (_isError) {
} else {
boolean _isResultError = ResultUtil.isResultError(((org.osate.result.Result)returned));
if (_isResultError) {
AssureUtilExtension.setToError(verificationResult);
} else {
boolean _isResultFailure = ResultUtil.isResultFailure(((org.osate.result.Result)returned));
if (_isResultFailure) {
AssureUtilExtension.setToFail(verificationResult);
} else {
AssureUtilExtension.setToSuccess(verificationResult);
}
}
}
} else {
if ((returned instanceof Diagnostic)) {
DiagnosticType _diagnosticType = ((Diagnostic)returned).getDiagnosticType();
boolean _equals = Objects.equal(_diagnosticType, DiagnosticType.ERROR);
if (_equals) {
AssureUtilExtension.setToFail(verificationResult);
} else {
AssureUtilExtension.setToSuccess(verificationResult);
}
verificationResult.getIssues().add(((Diagnostic)returned));
} else {
if ((returned instanceof AnalysisResult)) {
boolean _isAnalysisResultError = ResultUtil.isAnalysisResultError(((AnalysisResult)returned));
if (_isAnalysisResultError) {
AssureUtilExtension.setToError(verificationResult);
} else {
if ((verificationResult instanceof VerificationActivityResult)) {
EList<org.osate.result.Result> _results = ((AnalysisResult)returned).getResults();
for (final org.osate.result.Result r : _results) {
this.evaluateComputePredicate(((VerificationActivityResult)verificationResult), method, target, r);
}
}
boolean _isError_1 = AssureUtilExtension.isError(verificationResult);
if (_isError_1) {
} else {
boolean _hasResultErrors = ResultUtil.hasResultErrors(((AnalysisResult)returned));
if (_hasResultErrors) {
AssureUtilExtension.setToError(verificationResult);
} else {
boolean _hasResultFailures = ResultUtil.hasResultFailures(((AnalysisResult)returned));
if (_hasResultFailures) {
AssureUtilExtension.setToFail(verificationResult);
} else {
AssureUtilExtension.setToSuccess(verificationResult);
}
}
}
}
EList<AnalysisResult> _analysisresult = verificationResult.getAnalysisresult();
_analysisresult.add(((AnalysisResult)returned));
} else {
if ((returned instanceof Exception)) {
String _message = ((Exception)returned).getMessage();
String _plus = ("Verification method execution exception: " + _message);
AssureUtilExtension.setToError(verificationResult, _plus, target);
} else {
int _size = method.getResults().size();
boolean _equals_1 = (_size == 1);
if (_equals_1) {
if ((verificationResult instanceof VerificationActivityResult)) {
final ReqPredicate predicate = AssureUtilExtension.getTarget(AssureUtilExtension.getClaimResult(verificationResult)).getPredicate();
if ((predicate instanceof ValuePredicate)) {
boolean _containsComputeVariables = AssureUtilExtension.containsComputeVariables(((ValuePredicate)predicate));
if (_containsComputeVariables) {
final EList<ComputeRef> computevars = ((VerificationActivityResult)verificationResult).getTargetReference().getVerificationActivity().getComputes();
int _size_1 = computevars.size();
boolean _equals_2 = (_size_1 == 1);
if (_equals_2) {
final ComputeRef computeRef = IterableExtensions.<ComputeRef>head(computevars);
final PropertyExpression rval = this.toLiteral(returned, IterableExtensions.<FormalParameter>head(method.getResults()));
this.computes.clear();
this.computes.put(computeRef.getCompute().getName(), rval);
this.evaluatePredicate(verificationResult, ((ValuePredicate)predicate));
} else {
int _size_2 = computevars.size();
String _plus_1 = ("One value returned but " + Integer.valueOf(_size_2));
String _plus_2 = (_plus_1 + " compute variable assignments");
AssureUtilExtension.setToError(verificationResult, _plus_2);
}
return;
} else {
AssureUtilExtension.setToError(verificationResult, "Non-boolean single return value and predicate without compute variable", target);
}
}
AssureUtilExtension.setToError(verificationResult, "Single return value expected to be boolean value", target);
} else {
AssureUtilExtension.setToError(verificationResult, "Precondition or Validation expect boolean as single return value", target);
}
} else {
AssureUtilExtension.setToError(verificationResult, "Single non-boolean return value but no expected compute variable for predicate", target);
}
}
}
}
}
}
} else {
AssureUtilExtension.setToError(verificationResult, "Java method does not include class", target);
}
}
/**
* evaluate value predicate with compute variable results bound. Result is recorded in returned
*/
public void evaluateComputePredicate(final VerificationActivityResult verificationResult, final VerificationMethod method, final InstanceObject target, final org.osate.result.Result returned) {
final ReqPredicate predicate = AssureUtilExtension.getTarget(AssureUtilExtension.getClaimResult(verificationResult)).getPredicate();
if (((((!ResultUtil.isResultSuccess(returned)) || AssureUtilExtension.isError(verificationResult)) || (predicate == null)) || (!(predicate instanceof ValuePredicate)))) {
return;
}
final ValuePredicate valuePredicate = ((ValuePredicate) predicate);
boolean _containsComputeVariables = AssureUtilExtension.containsComputeVariables(valuePredicate);
boolean _not = (!_containsComputeVariables);
if (_not) {
return;
}
final EList<ComputeRef> computevars = verificationResult.getTargetReference().getVerificationActivity().getComputes();
boolean _isEmpty = computevars.isEmpty();
if (_isEmpty) {
ResultUtil.setToError(returned, "No return values assigned to compute variables");
return;
}
this.env.decrement("element");
this.env.add("element", target);
this.computes.clear();
final Iterator<FormalParameter> formalIter = method.getResults().iterator();
final Iterator<Value> valsIter = returned.getValues().iterator();
if (((computevars.size() <= returned.getValues().size()) && (computevars.size() <= method.getResults().size()))) {
final Consumer<ComputeRef> _function = (ComputeRef computeRef) -> {
final Value value = valsIter.next();
final FormalParameter formalReturn = formalIter.next();
this.computes.put(computeRef.getCompute().getName(), this.toLiteral(value, formalReturn));
};
computevars.forEach(_function);
this.evaluateComputePredicate(returned, valuePredicate);
} else {
ResultUtil.setToError(returned, "Fewer values returned than expected as compute variables");
}
}
/**
* check property values in method specification
*/
public boolean checkPropertyValues(final VerificationResult verificationResult, final InstanceObject target) {
if ((verificationResult instanceof VerificationActivityResult)) {
final VerificationMethod method = AssureUtilExtension.getMethod(verificationResult);
final EList<Property> properties = method.getProperties();
final EList<PropertyExpression> exps = AssureUtilExtension.getTarget(((VerificationActivityResult)verificationResult)).getPropertyValues();
final Iterator<Property> propIter = properties.iterator();
final Iterator<PropertyExpression> expIter = exps.iterator();
boolean success = true;
while ((propIter.hasNext() && expIter.hasNext())) {
{
final Property property = propIter.next();
final PropertyExpression exp = expIter.next();
try {
final Result<PropertyValue> expResult = this.interpreter.interpretExpression(this.env, exp);
boolean _failed = expResult.failed();
if (_failed) {
String _name = property.getName();
String _plus = ("Could not evaluate expression for " + _name);
String _plus_1 = (_plus + ": ");
String _failedMsg = CommonUtilExtension.getFailedMsg(expResult.getRuleFailedException());
String _plus_2 = (_plus_1 + _failedMsg);
AssureUtilExtension.setToError(verificationResult, _plus_2, null);
success = false;
} else {
PropertyValue modelPropValue = null;
boolean _xtrycatchfinallyexpression = false;
try {
boolean _xblockexpression = false;
{
final PropertyExpression modelExp = target.getSimplePropertyValue(property);
PropertyValue _xifexpression = null;
if ((modelExp instanceof PropertyValue)) {
_xifexpression = ((PropertyValue)modelExp);
} else {
_xifexpression = null;
}
modelPropValue = _xifexpression;
_xblockexpression = true;
}
_xtrycatchfinallyexpression = _xblockexpression;
} catch (final Throwable _t) {
if (_t instanceof PropertyNotPresentException) {
_xtrycatchfinallyexpression = false;
} else {
throw Exceptions.sneakyThrow(_t);
}
}
final boolean propertyIsSet = _xtrycatchfinallyexpression;
final PropertyValue value = expResult.getValue();
if (propertyIsSet) {
if ((value instanceof NumberValue)) {
final UnitLiteral unit = ((NumberValue)value).getUnit();
final double reqValue = ((NumberValue)value).getScaledValue(unit);
final double modelValue = PropertyUtils.getScaledNumberValue(target, property, unit);
if ((reqValue != modelValue)) {
String _qualifiedName = property.getQualifiedName();
String _plus_3 = ("Property " + _qualifiedName);
String _plus_4 = (_plus_3 + ": Value in model (");
String _plus_5 = (_plus_4 + Double.valueOf(modelValue));
String _name_1 = unit.getName();
String _plus_6 = (_plus_5 + _name_1);
String _plus_7 = (_plus_6 + ") does not match required value (");
String _plus_8 = (_plus_7 + Double.valueOf(reqValue));
String _name_2 = unit.getName();
String _plus_9 = (_plus_8 + _name_2);
String _plus_10 = (_plus_9 + ")");
AssureUtilExtension.addErrorIssue(verificationResult, target, _plus_10);
AssureUtilExtension.setToFail(verificationResult);
}
} else {
boolean _notEquals = (!Objects.equal(value, modelPropValue));
if (_notEquals) {
String _qualifiedName_1 = property.getQualifiedName();
String _plus_11 = ("Property " + _qualifiedName_1);
String _plus_12 = (_plus_11 + ": Value in model (");
String _plus_13 = (_plus_12 + modelPropValue);
String _plus_14 = (_plus_13 + ") does not match required value (");
String _plus_15 = (_plus_14 + value);
String _plus_16 = (_plus_15 + ")");
AssureUtilExtension.addErrorIssue(verificationResult, target, _plus_16);
AssureUtilExtension.setToFail(verificationResult);
}
}
} else {
final PropertyAssociation pa = target.createOwnedPropertyAssociation();
pa.setProperty(property);
final ModalPropertyValue mpv = pa.createOwnedValue();
mpv.setOwnedValue(EcoreUtil.<PropertyValue>copy(value));
}
}
} catch (final Throwable _t) {
if (_t instanceof Exception) {
String _name_3 = property.getName();
String _plus_17 = ("Could not process property " + _name_3);
AssureUtilExtension.setToError(verificationResult, _plus_17);
} else {
throw Exceptions.sneakyThrow(_t);
}
}
}
}
return success;
} else {
return true;
}
}
public void process(final AssureResult preconditionResult) {
if (preconditionResult instanceof PreconditionResult) {
_process((PreconditionResult)preconditionResult);
return;
} else if (preconditionResult instanceof PredicateResult) {
_process((PredicateResult)preconditionResult);
return;
} else if (preconditionResult instanceof ValidationResult) {
_process((ValidationResult)preconditionResult);
return;
} else if (preconditionResult instanceof VerificationActivityResult) {
_process((VerificationActivityResult)preconditionResult);
return;
} else if (preconditionResult instanceof ElseResult) {
_process((ElseResult)preconditionResult);
return;
} else if (preconditionResult instanceof ThenResult) {
_process((ThenResult)preconditionResult);
return;
} else if (preconditionResult instanceof AssuranceCaseResult) {
_process((AssuranceCaseResult)preconditionResult);
return;
} else if (preconditionResult instanceof ClaimResult) {
_process((ClaimResult)preconditionResult);
return;
} else if (preconditionResult instanceof ModelResult) {
_process((ModelResult)preconditionResult);
return;
} else if (preconditionResult instanceof SubsystemResult) {
_process((SubsystemResult)preconditionResult);
return;
} else {
throw new IllegalArgumentException("Unhandled parameter types: " +
Arrays.<Object>asList(preconditionResult).toString());
}
}
public void setProgressUpdater(final Procedure1<? super URI> progressUpdater) {
this.progressUpdater = progressUpdater;
}
public void setRequirementsCoverageUpdater(final Procedure0 requirementsCoverageUpdater) {
this.requirementsCoverageUpdater = requirementsCoverageUpdater;
}
}