(see Riot::AssertionMacro#evaluate)
 @param [Class] expected_class the expected Exception class
 @param [String, nil] expected_message an optional exception message or message partial
1238
def evaluate(actual_exception, expected_class, expected_message=nil)
      actual_message = actual_exception && actual_exception.message
      if actual_exception.nil?
        fail new_message.expected_to_raise(expected_class).but.raised_nothing
      elsif expected_class != actual_exception.class
        fail new_message.expected_to_raise(expected_class).not(actual_exception.class)
      elsif expected_message && !(actual_message.to_s =~ %r[#{expected_message}])
        fail expected_message(expected_message).for_message.not(actual_message)
      else
        message = new_message.raises(expected_class)
        pass(expected_message ? message.with_message(expected_message) : message)
      end
    end
942589
def devaluate(actual, expected)
      if actual.include?(expected)
        fail expected_message(actual).to_not_include(expected)
      else
        pass new_message.includes(expected)
      end
    end
1237908
static public void assertEquals(String message, byte expected, byte actual) {
        assertEquals(message, Byte.valueOf(expected), Byte.valueOf(actual));
    }
874679
static void assertEquals(String message, Object comparison1, Object comparison2)
    {
        if(comparison1 == comparison2)
        {
            return;
        }
        if(comparison1.equals(comparison2))
        {
            return;
        }

        System.err.println(message);
    }
363812
def Instance(expected, message="Not an instance of {}"):
    
    @wraps(Instance)
    def built(value):
        if not isinstance(value, expected):
            raise Error(message.format(expected.__name__))
        return value
    return built
1121539
function equal(actual, expected, message) {
    if (actual == expected) {
      this.pass(message);
    }
    else {
      this.fail({
        actual: actual,
        expected: expected,
        message: message,
        operator: "=="
      });
    }
  }
711184
def assertCallerError(self, expected_arg0, callable_obj, *args, **kwargs):
        
        try:
            callable_obj(*args, **kwargs)
            self.fail('Expected AssertionError, but no exception raised')
        except AssertionError, exc:
            self.assertEqual(exc.args[0], expected_arg0)
        except Exception, exc:
            self.fail('Expected AssertionError, but got %s' % repr(exc))
416920
def add_error(expected_value, target_value)
      @errors[target_value.error_key] = <<-MSG

        Mismatch in field: '#{target_value.error_key}'
          expected: '#{expected_value.value}'
          received: '#{target_value.value}'

      MSG
    end
65260
def AssertType(value, expected_type):
  
  if not isinstance(value, expected_type):
    message = "Expected type `%r`, but got value `%r` of type `%s`"
    message %= (expected_type, value, type(value))
    raise TypeError(message)
653119
def evaluate(actual, expected)
      if actual.kind_of?(expected)
        pass new_message.is_a_kind_of(expected)
      else
        fail expected_message.kind_of(expected).not(actual.class)
      end
    end
1318262
def devaluate(actual, expected)
      if actual.respond_to?(expected)
        fail(expected_message.method(expected).is_defined)
      else
        pass new_message.responds_to(expected)
      end
    end
728848
static public void assertEquals(String message, boolean expected, boolean actual) {
        assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
    }
599369
function assertMatch(actual, expected, message) {
  if (isRegExp(expected))
    assert(expected.test(actual), message || `Expected "${actual}" to match "${expected}"`);
  else if (typeof expected === 'function')
    assert(expected(actual), message);
  else
    assert.deepEqual(actual, expected, message);
}
239881
public static void assertEquals(Object expected, Object actual, String message) {
        if (!Objects.equals(expected, actual)) {
            fail(message);
        }
    }
1011467
Throwable getExpectedCause(Class expectedExceptionClass, 
			       Throwable exception) {
	Throwable result = exception.getCause();
	if (null != result) {
	    if (!expectedExceptionClass.isAssignableFrom(result.getClass())) {
		result = getExpectedCause(expectedExceptionClass, result);
	    }
	}
	return result;
    }
715739
def devaluate(actual, expected)
      expected = %r[#{Regexp.escape(expected)}] if expected.kind_of?(String)
      if actual.to_s =~ expected
        fail(expected_message(expected).not_to_match(actual))
      else
        pass(new_message.matches(expected))
      end
    end
216213
def devaluate(actual, expected)
      if actual.kind_of?(expected)
        fail expected_message.not_kind_of(expected).not(actual.class)
      else
        pass new_message.is_a_kind_of(expected)
      end
    end