module dmocks.mocks;

public import dmocks.dynamic;
import dmocks.factory;
public import dmocks.object_mock;
import dmocks.repository; 
import dmocks.util;

/++
    A class through which one creates mock objects and manages expectations about calls to their methods.
 ++/
public class Mocker 
{
    private MockRepository _repository;

    public 
    {
        this () 
        {
            _repository = new MockRepository();
        }

        /**
        * Start setting up expectations. Method calls on mock object will create (and record) new expectations. 
        * You can just call methods directly or use Mocker.expect/lastCall to customize expectations.
        */
        void record () 
        {
            _repository.BackToRecord();
        }

        /** 
         * Stop setting up expectations. Any method calls after this point will
         * be matched against the expectations set up before calling replay and
         * expectations' actions will be executed.
         */
        void replay () 
        {
            _repository.Replay();
        }

        /**
         * Verifies that certain expectation requirements were satisfied during replay phase.
         *
         * checkUnmatchedExpectations - Check to see if there are any expectations that haven't been
         * matched to a call. 
         *
         * checkUnexpectedCalls - Check to see if there are any calls that there were no
         * expectation set up for.
         *
         * Throws an ExpectationViolationException if those issues occur.
         */
        void verify (bool checkUnmatchedExpectations = true, bool checkUnexpectedCalls = true) 
        {
            _repository.Verify(checkUnmatchedExpectations, checkUnexpectedCalls);
        }

        /**
         * By default, all expectations are unordered. If I want to require that
         * one call happen immediately after another, I call Mocker.ordered, make
         * those expectations, and call Mocker.unordered to avoid requiring a
         * particular order afterward.
         */
        void ordered () 
        {
            _repository.Ordered(true);
        }

        void unordered () 
        {
            _repository.Ordered(false);
        }

        /** 
         * Disables exceptions thrown on unexpected calls while in Replay phase
         * Unexpected methods called will return default value of their type
         *
         * Useful when using mocks as stubs or when you don't want exceptions 
         * to change flow of execution of your tests, for example when using nothrow functions
         *
         * Default: false
         */
        void allowUnexpectedCalls(bool allow)
        {
            _repository.AllowUnexpected(allow);
        }

        /** 
         * Creates a mock object for a given type.
         *
         * Calls matching expectations with passThrough enabled
         * will call equivalent methods of T object constructed with args.
         *
         * Type returned is binarily compatibile with given type
         * All virtual calls made to the object will be mocked
         * Final and template calls will not be mocked
         *
         * Use this type of mock to substitute interface/class objects
         */
        T mock (T, CONSTRUCTOR_ARGS...) (CONSTRUCTOR_ARGS args) 
        {
            static assert (is(T == class) || is(T == interface), 
                           "only classes and interfaces can be mocked using this type of mock");
            return dmocks.factory.mock!(T)(_repository, args);
        }

        /** 
         * Creates a mock object for a given type.
         *
         * Calls matching expectations with passThrough enabled
         * will call equivalent methods of T object constructed with args.
         *
         * Type of the mock is incompatibile with given type
         * Final, template and virtual methods will be mocked
         *
         * Use this type of mock to substitute template parameters
         */
        MockedFinal!T mockFinal(T, CONSTRUCTOR_ARGS...) (CONSTRUCTOR_ARGS args)
        {
            static assert (is(T == class) || is(T == interface), 
                           "only classes and interfaces can be mocked using this type of mock");
            return dmocks.factory.mockFinal!(T)(_repository, args);
        }

        /** 
         * Creates a mock object for a given type.
         *
         * Calls matching expectations with passThrough enabled
         * will call equivalent methods of "to" object.
         *
         * Type of the mock is incompatibile with given type
         * Final, template and virtual methods will be mocked
         *
         * Use this type of mock to substitute template parameters
         */
        MockedFinal!T mockFinalPassTo(T) (T to)
        {
            static assert (is(T == class) || is(T == interface), 
                           "only classes and interfaces can be mocked using this type of mock");
            return dmocks.factory.mockFinalPassTo!(T)(_repository, to);
        }

        /** 
         * Creates a mock object for a given type.
         *
         * Calls matching expectations with passThrough enabled
         * will call equivalent methods of T object constructed with args.
         *
         * Type of the mock is incompatibile with given type
         * Final, template and virtual methods will be mocked
         *
         * Use this type of mock to substitute template parameters
         */
        MockedStruct!T mockStruct(T, CONSTRUCTOR_ARGS...) (CONSTRUCTOR_ARGS args)
        {
            static assert (is(T == struct), 
                           "only structs can be mocked using this type of mock");
            return dmocks.factory.mockStruct!(T)(_repository, args);
        }

        /** 
         * Creates a mock object for a given type.
         *
         * Calls matching expectations with passThrough enabled
         * will call equivalent methods of "to" object.
         *
         * Type of the mock is incompatibile with given type
         * Final, template and virtual methods will be mocked
         *
         * Use this type of mock to substitute template parameters
         */
        MockedStruct!T mockStructPassTo(T) (T to)
        {
            static assert (is(T == struct), 
                           "only structs can be mocked using this type of mock");
            return dmocks.factory.mockStructPassTo!(T)(_repository, to);
        }

        /**
         * Record new expectation that will exactly match method called in methodCall argument
         *
         * Returns an object that allows you to set various properties of the expectation,
         * such as return value, number of repetitions or matching options.
         *
         * Examples:
         * ---
         * Mocker m = new Mocker;
         * Object o = m.Mock!(Object);
         * m.expect(o.toString).returns("hello?");
         * ---
         */
        ExpectationSetup expect (T) (lazy T methodCall) {
            auto pre = _repository.LastRecordedCallExpectation();
            methodCall();
            auto post = _repository.LastRecordedCallExpectation();
            if (pre is post)
                throw new InvalidOperationException("mocks.Mocker.expect: you did not call a method mocked by the mocker!");
            return lastCall();
        }

        /**
         * Returns ExpectationSetup object for most recent call on a method of a mock object.
         *
         * This object allows you to set various properties of the expectation,
         * such as return value, number of repetitions or matching options.
         *
         * Examples:
         * ---
         * Mocker m = new Mocker;
         * Object o = m.Mock!(Object);
         * o.toString;
         * m.LastCall().returns("hello?");
         * ---
         */
        ExpectationSetup lastCall () {
            return new ExpectationSetup(_repository.LastRecordedCallExpectation(), _repository.LastRecordedCall());
        }

        /**
         * Set up a result for a method, but without any backend accounting for it.
         * Things where you want to allow this method to be called, but you aren't
         * currently testing for it.
         */
        ExpectationSetup allowing (T) (T ignored) {
            return lastCall().repeatAny;
        }

        /** Ditto */
        ExpectationSetup allowing (T = void) () {
            return lastCall().repeatAny();
        }

        /**
         * Do not require explicit return values for expectations. If no return
         * value is set, return the default value (null / 0 / nan, in most
         * cases). By default, if no return value, exception, delegate, or
         * passthrough option is set, an exception will be thrown.
         */
        void allowDefaults () {
            _repository.AllowDefaults(true);
        }
    }
}

