Parameter A must be lower than or equal to the given value.

@param aindex the index of the parameter A.
@param avalue the value of the parameter A.
@param value the value.
@return the error message.
975131
@Pure
	public static String lowerEqualParameter(int aindex, Object avalue, Object value) {
		return msg("A11", aindex, avalue, value); //$NON-NLS-1$
	}
743851
@Then("^'(?s)(.+?)' ((?!.*with).+?) '(.+?)'$")
    public void checkValue(String envVar, String operation, String value) throws Exception {
        switch (operation.toLowerCase()) {
            case "is":
                Assertions.assertThat(envVar).isEqualTo(value);
                break;
            case "matches":
                Assertions.assertThat(envVar).matches(value);
                break;
            case "is higher than":
                if (envVar.matches("^-?\\d+$") && value.matches("^-?\\d+$")) {
                    Assertions.assertThat(Integer.parseInt(envVar)).isGreaterThan(Integer.parseInt(value));
                } else {
                    Fail.fail("A number should be provided in order to perform a valid comparison.");
                }
                break;
            case "is lower than":
                if (envVar.matches("^-?\\d+$") && value.matches("^-?\\d+$")) {
                    Assertions.assertThat(Integer.parseInt(envVar)).isLessThan(Integer.parseInt(value));
                } else {
                    Fail.fail("A number should be provided in order to perform a valid comparison.");
                }
                break;
            case "contains":
                Assertions.assertThat(envVar).contains(value);
                break;
            case "does not contain":
                Assertions.assertThat(envVar).doesNotContain(value);
                break;
            case "is different from":
                Assertions.assertThat(envVar).isNotEqualTo(value);
                break;
            default:
                Fail.fail("Not a valid comparison. Valid ones are: is | matches | is higher than | is lower than | contains | does not contain | is different from");
        }
    }
1269080
public static void isTrue (@Nonnull final BooleanSupplier aValue, final String sMsg)
  {
    if (isEnabled ())
      isTrue (aValue, () -> sMsg);
  }
1305160
@FFDCIgnore({ NumberFormatException.class, ArithmeticException.class, ConfigEvaluatorException.class })
    private String tryEvaluateExpression(String expr, final EvaluationContext context, final boolean ignoreWarnings) {
        try {
            return new ConfigExpressionEvaluator() {

                @Override
                String getProperty(String argName) throws ConfigEvaluatorException {
                    return VariableEvaluator.this.getProperty(argName, context, ignoreWarnings, false);
                }

                @Override
                Object getPropertyObject(String argName) throws ConfigEvaluatorException {
                    return VariableEvaluator.this.getPropertyObject(argName, context, ignoreWarnings, false);
                }
            }.evaluateExpression(expr);

        } catch (NumberFormatException e) {
            // ${0+string}, or a number that exceeds MAX_LONG.
        } catch (ArithmeticException e) {
            // ${x/0}
        } catch (ConfigEvaluatorException e) {
            // If getPropertyObject fails
        }
        return null;
    }
1277608
public static void inferiorOrEqual(int a, int b)
    {
        if (a > b)
        {
            throw new LionEngineException(ERROR_ARGUMENT + String.valueOf(a) + ERROR_INFERIOR + String.valueOf(b));
        }
    }
1123213
public final Condition eq(final V value) {
        return new Condition().withComparisonOperator(EQ).withAttributeValueList(convert(value));
    }
388328
public static void validateBetween(Number value, Number min, Number max, String errorMsg) throws ValidateException {
		if (false == isBetween(value, min, max)) {
			throw new ValidateException(errorMsg);
		}
	}
233593
public AVQuery<T> whereNotEqualTo(String key, Object value) {
    conditions.whereNotEqualTo(key, value);
    return this;
  }
107917
public AVIMConversationsQuery whereEqualTo(String key, Object value) {
    conditions.whereEqualTo(key, value);
    return this;
  }
841525
public boolean isZeroVATAllowed (@Nonnull final Locale aCountry, final boolean bUndefinedValue)
  {
    ValueEnforcer.notNull (aCountry, "Country");

    // first get locale specific VAT types
    final VATCountryData aVATCountryData = getVATCountryData (aCountry);
    return aVATCountryData != null ? aVATCountryData.isZeroVATAllowed () : bUndefinedValue;
  }
587659
@Nonnull
  public final HCSWFObject addFlashVar (@Nonnull final String sName, final Object aValue)
  {
    if (!JSMarshaller.isJSIdentifier (sName))
      throw new IllegalArgumentException ("The name '" + sName + "' is not a legal JS identifier!");

    if (m_aFlashVars == null)
      m_aFlashVars = new CommonsLinkedHashMap <> ();
    m_aFlashVars.put (sName, aValue);
    return this;
  }
849307
@Override
    public Object visitEqualityExpression(ExcellentParser.EqualityExpressionContext ctx) {
        Pair<Object, Object> args = Conversions.toSame(visit(ctx.expression(0)), visit(ctx.expression(1)), m_evalContext);
        boolean equal;

        if (args.getLeft() instanceof String) {
            // string equality is case-insensitive
            equal = ((String) args.getLeft()).equalsIgnoreCase((String) args.getRight());
        }
        else if (args.getLeft() instanceof BigDecimal) {
            // compareTo doesn't take scale into account
            equal = ((BigDecimal) args.getLeft()).compareTo((BigDecimal) args.getRight()) == 0;
        }
        else {
            equal = args.getLeft().equals(args.getRight());
        }

        return ctx.EQ() != null ? equal : !equal;
    }
924024
protected Object parseEvalReply(EvalResult result) {
    String status = result.getStatus();

    if (!status.equals("completed")) {
      if (status.equals("unhandled-exception")) {
        // Would be great give the JS error here, but it appears that by the
        // time we callFunctionOnObject the error object has gone...
        throw new ScopeException("Ecmascript exception");
      } else if (status.equals("cancelled-by-scheduler")) {
        // TODO: what is the best approach here?
        return null;
      }
    }

    String dataType = result.getType();
    if (dataType.equals("object")) {
      return result.getObjectValue();
    } else {
      return parseValue(dataType, result.getValue());
    }
  }
288951
public static String unquote(final String aValue) {
        if (aValue != null && aValue.startsWith("\"") && aValue.endsWith("\"")) {
            return aValue.substring(0, aValue.length() - 1).substring(1);
        }
        return aValue;
    }
953392
public double repairSolutionVariableValue(double value, double lowerBound, double upperBound) {
    if (lowerBound > upperBound) {
      throw new JMetalException("The lower bound (" + lowerBound + ") is greater than the "
          + "upper bound (" + upperBound+")") ;
    }
    double result = value ;
    if (value < lowerBound) {
      result = randomGenerator.getRandomValue(lowerBound, upperBound) ;
    }
    if (value > upperBound) {
      result = randomGenerator.getRandomValue(lowerBound, upperBound) ;
    }

    return result ;
  }
344111
public static void badParamExAssertTrue(boolean cond, IApiError apiError) throws Http400Exception {
		if (!cond) {
			throw new Http400Exception(apiError != null ? apiError : new GenericApiError());
		}
	}
380304
protected Double eval(final Object[] _value)
    {
        final Double ret;

        if (_value == null) {
            ret = null;
        } else if ((_value[0] instanceof String) && (((String) _value[0]).length() > 0)) {
            ret = Double.parseDouble((String) _value[0]);
        } else if (_value[0] instanceof Number) {
            ret = ((Number) _value[0]).doubleValue();
        } else  {
            ret = null;
        }

        return ret;
    }