Asserts that two longs are equal. If they are not
an AssertionFailedError is thrown with the given message.
195025
static public void assertEquals(String message, long expected, long actual) {
        assertEquals(message, Long.valueOf(expected), Long.valueOf(actual));
    }
998665
static public void assertEquals(String message, short expected, short actual) {
        		assertEquals(message, new Short(expected), new Short(actual));
    	}
102590
def assert_eq(expected, actual, message=None, tolerance=None, extra=None):
    
    if tolerance is None:
        assert expected == actual, _assert_fail_message(
            message, expected, actual, "!=", extra
        )
    else:
        assert isinstance(tolerance, _number_types), (
            "tolerance parameter to assert_eq must be a number: %r" % tolerance
        )
        assert isinstance(expected, _number_types) and isinstance(
            actual, _number_types
        ), (
            "parameters must be numbers when tolerance is specified: %r, %r"
            % (expected, actual)
        )

        diff = abs(expected - actual)
        assert diff <= tolerance, _assert_fail_message(
            message, expected, actual, "is more than %r away from" % tolerance, extra
        )
1006605
def assert_not_equal(self, actual_val, unexpected_val, failure_message='Expected values to differ: "{}" and "{}"'):
        
        assertion = lambda: unexpected_val != actual_val
        self.webdriver_assert(assertion, unicode(failure_message).format(actual_val, unexpected_val))
655393
@Override
    public AssertionError newAssertionError(Description d, Representation representation) {
        AssertionError assertionError = getComparisonFailureInstance();
        if (assertionError != null) {
            return assertionError;
        }

        String message = String.format(EXPECTED_BUT_WAS_MESSAGE, getActual(), getExpected());
        return Failures.instance().failure(message);
    }
625946
static public void assertEquals(String message, char expected, char actual) {
        		assertEquals(message, new Character(expected), new Character(actual));
      	}
840781
function(a, length, msg) {
    return assert((this.assertIsArray(a, msg) && a.length <= length), msg);
  }
1297402
def assert_true(self, value, failure_message='Expected value to be True, was: {}'):
        
        assertion = lambda: bool(value)
        self.webdriver_assert(assertion, unicode(failure_message).format(value))
1175041
def asserts(self, *args, **kwargs):
        
        result = self.match(*args, **kwargs)
        self.expect(result)
        return result
259042
public void expectMin(String name, double minLength, String message) {
        String value = Optional.ofNullable(get(name)).orElse("");

        if (StringUtils.isNumeric(value)) {
            if (Double.parseDouble(value) < minLength) {
                addError(name, Optional.ofNullable(message).orElse(messages.get(Validation.MIN_KEY.name(), name, minLength)));
            }
        } else {
            if (value.length() < minLength) {
                addError(name, Optional.ofNullable(message).orElse(messages.get(Validation.MIN_KEY.name(), name, minLength)));
            }
        }
    }
771701
def assertNotNone(expr, message=None):
    
    if expr is None:
        raise TestStepFail(
            format_message(message) if message is not None else "Assert: %s == None" % str(expr))
874679
static void assertEquals(String message, Object comparison1, Object comparison2)
    {
        if(comparison1 == comparison2)
        {
            return;
        }
        if(comparison1.equals(comparison2))
        {
            return;
        }

        System.err.println(message);
    }
751764
def _check_len(a, b):
    
    if len(a) != len(b):
        msg = "Length must be {}. Got {}".format(len(a), len(b))
        raise ValueError(msg)
1175157
function notStrictEqual(actual, expected, message) {
    if (actual !== expected) {
      this.pass(message);
    }
    else {
      this.fail({
        actual: actual,
        expected: expected,
        message: message,
        operator: "!=="
      })
    }
  }
1058201
static public void assertEquals(String message, float expected, float actual, float delta) {
    		if (Float.compare(expected, actual) == 0)
    			return;
    		if (!(Math.abs(expected - actual) <= delta))
    				failNotEquals(message, new Float(expected), new Float(actual));
    	}
807978
function(expr, msg, negatedMsg, expected, showDiff){
        var msg = this.negate ? negatedMsg : msg
            , ok = this.negate ? !expr : expr
            , obj = this.obj;

        if (ok) return;

        var err = new AssertionError({
            message: msg.call(this)
            , actual: obj
            , expected: expected
            , stackStartFunction: this.assert
            , negated: this.negate
        });

        err.showDiff = showDiff;

        throw err;
    }
90917
public static void assertFalse(boolean condition, String message) {
		if (imp != null && condition) {
			imp.assertFailed(message);
		}
	}