Merge pull request #6051 from tommy9/AddingFakes

Adding more test fakes

Author: retailcoder

Rubberduck.Core/Runtime/BeepInterceptor.cs

@@ -15,6 +15,7 @@ public interface IBeepInterceptor : IDisposable
     {
         void SuppressBeep(double millisecondsToSuppress);
         event EventHandler<BeepEventArgs> Beep;
+        void NativeCall();
     }
 
     public sealed class BeepInterceptor : IBeepInterceptor
@@ -24,6 +25,7 @@ public sealed class BeepInterceptor : IBeepInterceptor
         private readonly IVbeNativeApi _vbeApi;
         private readonly LocalHook _hook;
         private readonly Timer _timer;
+        private VbaBeepDelegate nativeCall;
 
         public BeepInterceptor(IVbeNativeApi vbeApi)
         {
@@ -40,12 +42,19 @@ public void SuppressBeep(double millisecondsToSuppress)
             _timer.Enabled = true;
         }
 
+        public void NativeCall()
+        {
+            nativeCall();
+        }
+
         private LocalHook HookVbaBeep()
         {
             var processAddress = LocalHook.GetProcAddress(_vbeApi.DllName, "rtcBeep");
             var callbackDelegate = new VbaBeepDelegate(VbaBeepCallback);
             var hook = LocalHook.Create(processAddress, callbackDelegate, null);
             hook.ThreadACL.SetInclusiveACL(new[] { 0 });
+            var nativeFunctionAddress = hook.HookBypassAddress;
+            nativeCall = Marshal.GetDelegateForFunctionPointer<VbaBeepDelegate>(nativeFunctionAddress);
             return hook;
         }
 
@@ -65,7 +74,7 @@ private void VbaBeepCallback()
 
             if (!e.Handled)
             {
-                _vbeApi.Beep();
+                nativeCall();
             }
         }
 

Rubberduck.Main/ComClientLibrary/Abstract/UnitTesting/IFakesProvider.cs

@@ -13,11 +13,11 @@ namespace Rubberduck.UnitTesting
     public interface IFakesProvider
     {
         [DispId(1)]
-        [Description("Configures VBA.Interactions.MsgBox calls.")]
+        [Description("Configures VBA.Interaction.MsgBox calls.")]
         IFake MsgBox { get; }
 
         [DispId(2)]
-        [Description("Configures VBA.Interactions.InputBox calls.")]
+        [Description("Configures VBA.Interaction.InputBox calls.")]
         IFake InputBox { get; }
 
         [DispId(3)]
@@ -79,5 +79,61 @@ public interface IFakesProvider
         [DispId(17)]
         [Description("Configures VBA.DateTime.Date calls.")]
         IFake Date { get; }
+
+        [DispId(18)]
+        [Description("Configures VBA.Math.Rnd calls.")]
+        IFake Rnd { get; }
+
+        [DispId(19)]
+        [Description("Configures VBA.Interaction.DeleteSetting calls.")]
+        IStub DeleteSetting { get; }
+
+        [DispId(20)]
+        [Description("Configures VBA.Interaction.SaveSetting calls.")]
+        IStub SaveSetting { get; }
+
+        [DispId(21)]
+        [Description("Configures VBA.Interaction.GetSetting calls.")]
+        IFake GetSetting { get; }
+
+        [DispId(22)]
+        [Description("Configures VBA.Math.Randomize calls.")]
+        IStub Randomize { get; }
+
+        [DispId(23)]
+        [Description("Configures VBA.Interaction.GetAllSettings calls.")]
+        IFake GetAllSettings { get; }
+
+        [DispId(24)]
+        [Description("Configures VBA.FileSystem.SetAttr calls.")]
+        IStub SetAttr { get; }
+
+        [DispId(25)]
+        [Description("Configures VBA.FileSystem.GetAttr calls.")]
+        IFake GetAttr { get; }
+
+        [DispId(26)]
+        [Description("Configures VBA.FileSystem.FileLen calls.")]
+        IFake FileLen { get; }
+
+        [DispId(27)]
+        [Description("Configures VBA.FileSystem.FileDateTime calls.")]
+        IFake FileDateTime { get; }
+
+        [DispId(28)]
+        [Description("Configures VBA.FileSystem.FreeFile calls.")]
+        IFake FreeFile { get; }
+
+        [DispId(29)]
+        [Description("Configures VBA.Information.IMEStatus calls.")]
+        IFake IMEStatus { get; }
+
+        [DispId(30)]
+        [Description("Configures VBA.FileSystem.Dir calls.")]
+        IFake Dir { get; }
+
+        [DispId(31)]
+        [Description("Configures VBA.FileSystem.FileCopy calls.")]
+        IStub FileCopy { get; }
     }
 }

