Soft assert for whether the condition is false

        :params expr: the statement to evaluate
        :params msg: (Optional) msg explaining the difference
518666
def verify_false(self, expr, msg=None):
        
        try:
            self.assert_false(expr, msg)
        except AssertionError, e:
            if msg:
                m = "%s:\n%s" % (msg, str(e))
            else:
                m = str(e)
            self.verification_erorrs.append(m)
1358172
def verify_is(self, first, second, msg=None):
        
        try:
            self.assert_is(first, second, msg)
        except AssertionError, e:
            if msg:
                m = "%s:\n%s" % (msg, str(e))
            else:
                m = str(e)
            self.verification_erorrs.append(m)
1078604
public static void assertTrue(boolean expression, ExceptionType exceptionType, String message, Object... args) {
        if (!expression) {
            if (exceptionType == null) {
                exceptionType = ExceptionType.ILLEGAL_ARGUMENT;
            }

            throw exceptionType.newInstance(getMessage(message, args,
                                                       "[Assertion failed] - the expression must be true"));
        }
    }
1175041
def asserts(self, *args, **kwargs):
        
        result = self.match(*args, **kwargs)
        self.expect(result)
        return result
135844
function(a, length, allowNumbers, msg) {
    allowNumbers = allowNumbers || true;
    return assert((this.assertIsString(a, allowNumbers) && a.length <= length), msg);
  }
1198290
def exception(self, msg=None, *args, **kwargs):
        
        kwargs['exc_info'] = 1
        return self._log(logging.ERROR, msg, args, kwargs)
776438
public static void assertTrue(boolean expression, String messageFormat, Object... args) {
		if (!expression)
			throw (new KriptonProcessorException(String.format(messageFormat, args)));

	}
292212
def verify_is_not_none(self, expr, msg=None):
        
        try:
            self.assert_is_not_none(expr, msg)
        except AssertionError, e:
            if msg:
                m = "%s:\n%s" % (msg, str(e))
            else:
                m = str(e)
            self.verification_erorrs.append(m)
1191798
function assert(expr) {
  if (expr) return;

  var stack = callsite();
  var call = stack[1];
  var file = call.getFileName();
  var lineno = call.getLineNumber();
  var src = fs.readFileSync(file, 'utf8');
  var line = src.split('\n')[lineno-1];
  var src = line.match(/assert\((.*)\)/)[1];

  var err = new AssertionError({
    message: src,
    stackStartFunction: stack[0].getFunction()
  });

  throw err;
}
986689
def _get_args(self, *args) -> (Exception, str):
        
        ex = None
        msg = None
        for arg in args:
            if isinstance(arg, str):
                msg = arg
            elif isinstance(arg, Exception):
                ex = arg
        return ex, msg
1191036
def assertNone(expr, message=None):
    
    if expr is not None:
        raise TestStepFail(
            format_message(message) if message is not None else "Assert: %s != None" % str(expr))
908653
def verify_not_equal(self, first, second, msg=""):
        
        try:
            self.assert_not_equal(first, second, msg)
        except AssertionError, e:
            if msg:
                m = "%s:\n%s" % (msg, str(e))
            else:
                m = str(e)
            self.verification_erorrs.append(m)
291039
public static void assertXMLIdentical(String msg, Diff diff, boolean assertion) {
        if (assertion != diff.identical()) {
            fail(getFailMessage(msg, diff));
        }
    }
913148
function(a, min, max, msg) {
    return assert((this.assertArrayMinLength(a, min, msg)&&this.assertArrayMaxLength(a, max, msg)), msg);
  }
1264696
def get_bool_raw(s: str) -> Optional[bool]:
    
    if s == "Y" or s == "y":
        return True
    elif s == "N" or s == "n":
        return False
    return None
606275
function(a, msg) {
		a = !!a;
		var details = {
			result: a,
			message: msg
		};
		msg = escapeInnerText(msg);
		runLoggingCallbacks( 'log', QUnit, details );
		config.current.assertions.push({
			result: a,
			message: msg
		});
	}
79314
def Assert(predicate: vertex_constructor_param_types, error_message: str, label: Optional[str]=None) -> Vertex:
    
    return Boolean(context.jvm_view().AssertVertex, label, cast_to_vertex(predicate), error_message)