Mock.hookTo(MyTestingTool.globalTestScope);

var mockArray = Mock([]);   //create the mock object

mockArray.push("one");

verify( Acts.once, mockArray.push("one") );

when( mockArray.push("one") ).thenReturn(1);

console.log( mockArray.push("one") );   //prints "1"

verify( Acts.once, mockArray.push("one") );

when( mockArray.push(Match.anything) ).thenReturn("hello!");

console.log( mockArray.push("one") );   //prints "hello!"
console.log( mockArray.push(999) );   //prints "hello!"
    
//look into 102. for more information

verify( Acts.never, mockArray.push("one") );        //ok
    
mockArray.push("one");
verify( Acts.once, mockArray.push("one") );         //ok
verify( Acts.atLeast(1), mockArray.push("one") );   //ok
    
mockArray.push("one");
mockArray.push("one");
verify( Acts.atMost(2), mockArray.push("one") );    //fails
    
//look into 103. for more information

when( mockArray.push(Match.anything) ).thenThrow("Hi, I am an expcetion");
    
mockArray.push("something");    //throws our exception

when( mockArray.push(Match.anything) ).thenReturn(function(arg){ 
    console.log("array.push('"+arg+"') called!");
    return "hello!"; 
});
    
console.log( mockArray.push("one") );   //prints "array.push('one') called!" and "hello!"

Mock.isMock(someObject);

function sum(a, b){
    return a+b;
}
    
var mockSum = Mock(sum);
    
mockSum(5, 5); //returns undefined (default)

when( mockArray.push.apply(Match.anyContext, [Match.anything]) ).thenReturn("something");
    
mockArray.push.apply([], ["one"]);
    
verify( Acts.once, mockArray.push.apply(Match.anyContext, [Match.anything]) );

//argument matchers
Match.anyString         //argument is a string
Match.anyInt            //argument is an integer
Match.anyNumber         //argument is a number
Match.anyFunction       //argument is a function
Match.anything          //argument is not undefined  
    
Match.everything        //special matcher - all arguments from this point on will be accepted
                        //eg. when( foo("a", Match.everything) ) will match foo("a"), foo("a", "one"), foo("a", 1, 2, 3, 4, 5, 6);
                            
                            
//context matcher
Match.anyContext        //all contexts will be accepted

Acts.times(x);  //verifies call acted exactly x number of times
Acts.never      //never happens (short for Acts.times(0))
Acts.once       //acts once (short for Acts.times(1))
Acts.atLeast(x) //acts at least x times
Acts.atMost(x)  //acts at most x times
    
//Note: the following syntax should not be used:
var a = Acts.never
verify( a, foo() );                 //works 1st time
verify( a, foo("one") );            //throws unexpected action in MockJS on all further uses
    
    
verify( Acts.never, foo("one") );   //always use the complete API syntax

function myClass(){
}
    
var matchObjectClass = function(arg){
    return arg instanceof myClass;
}
    
when( foo(matchObjectClass) ).thenReturn("something");
    
foo(new myClass());  //returns "something"
    
verify( Acts.once, foo(matchObjectClass) ); //verifies correctly

//let's consider our global function foo
var foo = function(a){
    alert(a);
    return "hello";
}
    
foo = Mock.andSave(foo, "myFoo");        //mocks function foo but keeps a reference for teardown (below)
    
when( foo(Match.anything) ).thenReturn("hello");
    
console.log( foo("hey") );         //prints "hello" into console
    
    
//teardown
foo = Mock.teardown("myFoo");    //sets foo back to the original function
    
foo("hey");         //alerts "hey"

//Consider the function we need to mock:
function $(a){ 
    var privateObject = {
        whisper:function(){
            console.log(a);
            return true;
        },
        say:function(){
            alert(a);
            return true;
        }   
    }
        
    return privateObject;
}
// Notice we cannot get a "mockable" instance of privateObject
// but we do know it is going to have a method "say"
    
//our function being tested
function iNeedTesting(){
    var check = $("hello");
        
    if(check.whisper() && check.say()) console.log("works!");
}
    
    
    
    
//let's mock the main wrapper
$ = Mock($);
    
var privateObject = Mock.new(["whisper", "say"]);       //create a mock object with methods "whisper" and "say"
    
when( $("hello") ).thenReturn(mockPrivateObject);
when( privateObject.whisper() ).thenReturn(true);
when( privateObject.say() ).thenReturn(true);
    
iNeedTesting(); //run our function being tested - prints out "works!" to console
    
verify(Acts.once, $("hello"));
verify(Acts.once, privateObject.whisper());
verify(Acts.once, privateObject.say());
    
//all ok