/++
   An ExpectationSetup object allows you to set various properties of the expectation,
   such as: 
    - what action should be taken when method matching expectation is called
        - return value, action to call, exception to throw, etc

   Examples:
   ---
   Mocker m = new Mocker;
   Object o = m.Mock!(Object);
   o.toString;
   m.LastCall().returns("Are you still there?").repeat(1, 12);
   ---
++/
public class ExpectationSetup 
{
    import dmocks.arguments;
    import dmocks.expectation;
    import dmocks.dynamic;
    import dmocks.qualifiers;
    import dmocks.call;

    private CallExpectation _expectation;

    private Call _setUpCall;

   this (CallExpectation expectation, Call setUpCall) 
   {
       assert (expectation !is null, "can't create an ExpectationSetup if expectation is null");
       assert (setUpCall !is null, "can't create an ExpectationSetup if setUpCall is null");
       _expectation = expectation;
       _setUpCall = setUpCall;
   }

   /**
    * Ignore method argument values in matching calls to this expectation.
    */
   ExpectationSetup ignoreArgs () 
   {
       _expectation.arguments = new ArgumentsTypeMatch(_setUpCall.arguments, (Dynamic a, Dynamic b)=>true);
       return this;
   }

   /**
    * Allow providing custom argument comparator for matching calls to this expectation.
    */
   ExpectationSetup customArgsComparator (bool delegate(Dynamic expected, Dynamic provided) del) 
   {
       _expectation.arguments = new ArgumentsTypeMatch(_setUpCall.arguments, del);
       return this;
   }

