Merge branch 'method_mocks' into main

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(

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);
                 }

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();
+        }
+    }
+}

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);
+        }
+    }
+}

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);
+        }
+    }
+}