/// <summary>
/// Returns an IVsShell that does not implement any methods
/// </summary>
/// <returns></returns>
internal static BaseMock GetVsShellInstance()
{
if (vsShellFactory == null)
{
vsShellFactory = new GenericMockFactory("VsShell", new Type[] { typeof(IVsShell) });
}
BaseMock shell = vsShellFactory.GetInstance();
return(shell);
}
/// <summary>
/// Gets an IVsRegisterProject service mock object
/// </summary>
/// <returns></returns>
internal static BaseMock GetRegisterProjectInstance()
{
if (null == registerProjectFactory)
{
registerProjectFactory = new GenericMockFactory("MockRegisterProject", new Type[] { typeof(IVsRegisterProjectTypes) });
}
BaseMock mock = registerProjectFactory.GetInstance();
return(mock);
}
/// <summary>
/// Returns an IVsUiShell that does not implement any methods
/// </summary>
/// <returns></returns>
internal static BaseMock GetSolutionFactoryInstance()
{
if (solutionFactory == null)
{
solutionFactory = new GenericMockFactory("MockSolution", new Type[] { typeof(IVsSolution) });
}
BaseMock solution = solutionFactory.GetInstance();
return(solution);
}
/// <summary>
/// Returns an IVSUserSettings that does not implement any methods.
/// </summary>
/// <returns></returns>
internal static BaseMock GetUserSettingsFactoryInstance()
{
if (userSettingsFactory == null)
{
userSettingsFactory = new GenericMockFactory("MockUserSettings", new Type[] { typeof(IVsUserSettings) });
}
BaseMock userSettings = userSettingsFactory.GetInstance();
return(userSettings);
}
/// <summary>
/// Return a IVsWindowFrame without any special implementation
/// </summary>
/// <returns></returns>
internal static IVsWindowFrame GetBaseFrame()
{
if (frameFactory == null)
{
frameFactory = new GenericMockFactory("WindowFrame", new Type[] { typeof(IVsWindowFrame), typeof(IVsWindowFrame2) });
}
IVsWindowFrame frame = (IVsWindowFrame)frameFactory.GetInstance();
return(frame);
}
/// <summary>
/// Returns an SVsRegisterEditors service that does not implement any methods
/// </summary>
/// <returns></returns>
internal static BaseMock GetRegisterEditorsInstance()
{
if (registerEditorFactory == null)
{
registerEditorFactory = new GenericMockFactory("SVsRegisterEditors", new Type[] { typeof(IVsRegisterEditors) });
}
BaseMock registerEditor = registerEditorFactory.GetInstance();
return(registerEditor);
}
/// <summary>
/// Returns a property bag that does not implement any methods
/// </summary>
/// <returns></returns>
internal static BaseMock GetPBInstance()
{
if (PBFactory == null)
{
PBFactory = new GenericMockFactory("PropertyBag", new Type[] { typeof(IPropertyBag) });
}
BaseMock pb = PBFactory.GetInstance();
return(pb);
}
/// <summary>
/// Gets an IVsFileChnageEx service mock object
/// </summary>
/// <returns></returns>
internal static BaseMock GetIVsFileChangeEx()
{
if (null == fileChangeEx)
{
fileChangeEx = new GenericMockFactory("MockIVsFileChangeEx", new Type[] { typeof(IVsFileChangeEx) });
}
BaseMock mock = fileChangeEx.GetInstance();
return(mock);
}
/// <summary>
/// Returns a monitor selection object that does not implement any methods
/// </summary>
/// <returns></returns>
internal static BaseMock GetBaseMonSelInstance()
{
if (MonSelFactory == null)
{
MonSelFactory = new GenericMockFactory("MonitorSelection", new Type[] { typeof(IVsMonitorSelection), typeof(IVsMultiItemSelect) });
}
BaseMock pb = MonSelFactory.GetInstance();
return(pb);
}
/// <summary>
/// Return a IVsRegisterScciProvider without any special implementation
/// </summary>
/// <returns></returns>
internal static IVsRegisterScciProvider GetBaseRegisterScciProvider()
{
if (registerScciProviderFactory == null)
{
registerScciProviderFactory = new GenericMockFactory("RegisterScciProvider", new Type[] { typeof(IVsRegisterScciProvider) });
}
IVsRegisterScciProvider registerProvider = (IVsRegisterScciProvider)registerScciProviderFactory.GetInstance();
return(registerProvider);
}
/// <summary>
/// Returns a SVsSolutionBuildManager that does not implement any methods
/// </summary>
/// <returns></returns>
internal static BaseMock GetSolutionBuildManagerInstance()
{
if (solutionBuildManager == null)
{
solutionBuildManager = new GenericMockFactory("SolutionBuildManager", new Type[] { typeof(IVsSolutionBuildManager2), typeof(IVsSolutionBuildManager3) });
}
BaseMock buildManager = solutionBuildManager.GetInstance();
return(buildManager);
}
/// <summary>
/// Returns an IVsUiShell that does not implement any methods
/// </summary>
/// <returns></returns>
internal static BaseMock GetUiShellInstance()
{
if (uiShellFactory == null)
{
uiShellFactory = new GenericMockFactory("UiShell", new Type[] { typeof(IVsUIShell), typeof(IVsUIShellOpenDocument) });
}
BaseMock uiShell = uiShellFactory.GetInstance();
return(uiShell);
}
/// <summary>
/// Returns an IVsShell that does not implement any methods
/// </summary>
/// <returns></returns>
internal static BaseMock GetShellInstance()
{
if (ShellFactory == null)
{
ShellFactory = new GenericMockFactory("Shell", new Type[] { typeof(IVsShell) });
}
BaseMock Shell = ShellFactory.GetInstance();
return(Shell);
}
/// <summary>
/// Return a IVsTrackProjectDocuments2 without any special implementation
/// </summary>
/// <returns></returns>
internal static BaseMock GetBaseTrackProjectDocuments()
{
if (tpdFactory == null)
{
tpdFactory = new GenericMockFactory("TPDProvider", new Type[] { typeof(IVsTrackProjectDocuments2) });
}
BaseMock tpd = tpdFactory.GetInstance();
return(tpd);
}
/// <summary>
/// Get an ITrackSelection mock object which implements the OnSelectChange method
/// </summary>
/// <returns></returns>
internal static BaseMock GetTrackSelectionInstance()
{
if (trackSelFactory == null)
{
trackSelFactory = new GenericMockFactory("MockTrackSelection", new Type[] { typeof(ITrackSelection) });
}
BaseMock trackSel = trackSelFactory.GetInstance();
string name = string.Format("{0}.{1}", typeof(ITrackSelection).FullName, "OnSelectChange");
trackSel.AddMethodCallback(name, new EventHandler <CallbackArgs>(OnSelectChangeCallBack));
return(trackSel);
}
/// <summary>
/// Gets an IVsWindowFrame mock object which implements the SetProperty method
/// </summary>
/// <returns></returns>
internal static BaseMock GetWindowFrameInstance()
{
if (null == windowFrameFactory)
{
windowFrameFactory = new GenericMockFactory("WindowFrame", new Type[] { typeof(IVsWindowFrame) });
}
BaseMock windowFrame = windowFrameFactory.GetInstance();
string name = string.Format("{0}.{1}", typeof(IVsWindowFrame).FullName, "SetProperty");
windowFrame.AddMethodReturnValues(name, new object[] { VSConstants.S_OK });
return(windowFrame);
}
internal static BaseMock GetInstance()
{
//Create a base mock
GenericMockFactory factory = new GenericMockFactory("ILocalRegistry3", new Type[] { typeof(ILocalRegistry3) });
BaseMock mockObj = factory.GetInstance();
//Add method call back for GetLocalRegistryRoot
string methodName = string.Format("{0}.{1}", typeof(ILocalRegistry3).FullName, "GetLocalRegistryRoot");
mockObj.AddMethodCallback(methodName, new EventHandler <CallbackArgs>(GetLocalRegistryRootCallBack));
return(mockObj);
}
/// <summary>
/// Gets an IVsQueryEditQuerySave2 mock object which implements QuerySaveFile and QueryEditFiles methods
/// </summary>
/// <returns></returns>
internal static BaseMock GetQueryEditQuerySaveInstance()
{
if (null == qeqsFactory)
{
qeqsFactory = new GenericMockFactory("QueryEditQuerySave", new Type[] { typeof(IVsQueryEditQuerySave2) });
}
BaseMock qeqs = qeqsFactory.GetInstance();
string name = string.Format("{0}.{1}", typeof(IVsQueryEditQuerySave2).FullName, "QuerySaveFile");
qeqs.AddMethodCallback(name, new EventHandler <CallbackArgs>(QuerySaveFileCallBack));
name = string.Format("{0}.{1}", typeof(IVsQueryEditQuerySave2).FullName, "QueryEditFiles");
qeqs.AddMethodCallback(name, new EventHandler <CallbackArgs>(QueryEditFilesCallBack));
return(qeqs);
}
/// <summary>
/// Gets the IVsRunningDocumentTable mock object which implements FindAndLockIncrement,
/// NotifyDocumentChanged and UnlockDocument
/// </summary>
/// <returns></returns>
internal static BaseMock GetRunningDocTableInstance()
{
if (null == runningDocFactory)
{
runningDocFactory = new GenericMockFactory("RunningDocumentTable", new Type[] { typeof(IVsRunningDocumentTable) });
}
BaseMock runningDoc = runningDocFactory.GetInstance();
string name = string.Format("{0}.{1}", typeof(IVsRunningDocumentTable).FullName, "FindAndLockDocument");
runningDoc.AddMethodCallback(name, new EventHandler <CallbackArgs>(FindAndLockDocumentCallBack));
name = string.Format("{0}.{1}", typeof(IVsRunningDocumentTable).FullName, "NotifyDocumentChanged");
runningDoc.AddMethodReturnValues(name, new object[] { VSConstants.S_OK });
name = string.Format("{0}.{1}", typeof(IVsRunningDocumentTable).FullName, "UnlockDocument");
runningDoc.AddMethodReturnValues(name, new object[] { VSConstants.S_OK });
return(runningDoc);
}
public void TestIndexComboSetCurValWithInt()
{
ComboBoxPackage packageObject = new ComboBoxPackage();
Assert.IsNotNull(packageObject, "Failed to create package");
OleServiceProvider serviceProvider = OleServiceProvider.CreateOleServiceProviderWithBasicServices();
// Add site support to create and enumerate tool windows
GenericMockFactory mockFactory = new GenericMockFactory("MockUIShell", new Type[] { typeof(IVsUIShell) });
BaseMock uiShell = mockFactory.GetInstance();
serviceProvider.AddService(typeof(SVsUIShell), uiShell, false);
// Site the package
Assert.AreEqual(0, ((IVsPackage)packageObject).SetSite(serviceProvider), "SetSite did not return S_OK");
MethodInfo method = typeof(ComboBoxPackage).GetMethod("OnMenuMyIndexCombo", BindingFlags.NonPublic | BindingFlags.Instance);
int inChoice = 1;
object inParam1 = inChoice;
IntPtr outParam1 = IntPtr.Zero;
object inParam2 = null;
IntPtr outParam2 = Marshal.AllocCoTaskMem(64); //64 == size of a variant + a little extra padding
try
{
// Set IndexCombo to 2nd choice in list
OleMenuCmdEventArgs eventArgs1 = new OleMenuCmdEventArgs(inParam1, outParam1);
object result = method.Invoke(packageObject, new object[] { null, eventArgs1 });
// Retrieve current value of Index and verify it is "Oranges"
OleMenuCmdEventArgs eventArgs2 = new OleMenuCmdEventArgs(inParam2, outParam2);
result = method.Invoke(packageObject, new object[] { null, eventArgs2 });
string retrieved = (string)Marshal.GetObjectForNativeVariant(outParam2);
Assert.AreEqual <string>(expectedIndexComboChoices[inChoice], retrieved);
Assert.AreEqual(1, uiShell.FunctionCalls(String.Format("{0}.{1}", typeof(IVsUIShell).FullName, "ShowMessageBox")), "IVsUIShell.ShowMessageBox was not called");
}
finally
{
if (outParam2 != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(outParam2);
}
}
}
private static void GetToolWindowEnumCallBack0(object caller, CallbackArgs arguments)
{
arguments.ReturnValue = VSConstants.S_OK;
// Create the output mock object
if (enumWindowsFactory0 == null)
{
enumWindowsFactory0 = new GenericMockFactory("EnumWindows", new Type[] { typeof(IEnumWindowFrames) });
}
BaseMock enumWindows = enumWindowsFactory0.GetInstance();
// Add support for Next
string name = string.Format("{0}.{1}", typeof(IEnumWindowFrames).FullName, "Next");
enumWindows.AddMethodCallback(name, new EventHandler <CallbackArgs>(NextCallBack0));
arguments.SetParameter(0, enumWindows);
}
/// <summary>
/// Gets an IVsLocalRegistry mock object
/// </summary>
/// <returns></returns>
internal static BaseMock GetLocalRegistryInstance()
{
if (null == localRegistryFactory)
{
localRegistryFactory = new GenericMockFactory("MockLocalRegistry", new Type[] { typeof(ILocalRegistry), typeof(ILocalRegistry3) });
}
BaseMock localRegistry = localRegistryFactory.GetInstance();
string name = string.Format("{0}.{1}", typeof(IVsWindowFrame).FullName, "SetProperty");
localRegistry.AddMethodReturnValues(name, new object[] { VSConstants.S_OK });
name = string.Format("{0}.{1}", typeof(ILocalRegistry3).FullName, "GetLocalRegistryRoot");
localRegistry.AddMethodCallback(name, new EventHandler <CallbackArgs>(GetLocalRegistryRoot));
return(localRegistry);
}
public void TestDynamicComboSetCurValWithOverflowInt()
{
// NOTE: invalid input is ignored and treated as a NOP
ComboBoxPackage packageObject = new ComboBoxPackage();
Assert.IsNotNull(packageObject, "Failed to create package");
OleServiceProvider serviceProvider = OleServiceProvider.CreateOleServiceProviderWithBasicServices();
// Add site support to create and enumerate tool windows
GenericMockFactory mockFactory = new GenericMockFactory("MockUIShell", new Type[] { typeof(IVsUIShell) });
BaseMock uiShell = mockFactory.GetInstance();
serviceProvider.AddService(typeof(SVsUIShell), uiShell, false);
// Site the package
Assert.AreEqual(0, ((IVsPackage)packageObject).SetSite(serviceProvider), "SetSite did not return S_OK");
MethodInfo method = typeof(ComboBoxPackage).GetMethod("OnMenuMyDynamicCombo", BindingFlags.NonPublic | BindingFlags.Instance);
Int64 inChoice = Int64.MaxValue;
object inParam1 = inChoice.ToString() + inChoice.ToString() + inChoice.ToString();
IntPtr outParam1 = IntPtr.Zero;
object inParam2 = null;
IntPtr outParam2 = Marshal.AllocCoTaskMem(64); //64 == size of a variant + a little extra padding
try
{
// Set DynamicCombo to overflow value
OleMenuCmdEventArgs eventArgs1 = new OleMenuCmdEventArgs(inParam1, outParam1);
object result = method.Invoke(packageObject, new object[] { null, eventArgs1 });
// Retrieve current value of Zoom and verify
OleMenuCmdEventArgs eventArgs2 = new OleMenuCmdEventArgs(inParam2, outParam2);
result = method.Invoke(packageObject, new object[] { null, eventArgs2 });
string retrieved = (string)Marshal.GetObjectForNativeVariant(outParam2);
}
finally
{
if (outParam2 != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(outParam2);
}
}
}
/// <summary>
/// Return an IVsWindowFrame implements GetProperty
/// The peopertiesList will be used too look up PropertyIDs to find values for
/// requested properties
/// </summary>
/// <param name="propertiesList">The dictionary contains PropertyID/Value pairs</param>
/// <returns></returns>
internal static IVsWindowFrame GetFrameWithProperties(Dictionary <int, object> propertiesList)
{
if (frameFactory == null)
{
frameFactory = new GenericMockFactory("WindowFrame", new Type[] { typeof(IVsWindowFrame), typeof(IVsWindowFrame2) });
}
BaseMock frame = (BaseMock)frameFactory.GetInstance();
frame[propertiesName] = propertiesList;
// Add support for GetProperty
string name = string.Format("{0}.{1}", typeof(IVsWindowFrame).FullName, "GetProperty");
frame.AddMethodCallback(name, new EventHandler <CallbackArgs>(GetPropertiesCallBack));
// Add support for GetGuidProperty
name = string.Format("{0}.{1}", typeof(IVsWindowFrame).FullName, "GetGuidProperty");
frame.AddMethodCallback(name, new EventHandler <CallbackArgs>(GetPropertiesCallBack));
return((IVsWindowFrame)frame);
}
public void TestIndexComboSetCurValWithOverflowInt()
{
ComboBoxPackage packageObject = new ComboBoxPackage();
Assert.IsNotNull(packageObject, "Failed to create package");
OleServiceProvider serviceProvider = OleServiceProvider.CreateOleServiceProviderWithBasicServices();
// Add site support to create and enumerate tool windows
GenericMockFactory mockFactory = new GenericMockFactory("MockUIShell", new Type[] { typeof(IVsUIShell) });
BaseMock uiShell = mockFactory.GetInstance();
serviceProvider.AddService(typeof(SVsUIShell), uiShell, false);
// Site the package
Assert.AreEqual(0, ((IVsPackage)packageObject).SetSite(serviceProvider), "SetSite did not return S_OK");
MethodInfo method = typeof(ComboBoxPackage).GetMethod("OnMenuMyIndexCombo", BindingFlags.NonPublic | BindingFlags.Instance);
Int64 inChoice = Int64.MaxValue;
object inParam1 = inChoice;
IntPtr outParam1 = IntPtr.Zero;
object inParam2 = null;
IntPtr outParam2 = Marshal.AllocCoTaskMem(64); //64 == size of a variant + a little extra padding
try
{
// Set IndexCombo to 2nd choice in list
OleMenuCmdEventArgs eventArgs1 = new OleMenuCmdEventArgs(inParam1, outParam1);
bool hasTrown = Utilities.HasFunctionThrown <ArgumentException>(delegate { method.Invoke(packageObject, new object[] { null, eventArgs1 }); });
Assert.IsTrue(hasTrown);
OleMenuCmdEventArgs eventArgs2 = new OleMenuCmdEventArgs(inParam2, outParam2);
object result = method.Invoke(packageObject, new object[] { null, eventArgs2 });
}
finally
{
if (outParam2 != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(outParam2);
}
}
}
private static ICompiler CreateMockCompiler()
{
Type compilerType = GenericMockFactory.CreateType("MockCompiler", new Type[] { typeof(ICompiler) });
BaseMock mockCompiler = (BaseMock)Activator.CreateInstance(compilerType);
string name = string.Format("{0}.{1}", typeof(ICompiler).FullName, "set_SourceFiles");
mockCompiler.AddMethodCallback(name, new EventHandler <CallbackArgs>(SourceFilesCallBack));
name = string.Format("{0}.{1}", typeof(ICompiler).FullName, "set_OutputAssembly");
mockCompiler.AddMethodCallback(name, new EventHandler <CallbackArgs>(OutputAssemblyCallBack));
name = string.Format("{0}.{1}", typeof(ICompiler).FullName, "set_ReferencedAssemblies");
mockCompiler.AddMethodCallback(name, new EventHandler <CallbackArgs>(ReferencedAssembliesCallBack));
name = string.Format("{0}.{1}", typeof(ICompiler).FullName, "set_MainFile");
mockCompiler.AddMethodCallback(name, new EventHandler <CallbackArgs>(MainFileCallBack));
name = string.Format("{0}.{1}", typeof(ICompiler).FullName, "set_IncludeDebugInformation");
mockCompiler.AddMethodCallback(name, new EventHandler <CallbackArgs>(IncludeDebugInformationCallBack));
name = string.Format("{0}.{1}", typeof(ICompiler).FullName, "set_TargetKind");
mockCompiler.AddMethodCallback(name, new EventHandler <CallbackArgs>(TargetKindCallBack));
return((ICompiler)mockCompiler);
}
public void SetSite()
{
// Create the package
var package = new VsExtAutoShelvePackage() as IVsPackage;
Assert.IsNotNull(package, "The object does not implement IVsPackage");
// Create a basic service provider
var serviceProvider = OleServiceProvider.CreateOleServiceProviderWithBasicServices();
var activityLogMock = new GenericMockFactory("MockVsActivityLog", new[] { typeof(Microsoft.VisualStudio.Shell.Interop.IVsActivityLog) }).GetInstance();
serviceProvider.AddService(typeof(Microsoft.VisualStudio.Shell.Interop.SVsActivityLog), activityLogMock, true);
// Site the package
Assert.AreEqual(0, package.SetSite(serviceProvider), "SetSite did not return S_OK");
// Unsite the package
Assert.AreEqual(0, package.SetSite(null), "SetSite(null) did not return S_OK");
}
public void TestOutput()
{
callbackExecuted = false;
// As first create a service provider.
using (OleServiceProvider serviceProvider = OleServiceProvider.CreateOleServiceProviderWithBasicServices())
{
// Create a mock object for the output window pane.
GenericMockFactory mockWindowPaneFactory = new GenericMockFactory("MockOutputWindowPane", new Type[] { typeof(IVsOutputWindowPane) });
BaseMock mockWindowPane = mockWindowPaneFactory.GetInstance();
mockWindowPane.AddMethodCallback(string.Format("{0}.{1}", typeof(IVsOutputWindowPane).FullName, "OutputString"),
new EventHandler <CallbackArgs>(OutputWindowPaneCallback));
// Now create the mock object for the output window.
if (null == mockOutputWindowFactory)
{
mockOutputWindowFactory = new GenericMockFactory("MockOutputWindow1", new Type[] { typeof(IVsOutputWindow) });
}
BaseMock mockOutputWindow = mockOutputWindowFactory.GetInstance();
mockOutputWindow.AddMethodReturnValues(
string.Format("{0}.{1}", typeof(IVsOutputWindow).FullName, "GetPane"),
new object[] { 0, Guid.Empty, (IVsOutputWindowPane)mockWindowPane });
// Add the output window to the services provided by the service provider.
serviceProvider.AddService(typeof(SVsOutputWindow), mockOutputWindow, false);
// Create an instance of the package and initialize it calling SetSite.
ServicesPackage package = new ServicesPackage();
int result = ((IVsPackage)package).SetSite(serviceProvider);
Assert.IsTrue(Microsoft.VisualStudio.ErrorHandler.Succeeded(result), "SetSite failed.");
// Now we can create an instance of the service
MyGlobalService service = new MyGlobalService(package);
service.GlobalServiceFunction();
Assert.IsTrue(callbackExecuted, "OutputText not called.");
((IVsPackage)package).SetSite(null);
((IVsPackage)package).Close();
}
}
static MockObjectExtenders()
{
factory = new GenericMockFactory("MockObjectExtenders", new[] { typeof(ObjectExtenders) });
}
static MockIVsSolutionBuildManager()
{
factory = new GenericMockFactory("MockIVsSolutionBuildManager", new Type[] { typeof(IVsSolutionBuildManager2), typeof(IVsSolutionBuildManager3) });
}