   /**
    * This expectation must match to at least min number of calls and at most to max number of calls.
    */
   ExpectationSetup repeat (int min, int max) 
   {
       if (min > max) 
       {
           throw new InvalidOperationException("The specified range is invalid.");
       }
        _expectation.repeatInterval = Interval(min, max);
       return this;
   }

   /**
    * This expectation will match exactly i times.
    */
   ExpectationSetup repeat (int i) 
   {
       repeat(i,i);
       return this;
   }

   /**
    * This expectation will match to any number of calls.
    */
   ExpectationSetup repeatAny () 
   {
       return repeat(0, int.max);
   }

   /**
    * When the method which matches this expectation is called execute the
    * given delegate. The delegate's signature must match the signature
    * of the called method. If it does not, an exception will be thrown.
    * The called method will return whatever the given delegate returns.
    * Examples:
    * ---
    * m.expect(myObj.myFunc(0, null, null, 'a')
    *     .ignoreArgs()
    *     .action((int i, char[] s, Object o, char c) { return -1; });
    * ---
    */
   ExpectationSetup action (T, U...)(T delegate(U) action) 
   {
       _expectation.action.action = dynamic(action);
       return this;
   }

   // TODO: how can I get validation here that the type you're
   // inserting is the type expected before trying to execute it?
   // Not really an issue, since it'd be revealed in the space
   // of a single test.
   /**
    * Set the value to return when method matching this expectation is called on a mock object.
    * Params:
    *     value = the value to return
    */
   ExpectationSetup returns (T)(T value) 
   {
       _expectation.action.returnValue = dynamic(value);
       return this;
   }

   /**
    * When the method which matches this expectation is called,
    * throw the given exception. If there are any
    * actions specified (via the action method), they will not be executed.
    */
   ExpectationSetup throws (Exception e) 
   {
       _expectation.action.toThrow = e;
       return this;
   }

   /**
    * Instead of returning or throwing a given value, pass the call through to
    * the mocked type object. For mock***PassTo(obj) obj has to be valid for this to work.
    * 
    * This is useful for example for enabling use of mock object in hashmaps by enabling 
    * toHash and opEquals of your class.
    */
   ExpectationSetup passThrough () 
   {
       _expectation.action.passThrough = true;
       return this;
   }
}

/// backward compatibility alias
alias ExpectationSetup ExternalCall;

