public TestProjectFileOrAssemblyInfoPropertiesProvider(
Workspace workspace,
UnconfiguredProject project,
Lazy <IInterceptingPropertyValueProvider, IInterceptingPropertyValueProviderMetadata>?interceptingProvider = null,
IProjectThreadingService?threadingService = null,
IProjectProperties?defaultProperties = null,
IProjectInstancePropertiesProvider?instanceProvider = null,
Func <ProjectId>?getActiveProjectId = null)
: base(delegatedProvider : IProjectPropertiesProviderFactory.Create(defaultProperties ?? IProjectPropertiesFactory.MockWithProperty("").Object),
instanceProvider : instanceProvider ?? IProjectInstancePropertiesProviderFactory.Create(),
interceptingValueProviders : interceptingProvider == null ?
new[] { new Lazy <IInterceptingPropertyValueProvider, IInterceptingPropertyValueProviderMetadata>(
() => IInterceptingPropertyValueProviderFactory.Create(),
IInterceptingPropertyValueProviderMetadataFactory.Create("")) } :
new[] { interceptingProvider },
project : project,
getActiveProjectId : getActiveProjectId ?? (() => workspace.CurrentSolution.ProjectIds.SingleOrDefault()),
workspace : workspace,
threadingService : threadingService ?? IProjectThreadingServiceFactory.Create())
{
Requires.NotNull(workspace, nameof(workspace));
Requires.NotNull(project, nameof(project));
}
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(vsLangProjectProperties.OutputPath, "OldPath");
var testValue = "newPath";
vsLangProjectProperties.OutputPath = testValue;
Assert.Equal(setValues.Single(), testValue);
}
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(vsLangProjectProperties.CodeAnalysisRuleSet, "Blah");
var testValue = "Testing";
vsLangProjectProperties.CodeAnalysisRuleSet = 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("6", vsLangProjectProperties.LanguageVersion);
var testValue = "7.1";
vsLangProjectProperties.LanguageVersion = testValue;
Assert.Equal(setValues.Single(), testValue);
}
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 EditProjectFileCommand SetupScenario(string projectXml, string tempPath, string tempProjectFile, string projectFile,
IFileSystemMock fileSystem, ITextDocument textDoc, IVsWindowFrame frame, IExportFactory <IMsBuildModelWatcher> watcherFactory = null)
{
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.ImplementGetProjectXmlRunLocked(projectXml, async(writeLock, callback) =>
{
await callback();
Assert.True(writeLock);
});
var threadingService = IProjectThreadingServiceFactory.Create();
return(CreateInstance(unconfiguredProject, true, msbuildAccessor, fileSystem, textDocFactory,
editorFactoryService, threadingService, shellUtilities, watcherFactory));
}
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 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);
}
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)));
}
public void Constructor_NullAsGeneratePackageOnBuildPropertyProvider_ThrowsArgumentNull()
{
Assert.Throws <ArgumentNullException>(() => CreateInstanceCore(UnconfiguredProjectFactory.Create(), IProjectThreadingServiceFactory.Create(), SVsServiceProviderFactory.Create(null), null));
}
public void OutputType()
{
var setValues = new List <object>();
var project = UnconfiguredProjectFactory.Create();
var data = new PropertyPageData(ConfigurationGeneralBrowseObject.SchemaName, ConfigurationGeneralBrowseObject.OutputTypeProperty, 1, setValues);
var projectProperties = ProjectPropertiesFactory.Create(project, data);
var activeConfiguredProject = ActiveConfiguredProjectFactory.ImplementValue(() => projectProperties);
var vsLangProjectProperties = CreateInstance(Mock.Of <VSLangProj.VSProject>(), IProjectThreadingServiceFactory.Create(), activeConfiguredProject);
Assert.Equal(prjOutputType.prjOutputTypeExe, vsLangProjectProperties.OutputType);
vsLangProjectProperties.OutputType = prjOutputType.prjOutputTypeLibrary;
Assert.Equal(prjOutputType.prjOutputTypeLibrary, setValues.Single());
}
public async Task ScheduleAsyncTask_Noop_OriginalSourceTokenCancelled()
{
var cts = new CancellationTokenSource();
using (var scheduler = new TaskDelayScheduler(TimeSpan.FromMilliseconds(250), IProjectThreadingServiceFactory.Create(), cts.Token))
{
cts.Cancel();
bool taskRan = false;
var task = scheduler.ScheduleAsyncTask(ct =>
{
taskRan = true;
return(Task.CompletedTask);
});
await task;
Assert.False(taskRan);
}
}
public void NullEditorState_Throws()
{
Assert.Throws <ArgumentNullException>("editorState", () => new TempFileBufferStateListener(null,
IVsEditorAdaptersFactoryServiceFactory.Create(),
ITextDocumentFactoryServiceFactory.Create(),
IProjectThreadingServiceFactory.Create(),
IVsShellUtilitiesHelperFactory.Create(),
IServiceProviderFactory.Create()));
}
public async Task ScheduleAsyncTask_SkipsPendingTasks()
{
using (var scheduler = new TaskDelayScheduler(TimeSpan.FromMilliseconds(250), IProjectThreadingServiceFactory.Create(), CancellationToken.None))
{
var tasksRun = new bool[3];
var task1 = scheduler.ScheduleAsyncTask(ct =>
{
tasksRun[0] = true;
return(Task.CompletedTask);
});
var task2 = scheduler.ScheduleAsyncTask(ct =>
{
tasksRun[1] = true;
return(Task.CompletedTask);
});
var task3 = scheduler.ScheduleAsyncTask(ct =>
{
tasksRun[2] = true;
return(Task.CompletedTask);
});
await task1;
await task2;
await task3;
Assert.False(tasksRun[0]);
Assert.False(tasksRun[1]);
Assert.True(tasksRun[2]);
}
}
public async Task Dispose_SkipsPendingTasks()
{
using (var scheduler = new TaskDelayScheduler(TimeSpan.FromMilliseconds(250), IProjectThreadingServiceFactory.Create(), CancellationToken.None))
{
bool taskRan = false;
var task = scheduler.ScheduleAsyncTask(ct =>
{
taskRan = true;
return(Task.CompletedTask);
});
scheduler.Dispose();
await task;
Assert.False(taskRan);
}
}
public void Constructor_NullAsUnconfiguredProject_ThrowsArgumentNull()
{
Assert.Throws <ArgumentNullException>(() => CreateInstanceCore(null, IProjectThreadingServiceFactory.Create(), IVsServiceFactory.Create <SVsSolutionBuildManager, IVsSolutionBuildManager2>(null), CreateGeneratePackageOnBuildPropertyProvider()));
}
public void GetProperties_NotNull()
{
var provider = new TestSourceFilePropertiesProvider(IUnconfiguredProjectFactory.Create(), WorkspaceFactory.Create(""), IProjectThreadingServiceFactory.Create());
var properties = provider.GetProperties(null, null, null);
Assert.NotNull(properties);
}
public void OutputTypeEx()
{
var setValues = new List <object>();
var project = UnconfiguredProjectFactory.Create();
var data = new PropertyPageData()
{
Category = ConfigurationGeneralBrowseObject.SchemaName,
PropertyName = ConfigurationGeneralBrowseObject.OutputTypeProperty,
Value = 4,
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(prjOutputTypeEx.prjOutputTypeEx_AppContainerExe, vsLangProjectProperties.OutputTypeEx);
vsLangProjectProperties.OutputTypeEx = prjOutputTypeEx.prjOutputTypeEx_WinExe;
Assert.Equal(setValues.Single().ToString(), prjOutputTypeEx.prjOutputTypeEx_WinExe.ToString());
}
public void DefaultProjectPath()
{
var provider = new TestSourceFilePropertiesProvider(IUnconfiguredProjectFactory.Create(filePath: "D:\\TestFile"), WorkspaceFactory.Create(""), IProjectThreadingServiceFactory.Create());
Assert.Equal(provider.DefaultProjectPath, "D:\\TestFile");
}
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);
}
public TestTempPEBuildManager(IFileSystem fileSystem)
: base(IProjectThreadingServiceFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(threadingService: IProjectThreadingServiceFactory.Create()),
IActiveWorkspaceProjectContextHostFactory.Create(),
IActiveConfiguredProjectSubscriptionServiceFactory.Create(),
null,
fileSystem,
IProjectFaultHandlerServiceFactory.Create(),
null)
{
BuildManager = new TestBuildManager(this);
AppliedValue = new ProjectVersionedValue <DesignTimeInputsItem>(new DesignTimeInputsItem()
{
OutputPath = "TempPE"
}, ImmutableDictionary <NamedIdentity, IComparable> .Empty);
}
internal TestBuildManager()
: base(IProjectThreadingServiceFactory.Create(),
IUnconfiguredProjectCommonServicesFactory.Create(UnconfiguredProjectFactory.Create()))
{
}
public void FullPath()
{
var project = UnconfiguredProjectFactory.Create();
var data = new PropertyPageData(ConfigurationGeneral.SchemaName, ConfigurationGeneral.ProjectDirProperty, "somepath");
var projectProperties = ProjectPropertiesFactory.Create(project, data);
var activeConfiguredProject = ActiveConfiguredProjectFactory.ImplementValue(() => projectProperties);
var vsLangProjectProperties = CreateInstance(Mock.Of <VSLangProj.VSProject>(), IProjectThreadingServiceFactory.Create(), activeConfiguredProject);
Assert.Equal("somepath", vsLangProjectProperties.FullPath);
}
public async Task ScheduleAsyncTask_RunsAsyncMethod()
{
using (var scheduler = new TaskDelayScheduler(TimeSpan.FromMilliseconds(10), IProjectThreadingServiceFactory.Create(), CancellationToken.None))
{
bool taskRan = false;
var task = scheduler.ScheduleAsyncTask(ct =>
{
taskRan = true;
return(Task.CompletedTask);
});
await task;
Assert.True(taskRan);
}
}
protected override ITaskDelayScheduler CreateTaskScheduler()
{
return(new TaskDelayScheduler(TimeSpan.Zero, IProjectThreadingServiceFactory.Create(), default));
}
public void GetItemTypeProperties_ThrowsInvalidOperationException()
{
var provider = new TestSourceFilePropertiesProvider(IUnconfiguredProjectFactory.Create(), WorkspaceFactory.Create(""), IProjectThreadingServiceFactory.Create());
Assert.Throws <InvalidOperationException>(() => provider.GetItemTypeProperties(null));
}
public void AbsoluteProjectDirectory()
{
var project = UnconfiguredProjectFactory.Create();
var data = new PropertyPageData()
{
Category = ConfigurationGeneralBrowseObject.SchemaName,
PropertyName = ConfigurationGeneralBrowseObject.FullPathProperty,
Value = "testvalue",
};
var projectProperties = ProjectPropertiesFactory.Create(project, data);
var activeConfiguredProject = ActiveConfiguredProjectFactory.ImplementValue(() => projectProperties);
var vsLangProjectProperties = CreateInstance(Mock.Of <VSLangProj.VSProject>(), IProjectThreadingServiceFactory.Create(), activeConfiguredProject);
Assert.Equal("testvalue", vsLangProjectProperties.AbsoluteProjectDirectory);
}
internal TestBuildManager(TestTempPEBuildManager mgr)
: base(IProjectThreadingServiceFactory.Create(), IUnconfiguredProjectCommonServicesFactory.Create(UnconfiguredProjectFactory.Create()))
{
_mgr = mgr;
}
internal LaunchSettingsUnderTest GetLaunchSettingsProvider(IFileSystem fileSystem, string appDesignerFolder = @"c:\test\Project1\Properties", string activeProfile = "")
{
var 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 specialFilesManager = ActiveConfiguredProjectFactory.ImplementValue(() => AppDesignerFolderSpecialFileProviderFactory.ImplementGetFile(appDesignerFolder));
var project = UnconfiguredProjectFactory.Create(filePath: @"c:\test\Project1\Project1.csproj");
var properties = ProjectPropertiesFactory.Create(project, new[] { debuggerData });
var commonServices = IUnconfiguredProjectCommonServicesFactory.Create(project, null, IProjectThreadingServiceFactory.Create(), null, properties);
var projectServices = IUnconfiguredProjectServicesFactory.Create(IProjectAsynchronousTasksServiceFactory.Create());
var provider = new LaunchSettingsUnderTest(project, projectServices, fileSystem ?? new IFileSystemMock(), commonServices, null, specialFilesManager);
return(provider);
}
internal AbstractAddClassProjectCommand CreateInstance(IPhysicalProjectTree projectTree = null, IUnconfiguredProjectVsServices projectVsServices = null, Shell.SVsServiceProvider serviceProvider = null, IProjectTreeProvider provider = null, IVsAddProjectItemDlg dlg = null)
{
projectTree = projectTree ?? IPhysicalProjectTreeFactory.Create(provider);
projectVsServices = projectVsServices ?? IUnconfiguredProjectVsServicesFactory.Implement(threadingServiceCreator: () => IProjectThreadingServiceFactory.Create());
serviceProvider = serviceProvider ?? SVsServiceProviderFactory.Create(dlg);
return(CreateInstance(projectTree, projectVsServices, serviceProvider));
}
