diff --git a/meson.build b/meson.build
index 0f0375a..4319226 100644
--- a/meson.build
+++ b/meson.build
@@ -4,6 +4,14 @@ sources = files(
     'src/vest.vala',
     'src/testCaseDescriptor.vala',
     'src/testSuite.vala',
+    'src/methodMock/voidArglessMethodMock.vala',
+    'src/methodMock/voidMethodMock.vala',
+    'src/methodMock/voidMethodMockN.vala',
+    'src/methodMock/arglessMethodMock.vala',
+    'src/methodMock/methodMock.vala',
+    'src/methodMock/methodMockN.vala',
+    'src/methodMock/methodMockArguments.vala',
+    'src/methodMock/objectToString.vala',
     'src/errors.vala',
     'src/assert.vala',
     'src/results/testSuiteResult.vala',
@@ -37,6 +45,7 @@ test_files = files(
     'test/vestRunner.vala',
     'test/suiteTest.vala',
     'test/assertionTest.vala',
+    'test/methodMockTest.vala',
 )
 
 libvest_tests = executable(
diff --git a/src/assert.vala b/src/assert.vala
index 98d6158..76eda98 100644
--- a/src/assert.vala
+++ b/src/assert.vala
@@ -5,7 +5,7 @@ namespace io.github.jorchube.vest
     public errordomain assertionError {
         AssertionFailed
     }
-    
+
     public class Assert : Object
     {
         public delegate void RaisesDelegate() throws Error;
@@ -43,33 +43,74 @@ namespace io.github.jorchube.vest
             }
         }
 
-        public static void equals<T, S>(T a, S b, string? message = null) throws assertionError
+        public static void equals<T, S>(T expected, S value, string? message = null) throws assertionError
         {
+            if (expected == null && value != null)
+            {
+                equalsFailed("Expected null but was not null");
+                return;
+            }
+
+            if (expected != null && value == null)
+            {
+                equalsFailed("Expected not null but was null");
+                return;
+            }
+
             if (typeof(T) != typeof(S))
             {
                 equalsFailed(message);
+                return;
             }
-            
+
             if (typeof(T).is_object())
             {
-                objectEquals(a, b, message);
+                objectEquals(expected, value, message);
                 return;
             }
 
-            if (a != b)
+            if (typeof(T).is_a(Type.STRING))
             {
-                equalsFailed(message);
+                stringEquals((string)expected, (string)value);
+                return;
+            }
+
+            if (typeof(T).is_a(Type.INT))
+            {
+                intEquals((int)expected, (int)value);
+                return;
+            }
+
+            if (expected != value)
+            {
+                equalsFailed("Elements were not equal");
+            }
+        }
+
+        private static void intEquals(int expected, int value) throws assertionError
+        {
+            if (expected != value)
+            {
+                equalsFailed("Expected \"%d\" is not equal to \"%d\"".printf(expected, value));
+            }
+        }
+
+        private static void stringEquals(string expected, string value) throws assertionError
+        {
+            if (strcmp(expected, value) != 0)
+            {
+                equalsFailed("Expected \"%s\" is not equal to \"%s\"".printf(expected, value));
             }
         }
 
-        private static void objectEquals<T>(T a, T b, string? message = null) throws assertionError
+        private static void objectEquals<T>(T expected, T value, string? message = null) throws assertionError
         {
-            if (a == b)
+            if (expected == value)
             {
                 return;
             }
 
-            equalsComparable(a, b, message);
+            equalsComparable(expected, value, message);
         }
 
         public static void @null(Object? a, string? message = null) throws assertionError
@@ -88,11 +129,11 @@ namespace io.github.jorchube.vest
             }
         }
 