version (unittest)
{
    import std.exception;
    import std.stdio;

    class Templated(T)
    {
    }
    interface IM
    {
        void bar();
    }

    class ConstructorArg
    {
        this(int i)
        {
            a = i;
        }
        int a;
        int getA()
        {
            return a;
        }
    }

    class SimpleObject
    {
        this()
        {
        }
        void print()
        {
            writeln(toString());
        }
    }

    interface IRM 
    {
        IM get();
        void set(IM im);
    }

    class HasPrivateMethods
    {
        protected void method()
        {
        }
    }

    interface IFace
    {
        void foo(string s);
    }

    class Smthng : IFace
    {
        void foo(string s)
        {
        }
    }

    class HasMember
    {
        int member;
    }

    class Overloads
    {
        void foo()
        {
        }
        void foo(int i)
        {
        }
    }

    class Qualifiers
    {
        int make() shared
        {
            return 0;
        }

        int make() const
        {
            return 1;
        }

        int make() shared const
        {
            return 2;
        }

        int make()
        {
            return 3;
        }

        int make() immutable
        {
            return 4;
        }
    }

    interface VirtualFinal
    {
        int makeVir();
    }

    class MakeAbstract
    {
        int con;
        this(int con)
        {
            this.con = con;
        }
        abstract int abs();

        int concrete()
        {
            return con;
        }
    }

    class FinalMethods : VirtualFinal
    {
        final int make()
        {
            return 0;
        }
        final int make(int i)
        {
            return 2;
        }
        int makeVir()
        {
            return 5;
        }
    }

    final class FinalClass
    {
        int fortyTwo()
        {
            return 42;
        }
    }

    class TemplateMethods
    {
        string get(T)(T t)
        {
            import std.traits;
            return fullyQualifiedName!T;
        }

        int getSomethings(T...)(T t)
        {
            return T.length;
        }
    }

    struct Struct
    {
        int get()
        {
            return 1;
        }
    }

    struct StructWithFields
    {
        int field;
        int get()
        {
            return field;
        }
    }


    struct StructWithConstructor
    {
        int field;
        this(int i)
        {
            field = i;
        }
        int get()
        {
            return field;
        }
    }

    class Dependency
    {
        private int[] arr = [1, 2];
        private int index = 0;
        public int foo()
        {
            return arr[index++];
        }
    }

    class TakesFloat
    {
        public void foo(float a)
        {
        }
    }

    class Property
    {
        private int _foo;
        @property int foo()
        {
            return _foo;
        }

        @property void foo(int i)
        {
            _foo = i;
        }

        @property T foot(T)()
        {
            static if (is(T == int))
            {
                return _foo;
            }
            else
            {
                return T.init;
            }
        }

        @property void foot(T)(T i)
        {
            static if (is(T == int))
            {
                _foo = i;
            }
        }
    }

}

@("nontemplated mock")
unittest
{
    (new Mocker()).mock!(Object);
}

@("templated mock")
unittest
{
    (new Mocker()).mock!(Templated!(int));
}

@("templated mock")
unittest
{
    (new Mocker()).mock!(IM);
}

@("execute mock method")
unittest
{
    auto r = new Mocker();
    auto o = r.mock!(Object);
    o.toString();
}

@("constructor argument")
unittest
{
    auto r = new Mocker();
    auto o = r.mock!(ConstructorArg)(4);
}

@("lastCall")
unittest
{
    Mocker m = new Mocker();
    SimpleObject o = m.mock!(SimpleObject);
    o.print;
    auto e = m.lastCall;

    assert (e !is null);
}

@("return a value")
unittest
{
    Mocker m = new Mocker();
    Object o = m.mock!(Object);
    o.toString;
    auto e = m.lastCall;

    assert (e !is null);
    e.returns("frobnitz");
}

@("unexpected call")
unittest
{
    Mocker m = new Mocker();
    Object o = m.mock!(Object);
    m.replay();
    assertThrown!ExpectationViolationException(o.toString);
}

@("expect")
unittest
{
    Mocker m = new Mocker();
    Object o = m.mock!(Object);
    m.expect(o.toString).repeat(0).returns("mrow?");
    m.replay();
    assertThrown(o.toString);
}

@("repeat single")
unittest
{
    Mocker m = new Mocker();
    Object o = m.mock!(Object);
    m.expect(o.toString).repeat(2).returns("foom?");

    m.replay();

    o.toString;
    o.toString;
    assertThrown!ExpectationViolationException(o.toString);
}

@("repository match counts")
unittest
{
    auto r = new Mocker();
    auto o = r.mock!(Object);
    o.toString;
    r.lastCall().repeat(2, 2).returns("mew.");
    r.replay();
    assertThrown!ExpectationViolationException(r.verify());
}

@("delegate payload")
unittest
{
    bool calledPayload = false;
    Mocker r = new Mocker();
    auto o = r.mock!(SimpleObject);

    //o.print;
    r.expect(o.print).action({ calledPayload = true; });
    r.replay();

    o.print;
    assert (calledPayload);
}

@("exception payload")
unittest
{
    Mocker r = new Mocker();
    auto o = r.mock!(SimpleObject);

    string msg = "divide by cucumber error";
    o.print;
    r.lastCall().throws(new Exception(msg));
    r.replay();

    try {
        o.print;
        assert (false, "expected exception not thrown");
    } catch (Exception e) {
        // Careful -- assertion errors derive from Exception
        assert (e.msg == msg, e.msg);
    }
}

