public void VerifyFileWatcherRegistration(string inputTree, string fileToWatch)
{
var spMock = new IServiceProviderMoq();
uint adviseCookie = 100;
var fileChangeService = IVsFileChangeExFactory.CreateWithAdviseUnadviseFileChange(adviseCookie);
spMock.AddService(typeof(IVsFileChangeEx), typeof(SVsFileChangeEx), fileChangeService);
var propertyData = new PropertyPageData
{
Category = ConfigurationGeneral.SchemaName,
PropertyName = ConfigurationGeneral.BaseIntermediateOutputPathProperty,
Value = "obj\\"
};
var unconfiguredProject = IUnconfiguredProjectFactory.Create(filePath: @"C:\Foo\foo.proj");
var watcher = new ProjectLockFileWatcher(spMock,
IProjectTreeProviderFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(unconfiguredProject,
projectProperties: ProjectPropertiesFactory.Create(unconfiguredProject, new[] { propertyData })),
IProjectLockServiceFactory.Create());
var tree = ProjectTreeParser.Parse(inputTree);
watcher.Load();
watcher.ProjectTree_ChangedAsync(IProjectVersionedValueFactory <IProjectTreeSnapshot> .Create(IProjectTreeSnapshotFactory.Create(tree)));
// If fileToWatch is null then we expect to not register any filewatcher.
var times = fileToWatch == null?Times.Never() : Times.Once();
Mock.Get <IVsFileChangeEx>(fileChangeService).Verify(s => s.AdviseFileChange(fileToWatch ?? It.IsAny <string>(), It.IsAny <uint>(), watcher, out adviseCookie), times);
}
public async Task MsBuildModelWatcher_Dispose_CallsUnsubscribe()
{
var threadingService = IProjectThreadingServiceFactory.Create();
var fileSystem = new IFileSystemMock();
HandlerCallback subscription = null;
HandlerCallback unsubscription = null;
var xml = @"<Project></Project>";
var file = @"C:\Test\Test.proj";
var msbuildAccessor = IMsBuildAccessorFactory.ImplementGetProjectXmlAndXmlChangedEvents(xml, newSub => subscription = newSub,
sub => unsubscription = sub);
var project = IUnconfiguredProjectFactory.Create();
var watcher = new MsBuildModelWatcher(threadingService, fileSystem, msbuildAccessor, project);
await watcher.InitializeAsync(file);
Assert.NotNull(subscription);
watcher.XmlHandler(xml);
Assert.True(fileSystem.FileExists(file));
Assert.Equal(xml, fileSystem.ReadAllText(file));
watcher.Dispose();
Assert.NotNull(unsubscription);
Assert.Equal(subscription, unsubscription);
// Ensure multiple calls to dispose don't cause multiple calls to unsubscribe
watcher.Dispose();
Mock.Get(msbuildAccessor).Verify(m => m.UnsubscribeProjectXmlChangedEventAsync(project, unsubscription), Times.Once);
}
internal LaunchSettingsUnderTest GetLaunchSettingsProvider(IFileSystem fileSystem, string appDesignerFolder = "Properties", string activeProfile = "")
{
var appDesignerData = new PropertyPageData()
{
Category = AppDesigner.SchemaName,
PropertyName = AppDesigner.FolderNameProperty,
Value = appDesignerFolder
};
Mock <IEnumValue> activeProfileValue = new Mock <IEnumValue>();
activeProfileValue.Setup(s => s.Name).Returns(activeProfile);
var debuggerData = new PropertyPageData()
{
Category = ProjectDebugger.SchemaName,
PropertyName = ProjectDebugger.ActiveDebugProfileProperty,
Value = activeProfileValue.Object
};
var unconfiguredProject = IUnconfiguredProjectFactory.Create(null, null, @"c:\\test\Project1\Project1.csproj");
var properties = ProjectPropertiesFactory.Create(unconfiguredProject, new[] { debuggerData, appDesignerData });
var commonServices = IUnconfiguredProjectCommonServicesFactory.Create(unconfiguredProject, null, new IProjectThreadingServiceMock(), null, properties);
var projectServices = IUnconfiguredProjectServicesFactory.Create(IProjectAsynchronousTasksServiceFactory.Create(CancellationToken.None));
Lazy <ISourceCodeControlIntegration> sccIntegration = new Lazy <ISourceCodeControlIntegration>(() => ISourceCodeControlIntegrationFactory.Create());
var provider = new LaunchSettingsUnderTest(unconfiguredProject, projectServices, fileSystem != null? fileSystem : new IFileSystemMock(), commonServices, null, sccIntegration);
return(provider);
}
private EditProjectFileCommand SetupScenario(string projectXml, string tempPath, string tempProjectFile, string projectFile, string caption,
IFileSystemMock fileSystem, ITextDocument textDoc, IVsWindowFrame frame)
{
fileSystem.SetTempFile(tempPath);
var configuredProject = ConfiguredProjectFactory.Create();
var unconfiguredProject = IUnconfiguredProjectFactory.Create(filePath: projectFile, configuredProject: configuredProject);
var shellUtilities = new TestShellUtilitiesHelper((sp, path) =>
{
Assert.Equal(tempProjectFile, path);
return(Tuple.Create(IVsHierarchyFactory.Create(), (uint)0, IVsPersistDocDataFactory.ImplementAsIVsTextBuffer(), (uint)0));
}, (sp, path, factoryGuid, logicalView) =>
{
Assert.Equal(tempProjectFile, path);
Assert.Equal(XmlGuid, factoryGuid);
Assert.Equal(Guid.Empty, logicalView);
return(frame);
});
var textBuffer = ITextBufferFactory.ImplementSnapshot(projectXml);
var editorFactoryService = IVsEditorAdaptersFactoryServiceFactory.ImplementGetDocumentBuffer(textBuffer);
Mock.Get(textDoc).SetupGet(t => t.TextBuffer).Returns(textBuffer);
var textDocFactory = ITextDocumentFactoryServiceFactory.ImplementGetTextDocument(textDoc, true);
var msbuildAccessor = IMsBuildAccessorFactory.Implement(projectXml, async(writeLock, callback) =>
{
await callback();
Assert.True(writeLock);
});
var threadingService = IProjectThreadingServiceFactory.Create();
return(CreateInstance(unconfiguredProject, true, msbuildAccessor, fileSystem, textDocFactory, editorFactoryService, threadingService, shellUtilities));
}
private EditProjectFileCommand CreateInstance(
UnconfiguredProject unconfiguredProject = null,
bool implementCapabilities = true,
IMsBuildAccessor msbuildAccessor = null,
IFileSystem fileSystem = null,
ITextDocumentFactoryService textDocumentService = null,
IVsEditorAdaptersFactoryService editorAdapterService = null,
IProjectThreadingService threadingService = null,
IVsShellUtilitiesHelper shellUtilities = null
)
{
UnitTestHelper.IsRunningUnitTests = true;
var uProj = unconfiguredProject ?? IUnconfiguredProjectFactory.Create();
var capabilities = IProjectCapabilitiesServiceFactory.ImplementsContains(CapabilityChecker(implementCapabilities));
var msbuild = msbuildAccessor ?? IMsBuildAccessorFactory.Create();
var fs = fileSystem ?? new IFileSystemMock();
var tds = textDocumentService ?? ITextDocumentFactoryServiceFactory.Create();
var eas = editorAdapterService ?? IVsEditorAdaptersFactoryServiceFactory.Create();
var threadServ = threadingService ?? IProjectThreadingServiceFactory.Create();
var shellUt = shellUtilities ?? new TestShellUtilitiesHelper(
(sp, path) => Tuple.Create(IVsHierarchyFactory.Create(), (uint)1, IVsPersistDocDataFactory.Create(), (uint)1),
(sp, path, edType, logView) => IVsWindowFrameFactory.Create());
return(new EditProjectFileCommand(uProj, capabilities, IServiceProviderFactory.Create(), msbuild, fs, tds, eas, threadServ, shellUt));
}
private InterceptedProjectPropertiesProviderBase CreateInstance(FrameworkName configuredTargetFramework)
{
var data = new PropertyPageData()
{
Category = ConfigurationGeneral.SchemaName,
PropertyName = ConfigurationGeneral.TargetFrameworkMonikerProperty,
Value = configuredTargetFramework.FullName
};
var project = IUnconfiguredProjectFactory.Create();
var properties = ProjectPropertiesFactory.Create(project, data);
var instanceProvider = IProjectInstancePropertiesProviderFactory.Create();
var delegatePropertiesMock = IProjectPropertiesFactory
.MockWithProperty(TargetFrameworkPropertyName);
var delegateProperties = delegatePropertiesMock.Object;
var delegateProvider = IProjectPropertiesProviderFactory.Create(delegateProperties);
var targetFrameworkProvider = new TargetFrameworkValueProvider(properties);
var providerMetadata = IInterceptingPropertyValueProviderMetadataFactory.Create(TargetFrameworkPropertyName);
var lazyArray = new[] { new Lazy <IInterceptingPropertyValueProvider, IInterceptingPropertyValueProviderMetadata>(
() => targetFrameworkProvider, providerMetadata) };
return(new ProjectFileInterceptedProjectPropertiesProvider(delegateProvider, instanceProvider, project, lazyArray));
}
public void GetProperties_NotNull()
{
var provider = new TestSourceFilePropertiesProvider(IUnconfiguredProjectFactory.Create(), WorkspaceFactory.Create(""), IProjectThreadingServiceFactory.Create());
var properties = provider.GetProperties(null, null, null);
Assert.NotNull(properties);
}
private LocalDebuggerCommandArgumentsValueProvider CreateInstance(string targetExecutable = "", string outputKey = null, bool useOutputGroups = false)
{
var projectScope = IProjectCapabilitiesScopeFactory.Create();
var configuredProject = ConfiguredProjectFactory.Create(projectScope);
var configGeneralProperties = new PropertyPageData()
{
Category = ConfigurationGeneral.SchemaName,
PropertyName = ConfigurationGeneral.TargetPathProperty,
Value = useOutputGroups ? string.Empty : targetExecutable
};
var project = IUnconfiguredProjectFactory.Create();
var properties = ProjectPropertiesFactory.Create(project, configGeneralProperties);
Lazy <IOutputGroupsService, IAppliesToMetadataView> outputGroupsWithData = null;
if (useOutputGroups)
{
var metadata = new Mock <IAppliesToMetadataView>();
metadata.Setup(m => m.AppliesTo).Returns("");
var outputGroups = IOutputGroupsServiceFactory.Create(targetExecutable);
outputGroupsWithData = new Lazy <IOutputGroupsService, IAppliesToMetadataView>(() => outputGroups, metadata.Object);
}
return(new LocalDebuggerCommandArgumentsValueProvider(new Lazy <ProjectProperties>(() => properties), outputGroupsWithData, configuredProject));
}
private ManagedDebuggerImageTypeService CreateInstance()
{
var project = IUnconfiguredProjectFactory.Create();
var properties = ProjectPropertiesFactory.Create(project);
return(new ManagedDebuggerImageTypeService(properties));
}
public void Constructor_NullThreadingFactory_ThrowsArgumentNullException()
{
Assert.Throws <ArgumentNullException>("threadingService", () =>
{
new TestSourceFilePropertiesProvider(IUnconfiguredProjectFactory.Create(), WorkspaceFactory.Create(""), null);
});
}
public void Constructor_NullAsCommonSevices_ThrowsArgumentNull()
{
var project = IUnconfiguredProjectFactory.Create();
Assert.Throws <ArgumentNullException>("commonServices", () => {
new UnconfiguredProjectVsServices((IUnconfiguredProjectCommonServices)null);
});
}
public void Constructor_NullAsHost_ThrowsArgumentNull()
{
var project = IUnconfiguredProjectFactory.Create();
Assert.Throws <ArgumentNullException>("host", () => {
new LanguageServiceErrorListProvider(project, (ILanguageServiceHost)null);
});
}
private static LanguageServiceErrorListProvider CreateInstance(ILanguageServiceHost host)
{
host = host ?? ILanguageServiceHostFactory.Create();
var provider = new LanguageServiceErrorListProvider(IUnconfiguredProjectFactory.Create(), host);
return(provider);
}
ConsoleDebugTargetsProvider GetDebugTargetsProvider(string outputType = "exe", Dictionary <string, string> properties = null)
{
_mockFS.WriteAllText(@"c:\test\Project\someapp.exe", "");
_mockFS.CreateDirectory(@"c:\test\Project");
_mockFS.WriteAllText(@"c:\program files\dotnet\dotnet.exe", "");
LaunchProfile activeProfile = new LaunchProfile()
{
Name = "MyApplication", CommandLineArgs = "--someArgs", ExecutablePath = @"c:\test\Project\someapp.exe"
};
_mockEnvironment.Setup(s => s.GetEnvironmentVariable("Path")).Returns(() => _Path);
var project = IUnconfiguredProjectFactory.Create(null, null, _ProjectFile);
var outputTypeEnum = new PageEnumValue(new EnumValue()
{
Name = outputType
});
var data = new PropertyPageData()
{
Category = ConfigurationGeneral.SchemaName,
PropertyName = ConfigurationGeneral.OutputTypeProperty,
Value = outputTypeEnum
};
var projectProperties = ProjectPropertiesFactory.Create(project, data);
if (properties == null)
{
properties = new Dictionary <string, string>()
{
{ "TargetPath", @"c:\test\project\bin\project.dll" },
{ "TargetFrameworkIdentifier", @".NetCoreApp" }
};
}
var delegatePropertiesMock = IProjectPropertiesFactory
.MockWithPropertiesAndValues(properties);
var delegateProvider = IProjectPropertiesProviderFactory.Create(null, delegatePropertiesMock.Object);
IConfiguredProjectServices configuredProjectServices = Mock.Of <IConfiguredProjectServices>(o =>
o.ProjectPropertiesProvider == delegateProvider);
ConfiguredProject configuredProject = Mock.Of <ConfiguredProject>(o =>
o.UnconfiguredProject == project &&
o.Services == configuredProjectServices);
_mockTokenReplace.Setup(s => s.ReplaceTokensInProfileAsync(It.IsAny <ILaunchProfile>())).Returns <ILaunchProfile>(p => Task.FromResult(p));
var debugProvider = new ConsoleDebugTargetsProvider(
configuredProject,
_mockTokenReplace.Object,
_mockFS,
_mockEnvironment.Object,
projectProperties);
return(debugProvider);
}
public void UnconfiguredProject_CanGetSet()
{
var unconfiguedProject = IUnconfiguredProjectFactory.Create();
var provider = CreateInstance();
provider.UnconfiguredProject = unconfiguedProject;
Assert.Same(unconfiguedProject, provider.UnconfiguredProject);
}
public void Constructor_ValueAsCommonServices_SetsProjectToCommonServicesProject()
{
var project = IUnconfiguredProjectFactory.Create();
var commonServices = IUnconfiguredProjectCommonServicesFactory.Create(project: project);
var vsServices = CreateInstance(commonServices);
Assert.Same(project, vsServices.Project);
}
public async Task GetApplicationManifest(string appManifestPropValue, string noManifestValue, string expectedValue)
{
var provider = new ApplicationManifestValueProvider(IUnconfiguredProjectFactory.Create());
var defaultProperties = IProjectPropertiesFactory.CreateWithPropertyAndValue("NoWin32Manifest", noManifestValue);
var appManifestValue = await provider.OnGetEvaluatedPropertyValueAsync(appManifestPropValue, defaultProperties);
Assert.Equal(expectedValue, appManifestValue);
}
public void Constructor_ValueAsCommonServices_SetsActiveConfiguredProjectPropertiesToCommonServicesActiveConfiguredProjectProperties()
{
var project = IUnconfiguredProjectFactory.Create();
var projectProperties = ProjectPropertiesFactory.Create(project);
var commonServices = IUnconfiguredProjectCommonServicesFactory.Create(projectProperties: projectProperties);
var vsServices = CreateInstance(commonServices);
Assert.Same(projectProperties, vsServices.ActiveConfiguredProjectProperties);
}
public void Constructor_ValueAsCommonServices_SetsThreadingServiceToCommonServicesThreadingService()
{
var threadingService = IProjectThreadingServiceFactory.Create();
var project = IUnconfiguredProjectFactory.Create();
var commonServices = IUnconfiguredProjectCommonServicesFactory.Create(threadingService: threadingService);
var vsServices = CreateInstance(commonServices);
Assert.Same(threadingService, vsServices.ThreadingService);
}
public void Constructor_ValueAsUnconfiguedProject_SetsVsProjectToHostObject()
{
var hierarchy = IVsHierarchyFactory.Create();
var project = IUnconfiguredProjectFactory.Create(hostObject: hierarchy);
var commonServices = IUnconfiguredProjectCommonServicesFactory.Create(project: project);
var vsServices = CreateInstance(commonServices);
Assert.Same(hierarchy, vsServices.VsProject);
}
public void DebugPageViewModel_UICommands()
{
var unconfiguredProject = IUnconfiguredProjectFactory.Create(filePath: @"C:\Foo\foo.proj");
var viewModel = new DebugPageViewModel(false, unconfiguredProject);
Assert.IsType <VS.Utilities.DelegateCommand>(viewModel.BrowseDirectoryCommand);
Assert.IsType <VS.Utilities.DelegateCommand>(viewModel.BrowseExecutableCommand);
Assert.IsType <VS.Utilities.DelegateCommand>(viewModel.NewProfileCommand);
Assert.IsType <VS.Utilities.DelegateCommand>(viewModel.DeleteProfileCommand);
}
private static LanguageServiceErrorListProvider CreateInstance(IProjectWithIntellisense project)
{
var provider = new LanguageServiceErrorListProvider(IUnconfiguredProjectFactory.Create("CSharp"));
if (project != null)
{
provider.ProjectsWithIntellisense.Add(project, "CSharp");
}
return(provider);
}
public async void SourceFileProperties_GetUnevalutedPropertyAsync(string code, string propertyName, string expectedValue)
{
var workspace = WorkspaceFactory.Create(code);
var projectFilePath = workspace.CurrentSolution.Projects.First().FilePath;
var provider = new TestSourceFilePropertiesProvider(IUnconfiguredProjectFactory.Create(filePath: projectFilePath), workspace, IProjectThreadingServiceFactory.Create());
var properties = provider.GetProperties(projectFilePath, null, null);
var propertyValue = await properties.GetUnevaluatedPropertyValueAsync(propertyName);
Assert.Equal(expectedValue, propertyValue);
}
public void Constructor_NullDelegatedProvider_ThrowsArgumentNullException()
{
var unconfiguredProject = IUnconfiguredProjectFactory.Create();
Assert.Throws <ArgumentNullException>("provider", () =>
{
new ImplicitProjectPropertiesProvider(null,
IProjectInstancePropertiesProviderFactory.Create(),
new ImplicitProjectPropertiesStore <string, string>(unconfiguredProject),
unconfiguredProject);
});
}
private ProjectProperties CreateProperties()
{
var properties = ProjectPropertiesFactory.Create(IUnconfiguredProjectFactory.Create(),
new PropertyPageData()
{
Category = ConfigurationGeneral.SchemaName,
PropertyName = ConfigurationGeneral.TemplateLanguageProperty,
Value = "CSharp"
});
return(properties);
}
public void GetImageKey_SingleImageProviderReturningNull_ReturnsNull()
{
var unconfiguredProject = IUnconfiguredProjectFactory.Create(capabilities: new[] { "CSharp" });
var provider = IProjectImageProviderFactory.ImplementGetProjectImage((key) => null);
var aggregator = CreateInstance(unconfiguredProject);
aggregator.ImageProviders.Add(provider, "CSharp");
var result = aggregator.GetProjectImage("key");
Assert.Null(result);
}
public void Constructor_NullDelegatedInstanceProvider_ThrowsArgumentNullException()
{
var delegatePropertiesMock = IProjectPropertiesFactory
.MockWithPropertyAndValue("ProjectGuid", "7259e9ef-87d1-45a5-95c6-3a8432d23776");
var delegateProperties = delegatePropertiesMock.Object;
var delegateProvider = IProjectPropertiesProviderFactory.Create(delegateProperties);
Assert.Throws <ArgumentNullException>("instanceProvider", () =>
{
new ImplicitProjectPropertiesProvider(delegateProvider, null, IUnconfiguredProjectFactory.Create());
});
}
public async void SourceFileProperties_SetPropertyValueAsync(string code, string propertyName, string propertyValue, string expectedCode)
{
var language = code.Contains("[") ? LanguageNames.CSharp : LanguageNames.VisualBasic;
var workspace = WorkspaceFactory.Create(code, language);
var projectFilePath = workspace.CurrentSolution.Projects.First().FilePath;
var provider = new TestSourceFilePropertiesProvider(IUnconfiguredProjectFactory.Create(filePath: projectFilePath), workspace, IProjectThreadingServiceFactory.Create());
var properties = provider.GetProperties(projectFilePath, null, null);
await properties.SetPropertyValueAsync(propertyName, propertyValue);
var newCode = (await workspace.CurrentSolution.Projects.First().Documents.First().GetTextAsync()).ToString();
Assert.Equal(expectedCode, newCode);
}
public void GetImageKey_SingleImageProviderReturningKey_ReturnsKey()
{
ProjectImageMoniker moniker = new ProjectImageMoniker(Guid.NewGuid(), 0);
var unconfiguredProject = IUnconfiguredProjectFactory.Create(capabilities: new[] { "CSharp" });
var provider = IProjectImageProviderFactory.ImplementGetProjectImage((key) => moniker);
var aggregator = CreateInstance(unconfiguredProject);
aggregator.ImageProviders.Add(provider, "CSharp");
var result = aggregator.GetProjectImage("key");
Assert.Same(moniker, result);
}
private ManagedDebuggerImageTypeService CreateInstance(string outputType)
{
var data = new PropertyPageData()
{
Category = ConfigurationGeneral.SchemaName,
PropertyName = ConfigurationGeneral.OutputTypeProperty,
Value = outputType
};
var project = IUnconfiguredProjectFactory.Create();
var properties = ProjectPropertiesFactory.Create(project, data);
return(new ManagedDebuggerImageTypeService(properties));
}