-        private static void equalsComparable<T>(T a, T b, string? message = null) throws assertionError
+        private static void equalsComparable<T>(T expected, T value, string? message = null) throws assertionError
         {
             try
             {
-                if (((Comparable<T>)a).compare_to(b) != 0)
+                if (((Comparable<T>)expected).compare_to(value) != 0)
                 {
                     equalsFailed(message);
                 }
diff --git a/src/methodMock/arglessMethodMock.vala b/src/methodMock/arglessMethodMock.vala
new file mode 100644
index 0000000..587a4ce
--- /dev/null
+++ b/src/methodMock/arglessMethodMock.vala
@@ -0,0 +1,25 @@
+using Gee;
+
+namespace io.github.jorchube.vest
+{
+    public class ArglessMethod<R> : VoidArglessMethodMock
+    {
+        Gee.Queue<R> returnValues;
+
+        public ArglessMethod()
+        {
+            returnValues = new LinkedList<R>();
+        }
+
+        public void returns (R retval)
+        {
+            returnValues.offer(retval);
+        }
+
+        public new R call()
+        {
+            base.call();
+            return returnValues.poll();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/methodMock/methodMock.vala b/src/methodMock/methodMock.vala
new file mode 100644
index 0000000..4c66409
--- /dev/null
+++ b/src/methodMock/methodMock.vala
@@ -0,0 +1,32 @@
+using Gee;
+
+namespace io.github.jorchube.vest
+{
+    public class MethodMock<T, R> : VoidMethodMock<T>
+    {
+        HashMap<T, R> returnMap;
+
+        public MethodMock()
+        {
+            base();
+            returnMap = new HashMap<T, R>();
+        }
+
+        public new R call(T arg)
+        {
+            base.call(arg);
+
+            if (returnMap.has_key(arg))
+            {
+                return returnMap.get(arg);
+            }
+
+            return null;
+        }
+
+        public void returns(T? arg, R? returnValue)
+        {
+            returnMap.set(arg, returnValue);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/methodMock/methodMockArguments.vala b/src/methodMock/methodMockArguments.vala
new file mode 100644
index 0000000..26b8b6b
--- /dev/null
+++ b/src/methodMock/methodMockArguments.vala
@@ -0,0 +1,162 @@
+using Gee;
+
+namespace io.github.jorchube.vest
+{
+    public interface ToStringable : Object
+    {
+        public abstract string to_string();
+    }
+
+    public class ArgValue : Object
+    {
+        public Value value {get; private set; }
+        public string valueString {get; private set; }
+
+        public ArgValue (Value value, string valueString)
+        {
+            this.value = value;
+            this.valueString = valueString;
+        }
+    }
+
+    public class MethodMockArguments<T1, T2, T3, T4, T5, T6, T7, T8, T9> : Object, Hashable<MethodMockArguments>
+    {
+        Gee.List<ArgValue> arguments;
+
+        private delegate ArgValue argValueFromArgDelegate<TN>(TN arg);
+
+        private argValueFromArgDelegate<T1> valueFromArg1;
+        private argValueFromArgDelegate<T2> valueFromArg2;
+        private argValueFromArgDelegate<T3> valueFromArg3;
+        private argValueFromArgDelegate<T4> valueFromArg4;
+        private argValueFromArgDelegate<T5> valueFromArg5;
+        private argValueFromArgDelegate<T6> valueFromArg6;
+        private argValueFromArgDelegate<T7> valueFromArg7;
+        private argValueFromArgDelegate<T8> valueFromArg8;
+        private argValueFromArgDelegate<T9> valueFromArg9;
+
+        private int numArgs;
+
+        public MethodMockArguments(int numArgs, T1? arg1, T2? arg2, T3? arg3, T4? arg4, T5? arg5, T6? arg6, T7? arg7, T8? arg8, T9? arg9)
+        {
+            arguments = new ArrayList<ArgValue>();
+
+            this.numArgs = numArgs;
+
+            initArgValueFromArgDelegates();
+
+            arguments.add(valueFromArg1(arg1));
+            arguments.add(valueFromArg2(arg2));
+            arguments.add(valueFromArg3(arg3));
+            arguments.add(valueFromArg4(arg4));
+            arguments.add(valueFromArg5(arg5));
+            arguments.add(valueFromArg6(arg6));
+            arguments.add(valueFromArg7(arg7));
+            arguments.add(valueFromArg8(arg8));
+            arguments.add(valueFromArg9(arg9));
+        }
+
+        public uint hash()
+        {
+            return to_string().hash();
+        }
+
+        public bool equal_to(MethodMockArguments other)
+        {
+            return hash() == other.hash();
+        }
+
+        public string to_string()
+        {
+            StringBuilder strBuilder = new StringBuilder(typeof(MethodMockArguments).name());
+
+            strBuilder.append("(");
+
+            for(int i=0; i<numArgs; ++i)
+            {
+                strBuilder.append(argToString(arguments[i]));
+            }
+
+            strBuilder.append(")");
+
+            return strBuilder.str;
+        }
+
+        private string argToString(ArgValue arg)
+        {
+            StringBuilder strBuilder = new StringBuilder();
+
+            strBuilder
+                .append(arg.value.type_name())
+                .append("(")
+                .append(arg.valueString)
+                .append(")");
+
+            return strBuilder.str;
+        }
+
+        private void initArgValueFromArgDelegates()
+        {
+            valueFromArg1 = (a) => { return valueFromArg<T1>(a); };
+            valueFromArg2 = (a) => { return valueFromArg<T2>(a); };
+            valueFromArg3 = (a) => { return valueFromArg<T3>(a); };
+            valueFromArg4 = (a) => { return valueFromArg<T4>(a); };
+            valueFromArg5 = (a) => { return valueFromArg<T5>(a); };
+            valueFromArg6 = (a) => { return valueFromArg<T6>(a); };
+            valueFromArg7 = (a) => { return valueFromArg<T7>(a); };
+            valueFromArg8 = (a) => { return valueFromArg<T8>(a); };
+            valueFromArg9 = (a) => { return valueFromArg<T9>(a); };
+        }
+
+        private ArgValue valueFromArg<TN>(TN arg)
+        {
+            Value value = Value(typeof(TN));
+            string valueString = "";
+
+            switch(typeof(TN))
+            {
+                case Type.INT:
+                    value.set_int((int)arg);
+                    valueString = ((int)arg).to_string();
+                    break;
+                case Type.BOOLEAN:
+                    value.set_boolean((bool)arg);
+                    valueString = ((bool)arg).to_string();
+                    break;
+                case Type.CHAR:
+                    value.set_schar((int8)arg);
+                    valueString = ((char)arg).to_string();
+                    break;
+                case Type.LONG:
+                    value.set_long((long)arg);
+                    valueString = ((long)arg).to_string();
+                    break;
+                case Type.DOUBLE:
+                    value.set_double((double?)arg);
+                    valueString = ((double?)arg).to_string();
+                    break;
+                case Type.STRING:
+                    value.set_string((string)arg);
+                    valueString = (string)arg;
+                    break;
+                default:
+                    if (typeof(TN).is_a(Type.OBJECT))
+                    {
+                        value.set_object((Object)arg);
+                        valueString = object_to_string((Object)arg);
+                        break;
+                    }
+                    if (typeof(TN).is_a(Type.ENUM))
+                    {
+                        value.set_enum((int)arg);
+                        valueString = ((int)arg).to_string();
+                        break;
+                    }
+
+                    break;
+            }
+
+            return new ArgValue(value, valueString);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/methodMock/methodMockN.vala b/src/methodMock/methodMockN.vala
new file mode 100644
index 0000000..d6b6833
--- /dev/null
+++ b/src/methodMock/methodMockN.vala
@@ -0,0 +1,272 @@
+namespace io.github.jorchube.vest
+{
+    public class MethodMock1<T1, R> : MethodMock<MethodMockArguments, R>
+    {
+        private const int numArgs = 1;
+
+        public MethodMock1()
+        {
+            base();
+        }
+
+        public new R call(T1 arg1)
+        {
+            return base.call(mockArgs(arg1));
+        }
+
+        public new bool calledWith(T1 arg1)
+        {
+            return base.calledWith(mockArgs(arg1));
+        }
+
+        public new void returns(T1 arg1, R returnValue)
+        {
+            base.returns(mockArgs(arg1), returnValue);
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1)
+        {
+            return new MethodMockArguments<T1, int, int, int, int, int, int, int, int>(numArgs, arg1, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+    }
+
+    public class MethodMock2<T1, T2, R> : MethodMock<MethodMockArguments, R>
+    {
+        private const int numArgs = 2;
+
+        public MethodMock2()
+        {
+            base();
+        }
+
+        public new R call(T1 arg1, T2 arg2)
+        {
+            return base.call(mockArgs(arg1, arg2));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2)
+        {
+            return base.calledWith(mockArgs(arg1, arg2));
+        }
+
+        public new void returns(T1 arg1, T2 arg2, R returnValue)
+        {
+            base.returns(mockArgs(arg1, arg2), returnValue);
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2)
+        {
+            return new MethodMockArguments<T1, T2, int, int, int, int, int, int, int>(numArgs, arg1, arg2, 0, 0, 0, 0, 0, 0, 0);
+        }
+    }
+
+    public class MethodMock3<T1, T2, T3, R> : MethodMock<MethodMockArguments, R>
+    {
+        private const int numArgs = 3;
+
+        public MethodMock3()
+        {
+            base();
+        }
+
+        public new R call(T1 arg1, T2 arg2, T3 arg3)
+        {
+            return base.call(mockArgs(arg1, arg2, arg3));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3));
+        }
+
+        public new void returns(T1 arg1, T2 arg2, T3 arg3, R returnValue)
+        {
+            base.returns(mockArgs(arg1, arg2, arg3), returnValue);
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3)
+        {
+            return new MethodMockArguments<T1, T2, T3, int, int, int, int, int, int>(numArgs, arg1, arg2, arg3, 0, 0, 0, 0, 0, 0);
+        }
+    }
+
+    public class MethodMock4<T1, T2, T3, T4, R> : MethodMock<MethodMockArguments, R>
+    {
+        private const int numArgs = 4;
+
+        public MethodMock4()
+        {
+            base();
+        }
+
+        public new R call(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            return base.call(mockArgs(arg1, arg2, arg3, arg4));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4));
+        }
+
+        public new void returns(T1 arg1, T2 arg2, T3 arg3, T4 arg4, R returnValue)
+        {
+            base.returns(mockArgs(arg1, arg2, arg3, arg4), returnValue);
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, int, int, int, int, int>(numArgs, arg1, arg2, arg3, arg4, 0, 0, 0, 0, 0);
+        }
+    }
+
+    public class MethodMock5<T1, T2, T3, T4, T5, R> : MethodMock<MethodMockArguments, R>
+    {
+        private const int numArgs = 5;
+
+        public MethodMock5()
+        {
+            base();
+        }
+
+        public new R call(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        {
+            return base.call(mockArgs(arg1, arg2, arg3, arg4, arg5));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4, arg5));
+        }
+
+        public new void returns(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, R returnValue)
+        {
+            base.returns(mockArgs(arg1, arg2, arg3, arg4, arg5), returnValue);
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, T5, int, int, int, int>(numArgs, arg1, arg2, arg3, arg4, arg5, 0, 0, 0, 0);
+        }
+    }
+
+    public class MethodMock6<T1, T2, T3, T4, T5, T6, R> : MethodMock<MethodMockArguments, R>
+    {
+        private const int numArgs = 6;
+
+        public MethodMock6()
+        {
+            base();
+        }
+
+        public new R call(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+        {
+            return base.call(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6));
+        }
+
+        public new void returns(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, R returnValue)
+        {
+            base.returns(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6), returnValue);
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, T5, T6, int, int, int>(numArgs, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0, 0);
+        }
+    }
+
+    public class MethodMock7<T1, T2, T3, T4, T5, T6, T7, R> : MethodMock<MethodMockArguments, R>
+    {
+        private const int numArgs = 7;
+
+        public MethodMock7()
+        {
+            base();
+        }
+
+        public new R call(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+        {
+            return base.call(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7));
+        }
+
+        public new void returns(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, R returnValue)
+        {
+            base.returns(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7), returnValue);
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, T5, T6, T7, int, int>(numArgs, arg1, arg2, arg3, arg4, arg5, arg6, arg7, 0, 0);
+        }
+    }
+
+    public class MethodMock8<T1, T2, T3, T4, T5, T6, T7, T8, R> : MethodMock<MethodMockArguments, R>
+    {
+        private const int numArgs = 8;
+
+        public MethodMock8()
+        {
+            base();
+        }
+
+        public new R call(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
+        {
+            return base.call(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
+        }
+
+        public new void returns(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, R returnValue)
+        {
+            base.returns(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8), returnValue);
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, T5, T6, T7, T8, int>(numArgs, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, 0);
+        }
+    }
+
+    public class MethodMock9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> : MethodMock<MethodMockArguments, R>
+    {
+        private const int numArgs = 9;
+
+        public MethodMock9()
+        {
+            base();
+        }
+
+        public new R call(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
+        {
+            return base.call(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
+        }
+
+        public new void returns(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, R returnValue)
+        {
+            base.returns(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9), returnValue);
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, T5, T6, T7, T8, T9>(numArgs, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/methodMock/objectToString.vala b/src/methodMock/objectToString.vala
new file mode 100644
index 0000000..74267a4
--- /dev/null
+++ b/src/methodMock/objectToString.vala
@@ -0,0 +1,153 @@
+/*
+    https://gitlab.gnome.org/-/snippets/1116
+*/
+
+/* * Do what you will with this code! * */
+  /**
+   * prints the property values of a GLib.Objcet/GObject.
+   */
+public string object_to_string (GLib.Object obj) {
+    GLib.ObjectClass real_obj = (GLib.ObjectClass) obj.get_type ().class_ref ();
+
+    var str_builder = new GLib.StringBuilder ();
+
+
+    str_builder.append ("(")
+                .append (obj.get_type().name ())
+                .append ("):\n");
+
+    foreach (GLib.ParamSpec ps in real_obj.list_properties ()) {
+
+        if (ps.value_type == 0 || ps.value_type == GLib.Type.INVALID) {
+            continue;
+        }
+
+        var prop_name = ps.get_name ();
+
+        Value prop_val = GLib.Value (ps.value_type);
+
+        if (prop_val.type () == GLib.Type.INVALID || prop_val.type () == 0) {
+            continue;
+        }
+
+        obj.get_property (prop_name, ref prop_val);
+
+
+        str_builder.append ("\t(")
+                    .append (prop_val.type_name ())
+                    .append (") ")
+                    .append (prop_name)
+                    .append (": ");
+
+
+        switch (prop_val.type ()) {
+        case (GLib.Type.STRING):
+            if (prop_val.dup_string () == null) {
+            str_builder.append ("(null)");
+            } else {
+            str_builder.append (prop_val.dup_string ());
+            }
+        break;
+        case (GLib.Type.INT):
+            str_builder.append (prop_val.get_int ().to_string ());
+        break;
+        case (GLib.Type.BOOLEAN):
+            str_builder.append (prop_val.get_boolean ().to_string ());
+        break;
+        case (GLib.Type.CHAR):
+            var v = prop_val.get_schar ();
+            str_builder.append_c (v)
+                        .append (" (")
+                        .append_printf ("%hhx", v);
+            str_builder.append (")");
+        break;
+        case (GLib.Type.DOUBLE):
+            str_builder.append (prop_val.get_double ().to_string ());
+        break;
+        case (GLib.Type.ENUM):
+            str_builder.append (prop_val.get_enum ().to_string ());
+        break;
+        case (GLib.Type.FLAGS):
+            // TODO: Probobly needs better handling, but this will do.
+            str_builder.append (prop_val.get_flags ().to_string ());
+        break;
+        case (GLib.Type.FLOAT):
+            str_builder.append (prop_val.get_float ().to_string ());
+        break;
+        case (GLib.Type.INT64):
+            str_builder.append (prop_val.get_int64 ().to_string ());
+        break;
+        case (GLib.Type.LONG):
+            str_builder.append (prop_val.get_long ().to_string ());
+        break;
+        case (GLib.Type.OBJECT):
+            str_builder.append_printf ("%llX", (((long)((pointer)prop_val.dup_object ()))));
+        break;
+        /* /!\ NOTE: Invalid case /!\
+            * A ParamSpec can't "contain" a ParamSpec.
+        case (GLib.Type.PARAM):
+            var spsc = prop_val.get_param ();
+            if (spsc == null) {
+            str_builder.append ("(null)");
+            } else {
+            str_builder.append ("name: ")
+                        .append (spsc.name)
+                        .append (" type: ")
+                        .append (spsc.value_type.name ());
+            }
+        break;
+        */
+        case (GLib.Type.POINTER):
+            str_builder.append ("(")
+                        .append_printf ("%llX", (((long)prop_val.get_pointer ())));
+            str_builder.append (")");
+        break;
+        case (GLib.Type.BOXED):
+            str_builder.append ("(")
+                        .append_printf ("%llX", (((long)prop_val.get_boxed ())));
+            str_builder.append (")");
+        break;
+        case (GLib.Type.UCHAR):
+            var v = prop_val.get_uchar ();
+            str_builder.append_c ((char) v)
+                        .append (" (")
+                        .append_printf ("%hhx", v);
+            str_builder.append (")");
+        break;
+        case (GLib.Type.UINT):
+            str_builder.append (prop_val.get_uint ().to_string ());
+        break;
+        case (GLib.Type.UINT64):
+            str_builder.append (prop_val.get_uint64 ().to_string ());
+        break;
+        case (GLib.Type.ULONG):
+            str_builder.append (prop_val.get_ulong ().to_string ());
+        break;
+        case (GLib.Type.VARIANT):
+            GLib.Variant v = prop_val.dup_variant ();
+            GLib.Variant? tv = null;
+            unowned string ts1 = v.get_type_string ();
+            str_builder.append ("")
+                        .append (ts1)
+                        .append ("\n\t(\n");
+            GLib.VariantIter iter = v.iterator ();
+            tv = iter.next_value ();
+            while (tv != null) {
+            unowned string ts2 = tv.get_type_string ();
+            string tp = tv.print (true);
+            str_builder.append ("\t\t((")
+                        .append (ts2)
+                        .append ("): ")
+                        .append (tp)
+                        .append (")\n");
+            tv = iter.next_value ();
+            }
+            str_builder.append ("\t)");
+
+        break;
+        }
+        str_builder.append ("\n");
+    }
+
+    return str_builder.str;
+}
\ No newline at end of file
diff --git a/src/methodMock/voidArglessMethodMock.vala b/src/methodMock/voidArglessMethodMock.vala
new file mode 100644
index 0000000..a666a1f
--- /dev/null
+++ b/src/methodMock/voidArglessMethodMock.vala
@@ -0,0 +1,17 @@
+namespace io.github.jorchube.vest
+{
+    public class VoidArglessMethodMock
+    {
+        private int calls = 0;
+
+        public int numCalls()
+        {
+            return calls;
+        }
+
+        public void call()
+        {
+            calls++;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/methodMock/voidMethodMock.vala b/src/methodMock/voidMethodMock.vala
new file mode 100644
index 0000000..75b0f08
--- /dev/null
+++ b/src/methodMock/voidMethodMock.vala
@@ -0,0 +1,25 @@
+using Gee;
+
+namespace io.github.jorchube.vest
+{
+    public class VoidMethodMock<T> : VoidArglessMethodMock
+    {
+        HashSet<T> callMap;
+
+        public VoidMethodMock()
+        {
+            callMap = new HashSet<T>();
+        }
+
+        public bool calledWith(T? arg)
+        {
+            return callMap.contains(arg);
+        }
+
+        public new void call(T? arg)
+        {
+            base.call();
+            callMap.add(arg);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/methodMock/voidMethodMockN.vala b/src/methodMock/voidMethodMockN.vala
new file mode 100644
index 0000000..e60ddf3
--- /dev/null
+++ b/src/methodMock/voidMethodMockN.vala
@@ -0,0 +1,227 @@
+namespace io.github.jorchube.vest
+{
+    public class VoidMethodMock1<T1> : VoidMethodMock<MethodMockArguments>
+    {
+        private const int numArgs = 1;
+
+        public VoidMethodMock1()
+        {
+            base();
+        }
+
+        public new void call(T1 arg1)
+        {
+            base.call(mockArgs(arg1));
+        }
+
+        public new bool calledWith(T1 arg1)
+        {
+            return base.calledWith(mockArgs(arg1));
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1)
+        {
+            return new MethodMockArguments<T1, int, int, int, int, int, int, int, int>(numArgs, arg1, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+    }
+
+    public class VoidMethodMock2<T1, T2> : VoidMethodMock<MethodMockArguments>
+    {
+        private const int numArgs = 2;
+
+        public VoidMethodMock2()
+        {
+            base();
+        }
+
+        public new void call(T1 arg1, T2 arg2)
+        {
+            base.call(mockArgs(arg1, arg2));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2)
+        {
+            return base.calledWith(mockArgs(arg1, arg2));
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2)
+        {
+            return new MethodMockArguments<T1, T2, int, int, int, int, int, int, int>(numArgs, arg1, arg2, 0, 0, 0, 0, 0, 0, 0);
+        }
+    }
+
+    public class VoidMethodMock3<T1, T2, T3> : VoidMethodMock<MethodMockArguments>
+    {
+        private const int numArgs = 3;
+
+        public VoidMethodMock3()
+        {
+            base();
+        }
+
+        public new void call(T1 arg1, T2 arg2, T3 arg3)
+        {
+            base.call(mockArgs(arg1, arg2, arg3));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3));
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3)
+        {
+            return new MethodMockArguments<T1, T2, T3, int, int, int, int, int, int>(numArgs, arg1, arg2, arg3, 0, 0, 0, 0, 0, 0);
+        }
+    }
+
+    public class VoidMethodMock4<T1, T2, T3, T4> : VoidMethodMock<MethodMockArguments>
+    {
+        private const int numArgs = 4;
+
+        public VoidMethodMock4()
+        {
+            base();
+        }
+
+        public new void call(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            base.call(mockArgs(arg1, arg2, arg3, arg4));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4));
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, int, int, int, int, int>(numArgs, arg1, arg2, arg3, arg4, 0, 0, 0, 0, 0);
+        }
+    }
+
+    public class VoidMethodMock5<T1, T2, T3, T4, T5> : VoidMethodMock<MethodMockArguments>
+    {
+        private const int numArgs = 5;
+
+        public VoidMethodMock5()
+        {
+            base();
+        }
+
+        public new void call(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        {
+            base.call(mockArgs(arg1, arg2, arg3, arg4, arg5));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4, arg5));
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, T5, int, int, int, int>(numArgs, arg1, arg2, arg3, arg4, arg5, 0, 0, 0, 0);
+        }
+    }
+
+    public class VoidMethodMock6<T1, T2, T3, T4, T5, T6> : VoidMethodMock<MethodMockArguments>
+    {
+        private const int numArgs = 6;
+
+        public VoidMethodMock6()
+        {
+            base();
+        }
+
+        public new void call(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+        {
+            base.call(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6));
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, T5, T6, int, int, int>(numArgs, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0, 0);
+        }
+    }
+
+    public class VoidMethodMock7<T1, T2, T3, T4, T5, T6, T7> : VoidMethodMock<MethodMockArguments>
+    {
+        private const int numArgs = 7;
+
+        public VoidMethodMock7()
+        {
+            base();
+        }
+
+        public new void call(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+        {
+            base.call(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7));
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, T5, T6, T7, int, int>(numArgs, arg1, arg2, arg3, arg4, arg5, arg6, arg7, 0, 0);
+        }
+    }
+
+    public class VoidMethodMock8<T1, T2, T3, T4, T5, T6, T7, T8> : VoidMethodMock<MethodMockArguments>
+    {
+        private const int numArgs = 8;
+
+        public VoidMethodMock8()
+        {
+            base();
+        }
+
+        public new void call(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
+        {
+            base.call(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, T5, T6, T7, T8, int>(numArgs, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, 0);
+        }
+    }
+
+    public class VoidMethodMock9<T1, T2, T3, T4, T5, T6, T7, T8, T9> : VoidMethodMock<MethodMockArguments>
+    {
+        private const int numArgs = 9;
+
+        public VoidMethodMock9()
+        {
+            base();
+        }
+
+        public new void call(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
+        {
+            base.call(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
+        }
+
+        public new bool calledWith(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
+        {
+            return base.calledWith(mockArgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
+        }
+
+        private MethodMockArguments mockArgs(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
+        {
+            return new MethodMockArguments<T1, T2, T3, T4, T5, T6, T7, T8, T9>(numArgs, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/assertionTest.vala b/test/assertionTest.vala
index 0bdc413..c0ea83f 100644
--- a/test/assertionTest.vala
+++ b/test/assertionTest.vala
@@ -51,11 +51,43 @@ namespace io.github.jorchube.vest.test
                 Assert.raises(new assertionError.AssertionFailed(""), () => { Assert.false(true); });
             });
 
+            test("Assert equals does not raise on two strings that are equal", () =>
+            {
+                string a = "string";
+                string b = "string";
+
+                Assert.equals(a, b);
+            });
+
+            test("Assert equals raises on two strings that are not equal", () =>
+            {
+                string a = "aaa";
+                string b = "bbb";
+
+                Assert.raises(new assertionError.AssertionFailed(""), () => { Assert.equals(a, b); });
+            });
+
             test("Assert equals raises on two objects of different types", () =>
             {
                 Assert.raises(new assertionError.AssertionFailed(""), () => { Assert.equals(new ObjectTypeA(), new ObjectTypeB()); });
             });
 
+            test("Assert equals does not raise on two integers that are equal", () =>
+            {
+                int a = 1;
+                int b = 1;
+
+                Assert.equals(a, b);
+            });
+
+            test("Assert equals does raises on two integers that are not equal", () =>
+            {
+                int a = 1234;
+                int b = 154576;
+
+                Assert.raises(new assertionError.AssertionFailed(""), () => { Assert.equals(a, b); });
+            });
+
             test("Assert equals does not raise on two objects with same reference", () =>
             {
                 Object a = new Object();
diff --git a/test/methodMockTest.vala b/test/methodMockTest.vala
new file mode 100644
index 0000000..dccb086
--- /dev/null
+++ b/test/methodMockTest.vala
@@ -0,0 +1,310 @@
+using io.github.jorchube.vest;
+
+namespace io.github.jorchube.vest.test
+{
+    public class MethodMockTest : Suite
+    {
+        public override void testCases ()
+        {
+            test("It returns method number of calls", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                Assert.equals(0, stub.aVoidArglessMethodMock.numCalls());
+
+                stub.aVoidArglessMethod();
+                Assert.equals(1, stub.aVoidArglessMethodMock.numCalls());
+
+                stub.aVoidArglessMethod();
+                Assert.equals(2, stub.aVoidArglessMethodMock.numCalls());
+            });
+
+            test("It returns true if call has been made with given argument", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.aVoidMethod(3);
+
+                Assert.equals(1, stub.aVoidMethodMock.numCalls());
+                Assert.false(stub.aVoidMethodMock.calledWith(2));
+                Assert.true(stub.aVoidMethodMock.calledWith(3));
+            });
+
+            test("It returns the given return value", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.anArglessMethodMock.returns("to return");
+
+                string ret = stub.anArglessMethod();
+
+                Assert.equals(1, stub.anArglessMethodMock.numCalls());
+                Assert.equals("to return", ret);
+            });
+
+            test("It returns the given return values in the same order as set up", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.anArglessMethodMock.returns("to return first");
+                stub.anArglessMethodMock.returns("to return second");
+                stub.anArglessMethodMock.returns("to return last");
+
+                Assert.equals("to return first", stub.anArglessMethod());
+                Assert.equals("to return second", stub.anArglessMethod());
+                Assert.equals("to return last", stub.anArglessMethod());
+                Assert.equals(3, stub.anArglessMethodMock.numCalls());
+            });
+
+            test("It returns null if no more return values have been set up", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.anArglessMethodMock.returns("to return");
+
+                Assert.equals("to return", stub.anArglessMethod());
+                Assert.null((Object)stub.anArglessMethod());
+                Assert.equals(2, stub.anArglessMethodMock.numCalls());
+            });
+
+            test("It returns the given value for the given argument or null otherwise", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.aMethodMock.returns(1, "one");
+                stub.aMethodMock.returns(2, "two");
+
+                Assert.equals("one", stub.aMethod(1));
+                Assert.equals("two", stub.aMethod(2));
+                Assert.null((Object)stub.aMethod(3));
+                Assert.equals(3, stub.aMethodMock.numCalls());
+
+                Assert.true(stub.aMethodMock.calledWith(1));
+                Assert.true(stub.aMethodMock.calledWith(2));
+                Assert.true(stub.aMethodMock.calledWith(3));
+                Assert.false(stub.aMethodMock.calledWith(4));
+            });
+
+            test("It returns the given value for the given 1 int argument or null otherwise", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.aMethodMock1Int.returns(1, "one");
+                stub.aMethodMock1Int.returns(2, "two");
+
+                Assert.equals("one", stub.aMethod1Int(1));
+                Assert.equals("two", stub.aMethod1Int(2));
+                Assert.null((Object)stub.aMethod1Int(3));
+                Assert.equals(3, stub.aMethodMock1Int.numCalls());
+
+                Assert.true(stub.aMethodMock1Int.calledWith(1));
+                Assert.true(stub.aMethodMock1Int.calledWith(2));
+                Assert.true(stub.aMethodMock1Int.calledWith(3));
+                Assert.false(stub.aMethodMock1Int.calledWith(4));
+            });
+
+            test("It returns the given value for the given 1 string argument or null otherwise", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.aMethodMock1String.returns("one", 1);
+                stub.aMethodMock1String.returns("two", 2);
+
+                Assert.equals(1, stub.aMethod1String("one"));
+                Assert.equals(2, stub.aMethod1String("two"));
+                Assert.null((Object)stub.aMethod1String("three"));
+                Assert.equals(3, stub.aMethodMock1String.numCalls());
+
+                Assert.true(stub.aMethodMock1String.calledWith("one"));
+                Assert.true(stub.aMethodMock1String.calledWith("two"));
+                Assert.true(stub.aMethodMock1String.calledWith("three"));
+                Assert.false(stub.aMethodMock1String.calledWith("four"));
+            });
+
+            test("It returns the given value for the given 1 object argument or null otherwise", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.aMethodMock1Object.returns(new AnObject(1), "one");
+                stub.aMethodMock1Object.returns(new AnObject(2), "two");
+
+                Assert.equals("one", stub.aMethod1Object(new AnObject(1)));
+                Assert.equals("two", stub.aMethod1Object(new AnObject(2)));
+                Assert.null((Object)stub.aMethod1Object(new AnObject(3)));
+                Assert.equals(3, stub.aMethodMock1Object.numCalls());
+
+                Assert.true(stub.aMethodMock1Object.calledWith(new AnObject(1)));
+                Assert.true(stub.aMethodMock1Object.calledWith(new AnObject(2)));
+                Assert.true(stub.aMethodMock1Object.calledWith(new AnObject(3)));
+                Assert.false(stub.aMethodMock1Object.calledWith(new AnObject(4)));
+            });
+
+            test("It returns the given value for the given 2 arguments or null otherwise", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.aMethodMock2.returns(1, 2.2, "one");
+                stub.aMethodMock2.returns(2, 1.1, "two");
+
+                Assert.equals("one", stub.aMethod2(1, 2.2));
+                Assert.equals("two", stub.aMethod2(2, 1.1));
+                Assert.null((Object)stub.aMethod2(1, 2.1));
+                Assert.equals(3, stub.aMethodMock2.numCalls());
+
+                Assert.true(stub.aMethodMock2.calledWith(1, 2.2));
+                Assert.true(stub.aMethodMock2.calledWith(2, 1.1));
+                Assert.true(stub.aMethodMock2.calledWith(1, 2.1));
+                Assert.false(stub.aMethodMock2.calledWith(4, 5.0));
+            });
+
+            test("It returns true if a call has been done with the given 9 (LOL 9) arguments", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.aVoidMethod9(1, AnEnum.A, true, 'c', 123, 0.99, "aaa", new AnObject(999), 0);
+                stub.aVoidMethod9(1, AnEnum.B, false, 'c', 123, 0.99, "aba", new AnObject(333), 0);
+
+                Assert.equals(2, stub.aVoidMethodMock9.numCalls());
+
+                Assert.true(stub.aVoidMethodMock9.calledWith(1, AnEnum.A, true, 'c', 123, 0.99, "aaa", new AnObject(999), 0));
+                Assert.true(stub.aVoidMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.99, "aba", new AnObject(333), 0));
+
+                Assert.false(stub.aVoidMethodMock9.calledWith(0, AnEnum.B, false, 'c', 123, 0.99, "aba", new AnObject(333), 0));
+                Assert.false(stub.aVoidMethodMock9.calledWith(1, AnEnum.A, false, 'c', 123, 0.99, "aba", new AnObject(333), 0));
+                Assert.false(stub.aVoidMethodMock9.calledWith(1, AnEnum.B, true, 'c', 123, 0.99, "aba", new AnObject(333), 0));
+                Assert.false(stub.aVoidMethodMock9.calledWith(1, AnEnum.B, false, 'd', 123, 0.99, "aba", new AnObject(333), 0));
+                Assert.false(stub.aVoidMethodMock9.calledWith(1, AnEnum.B, false, 'c', 124, 0.99, "aba", new AnObject(333), 0));
+                Assert.false(stub.aVoidMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.98, "aba", new AnObject(333), 0));
+                Assert.false(stub.aVoidMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.99, "abc", new AnObject(333), 0));
+                Assert.false(stub.aVoidMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.99, "aba", new AnObject(334), 0));
+                Assert.false(stub.aVoidMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.99, "aba", new AnObject(333), 1));
+            });
+
+            test("It returns the given value for the given 9 (LOL 9) arguments or null otherwise", () =>
+            {
+                AnInterfaceStub stub = new AnInterfaceStub();
+
+                stub.aMethodMock9.returns(1, AnEnum.A, true, 'c', 123, 0.99, "aaa", new AnObject(999), 0, "a return");
+                stub.aMethodMock9.returns(1, AnEnum.B, false, 'c', 123, 0.99, "aaa", new AnObject(333), 0, "another return");
+
+                Assert.equals("a return", stub.aMethod9(1, AnEnum.A, true, 'c', 123, 0.99, "aaa", new AnObject(999), 0));
+                Assert.equals("another return", stub.aMethod9(1, AnEnum.B, false, 'c', 123, 0.99, "aaa", new AnObject(333), 0));
+                Assert.null((Object)stub.aMethod9(1, AnEnum.B, false, 'c', 123, 0.99, "aba", new AnObject(333), 0));
+                Assert.equals(3, stub.aMethodMock9.numCalls());
+
+                Assert.true(stub.aMethodMock9.calledWith(1, AnEnum.A, true, 'c', 123, 0.99, "aaa", new AnObject(999), 0));
+                Assert.true(stub.aMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.99, "aaa", new AnObject(333), 0));
+                Assert.true(stub.aMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.99, "aba", new AnObject(333), 0));
+
+                Assert.false(stub.aMethodMock9.calledWith(0, AnEnum.B, false, 'c', 123, 0.99, "aba", new AnObject(333), 0));
+                Assert.false(stub.aMethodMock9.calledWith(1, AnEnum.A, false, 'c', 123, 0.99, "aba", new AnObject(333), 0));
+                Assert.false(stub.aMethodMock9.calledWith(1, AnEnum.B, true, 'c', 123, 0.99, "aba", new AnObject(333), 0));
+                Assert.false(stub.aMethodMock9.calledWith(1, AnEnum.B, false, 'd', 123, 0.99, "aba", new AnObject(333), 0));
+                Assert.false(stub.aMethodMock9.calledWith(1, AnEnum.B, false, 'c', 124, 0.99, "aba", new AnObject(333), 0));
+                Assert.false(stub.aMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.98, "aba", new AnObject(333), 0));
+                Assert.false(stub.aMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.99, "abc", new AnObject(333), 0));
+                Assert.false(stub.aMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.99, "aba", new AnObject(334), 0));
+                Assert.false(stub.aMethodMock9.calledWith(1, AnEnum.B, false, 'c', 123, 0.99, "aba", new AnObject(333), 1));
+            });
+        }
+    }
+
+    public class AnInterfaceStub : Object
+    {
+        public VoidArglessMethodMock aVoidArglessMethodMock;
+        public VoidMethodMock<int> aVoidMethodMock;
+        public ArglessMethod<string> anArglessMethodMock;
+        public MethodMock<int, string> aMethodMock;
+        public MethodMock1<int, string> aMethodMock1Int;
+        public MethodMock1<string, int> aMethodMock1String;
+        public MethodMock1<AnObject, string> aMethodMock1Object;
+        public MethodMock2<long, double?, string> aMethodMock2;
+        public VoidMethodMock9<int, AnEnum, bool, char, long, double?, string, AnObject, int> aVoidMethodMock9;
+        public MethodMock9<int, AnEnum, bool, char, long, double?, string, AnObject, int, string> aMethodMock9;
+
+        public AnInterfaceStub()
+        {
+            aVoidArglessMethodMock = new VoidArglessMethodMock();
+            aVoidMethodMock = new VoidMethodMock<int>();
+            anArglessMethodMock = new ArglessMethod<string>();
+            aMethodMock = new MethodMock<int, string>();
+            aMethodMock1Int = new MethodMock1<int, string>();
+            aMethodMock1String = new MethodMock1<string, int>();
+            aMethodMock1Object = new MethodMock1<AnObject, string>();
+            aMethodMock2 = new MethodMock2<long, double?, string>();
+            aVoidMethodMock9 = new VoidMethodMock9<int, AnEnum, bool, char, long, double, string, AnObject, int>();
+            aMethodMock9 = new MethodMock9<int, AnEnum, bool, char, long, double, string, AnObject, int, string>();
+        }
+
+        public void aVoidArglessMethod()
+        {
+            aVoidArglessMethodMock.call();
+        }
+
+        public void aVoidMethod(int arg)
+        {
+            aVoidMethodMock.call(arg);
+        }
+
+        public string anArglessMethod()
+        {
+            return anArglessMethodMock.call();
+        }
+
+        public string aMethod(int arg)
+        {
+            return aMethodMock.call(arg);
+        }
+
+        public string aMethod1Int(int arg)
+        {
+            return aMethodMock1Int.call(arg);
+        }
+
+        public int aMethod1String(string arg)
+        {
+            return aMethodMock1String.call(arg);
+        }
+
+        public string aMethod1Object(AnObject arg)
+        {
+            return aMethodMock1Object.call(arg);
+        }
+
+        public string aMethod2(long arg1, double arg2)
+        {
+            return aMethodMock2.call(arg1, arg2);
+        }
+
+        public void aVoidMethod9(int arg1, AnEnum arg2, bool arg3, char arg4, long arg5, double arg6, string arg7, AnObject arg8, int arg9)
+        {
+            aVoidMethodMock9.call(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+        }
+
+        public string aMethod9(int arg1, AnEnum arg2, bool arg3, char arg4, long arg5, double arg6, string arg7, AnObject arg8, int arg9)
+        {
+            return aMethodMock9.call(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+        }
+    }
+
+    public enum AnEnum
+    {
+        A,
+        B
+    }
+
+    public class AnObject : Object
+    {
+        public int a {get; private set;}
+
+        public AnObject(int a)
+        {
+            this.a = a;
+        }
+
+        public string to_string()
+        {
+            return "AnObject(%d)".printf(a);
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/suiteTest.vala b/test/suiteTest.vala
index 1cc654a..bda48bb 100644
--- a/test/suiteTest.vala
+++ b/test/suiteTest.vala
@@ -2,7 +2,7 @@ using io.github.jorchube.vest;
 
 namespace io.github.jorchube.vest.test
 {
-    class SuiteTest : Suite
+    public class SuiteTest : Suite
     {
         private bool setupCalled = false;
 
diff --git a/test/vestRunner.vala b/test/vestRunner.vala
index fec4207..c6cd109 100644
--- a/test/vestRunner.vala
+++ b/test/vestRunner.vala
@@ -10,6 +10,8 @@ namespace io.github.jorchube.vest.test
 
         Vest.addSuite(new AssertionTest(), "Assertions");
 
+        Vest.addSuite(new MethodMockTest(), "MethodMock");
+
         Vest.run();
     }
 }
\ No newline at end of file