@("passthrough")
unittest
{
    Mocker r = new Mocker();
    auto o = r.mock!(Object);
    o.toString;
    r.lastCall().passThrough();

    r.replay();
    string str = o.toString;
    assert (str == "dmocks.object_mock.Mocked!(Object).Mocked", str);
}

@("class with constructor init check")
unittest
{
    auto r = new Mocker();
    auto o = r.mock!(ConstructorArg)(4);
    o.getA();
    r.lastCall().passThrough();
    r.replay();
    assert (4 == o.getA());
}

@("associative arrays")
unittest
{
    Mocker r = new Mocker();
    auto o = r.mock!(Object);
    r.expect(o.toHash()).passThrough().repeatAny;
    r.expect(o.opEquals(null)).ignoreArgs().passThrough().repeatAny;

    r.replay();
    int[Object] i;
    i[o] = 5;
    int j = i[o];
}

@("ordering in order")
unittest
{
    Mocker r = new Mocker();
    auto o = r.mock!(Object);
    r.ordered;
    r.expect(o.toHash).returns(cast(hash_t)5);
    r.expect(o.toString).returns("mow!");

    r.replay();
    o.toHash;
    o.toString;
    r.verify;
}

@("ordering not in order")
unittest
{
    Mocker r = new Mocker();
    auto o = r.mock!(Object);
    r.ordered;
    r.expect(o.toHash).returns(5);
    r.expect(o.toString).returns("mow!");

    r.replay();
    try {
        o.toString;
        o.toHash;
        assert (false);
    } catch (ExpectationViolationException) {}
}

@("ordering interposed")
unittest
{
    Mocker r = new Mocker();
    auto o = r.mock!(SimpleObject);
    r.ordered;
    r.expect(o.toHash).returns(cast(hash_t)5);
    r.expect(o.toString).returns("mow!");
    r.unordered;
    o.print;

    r.replay();
    o.toHash;
    o.print;
    o.toString;
}

@("allow unexpected")
unittest
{
    Mocker r = new Mocker();
    auto o = r.mock!(Object);
    r.ordered;
    r.allowUnexpectedCalls(true);
    r.expect(o.toString).returns("mow!");
    r.replay();
    o.toHash; // unexpected tohash calls
    o.toString;
    o.toHash;
    assertThrown!ExpectationViolationException(r.verify(false, true));
    r.verify(true, false);
}

@("allowing")
unittest
{
    Mocker r = new Mocker();
    auto o = r.mock!(Object);
    r.allowing(o.toString).returns("foom?");

    r.replay();
    o.toString;
    o.toString;
    o.toString;
    r.verify;
}

@("nothing for method to do")
unittest
{
    try {
        Mocker r = new Mocker();
        auto o = r.mock!(Object);
        r.allowing(o.toString);

        r.replay();
        assert (false, "expected a mocks setup exception");
    } catch (MocksSetupException e) {
    }
}

@("allow defaults test")
unittest
{
    Mocker r = new Mocker();
    auto o = r.mock!(Object);
    r.allowDefaults;
    r.allowing(o.toString);

    r.replay();
    assert (o.toString == (char[]).init);
}

// Going through the guts of Smthng
// unittest
// {
//     auto foo = new Smthng();
//     auto guts = *(cast(int**)&foo);
//     auto len = __traits(classInstanceSize, Smthng) / size_t.sizeof; 
//     auto end = guts + len;
//     for (; guts < end; guts++) {
//         writefln("\t%x", *guts);
//     } 
// }

@("mock interface")
unittest
{
    auto r = new Mocker;
    IFace o = r.mock!(IFace);
    debugLog("about to call once...");
    o.foo("hallo");
    r.replay;
    debugLog("about to call twice...");
    o.foo("hallo");
    r.verify;
}

@("cast mock to interface")
unittest
{
    auto r = new Mocker;
    IFace o = r.mock!(Smthng);
    debugLog("about to call once...");
    o.foo("hallo");
    r.replay;
    debugLog("about to call twice...");
    o.foo("hallo");
    r.verify;
}