Rubberduck.Main/ComClientLibrary/UnitTesting/Fakes/Date.cs

@@ -24,9 +24,8 @@ public void DateCallback(IntPtr retVal)
             }
             if (PassThrough)
             {
-                object result;
-                VbeProvider.VbeNativeApi.GetDateVar(out result);
-                Marshal.GetNativeVariantForObject(result, retVal);
+                var nativeCall = Marshal.GetDelegateForFunctionPointer<DateDelegate>(NativeFunctionAddress);
+                nativeCall(retVal);
                 return;
             }
             Marshal.GetNativeVariantForObject(ReturnValue ?? 0, retVal);

Rubberduck.Main/ComClientLibrary/UnitTesting/Fakes/Dir.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Runtime.InteropServices;
+using Rubberduck.Parsing.Grammar;
+
+namespace Rubberduck.UnitTesting.Fakes
+{
+    internal class Dir : FakeBase
+    {
+        public Dir()
+        {
+            var processAddress = EasyHook.LocalHook.GetProcAddress(VbeProvider.VbeNativeApi.DllName, "rtcDir");
+
+            InjectDelegate(new DirDelegate(DirCallback), processAddress);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.BStr)]
+        private delegate string DirDelegate(IntPtr pathname, short attributes);
+
+        public string DirCallback(IntPtr pathname, short attributes)
+        {
+            OnCallBack();
+
+            TrackUsage("pathname", pathname);
+            TrackUsage("attributes", attributes, Tokens.Integer);
+            if (PassThrough)
+            {
+                var nativeCall = Marshal.GetDelegateForFunctionPointer<DirDelegate>(NativeFunctionAddress);
+                return nativeCall(pathname, attributes);
+            }
+
+            return ReturnValue?.ToString() ?? string.Empty;
+        }    
+    }
+}

Rubberduck.Main/ComClientLibrary/UnitTesting/Fakes/DoEvents.cs

@@ -29,7 +29,8 @@ public int DoEventsCallback()
 
             if (PassThrough)
             {
-                return VbeProvider.VbeNativeApi.DoEvents();
+                var nativeCall = Marshal.GetDelegateForFunctionPointer<DoEventsDelegate>(NativeFunctionAddress);
+                return nativeCall();
             }
             return (int)(ReturnValue ?? 0);
         }

Rubberduck.Main/ComClientLibrary/UnitTesting/Fakes/FileDateTime.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Runtime.InteropServices;
+using Rubberduck.Parsing.Grammar;
+
+namespace Rubberduck.UnitTesting.Fakes
+{
+    internal class FileDateTime : FakeBase
+    {
+        public FileDateTime()
+        {
+            var processAddress = EasyHook.LocalHook.GetProcAddress(VbeProvider.VbeNativeApi.DllName, "rtcFileDateTime");
+
+            InjectDelegate(new FileDateTimeDelegate(FileDateTimeCallback), processAddress);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true)]
+        private delegate void FileDateTimeDelegate(IntPtr retVal, IntPtr pathname);
+
+        public void FileDateTimeCallback(IntPtr retVal, IntPtr pathname)
+        {
+            OnCallBack();
+
+            var pathNameArg = Marshal.PtrToStringBSTR(pathname);
+            TrackUsage("pathname", pathNameArg, Tokens.String);
+            if (PassThrough)
+            {
+                var nativeCall = Marshal.GetDelegateForFunctionPointer<FileDateTimeDelegate>(NativeFunctionAddress);
+                nativeCall(retVal, pathname);
+            }
+
+            Marshal.GetNativeVariantForObject(ReturnValue ?? 0, retVal);
+        }    
+    }
+}

