(see Riot::AssertionMacro#evaluate)
493738
def evaluate(actual)
      warn "any is deprecated; please use asserts.empty or denies.empty instead"
      any?(actual) ? pass("has items") : fail(expected_message(actual).to_have_items)
    end
616842
def evaluate_scope(scope)
      return send(scope) if scope.is_a? Symbol
      return instance_exec(&scope) if scope.is_a? Proc
      fail ArgumentError, 'scope is not a Symbol or a Proc'
    end
1317485
def evaluate(scope, locals, &block)
      c = Handlebarer::Compiler.new
      c.compile(data)
    end
559885
function evaluateCached(path, state) {
  const { node } = path;
  const { seen } = state;

  if (seen.has(node)) {
    const existing = seen.get(node);
    if (existing.resolved) {
      return existing.value;
    } else {
      deopt(path, state);
      return;
    }
  } else {
    const item = { resolved: false };
    seen.set(node, item);

    const val = _evaluate(path, state);
    if (state.confident) {
      item.resolved = true;
      item.value = val;
    }
    return val;
  }
}
1230002
def evaluate_handler(handler)
      case handler
      when Symbol
        target.method(handler)
      when Proc
        if handler.arity.zero?
          proc { instance_exec(&handler) }
        else
          proc { |_exception| instance_exec(_exception, &handler) }
        end
      end
    end
935086
function(err) {
        if (err) { done(err); return; }
        var assert = require('assert');
        var difflet = require('difflet')({indent: 2, comment: true});
        try {
          assert.deepEqual(options.test.actual, options.expected, 'Actual should match expected.');
          grunt.log.writeln('Test passed.');
          done();
        } catch (err) {
          grunt.log.subhead('Assertion Failure');
          console.log(difflet.compare(err.expected, err.actual));
          done(err);
        }
      }
1183008
def assertion(func):
    """"""
    func = assertionmethod(func)
    setattr(AssertionBuilder, func.__name__, func)
    return func
861873
def POST_evaluate(self) -> None:
        
        for name, value in self._inputs.items():
            result = eval(value)
            self._outputs[name] = objecttools.flatten_repr(result)
655355
def evaluable?
      !lambda? &&
        !aop? &&
        ( !args || args.all?{|a| Evaller.evaluable? a } ) &&
        ( !custom_target? || Evaller.evaluable?( custom_target? ) )
    end
1291652
def evaluate(context, *args)
      {}.tap do |evaluated|
        each do |k,v|
          evaluated[k] = v.(context, *args)
        end
      end
    end
384917
function internalAssert(condition, message) {
  if (!condition) {
    throw new AssertionError({
      message,
      actual: false,
      expected: true,
      operator: '=='
    });
  }
}
309891
def evalsha(self, sha, numkeys, *keys_and_args):
        """"""
        if not self.script_exists(sha)[0]:
            raise RedisError("Sha not registered")
        script_callable = Script(self, self.shas[sha], self.load_lua_dependencies)
        numkeys = max(numkeys, 0)
        keys = keys_and_args[:numkeys]
        args = keys_and_args[numkeys:]
        return script_callable(keys, args)
377061
def evaluate(scope, locals, &block)
      binding.pry
      template = data.dup
      template.gsub!(/"/, '\\"')
      template.gsub!(/\r?\n/, '\\n')
      template.gsub!(/\t/, '\\t')
      return 'console.log(1223);'
    end
268240
def do_eval(self, inputs, ctx):
        """"""
        return cwltool.expression.do_eval(
            self.expr, inputs, self.req, None, None, {}, context=ctx)
1202176
def evaluate(actual, expected)
      if actual.respond_to?(expected)
        pass(new_message.responds_to(expected))
      else
        fail(expected_message.method(expected).is_not_defined)
      end
    end
1346042
def safe_evaluate(command, glob, local):
    
    while True:
        try:
            return eval(command, glob, local)
        except NameError as e:
            match = re.match("name '(.*)' is not defined", e.message)
            if not match:
                raise e
            try:
                exec ('import %s' % (match.group(1), )) in glob
            except ImportError:
                raise e
976368
def _eval(self, m: EvalParam) -> object:
        
        if inspect.ismethod(m) or inspect.isroutine(m):
            return m()
        elif inspect.isfunction(m):
            return m(self) if len(inspect.signature(m)) > 0 else m()
        else:
            return m