@("cast mock to interface")
unittest
{
    auto r = new Mocker;
    IFace o = r.mock!(Smthng);
    debugLog("about to call once...");
    o.foo("hallo");
    r.replay;
    debugLog("about to call twice...");
    o.foo("hallo");
    r.verify;
}

@("return user-defined type")
unittest
{
    auto r = new Mocker;
    auto o = r.mock!(IRM);
    auto im = r.mock!(IM);
    debugLog("about to call once...");
    r.expect(o.get).returns(im);
    o.set(im);
    r.replay;
    debugLog("about to call twice...");
    assert (o.get is im, "returned the wrong value");
    o.set(im);
    r.verify;
}

@("return user-defined type")
unittest
{
    auto r = new Mocker;
    auto o = r.mock!(HasMember);    	
}

@("overloaded method")
unittest
{
    auto r = new Mocker;
    auto o = r.mock!(Overloads);  
    o.foo();
    o.foo(1);
    r.replay;
    o.foo(1);
    o.foo;
    r.verify;
}

@("overloaded method qualifiers")
unittest
{
    {
        auto r = new Mocker;
        auto s = r.mock!(shared(Qualifiers));
        auto sc = cast(shared const) s;

        r.expect(s.make).passThrough;
        r.expect(sc.make).passThrough; 
        r.replay;

        assert(s.make == 0);
        assert(sc.make == 2);

        r.verify;
    }
    {
        auto r = new Mocker;
        auto m = r.mock!(Qualifiers);
        auto c = cast(const) m;
        auto i = cast(immutable) m;

        r.expect(i.make).passThrough;
        r.expect(m.make).passThrough; 
        r.expect(c.make).passThrough; 
        r.replay;

        assert(i.make == 4);
        assert(m.make == 3);
        assert(c.make == 1);

        r.verify;
    }
    {
        auto r = new Mocker;
        auto m = r.mock!(Qualifiers);
        auto c = cast(const) m;
        auto i = cast(immutable) m;

        r.expect(i.make).passThrough;
        r.expect(m.make).passThrough; 
        r.expect(m.make).passThrough; 
        r.replay;

        assert(i.make == 4);
        assert(m.make == 3);
        try
        {
            assert(c.make == 1);
            assert(false, "exception not thrown");
        }
        catch (ExpectationViolationException e)
        {
        }
    }
}

@("final mock of virtual methods")
unittest
{
    import std.exception;

    auto r = new Mocker;
    auto o = r.mockFinal!(VirtualFinal);  
    r.expect(o.makeVir()).returns(5);
    r.replay;
    assert(o.makeVir == 5);
}

@("final mock of abstract methods")
unittest
{
    auto r = new Mocker;
    auto o = r.mockFinal!(MakeAbstract)(6);
    r.expect(o.concrete()).passThrough;
    r.replay;
    assert(o.concrete == 6);
    r.verify;
}

@("final methods")
unittest
{
    auto r = new Mocker;
    auto o = r.mockFinal!(FinalMethods);  
    r.expect(o.make()).passThrough;
    r.expect(o.make(1)).passThrough; 
    r.replay;
    static assert(!is(typeof(o)==FinalMethods));
    assert(o.make == 0);
    assert(o.make(1) == 2);
    r.verify;
}

@("final class")
unittest
{
    auto r = new Mocker;
    auto o = r.mockFinal!(FinalClass);  
    r.expect(o.fortyTwo()).passThrough;
    r.replay;
    assert(o.fortyTwo == 42);
    r.verify;
}

@("final class with no underlying object")
unittest
{
    auto r = new Mocker;
    auto o = r.mockFinalPassTo!(FinalClass)(null);  
    r.expect(o.fortyTwo()).returns(43);
    r.replay;
    assert(o.fortyTwo == 43);
    r.verify;
}

@("template methods")
unittest
{
    auto r = new Mocker;
    auto o = r.mockFinal!(TemplateMethods);  
    r.expect(o.get(1)).passThrough;
    r.expect(o.getSomethings(1, 2, 3)).passThrough;
    r.replay;
    assert(o.get(1) == "int");
    auto tm = new TemplateMethods();
    assert(o.getSomethings(1, 2, 3) == 3);
    r.verify;
}