Rubberduck.Main/ComClientLibrary/UnitTesting/Fakes/FileLen.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Runtime.InteropServices;
+using Rubberduck.Parsing.Grammar;
+
+namespace Rubberduck.UnitTesting.Fakes
+{
+    internal class FileLen : FakeBase
+    {
+        public FileLen()
+        {
+            var processAddress = EasyHook.LocalHook.GetProcAddress(VbeProvider.VbeNativeApi.DllName, "rtcFileLen");
+
+            InjectDelegate(new FileLenDelegate(FileLenCallback), processAddress);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.I4)]
+        private delegate int FileLenDelegate(IntPtr pathname);
+
+        public int FileLenCallback(IntPtr pathname)
+        {
+            OnCallBack();
+
+            var pathNameArg = Marshal.PtrToStringBSTR(pathname);
+            TrackUsage("pathname", pathNameArg, Tokens.String);
+            if (PassThrough)
+            {
+                var nativeCall = Marshal.GetDelegateForFunctionPointer<FileLenDelegate>(NativeFunctionAddress);
+                return nativeCall(pathname);
+            }
+
+            return Convert.ToInt32(ReturnValue ?? 0);
+        }    
+    }
+}

Rubberduck.Main/ComClientLibrary/UnitTesting/Fakes/FreeFile.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Rubberduck.UnitTesting.Fakes
+{
+    internal class FreeFile : FakeBase
+    {
+        public FreeFile()
+        {
+            var processAddress = EasyHook.LocalHook.GetProcAddress(VbeProvider.VbeNativeApi.DllName, "rtcFreeFile");
+
+            InjectDelegate(new FreeFileDelegate(FreeFileCallback), processAddress);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.I2)]
+        private delegate short FreeFileDelegate(IntPtr rangenumber);
+
+        public short FreeFileCallback(IntPtr rangenumber)
+        {
+            OnCallBack();
+
+            TrackUsage("rangenumber", rangenumber);
+            if (PassThrough)
+            {
+                var nativeCall = Marshal.GetDelegateForFunctionPointer<FreeFileDelegate>(NativeFunctionAddress);
+                return nativeCall(rangenumber);
+            }
+
+            return Convert.ToInt16(ReturnValue ?? 0);
+        }    
+    }
+}

Rubberduck.Main/ComClientLibrary/UnitTesting/Fakes/GetAllSettings.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Runtime.InteropServices;
+using Rubberduck.Parsing.Grammar;
+
+namespace Rubberduck.UnitTesting.Fakes
+{
+    internal class GetAllSettings : FakeBase
+    {
+        public GetAllSettings()
+        {
+            var processAddress = EasyHook.LocalHook.GetProcAddress(VbeProvider.VbeNativeApi.DllName, "rtcGetAllSettings");
+
+            InjectDelegate(new GetAllSettingsDelegate(GetAllSettingsCallback), processAddress);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true)]
+        private delegate void GetAllSettingsDelegate(IntPtr retVal, IntPtr appName, IntPtr section);
+
+        public void GetAllSettingsCallback(IntPtr retVal, IntPtr appName, IntPtr section)
+        {
+            OnCallBack();
+
+            var appNameArg = Marshal.PtrToStringBSTR(appName);
+            var sectionArg = Marshal.PtrToStringBSTR(section);
+            TrackUsage("appname", appNameArg, Tokens.String);
+            TrackUsage("section", sectionArg, Tokens.String);
+            if (PassThrough)
+            {
+                var nativeCall = Marshal.GetDelegateForFunctionPointer<GetAllSettingsDelegate>(NativeFunctionAddress);
+                nativeCall(retVal, appName, section);
+                return;
+            }
+            Marshal.GetNativeVariantForObject(ReturnValue ?? 0, retVal);
+        }
+    }
+}

Rubberduck.Main/ComClientLibrary/UnitTesting/Fakes/GetAttr.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Runtime.InteropServices;
+using Rubberduck.Parsing.Grammar;
+
+namespace Rubberduck.UnitTesting.Fakes
+{
+    internal class GetAttr : FakeBase
+    {
+        public GetAttr()
+        {
+            var processAddress = EasyHook.LocalHook.GetProcAddress(VbeProvider.VbeNativeApi.DllName, "rtcGetFileAttr");
+
+            InjectDelegate(new GetAttrDelegate(GetAttrCallback), processAddress);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.I2)]
+        private delegate short GetAttrDelegate(IntPtr pathname);
+
+        public short GetAttrCallback(IntPtr pathname)
+        {
+            OnCallBack();
+
+            var pathNameArg = Marshal.PtrToStringBSTR(pathname);
+            TrackUsage("pathname", pathNameArg, Tokens.String);
+            if (PassThrough)
+            {
+                var nativeCall = Marshal.GetDelegateForFunctionPointer<GetAttrDelegate>(NativeFunctionAddress);
+                return nativeCall(pathname);
+            }
+
+            return Convert.ToInt16(ReturnValue ?? 0);
+        }    
+    }
+}