public async Task GetProjectFrameworksAsync_ReturnsFrameworksInCorrectOrder(string frameworks, string[] expectedOrder)
{
var project = UnconfiguredProjectFactory.Create();
var data = new PropertyPageData()
{
Category = ConfigurationGeneral.SchemaName,
PropertyName = ConfigurationGeneral.TargetFrameworksProperty,
Value = frameworks
};
var projectProperties = ProjectPropertiesFactory.Create(project, data);
var commonServices = IUnconfiguredProjectCommonServicesFactory.Create(projectProperties: projectProperties);
var debugFrameworkSvcs = new ActiveDebugFrameworkServices(null, commonServices);
var result = await debugFrameworkSvcs.GetProjectFrameworksAsync();
Assert.Equal(expectedOrder.Length, result.Count);
for (int i = 0; i < result.Count; i++)
{
Assert.Equal(expectedOrder[i], result[i]);
}
}
public void CSharpProjectConfigurationProperties_CodeAnalysisRuleSet()
{
var setValues = new List <object>();
var project = UnconfiguredProjectFactory.Create();
var data = new PropertyPageData()
{
Category = ConfiguredBrowseObject.SchemaName,
PropertyName = ConfiguredBrowseObject.CodeAnalysisRuleSetProperty,
Value = "Blah",
SetValues = setValues
};
var projectProperties = ProjectPropertiesFactory.Create(project, data);
var vsLangProjectProperties = CreateInstance(projectProperties, IProjectThreadingServiceFactory.Create());
Assert.Equal("Blah", vsLangProjectProperties.CodeAnalysisRuleSet);
var testValue = "Testing";
vsLangProjectProperties.CodeAnalysisRuleSet = testValue;
Assert.Equal(setValues.Single(), testValue);
}
public void RootedReferencesPushedToWorkspace()
{
var referencesPushedToWorkspace = new HashSet <string>(StringComparers.Paths);
void onReferenceAdded(string s) => referencesPushedToWorkspace.Add(s);
void onReferenceRemoved(string s) => referencesPushedToWorkspace.Remove(s);
var project = UnconfiguredProjectFactory.Create(filePath: @"C:\ProjectFolder\Myproject.csproj");
var context = IWorkspaceProjectContextFactory.CreateForMetadataReferences(project, onReferenceAdded, onReferenceRemoved);
var logger = Mock.Of <IProjectLogger>();
var handler = new MetadataReferenceItemHandler(project, context);
var projectDir = Path.GetDirectoryName(project.FullPath);
var added = BuildOptions.FromCommandLineArguments(CSharpCommandLineParser.Default.Parse(args: new[] { @"/reference:Assembly1.dll", @"/reference:C:\ProjectFolder\Assembly2.dll", @"/reference:..\ProjectFolder\Assembly3.dll" }, baseDirectory: projectDir, sdkDirectory: null));
var removed = BuildOptions.FromCommandLineArguments(CSharpCommandLineParser.Default.Parse(args: new string[] { }, baseDirectory: projectDir, sdkDirectory: null));
handler.Handle(10, added: added, removed: removed, isActiveContext: true, logger: logger);
AssertEx.CollectionLength(referencesPushedToWorkspace, 3);
Assert.Contains(@"C:\ProjectFolder\Assembly1.dll", referencesPushedToWorkspace);
Assert.Contains(@"C:\ProjectFolder\Assembly2.dll", referencesPushedToWorkspace);
Assert.Contains(@"C:\ProjectFolder\Assembly3.dll", referencesPushedToWorkspace);
}
public async Task OnDimensionValueChanged_Rename_MissingValue()
{
var rootElement = ProjectRootElementFactory.Create(projectXml);
var projectAccessor = IProjectAccessorFactory.Create(rootElement);
var provider = new ConfigurationProjectConfigurationDimensionProvider(projectAccessor);
var project = UnconfiguredProjectFactory.Create();
var args = new ProjectConfigurationDimensionValueChangedEventArgs(
project,
ConfigurationDimensionChange.Rename,
ChangeEventStage.After,
ConfigurationGeneral.ConfigurationProperty,
"RenamedConfiguration",
"NonExistantConfiguration");
await Assert.ThrowsAsync <ArgumentException>(() => provider.OnDimensionValueChangedAsync(args));
var property = BuildUtilities.GetProperty(rootElement, Configurations);
Assert.NotNull(property);
Assert.Equal("Debug;Release;CustomConfiguration", property !.Value);
}
public async Task GetProjectConfigurationDimensionsAsync()
{
string projectXml =
@"<Project>
<PropertyGroup>
<PROP>A;B;C</PROP>
<DIM>X</DIM>
</PropertyGroup>
</Project>";
var provider = CreateInstance(projectXml.Replace("PROP", PropertyName).Replace("DIM", DimensionName));
var project = UnconfiguredProjectFactory.Create(configuredProject: ConfiguredProjectFactory.Create());
var values = await provider.GetProjectConfigurationDimensionsAsync(project);
var(key, value) = Assert.Single(values);
Assert.Equal(DimensionName, key);
string[] dimensionValues = value.ToArray();
AssertEx.CollectionLength(dimensionValues, 3);
Assert.Equal("A", dimensionValues[0]);
Assert.Equal("B", dimensionValues[1]);
Assert.Equal("C", dimensionValues[2]);
}
public async Task OnDimensionValueChanged(ConfigurationDimensionChange change, ChangeEventStage stage)
{
// No changes should happen for TFM so verify that the property is the same before and after
using (var projectFile = new MsBuildProjectFile(ProjectXmlTFMs))
{
IProjectXmlAccessor _projectXmlAccessor = IProjectXmlAccessorFactory.Create(projectFile.Project);
var provider = new TargetFrameworkProjectConfigurationDimensionProvider(_projectXmlAccessor);
var unconfiguredProject = UnconfiguredProjectFactory.Create(filePath: projectFile.Filename);
var property = BuildUtilities.GetProperty(projectFile.Project, ConfigurationGeneral.TargetFrameworksProperty);
string expectedTFMs = property.Value;
ProjectConfigurationDimensionValueChangedEventArgs args = new ProjectConfigurationDimensionValueChangedEventArgs(
unconfiguredProject,
change,
stage,
ConfigurationGeneral.TargetFrameworkProperty,
"NewTFM");
await provider.OnDimensionValueChangedAsync(args);
Assert.NotNull(property);
Assert.Equal(expectedTFMs, property.Value);
}
}
public void CSharpProjectConfigurationProperties_OutputPath()
{
var setValues = new List <object>();
var project = UnconfiguredProjectFactory.Create();
var data = new PropertyPageData()
{
Category = ConfiguredBrowseObject.SchemaName,
PropertyName = ConfiguredBrowseObject.OutputPathProperty,
Value = "OldPath",
SetValues = setValues
};
var projectProperties = ProjectPropertiesFactory.Create(project, data);
var vsLangProjectProperties = CreateInstance(projectProperties, IProjectThreadingServiceFactory.Create());
Assert.Equal("OldPath", vsLangProjectProperties.OutputPath);
var testValue = "newPath";
vsLangProjectProperties.OutputPath = testValue;
Assert.Equal(setValues.Single(), testValue);
}
public void CSharpProjectConfigurationProperties_LangVersion()
{
var setValues = new List <object>();
var project = UnconfiguredProjectFactory.Create();
var data = new PropertyPageData()
{
Category = ConfiguredBrowseObject.SchemaName,
PropertyName = ConfiguredBrowseObject.LangVersionProperty,
Value = "6",
SetValues = setValues
};
var projectProperties = ProjectPropertiesFactory.Create(project, data);
var vsLangProjectProperties = CreateInstance(projectProperties, IProjectThreadingServiceFactory.Create());
Assert.Equal(vsLangProjectProperties.LanguageVersion, "6");
var testValue = "7.1";
vsLangProjectProperties.LanguageVersion = testValue;
Assert.Equal(setValues.Single(), testValue);
}
public async void ConfigurationProjectConfigurationDimensionProvider_OnDimensionValueChanged_Rename()
{
using (var projectFile = new MsBuildProjectFile(projectXml))
{
IProjectXmlAccessor _projectXmlAccessor = IProjectXmlAccessorFactory.Create(projectFile.Project);
var provider = new ConfigurationProjectConfigurationDimensionProvider(_projectXmlAccessor);
var unconfiguredProject = UnconfiguredProjectFactory.Create(filePath: projectFile.Filename);
// On ChangeEventStage.Before nothing should be changed
ProjectConfigurationDimensionValueChangedEventArgs args = new ProjectConfigurationDimensionValueChangedEventArgs(
unconfiguredProject,
ConfigurationDimensionChange.Rename,
ChangeEventStage.Before,
ConfigurationGeneral.ConfigurationProperty,
"RenamedConfiguration",
"CustomConfiguration");
await provider.OnDimensionValueChangedAsync(args);
var property = BuildUtilities.GetProperty(projectFile.Project, Configurations);
Assert.NotNull(property);
Assert.Equal("Debug;Release;CustomConfiguration", property.Value);
// On ChangeEventStage.Before the property should be renamed
args = new ProjectConfigurationDimensionValueChangedEventArgs(
unconfiguredProject,
ConfigurationDimensionChange.Rename,
ChangeEventStage.After,
ConfigurationGeneral.ConfigurationProperty,
"RenamedConfiguration",
"CustomConfiguration");
await provider.OnDimensionValueChangedAsync(args);
property = BuildUtilities.GetProperty(projectFile.Project, Configurations);
Assert.NotNull(property);
Assert.Equal("Debug;Release;RenamedConfiguration", property.Value);
}
}
public async Task WhenGivenMultipleProjectPropertyContexts_GetItemsAsyncReturnsNullOrAnItemForEach()
{
var profile1 = new WritableLaunchProfile {
Name = "Profile1"
};
var profile2 = new WritableLaunchProfile {
Name = "Profile2"
};
var profile3 = new WritableLaunchProfile {
Name = "Profile3"
};
var launchSettingsProvider = ILaunchSettingsProviderFactory.Create(
launchProfiles: new[]
{
profile1.ToLaunchProfile(),
profile2.ToLaunchProfile(),
profile3.ToLaunchProfile()
});
var itemProvider = new LaunchProfileProjectItemProvider(
UnconfiguredProjectFactory.Create(),
launchSettingsProvider);
List <IProjectPropertiesContext> contexts = new()
{
new TestProjectPropertiesContext(true, "Foo", null, "Profile3"),
new TestProjectPropertiesContext(true, "Foo", "RandomItemType", "Profile2"),
new TestProjectPropertiesContext(true, "Foo", LaunchProfileProjectItemProvider.ItemType, "Profile1")
};
var items = await itemProvider.GetItemsAsync(contexts);
Assert.Collection(items,
item => Assert.Equal("Profile3", item !.EvaluatedInclude),
item => Assert.Null(item),
item => Assert.Equal("Profile1", item !.EvaluatedInclude));
}
public async Task VerifyInterceptedViaSnapshotCommonPropertiesProviderAsync()
{
var delegatePropertiesMock = IProjectPropertiesFactory.MockWithPropertiesAndValues(
new Dictionary<string, string?>
{
{ MockPropertyName, "DummyValue" }
});
var delegateProperties = delegatePropertiesMock.Object;
var delegateProvider = IProjectPropertiesProviderFactory.Create(commonProps: delegateProperties);
bool getEvaluatedInvoked = false;
bool getUnevaluatedInvoked = false;
bool setValueInvoked = false;
var mockPropertyProvider = IInterceptingPropertyValueProviderFactory.Create(MockPropertyName,
onGetEvaluatedPropertyValue: (v, p) => { getEvaluatedInvoked = true; return v; },
onGetUnevaluatedPropertyValue: (v, p) => { getUnevaluatedInvoked = true; return v; },
onSetPropertyValue: (v, p, d) => { setValueInvoked = true; return v; });
var unconfiguredProject = UnconfiguredProjectFactory.Create();
var instanceProvider = IProjectInstancePropertiesProviderFactory.Create();
var interceptedProvider = new ProjectFileInterceptedViaSnapshotProjectPropertiesProvider(delegateProvider, instanceProvider, unconfiguredProject, new[] { mockPropertyProvider });
var properties = interceptedProvider.GetCommonProperties();
// Verify interception for GetEvaluatedPropertyValueAsync.
string? propertyValue = await properties.GetEvaluatedPropertyValueAsync(MockPropertyName);
Assert.True(getEvaluatedInvoked);
// Verify interception for GetUnevaluatedPropertyValueAsync.
propertyValue = await properties.GetUnevaluatedPropertyValueAsync(MockPropertyName);
Assert.True(getUnevaluatedInvoked);
// Verify interception for SetPropertyValueAsync.
await properties.SetPropertyValueAsync(MockPropertyName, "NewValue", null);
Assert.True(setValueInvoked);
}
public async Task PlatformProjectConfigurationDimensionProvider_OnDimensionValueChanged_Rename()
{
var rootElement = ProjectRootElementFactory.Create(projectXml);
var projectAccessor = IProjectAccessorFactory.Create(rootElement);
var provider = new PlatformProjectConfigurationDimensionProvider(projectAccessor);
var project = UnconfiguredProjectFactory.Create();
// Nothing should happen on platform rename as it's unsupported
var args = new ProjectConfigurationDimensionValueChangedEventArgs(
project,
ConfigurationDimensionChange.Rename,
ChangeEventStage.Before,
ConfigurationGeneral.PlatformProperty,
"RenamedPlatform",
"x86");
await provider.OnDimensionValueChangedAsync(args);
var property = BuildUtilities.GetProperty(rootElement, Platforms);
Assert.NotNull(property);
Assert.Equal("AnyCPU;x64;x86", property.Value);
// On ChangeEventStage.Before the property should be renamed
args = new ProjectConfigurationDimensionValueChangedEventArgs(
project,
ConfigurationDimensionChange.Rename,
ChangeEventStage.After,
ConfigurationGeneral.PlatformProperty,
"RenamedPlatform",
"x86");
await provider.OnDimensionValueChangedAsync(args);
property = BuildUtilities.GetProperty(rootElement, Platforms);
Assert.NotNull(property);
Assert.Equal("AnyCPU;x64;x86", property.Value);
}
public async Task WhenDuplicatingAProfile_AndNameAndCommandAreNotProvided_DefaultsAreProvided()
{
var project = UnconfiguredProjectFactory.Create();
ILaunchProfile?duplicatedProfile = null;
var profiles = new List <ILaunchProfile>
{
new WritableLaunchProfile {
Name = "Alpha", CommandName = "Beta", ExecutablePath = @"C:\iguana\aardvark.exe"
}.ToLaunchProfile()
};
var launchSettingsProvider = ILaunchSettingsProviderFactory.Create(
launchProfiles: profiles,
addOrUpdateProfileCallback: (profile, addToFront) => { profiles.Add(profile); duplicatedProfile = profile; },
getProfilesCallback: (p) => ImmutableList.CreateRange(profiles));
var queryVersionProvider = new LaunchSettingsQueryVersionProvider();
var tracker = new LaunchSettingsTracker(project, launchSettingsProvider, queryVersionProvider);
var handler = new ProjectLaunchProfileHandler(project, launchSettingsProvider, tracker);
var context = IQueryExecutionContextFactory.Create();
var parent = IEntityWithIdFactory.Create("Project", "MyProject");
var duplicatedProfileId = await handler.DuplicateLaunchProfileAsync(context, parent, currentProfileName : "Alpha", newProfileName : null, newProfileCommandName : null);
Assert.NotNull(duplicatedProfile);
Assert.NotNull(duplicatedProfile.Name);
Assert.NotEqual(expected: "Alpha", actual: duplicatedProfile.Name);
Assert.Equal(expected: "Beta", actual: duplicatedProfile.CommandName);
Assert.Equal(expected: @"C:\iguana\aardvark.exe", actual: duplicatedProfile.ExecutablePath);
Assert.Equal(expected: 2, actual: profiles.Count);
Assert.NotNull(duplicatedProfileId);
Assert.Equal(expected: "LaunchProfile", actual: duplicatedProfileId[ProjectModelIdentityKeys.SourceItemType]);
Assert.Equal(expected: duplicatedProfile.Name, actual: duplicatedProfileId[ProjectModelIdentityKeys.SourceItemName]);
}
public async void PlatformProjectConfigurationDimensionProvider_OnDimensionValueChanged_Rename()
{
using (var projectFile = new MsBuildProjectFile(projectXml))
{
IProjectXmlAccessor _projectXmlAccessor = IProjectXmlAccessorFactory.Create(projectFile.Project);
var provider = new PlatformProjectConfigurationDimensionProvider(_projectXmlAccessor);
var unconfiguredProject = UnconfiguredProjectFactory.Create(filePath: projectFile.Filename);
// Nothing should happen on platform rename as it's unsupported
ProjectConfigurationDimensionValueChangedEventArgs args = new ProjectConfigurationDimensionValueChangedEventArgs(
unconfiguredProject,
ConfigurationDimensionChange.Rename,
ChangeEventStage.Before,
ConfigurationGeneral.PlatformProperty,
"RenamedPlatform",
"x86");
await provider.OnDimensionValueChangedAsync(args);
var property = BuildUtilities.GetProperty(projectFile.Project, Platforms);
Assert.NotNull(property);
Assert.Equal("AnyCPU;x64;x86", property.Value);
// On ChangeEventStage.Before the property should be renamed
args = new ProjectConfigurationDimensionValueChangedEventArgs(
unconfiguredProject,
ConfigurationDimensionChange.Rename,
ChangeEventStage.After,
ConfigurationGeneral.PlatformProperty,
"RenamedPlatform",
"x86");
await provider.OnDimensionValueChangedAsync(args);
property = BuildUtilities.GetProperty(projectFile.Project, Platforms);
Assert.NotNull(property);
Assert.Equal("AnyCPU;x64;x86", property.Value);
}
}
public async Task OnDimensionValueChanged_Add()
{
var rootElement = ProjectRootElementFactory.Create(projectXml);
var projectAccessor = IProjectAccessorFactory.Create(rootElement);
var provider = new ConfigurationProjectConfigurationDimensionProvider(projectAccessor);
var project = UnconfiguredProjectFactory.Create();
// On ChangeEventStage.After nothing should be changed
var args = new ProjectConfigurationDimensionValueChangedEventArgs(
project,
ConfigurationDimensionChange.Add,
ChangeEventStage.After,
ConfigurationGeneral.ConfigurationProperty,
"CustomConfig");
await provider.OnDimensionValueChangedAsync(args);
var property = BuildUtilities.GetProperty(rootElement, Configurations);
Assert.NotNull(property);
Assert.Equal("Debug;Release;CustomConfiguration", property.Value);
// On ChangeEventStage.Before the property should be added
args = new ProjectConfigurationDimensionValueChangedEventArgs(
project,
ConfigurationDimensionChange.Add,
ChangeEventStage.Before,
ConfigurationGeneral.ConfigurationProperty,
"CustomConfig");
await provider.OnDimensionValueChangedAsync(args);
property = BuildUtilities.GetProperty(rootElement, Configurations);
Assert.NotNull(property);
Assert.Equal("Debug;Release;CustomConfiguration;CustomConfig", property.Value);
}
private PackageRestoreDataSource CreateInstance(UnconfiguredProject?project = null, IPackageRestoreUnconfiguredInputDataSource?dataSource = null, IVsSolutionRestoreService3?solutionRestoreService = null)
{
project ??= UnconfiguredProjectFactory.Create(IProjectThreadingServiceFactory.Create());
dataSource ??= IPackageRestoreUnconfiguredInputDataSourceFactory.Create();
IProjectAsynchronousTasksService projectAsynchronousTasksService = IProjectAsynchronousTasksServiceFactory.Create();
solutionRestoreService ??= IVsSolutionRestoreServiceFactory.Create();
IProjectLogger logger = IProjectLoggerFactory.Create();
IFileSystem fileSystem = IFileSystemFactory.Create();
var hintService = new Lazy <IProjectChangeHintSubmissionService>(() => IProjectChangeHintSubmissionServiceFactory.Create());
var projectAccessor = IProjectAccessorFactory.Create();
var packageReferenceTelemetryService = IUnconfiguredProjectPackageRestoreTelemetryServiceFactory.Create();
return(new PackageRestoreDataSource(
project,
dataSource,
projectAsynchronousTasksService,
solutionRestoreService,
fileSystem,
hintService,
projectAccessor,
logger,
packageReferenceTelemetryService));
}
private ConsoleDebugTargetsProvider GetDebugTargetsProvider(string outputType = "exe", Dictionary<string, string?>? properties = null, IVsDebugger10? debugger = null)
{
_mockFS.WriteAllText(@"c:\test\Project\someapp.exe", "");
_mockFS.CreateDirectory(@"c:\test\Project");
_mockFS.CreateDirectory(@"c:\test\Project\bin\");
_mockFS.WriteAllText(@"c:\program files\dotnet\dotnet.exe", "");
var project = UnconfiguredProjectFactory.Create(filePath: _ProjectFile);
var outputTypeEnum = new PageEnumValue(new EnumValue() { Name = outputType });
var data = new PropertyPageData(ConfigurationGeneral.SchemaName, ConfigurationGeneral.OutputTypeProperty, outputTypeEnum);
var projectProperties = ProjectPropertiesFactory.Create(project, data);
properties ??= new Dictionary<string, string?>()
{
{"RunCommand", @"dotnet"},
{"RunArguments", "exec " + "\"" + @"c:\test\project\bin\project.dll" + "\""},
{"RunWorkingDirectory", @"bin\"},
{"TargetFrameworkIdentifier", @".NetCoreApp"},
{"OutDir", @"c:\test\project\bin\"}
};
var delegatePropertiesMock = IProjectPropertiesFactory.MockWithPropertiesAndValues(properties);
var delegateProvider = IProjectPropertiesProviderFactory.Create(null, delegatePropertiesMock.Object);
var configuredProjectServices = Mock.Of<ConfiguredProjectServices>(o =>
o.ProjectPropertiesProvider == delegateProvider);
var configuredProject = Mock.Of<ConfiguredProject>(o =>
o.UnconfiguredProject == project &&
o.Services == configuredProjectServices);
var environment = IEnvironmentHelperFactory.ImplementGetEnvironmentVariable(_Path);
return CreateInstance(project: project, configuredProject : configuredProject, fileSystem: _mockFS, properties: projectProperties, environment: environment, debugger : debugger);
}
private static PackageRestoreDataSource CreateInstance(UnconfiguredProject?project = null, IPackageRestoreUnconfiguredInputDataSource?dataSource = null, IVsSolutionRestoreService3?solutionRestoreService = null)
{
project ??= UnconfiguredProjectFactory.CreateWithActiveConfiguredProjectProvider(IProjectThreadingServiceFactory.Create());
dataSource ??= IPackageRestoreUnconfiguredInputDataSourceFactory.Create();
IProjectAsynchronousTasksService projectAsynchronousTasksService = IProjectAsynchronousTasksServiceFactory.Create();
solutionRestoreService ??= IVsSolutionRestoreServiceFactory.Create();
IProjectDiagnosticOutputService logger = IProjectDiagnosticOutputServiceFactory.Create();
IFileSystem fileSystem = IFileSystemFactory.Create();
var projectDependentFileChangeNotificationService = IProjectDependentFileChangeNotificationServiceFactory.Create();
var vsSolutionRestoreService4 = IVsSolutionRestoreService4Factory.ImplementRegisterRestoreInfoSourceAsync();
var sharedJoinableTaskCollection = new PackageRestoreSharedJoinableTaskCollection(IProjectThreadingServiceFactory.Create());
return(new PackageRestoreDataSourceMocked(
project,
dataSource,
projectAsynchronousTasksService,
solutionRestoreService,
fileSystem,
logger,
projectDependentFileChangeNotificationService,
vsSolutionRestoreService4,
sharedJoinableTaskCollection));
}
public async Task Dispose_WhenInitialized_DisposesSubscription()
{
var configuredProject = ConfiguredProjectFactory.Create();
int callCount = 0;
UnconfiguredProject project = UnconfiguredProjectFactory.ImplementLoadConfiguredProjectAsync(configuration =>
{
callCount++;
return(Task.FromResult(configuredProject));
});
var loader = CreateInstance(project, out ProjectValueDataSource <IConfigurationGroup <ProjectConfiguration> > source);
await loader.InitializeAsync();
await loader.DisposeAsync();
var configurationGroups = IConfigurationGroupFactory.CreateFromConfigurationNames("Debug|AnyCPU");
// Change the active configurations
await source.SendAndCompleteAsync(configurationGroups, loader.TargetBlock);
// Should not be listening
Assert.Equal(0, callCount);
}
public async Task InitializeAsync_CanNotInitializeTwice()
{
var configuredProject = ConfiguredProjectFactory.Create();
var results = new List <string>();
var project = UnconfiguredProjectFactory.ImplementLoadConfiguredProjectAsync(configuration =>
{
results.Add(configuration.Name);
return(Task.FromResult(configuredProject));
});
var loader = CreateInstance(project, out var source);
await loader.InitializeAsync();
await loader.InitializeAsync();
var configurationGroups = IConfigurationGroupFactory.CreateFromConfigurationNames("Debug|AnyCPU");
// Change the active configurations
await source.SendAndCompleteAsync(configurationGroups, loader.TargetBlock);
Assert.Equal(new string[] { "Debug|AnyCPU" }, results);
}
public async Task WhenAddingMultipleItems_TheReturnedItemsHaveTheCorrectNames()
{
ImmutableList <ILaunchProfile> newProfiles = ImmutableList <ILaunchProfile> .Empty;;
var launchSettingsProvider = ILaunchSettingsProviderFactory.Create(
addOrUpdateProfileCallback: (p, a) =>
{
newProfiles = newProfiles.Add(p);
},
getProfilesCallback: initialProfiles =>
{
return(initialProfiles.AddRange(newProfiles));
});
var itemProvider = new LaunchProfileProjectItemProvider(
UnconfiguredProjectFactory.Create(),
launchSettingsProvider);
var items = await itemProvider.AddAsync(
new Tuple <string, string, IEnumerable <KeyValuePair <string, string> >?>[]
{
new(LaunchProfileProjectItemProvider.ItemType, "Alpha Profile", null),
new(LaunchProfileProjectItemProvider.ItemType, "Beta Profile", null),
new(LaunchProfileProjectItemProvider.ItemType, "Gamma Profile", null),
});
public async Task RemoteMachineName_OnSetPropertyValueAsync_SetsDirectoryInActiveProfile()
{
string activeProfileRemoteMachineName = "Tiger";
var activeProfileOtherSettings = new Dictionary <string, object>
{
{ LaunchProfileExtensions.RemoteDebugMachineProperty, activeProfileRemoteMachineName }
};
var settingsProvider = SetupLaunchSettingsProvider(
activeProfileName: "One",
activeProfileOtherSettings: activeProfileOtherSettings,
updateLaunchSettingsCallback: s =>
{
activeProfileRemoteMachineName = (string)s.ActiveProfile !.OtherSettings[LaunchProfileExtensions.RemoteDebugMachineProperty];
});
var project = UnconfiguredProjectFactory.Create();
var threadingService = IProjectThreadingServiceFactory.Create();
var provider = new ActiveLaunchProfileExtensionValueProvider(project, settingsProvider, threadingService);
await provider.OnSetPropertyValueAsync(ActiveLaunchProfileExtensionValueProvider.RemoteDebugMachinePropertyName, "Cheetah", Mock.Of <IProjectProperties>());
Assert.Equal(expected: "Cheetah", actual: activeProfileRemoteMachineName);
}
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 async Task SqlDebugEnabled_OnSetPropertyValueAsync_SetsDirectoryInActiveProfile()
{
bool activeProfileSqlDebugEnabled = false;
var activeProfileOtherSettings = new Dictionary <string, object>
{
{ LaunchProfileExtensions.SqlDebuggingProperty, activeProfileSqlDebugEnabled }
};
var settingsProvider = SetupLaunchSettingsProvider(
activeProfileName: "One",
activeProfileOtherSettings: activeProfileOtherSettings,
updateLaunchSettingsCallback: s =>
{
activeProfileSqlDebugEnabled = (bool)s.ActiveProfile !.OtherSettings[LaunchProfileExtensions.SqlDebuggingProperty];
});
var project = UnconfiguredProjectFactory.Create();
var threadingService = IProjectThreadingServiceFactory.Create();
var provider = new ActiveLaunchProfileExtensionValueProvider(project, settingsProvider, threadingService);
await provider.OnSetPropertyValueAsync(ActiveLaunchProfileExtensionValueProvider.SqlDebuggingPropertyName, "true", Mock.Of <IProjectProperties>());
Assert.True(activeProfileSqlDebugEnabled);
}
public async Task GetCommandStatusAsync_FolderAsNodes_ReturnsHandled()
{
var projectProperties = ProjectPropertiesFactory.Create(UnconfiguredProjectFactory.Create(), new[] {
new PropertyPageData {
Category = ConfigurationGeneral.SchemaName, PropertyName = ConfigurationGeneral.ProjectGuidProperty, Value = Guid.NewGuid().ToString()
}
});
var command = CreateInstance(provider: IProjectTreeProviderFactory.Create(""), dlg:
IVsAddProjectItemDlgFactory.Create(0), properties: () => projectProperties);
var tree = ProjectTreeParser.Parse(@"
Root (flags: {ProjectRoot})
Code (flags: {Folder})
");
var nodes = ImmutableHashSet.Create(tree.Children[0]);
var result = await command.GetCommandStatusAsync(nodes, GetCommandId(), true, "commandText", (CommandStatus)0);
Assert.True(result.Handled);
Assert.Equal("commandText", result.CommandText);
Assert.Equal(CommandStatus.Enabled | CommandStatus.Supported, result.Status);
}
public void AssemblyName()
{
var setValues = new List <object>();
var project = UnconfiguredProjectFactory.Create();
var data = new PropertyPageData()
{
Category = ConfigurationGeneral.SchemaName,
PropertyName = ConfigurationGeneral.AssemblyNameProperty,
Value = "Blah",
SetValues = setValues
};
var projectProperties = ProjectPropertiesFactory.Create(project, data);
var activeConfiguredProject = ActiveConfiguredProjectFactory.ImplementValue(() => projectProperties);
var vsLangProjectProperties = CreateInstance(Mock.Of <VSLangProj.VSProject>(), IProjectThreadingServiceFactory.Create(), activeConfiguredProject);
Assert.Equal("Blah", vsLangProjectProperties.AssemblyName);
var testValue = "Testing";
vsLangProjectProperties.AssemblyName = testValue;
Assert.Equal(setValues.Single(), testValue);
}
private static DesignTimeInputsFileWatcher CreateDesignTimeInputsFileWatcher(IVsAsyncFileChangeEx fileChangeService, out ProjectValueDataSource <DesignTimeInputs> source)
{
// Create our mock design time inputs data source, but with a source we can actually use
var services = IProjectCommonServicesFactory.CreateWithDefaultThreadingPolicy();
source = ProjectValueDataSourceFactory.Create <DesignTimeInputs>(services);
var mock = new Mock <IDesignTimeInputsDataSource>();
mock.SetupGet(s => s.SourceBlock)
.Returns(source.SourceBlock);
var dataSource = mock.Object;
var threadingService = IProjectThreadingServiceFactory.Create();
var unconfiguredProject = UnconfiguredProjectFactory.Create(fullPath: @"C:\MyProject\MyProject.csproj");
var unconfiguredProjectServices = IUnconfiguredProjectServicesFactory.Create(
projectService: IProjectServiceFactory.Create(
services: ProjectServicesFactory.Create(
threadingService: threadingService)));
// Create our class under test
return(new DesignTimeInputsFileWatcher(unconfiguredProject, unconfiguredProjectServices, threadingService, dataSource, IVsServiceFactory.Create <SVsFileChangeEx, IVsAsyncFileChangeEx>(fileChangeService)));
}
private UnconfiguredProject GetMockProject(string projectFullPath = "D:\\Test\\Projects\\UCProject\\UCProject.csproj") => UnconfiguredProjectFactory.Create(filePath: projectFullPath);
public void Constructor_NullAsGeneratePackageOnBuildPropertyProvider_ThrowsArgumentNull()
{
Assert.Throws <ArgumentNullException>(() => CreateInstanceCore(UnconfiguredProjectFactory.Create(), IProjectThreadingServiceFactory.Create(), SVsServiceProviderFactory.Create(null), null));
}
private ProjectImageProviderAggregator CreateInstance(UnconfiguredProject project = null)
{
project = project ?? UnconfiguredProjectFactory.Create();
return(new ProjectImageProviderAggregator(project));
}