@("struct")
unittest
{
    auto r = new Mocker;
    auto o = r.mockStruct!(Struct);  
    r.expect(o.get).passThrough;
    r.replay;
    assert(o.get() == 1);
    r.verify;
}

@("struct with fields")
unittest
{
    auto r = new Mocker;
    auto o = r.mockStruct!(StructWithFields)(5);  
    r.expect(o.get).passThrough;
    r.replay;
    assert(o.get() == 5);
    r.verify;
}

@("struct with fields")
unittest
{
    auto r = new Mocker;
    auto o = r.mockStruct!(StructWithConstructor)(5);  
    r.expect(o.get).passThrough;
    r.replay;
    assert(o.get() == 5);
    r.verify;
}

@("struct with no underlying object")
unittest
{
    auto r = new Mocker;
    auto o = r.mockStructPassTo(StructWithConstructor.init);  
    r.expect(o.get).returns(6);
    r.replay;
    assert(o.get() == 6);
    r.verify;
}

@("returning different values on the same expectation")
unittest
{
    auto mocker = new Mocker;
    auto dependency = mocker.mock!Dependency;

    //mocker.ordered;
    mocker.expect(dependency.foo).returns(1);
    mocker.expect(dependency.foo).returns(2);
    mocker.replay;
    assert(dependency.foo == 1);
    assert(dependency.foo == 2);
    mocker.verify;
}

@("customArgsComparator")
unittest
{
    import std.math;

    auto mocker = new Mocker;
    auto dependency = mocker.mock!TakesFloat;
    mocker.expect(dependency.foo(1.0f)).customArgsComparator(
         (Dynamic a, Dynamic b) 
         { 
             if (a.type == typeid(float))
                { return ( abs(a.get!float() - b.get!float()) < 0.1f); } 
             return true;
         }).repeat(2);
    mocker.replay;

    // custom comparison example - treat similar floats as equals
    dependency.foo(1.01);
    dependency.foo(1.02);
}

unittest
{
    auto mocker = new Mocker;
    auto dependency = mocker.mockFinal!Property;
    mocker.ordered;
    mocker.expect(dependency.foo = 2).ignoreArgs.passThrough;
    mocker.expect(dependency.foo).passThrough;
    //TODO: these 2 don't work yet
    //mocker.expect(dependency.foot!int = 5).passThrough;
    //mocker.expect(dependency.foot!int).passThrough;
    mocker.replay;

    dependency.foo = 7;
    assert(dependency.foo ==7);
    //dependency.foot!int = 3;
    //assert(dependency.foot!int == 3);
    mocker.verify;
}

/*TODO - typesafe variadic methods do not work yet
class Foo {
    int x;
    string s;

    this(int x, string s) {
        this.x = x;
        this.s = s;
    }
}

class Varargs
{
    import core.vararg;
    
    int varDyn(int first, ...)
    {
        return vvarDyn(first, _arguments, _argptr);
    }

    // idiom from C - for every dynamic vararg function there has to be vfunction(Args, TypeInfo[] arguments, va_list argptr)
    // otherwise passThrough is impossible
    int vvarDyn(int first, TypeInfo[] arguments, va_list argptr)
    {
        assert(arguments[0] == typeid(int));
        int second = va_arg!int(argptr);
        return first + second;
    }

    int varArray(int first, int[] next...)
    {
        return first + next[0];
    }

    int varClass(int first, Foo f...)
    {
        return first + f.x;
    }
}

unittest 
{
    import core.vararg;

    auto mocker = new Mocker;
    auto dependency = mocker.mock!Varargs;
    mocker.record;
    // we only specify non-vararg arguments in setup because typeunsafe varargs can't have meaningful operations on them (like comparision, etc)
    mocker.expect(dependency.varDyn(42)).passThrough; // passThrough works with typeunsafe vararg functions only when v[funcname](Args, Typeinfo[], va_list) function variant is provided
    mocker.replay;

    assert(dependency.varDyn(42, 5) == 47);
}*/