// Call a function with no arguments.
function a_g() {
 return 5;
}

function a_f(g) {
 return g();
}

a_g();
assertEq(a_f(a_g), 5);

///////////////////////////////////////////////////////////////////////////////
// Call a function with one argument.
function b_g(a) {
 return a;
}

function b_f(h,b) {
 return h(5);
}
b_g(5);
assertEq(b_f(b_g,4), 5);

///////////////////////////////////////////////////////////////////////////////
// Try to confuse the register allocator.
function c_g(a) {
 return a;
}
function c_f(h,b) {
 var x = h(5);
 var y = x + 1;
 var z = h(h(y + x + 2));
 var k = 2 + z + 3;
 return h(h(h(k)));
}
c_g(2); // prime g().
assertEq(c_f(c_g,7), 18)

///////////////////////////////////////////////////////////////////////////////
// Fail during unboxing, get kicked to interpreter.
// Interpreter throws an exception; handle it.

function d_f(a) {
 return a(); // Call a known non-object. This fails in unboxing.
}
var d_x = 0;
try {
 d_f(1); // Don't assert.
} catch(e) {
 d_x = 1;
}
assertEq(d_x, 1);

///////////////////////////////////////////////////////////////////////////////
// Try passing an uncompiled function.

function e_uncompiled(a,b,c) {
 return eval("b");
}
function e_f(h) {
 return h(0,h(2,4,6),1);
}
assertEq(e_f(e_uncompiled),4);

///////////////////////////////////////////////////////////////////////////////
// Try passing a native function.

function f_app(f,n) {
 return f(n);
}
assertEq(f_app(Math.sqrt, 16), 4);

///////////////////////////////////////////////////////////////////////////////
// Handle the case where too few arguments are passed.
function g_g(a,b,c,d,e) {
 return e;
}

function g_f(g) {
 return g(2);
}

g_g();
assertEq(g_f(g_g), undefined);

///////////////////////////////////////////////////////////////////////////////
// Don't assert when given a non-function object.
function h_f(a) {
 return a();
}

var x = new Object();
var h_ret = 0;
try {
 h_f(x); // don't assert.
} catch (e) {
 h_ret = 1;
}
assertEq(h_ret, 1);