public void FrameOpenCloseListener_QueryUnloadWrongProject_DoesNotCallClose()
{
var uiShell = IVsUIShell7Factory.ImplementAdviseUnadviseWindowEvents(l => 1234, c => Assert.Equal <uint>(1234, c));
var solution = IVsSolutionFactory.CreateWithAdviseUnadviseSolutionEvents(4321);
var serviceProvider = IServiceProviderFactory.ImplementGetService(ServiceTypeChecker(uiShell, solution));
var editorState = IProjectFileEditorPresenterFactory.ImplementCloseWindowAsync(false);
var projPath = @"C:\ConsoleApp\ConsoleApp1\ConsoleApp1.csproj";
var unconfiguredProject = UnconfiguredProjectFactory.Create(filePath: projPath);
var hierarchy = IVsHierarchyFactory.ImplementAsUnconfiguredProject(unconfiguredProject);
int shouldCancel = -1;
var listener = new FrameOpenCloseListener(serviceProvider, editorState, new IProjectThreadingServiceMock(),
UnconfiguredProjectFactory.Create(filePath: @"C:\ConsoleApp\ADifferentProject\ADifferentProject.csproj"));
Assert.Equal(VSConstants.S_OK, listener.OnQueryUnloadProject(hierarchy, ref shouldCancel));
Assert.Equal(0, shouldCancel);
Mock.Get(editorState).Verify(e => e.CanCloseWindowAsync(), Times.Never);
}
public async Task NonFileSavedToDisk_DoesNotSaveProjectFile(FileActionTypes action)
{
var tempFile = @"C:\Temp\ConsoleApp1.csproj";
var docData = IVsPersistDocDataFactory.ImplementAsIVsTextBuffer();
var shellUtilities = IVsShellUtilitiesHelperFactory.ImplementGetRDTInfo(tempFile, docData);
var textBuffer = ITextBufferFactory.Create();
var editorAdaptersService = IVsEditorAdaptersFactoryServiceFactory.ImplementGetDocumentBuffer(textBuffer);
var textDoc = ITextDocumentFactory.Create();
var textDocFactoryService = ITextDocumentFactoryServiceFactory.ImplementGetTextDocument(textDoc, true);
var editorModel = IProjectFileEditorPresenterFactory.Create();
var watcher = new TempFileBufferStateListener(editorModel, editorAdaptersService, textDocFactoryService, new IProjectThreadingServiceMock(), shellUtilities,
IServiceProviderFactory.Create());
await watcher.InitializeListenerAsync(tempFile);
Mock.Get(shellUtilities).Verify(u => u.GetRDTDocumentInfoAsync(It.IsAny <IServiceProvider>(), tempFile), Times.Once);
Mock.Get(editorAdaptersService).Verify(e => e.GetDocumentBuffer((IVsTextBuffer)docData), Times.Once);
Mock.Get(textDocFactoryService).Verify(t => t.TryGetTextDocument(textBuffer, out textDoc), Times.Once);
Mock.Get(textDoc).Raise(t => t.FileActionOccurred += null, new[] { null, new TextDocumentFileActionEventArgs(tempFile, DateTime.Now, action) });
Mock.Get(editorModel).Verify(e => e.SaveProjectFileAsync(), Times.Never);
}
public void SingleFileGeneratorFactoryAggregator_GivenValidRegistry_RetrievesData(int designTimeSource, int sharedDesignTimeSource, int compileFlag)
{
UnitTestHelper.IsRunningUnitTests = true;
var manager = CreateManager(true, designTimeSource, sharedDesignTimeSource, compileFlag);
var serviceProvider = IServiceProviderFactory.ImplementGetService(type => manager);
var integrationService = IVsUnconfiguredProjectIntegrationServiceFactory.ImplementProjectTypeGuid(PackageGuid);
var aggregator = new SingleFileGeneratorFactoryAggregator(serviceProvider, integrationService);
int actualDesignTime;
int actualSharedDesignTime;
int actualCompileFlag;
Guid actualGuid;
Assert.Equal(VSConstants.S_OK,
aggregator.GetGeneratorInformation("ResXCodeFileGenerator", out actualDesignTime, out actualSharedDesignTime, out actualCompileFlag, out actualGuid));
Assert.Equal(designTimeSource == 1 ? 1 : 0, actualDesignTime);
Assert.Equal(sharedDesignTimeSource == 1 ? 1 : 0, actualSharedDesignTime);
Assert.Equal(compileFlag == 1 ? 1 : 0, actualCompileFlag);
Assert.Equal(ResXGuid, actualGuid);
}
public static void Initialize(IServiceProviderFactory serviceProvider)
{
using (var context = new CellPhonesContext(serviceProvider.GetRequiredService<DbContextOptions<CellPhonesContext>>()))
{
//Look for any cellphones.
if(context.Cellphone.Any())
{
return; //DBhas been seeded
}
context.Cellphone.AddRange(
new Cellphone
{
Make = "iPhone",
Model = "5s",
OS = "MacOS",
ScreenSize = "1240 x 1560"
},
new Cellphone
{
Make = "iPhone",
Model = "6",
OS = "MacOS",
ScreenSize = "1240 x 1560"
},
new Cellphone
{
Make = "iPhone",
Model = "X",
OS = "MacOS",
ScreenSize = "2560 x 4000"
}
},
public async Task ProjectFileEditorPresenter_CloseWindowFail_ReturnsStopClose()
{
var filePath = @"C:\Temp\ConsoleApp1.csproj";
var textBufferManager = ITextBufferManagerFactory.ImplementFilePath(filePath);
var textBufferManagerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferManager);
var textBufferListener = ITextBufferStateListenerFactory.Create();
var textBufferListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => textBufferListener);
var frameListener = IFrameOpenCloseListenerFactory.Create();
var frameListenerFactory = ExportFactoryFactory.ImplementCreateValue(() => frameListener);
var projectFileWatcher = IProjectFileModelWatcherFactory.Create();
var projectFileWatcherFactory = ExportFactoryFactory.ImplementCreateValue(() => projectFileWatcher);
var windowFrame = IVsWindowFrameFactory.ImplementCloseFrame(options =>
{
Assert.Equal((uint)__FRAMECLOSE.FRAMECLOSE_PromptSave, options);
return(VSConstants.E_FAIL);
});
var shellUtilities = IVsShellUtilitiesHelperFactory.ImplementOpenDocument(filePath, XmlFactoryGuid, Guid.Empty, windowFrame);
var editorState = new ProjectFileEditorPresenterTester(
new IProjectThreadingServiceMock(),
UnconfiguredProjectFactory.Create(),
IServiceProviderFactory.Create(),
shellUtilities,
projectFileWatcherFactory,
textBufferListenerFactory,
frameListenerFactory,
textBufferManagerFactory);
await editorState.OpenEditorAsync();
Assert.False(await editorState.CanCloseWindowAsync());
}
public void GlobalJsonRemover_AfterRemoval_UnadvisesEvents()
{
UnitTestHelper.IsRunningUnitTests = true;
var solution = IVsSolutionFactory.CreateWithSolutionDirectory(DirectoryInfoCallback);
var projectItem = ProjectItemFactory.Create();
var dteSolution = SolutionFactory.ImplementFindProjectItem(path =>
{
Assert.Equal(Path.Combine(Directory, "global.json"), path);
return(projectItem);
});
var dte = DteFactory.ImplementSolution(() => dteSolution);
var serviceProvider = IServiceProviderFactory.ImplementGetService(t =>
{
if (typeof(SVsSolution) == t)
{
return(solution);
}
if (typeof(DTE) == t)
{
return(dte);
}
Assert.False(true);
throw new InvalidOperationException();
});
var remover = new GlobalJsonRemover(serviceProvider)
{
SolutionCookie = 1234
};
Assert.Equal(VSConstants.S_OK, remover.OnAfterOpenSolution(null, 0));
Mock.Get(solution).Verify(s => s.UnadviseSolutionEvents(1234), Times.Once);
}
public EmptyStartup(IServiceProviderFactory <NInjectServiceProviderBuilder> providerFactory) : base(providerFactory)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ProjectController"/> class.
/// </summary>
/// <param name="serviceProviderFactory">The service provider factory.</param>
public ProjectController(IServiceProviderFactory serviceProviderFactory)
: base(serviceProviderFactory)
{
this.projectServices = serviceProviderFactory.GetProjectServices();
}
public ServiceFactoryAdapter(IServiceProviderFactory <TContainerBuilder> serviceProviderFactory)
{
_serviceProviderFactory = serviceProviderFactory ?? throw new ArgumentNullException(nameof(serviceProviderFactory));
}
private static ProjectNodeCommandHandler CreateCommandHandler()
{
return(new ProjectNodeCommandHandler(
GetJoinableTaskContext(),
IServiceProviderFactory.ImplementGetService(t => null)));
}
public ManagementServerBuilder(IServiceProviderFactory <IServiceCollection> serviceProviderFactory)
{
_serviceProviderFactory = serviceProviderFactory;
}
public DelegateStartup(IServiceProviderFactory <IServiceCollection> factory, Action <IApplicationBuilder> configureApp) : base(factory)
{
_configureApp = configureApp;
}
public override SuperSocketHostBuilder <TReceivePackage> UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory)
{
_serviceProviderBuilder = (context, services) =>
{
var containerBuilder = factory.CreateBuilder(services);
ConfigureContainerBuilder(context, containerBuilder);
return(factory.CreateServiceProvider(containerBuilder));
};
return(this);
}
protected AspNetCoreStartupBase(IServiceProviderFactory <NinjectServiceProviderBuilder> providerFactory)
{
_providerFactory = providerFactory;
}
/// <summary>
/// ʹÓ÷þÎñÌṩ¹¤³§
/// </summary>
/// <typeparam name="TContainerBuilder">ÈÝÆ÷½¨ÔìÆ÷</typeparam>
/// <param name="factory">ÈÝÆ÷½¨ÔìÆ÷</param>
/// <returns></returns>
public virtual THostBuilder UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory)
{
HostBuilder.UseServiceProviderFactory <TContainerBuilder>(factory);
return(this as THostBuilder);
}
public static IHostBuilder UseLightInject(this IHostBuilder @this,
IServiceProviderFactory <IServiceContainer> factory)
=> @this.UseServiceProviderFactory(factory);
/// <summary>
/// Overrides the factory used to create the service provider.
/// </summary>
/// <typeparam name="TContainerBuilder">The type of the builder to create.</typeparam>
/// <param name="factory">A factory used for creating service providers.</param>
/// <returns>The same instance of the <see cref="IHostBuilder"/> for chaining.</returns>
public IModulesHostBuilder UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory)
{
_innerBuilder.UseServiceProviderFactory(factory);
return(this);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TContainerBuilder"></typeparam>
/// <param name="factory"></param>
public void UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory)
{
ServiceFactory = () => new ServiceFactoryAdapter <TContainerBuilder>(factory);
}
public ServiceProviderFactoryAdapter(IServiceProviderFactory <TContainerBuilder> serviceProviderFactory)
{
_serviceProviderFactory = serviceProviderFactory;
}
protected TempestBootstrapper(IServiceProviderFactory <IServiceCollection> serviceProviderFactory)
: base(serviceProviderFactory)
{
}
/// <inheritdoc />
public IClientBuilder UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory)
{
this.serviceProviderBuilder.UseServiceProviderFactory(factory);
return(this);
}
IHostBuilder IHostBuilder.UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory)
{
return(UseServiceProviderFactory(factory));
}
public ServiceProviderFactoryGenericAdapter(IServiceProviderFactory <TContainerBuilder> factory)
{
this.factory = factory;
}
public void NullEditorState_Throws()
{
Assert.Throws <ArgumentNullException>("editorState", () => new TempFileBufferStateListener(null,
IVsEditorAdaptersFactoryServiceFactory.Create(),
ITextDocumentFactoryServiceFactory.Create(),
IProjectThreadingServiceFactory.Create(),
IVsShellUtilitiesHelperFactory.Create(),
IServiceProviderFactory.Create()));
}
/// <inheritdoc /> public IHostBuilder UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory) => throw new NotImplementedException();
public IHostBuilder UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory)
{
_operations += b => b.UseServiceProviderFactory(factory);
return(this);
}
public MyContainerStartupBaseClass(IServiceProviderFactory <MyContainer> factory) : base(factory)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ControllerBase"/> class.
/// </summary>
/// <param name="serviceProviderFactory">The service provider factory.</param>
protected ControllerBase(IServiceProviderFactory serviceProviderFactory)
{
this.ServiceProviderFactory = serviceProviderFactory;
}
public IHostBuilder UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory)
{
_hostBuilder.UseServiceProviderFactory <TContainerBuilder>(factory);
return(this);
}
public void GlobaJsonSetup_NoExistingRemover_RegistersForAdvise()
{
UnitTestHelper.IsRunningUnitTests = true;
GlobalJsonRemover.Remover = null;
var solution = IVsSolutionFactory.CreateWithAdviseUnadviseSolutionEvents(1234);
var setupOccurred = new GlobalJsonRemover.GlobalJsonSetup().SetupRemoval(solution, IServiceProviderFactory.Create(), IFileSystemFactory.Create());
Assert.True(setupOccurred);
Assert.Equal(1234u, GlobalJsonRemover.Remover.SolutionCookie);
}
/// <summary>
/// Overrides the factory used to create the service provider.
/// </summary>
/// <typeparam name="TContainerBuilder">The type of the builder to create.</typeparam>
/// <param name="factory">A factory used for creating service providers.</param>
/// <returns>The same instance of the <see cref="IHostBuilder"/> for chaining.</returns>
public IHostBuilder UseServiceProviderFactory <TContainerBuilder>(IServiceProviderFactory <TContainerBuilder> factory)
{
_serviceProviderFactory = new ServiceFactoryAdapter <TContainerBuilder>(factory ?? throw new ArgumentNullException(nameof(factory)));
return(this);
}
public void GlobalJsonRemover_NullFileSystem_Throws()
{
Assert.Throws <ArgumentNullException>("fileSystem", () => new GlobalJsonRemover(IServiceProviderFactory.Create(), null));
}
