Returns <code>true</code> if the operation was a success; <code>false</code> otherwise.

@param operationResult the operation result to test
@return the success or failure flag of the result
770896
public static boolean isSuccess(ModelNode operationResult) {
        if (operationResult != null) {
            return operationResult.hasDefined(OUTCOME)
                && operationResult.get(OUTCOME).asString().equals(OUTCOME_SUCCESS);
        }
        return false;
    }
442075
public static BooleanOperation value() {
		JcValue val = new WhenJcValue();
		BooleanOperation ret = P.valueOf(val);
		ASTNode an = APIObjectAccess.getAstNode(ret);
		an.setClauseType(ClauseType.WHEN);
		return ret;
	}
229744
public boolean isFailure(R result, Throwable failure) {
    for (BiPredicate<R, Throwable> predicate : failureConditions) {
      try {
        if (predicate.test(result, failure))
          return true;
      } catch (Exception ignored) {
        // Ignore confused user-supplied predicates.
        // They should not be allowed to halt execution of the operation.
      }
    }

    // Fail by default if a failure is not checked by a condition
    return failure != null && !failuresChecked;
  }
83304
private boolean isError(Object result) {
		if(result != null){
			if(result instanceof BaseResult){
				BaseResult baseResult = (BaseResult)result;
				return !baseResult.isSuccess();
			}else if(result instanceof MchBase){
				MchBase mchBase = (MchBase)result;
				if("FAIL".equalsIgnoreCase(mchBase.getReturn_code())||
				   "FAIL".equalsIgnoreCase(mchBase.getResult_code())){
					return true;
				}
			}
		}
		return false;
	}
996858
private RunFailure getRunFailure(RootMethodRunResult runResult) {
        if (runResult == null || runResult.getRunFailures().size() == 0) {
            return null; // no failure
        }

        // multiple run failures in one test method are not supported yet
        return runResult.getRunFailures().get(0);
    }
196863
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSInt enum_key_validator = new MPSInt();
		enum_key_validator.validate(operationType, enum_key, "\"enum_key\"");
		
		MPSString enum_value_validator = new MPSString();
		enum_value_validator.validate(operationType, enum_value, "\"enum_value\"");
		
	}
501659
public <T> T runUnchecked(Retryable<T> operation) throws RuntimeException
	{
		try
		{
			return run(operation);
		}
		catch (RuntimeException e)
		{
			throw e;
		}
		catch (Exception e)
		{
			throw new RuntimeException("Retryable " + operation + " failed: " + e.getMessage(), e);
		}
	}
217811
boolean isFailure(ExecutionResult result) {
    return failureConditions.isEmpty() ?
        result.getFailure() != null :
        isFailure((R) result.getResult(), result.getFailure());
  }
956470
public boolean hasOverride(String operation) {
        boolean result = false;

        if (this.overrideOnce.containsKey(operation) == true || this.override.containsKey(operation) == true) {
            result = true;
        }

        return result;
    }
1151652
private static OperationId getOperationId(Method method) {
    Command command = method.getAnnotation(Command.class);
    if (command != null) {
      String name = command.value().equals("") ? method.getName() : command.value();
      return OperationId.from(name, OperationType.COMMAND);
    }
    Query query = method.getAnnotation(Query.class);
    if (query != null) {
      String name = query.value().equals("") ? method.getName() : query.value();
      return OperationId.from(name, OperationType.QUERY);
    }
    Operation operation = method.getAnnotation(Operation.class);
    if (operation != null) {
      String name = operation.value().equals("") ? method.getName() : operation.value();
      return OperationId.from(name, operation.type());
    }
    return null;
  }
12499
private <T> T execute(Operation<T> operation) throws Exception {
    return execute(operation, null);
  }
1323488
ResultAction executeOperation() {

        assert isControllingThread();
        try {
            /** Execution has begun */
            executing = true;

            processStages();

            if (resultAction == ResultAction.KEEP) {
                report(MessageSeverity.INFO, ControllerLogger.ROOT_LOGGER.operationSucceeded());
            } else {
                report(MessageSeverity.INFO, ControllerLogger.ROOT_LOGGER.operationRollingBack());
            }
        } catch (RuntimeException e) {
            handleUncaughtException(e);
            ControllerLogger.MGMT_OP_LOGGER.unexpectedOperationExecutionException(e, controllerOperations);
        } finally {
            // On failure close any attached response streams
            if (resultAction != ResultAction.KEEP && !isBooting()) {
                synchronized (this) {
                    if (responseStreams != null) {
                        int i = 0;
                        for (OperationResponse.StreamEntry is : responseStreams.values()) {
                            try {
                                is.getStream().close();
                            } catch (Exception e) {
                                ControllerLogger.MGMT_OP_LOGGER.debugf(e, "Failed closing stream at index %d", i);
                            }
                            i++;
                        }
                        responseStreams.clear();
                    }
                }
            }
        }


        return resultAction;
    }
829071
boolean isPurableOperation(XtendFunction operation, ISideEffectContext context) {
		if (isUnpureOperationPrototype(operation)) {
			return false;
		}
		if (this.nameValidator.isNamePatternForNotPureOperation(operation)) {
			return false;
		}
		if (this.nameValidator.isNamePatternForPureOperation(operation)) {
			return true;
		}
		if (context == null) {
			return !hasSideEffects(
					getInferredPrototype(operation),
					operation.getExpression());
		}
		final Boolean result = internalHasSideEffects(operation.getExpression(), context);
		return result == null || !result.booleanValue();
	}
515726
public synchronized <RESULT> boolean supports(final Operation<RESULT> operation, Hint... hints) {
        final Frame<RESULT> frame = new Frame<>(Phase.SUPPORT_CHECK, operation, hints);
        try {
            return handle(frame);
        } catch (Frame.RecursionException e) {
            return false;
        }
    }
1300969
@Override
  public Result<K, V> apply(final Result<K, V> previousOperation) {
    if(previousOperation == null) {
      return this;
    } else {
      return previousOperation;
    }
  }
1237173
public boolean isShuffle(){
		if (this.operationNames.size() > 0){
			String operationName = this.operationNames.get(0);
			return Ops.isShuffle(operationName);
		}
		return false;
	}
19010
public boolean isResult() {
        if (StringUtils.isNotBlank(serverResponse)) {
            try {
                return fromJson.castTo(Result.class) != null;
            } catch (Exception e) {
                log.warn("isResult: exception occurred - {}", e);
            }
        }
        return false;
    }