public async Task UpdateOutputFilesMovesPreviouslyCreatedItemToTargetProject() { await UIThreadDispatcher.Invoke <Task>(async delegate { // Generate output file in the source project Project sourceProject = this.input.ContainingProject; this.output.Project = sourceProject.FullName; this.output.Directory = this.folder.FileNames[1]; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); // Create a new project in the same directory string projectTemplate = Solution.GetProjectTemplate(this.TargetProject.Template, this.TargetProject.Language); string projectName = Path.GetRandomFileName(); string projectFolder = Path.GetDirectoryName(sourceProject.FullName); Solution.AddFromTemplate(projectTemplate, projectFolder, projectName); Project targetProject = Solution.Projects.Cast <Project>().Single(project => project.Name == projectName); // Re-generate output in the target project this.output.Project = targetProject.FullName; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); // Verify that the output file was moved from the source project to the target project Assert.IsFalse(this.folder.ProjectItems.Cast <ProjectItem>().Any(item => item.Name == this.output.File)); ProjectItem targetFolder = targetProject.ProjectItems.Cast <ProjectItem>().Single(item => item.Name == this.folder.Name); Assert.IsTrue(targetFolder.ProjectItems.Cast <ProjectItem>().Any(item => item.Name == this.output.File)); }); }
public void TestInitialize() { UIThreadDispatcher.Invoke(delegate { this.project = this.CreateTestProject(); this.provider = (ITransformationContextProvider)ServiceProvider.GetService(typeof(ITransformationContextProvider)); }); }
public async Task UpdateOutputFilesDoesNotStoreNameOfDefaultOutputTwice() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.File = string.Empty; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); Assert.AreEqual(string.Empty, this.input.GetItemAttribute(ItemMetadata.LastOutputs)); }); }
public async Task UpdateOutputFilesCreatesNewProjectItemInProjectSpecifiedAsPathRelativeToInputFile() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.Project = FileMethods.GetRelativePath(this.input.FileNames[1], this.project.FullName); this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); Assert.IsTrue(this.project.ProjectItems.Cast <ProjectItem>().Any(item => item.Name == this.output.File)); }); }
public async Task UpdateOutputFilesCreatesNewProjectItemWithSpecifiedFile() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); ProjectItem outputItem = this.input.ProjectItems.Cast <ProjectItem>().Single(item => item.Name == this.output.File); Assert.AreEqual(this.output.Content.ToString(), File.ReadAllText(outputItem.FileNames[1])); }); }
public async Task UpdateOutputFilesConfiguresDefaultOutputCreatedAfterTransformation() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.File = string.Empty; this.output.ItemType = ItemType.Content; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); ProjectItem outputItem = await this.SimulateCustomTool(); Assert.AreEqual(this.output.ItemType, outputItem.Properties.Item(ProjectItemProperty.ItemType).Value); }); }
public async Task UpdateOutputFilesCreatesNewProjectItemInDirectorySpecifiedAsPathRelativeToInputFile() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.Directory = Path.GetRandomFileName(); this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); ProjectItem outputFolder = this.folder.ProjectItems.Cast <ProjectItem>().Single(item => item.Name == this.output.Directory); Assert.IsTrue(outputFolder.ProjectItems.Cast <ProjectItem>().Any(item => item.Name == this.output.File)); }); }
public async Task UpdateOutputFilesConfiguresDefaultOutputItemWithSpecifiedCustomToolNamespace() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.File = string.Empty; this.output.CustomToolNamespace = "T4Toolbox"; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); ProjectItem outputItem = await this.SimulateCustomTool(); Assert.AreEqual(this.output.CustomToolNamespace, outputItem.Properties.Item(ProjectItemProperty.CustomToolNamespace).Value); }); }
public async Task UpdateOutputFilesCreatesDefaultOutputItemWithSpecifiedMetadata() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.File = string.Empty; this.output.Metadata["Marco"] = "Polo"; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); ProjectItem outputItem = await this.SimulateCustomTool(); Assert.AreEqual("Polo", outputItem.GetItemAttribute("Marco")); }); }
public async Task UpdateOutputFilesReportsErrorWhenReferenceCannotBeAdded() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.References.Add("InvalidAssemblyName"); this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); ErrorItem error = IntegrationTest.ErrorItems.Single(item => item.FileName == this.input.FileNames[1]); StringAssert.Contains(error.Description, this.output.References.Single()); }); }
public async Task UpdateOutputFilesConfiguresDefaultOutputItemWithSpecifiedCopyToOutputDirectory() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.File = string.Empty; this.output.CopyToOutputDirectory = CopyToOutputDirectory.CopyAlways; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); ProjectItem outputItem = await this.SimulateCustomTool(); Assert.AreEqual((uint)this.output.CopyToOutputDirectory, outputItem.Properties.Item(ProjectItemProperty.CopyToOutputDirectory).Value); }); }
public async Task UpdateOutputFilesCreatesProjectItemWithSpecifiedCustomToolNamespace() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.CustomToolNamespace = "T4Toolbox"; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); ProjectItem outputItem = this.input.ProjectItems.Cast <ProjectItem>().Single(item => item.Name == this.output.File); Assert.AreEqual(this.output.CustomToolNamespace, outputItem.Properties.Item(ProjectItemProperty.CustomToolNamespace).Value); }); }
public async Task UpdateOutputFilesCreatesProjectItemWithSpecifiedCopyToOutputDirectory() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.CopyToOutputDirectory = CopyToOutputDirectory.CopyAlways; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); ProjectItem outputItem = this.input.ProjectItems.Cast <ProjectItem>().Single(item => item.Name == this.output.File); Assert.AreEqual((uint)this.output.CopyToOutputDirectory, outputItem.Properties.Item(ProjectItemProperty.CopyToOutputDirectory).Value); }); }
public async Task UpdateOutputFilesDoesNotGenerateWarningWhenDefaultOutputFileIsEmpty() // Because there may be nothing developer can do about it { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.File = string.Empty; this.output.Content.Clear(); this.output.Content.Append(WhiteSpaceText); this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); Assert.IsFalse(ErrorItems.Any(item => item.FileName == this.input.FileNames[1])); }); }
public async Task UpdateOutputFilesGeneratesWarningWhenAdditionalOutputFileIsEmpty() // To encourage developer to cleanup their code generator { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.Content.Clear(); this.output.Content.Append(WhiteSpaceText); this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); ErrorItem warning = ErrorItems.Single(item => item.FileName == this.input.FileNames[1]); StringAssert.Contains(warning.Description, this.output.Path); Assert.AreEqual(vsBuildErrorLevel.vsBuildErrorLevelMedium, warning.ErrorLevel); }); }
public async Task UpdateOutputFilesDeletesPreviouslyCreatedFileThatWasNotRecreated() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); this.provider.UpdateOutputFiles(this.input.FileNames[1], new OutputFile[0]); await this.SimulateCustomTool(); Assert.IsFalse(this.input.ProjectItems.Cast <ProjectItem>().Any(item => item.Name == this.output.File)); }); }
public TemplateErrorReporterTest() { UIThreadDispatcher.Invoke(delegate { var componentModel = (IComponentModel)ServiceProvider.GetService(typeof(SComponentModel)); // Use Text content type to test in isolation from TemplateErrorTaggerProvider var contentTypeRegistry = componentModel.DefaultExportProvider.GetExportedValue <IContentTypeRegistryService>(); this.textContentType = contentTypeRegistry.GetContentType("Text"); this.documentFactory = componentModel.DefaultExportProvider.GetExportedValue <ITextDocumentFactoryService>(); }); }
public async Task UpdateOutputFilesStoresRelativePathsOfGeneratedFiles() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.Directory = Path.GetRandomFileName(); this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); string lastGenOutput = this.input.GetItemAttribute(ItemMetadata.LastOutputs); Assert.AreEqual(this.output.Path, lastGenOutput.TrimStart('.', '\\')); Assert.IsFalse(Path.IsPathRooted(lastGenOutput)); }); }
public async Task UpdateOutputFilesConfiguresReferencesOfOutputItem() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.References.Add("System.Web"); this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); var project = (VSProject)this.project.Object; Reference reference = project.References.Find(this.output.References.Single()); Assert.IsNotNull(reference); reference.Remove(); }); }
public async Task UpdateOutputFilesDoesNotDeletePreviouslyCreatedFileWhenPreserveExistingFileIsTrue() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.PreserveExistingFile = true; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); this.provider.UpdateOutputFiles(this.input.FileNames[1], new OutputFile[0]); await this.SimulateCustomTool(); Assert.IsTrue(this.input.ProjectItems.Cast <ProjectItem>().Any(item => item.Name == this.output.File)); }); }
public async Task UpdateOutputFilesCreatesProjectItemWithSpecifiedEncoding() { await UIThreadDispatcher.Invoke <Task>(async delegate { this.output.Encoding = Encoding.UTF32; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); ProjectItem outputItem = this.input.ProjectItems.Cast <ProjectItem>().Single(item => item.Name == this.output.File); byte[] preamble = this.output.Encoding.GetPreamble(); byte[] contents = File.ReadAllBytes(outputItem.FileNames[1]); Assert.IsTrue(preamble.Length > 0); CollectionAssert.AreEqual(preamble, contents.Take(preamble.Length).ToArray()); }); }
public async Task UpdateOutputFilesCreatesNewProjectItemInAbsoluteDirectoryOfTargetProject() { await UIThreadDispatcher.Invoke <Task>(async delegate { string directoryName = Path.GetRandomFileName(); this.output.Directory = Path.Combine(Path.GetDirectoryName(this.project.FullName), directoryName); this.output.Project = this.project.FullName; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); ProjectItem outputFolder = this.project.ProjectItems.Cast <ProjectItem>().Single(item => item.Name == directoryName); Assert.IsTrue(outputFolder.ProjectItems.Cast <ProjectItem>().Any(item => item.Name == this.output.File)); }); }
public async Task UpdateOutputFilesDoesNotOverwriteExistingFileWhenPreserveExistingFileIsTrue() { await UIThreadDispatcher.Invoke <Task>(async delegate { const string ExistingContent = "Existing Content"; string outputFilePath = Path.Combine(Path.GetDirectoryName(this.input.FileNames[1]), this.output.File); File.WriteAllText(outputFilePath, ExistingContent); this.output.PreserveExistingFile = true; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); ProjectItem outputItem = this.input.ProjectItems.Cast <ProjectItem>().Single(item => item.Name == this.output.File); Assert.AreEqual(ExistingContent, File.ReadAllText(outputItem.FileNames[1])); }); }
public async Task UpdateOutputFilesMovesPreviouslyCreatedItemToTheSpecifiedDirectory() { await UIThreadDispatcher.Invoke <Task>(async delegate { // Create output file nested under the input file this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); // Now regenerate the file, this time specifying Directory this.output.Directory = Path.GetDirectoryName(this.input.FileNames[1]); this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); // The output file path hasn't changed, however, it should be moved from the input's collection to the folder's collection Assert.IsTrue(this.folder.ProjectItems.Cast <ProjectItem>().Any(item => item.Name == this.output.File)); }); }
public async Task UpdateOutputFilesConfiguresDefaultOutputCreatedBeforeTransformation() { await UIThreadDispatcher.Invoke <Task>(async delegate { // Default output was created by previous transformation ProjectItem outputItem = await this.SimulateCustomTool(); // New transformation generates the file with the same extension this.SimulateTransformation(); this.output.File = string.Empty; this.output.ItemType = ItemType.EmbeddedResource; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); // Verify that output item was configured Assert.AreEqual(this.output.ItemType, outputItem.Properties.Item(ProjectItemProperty.ItemType).Value); }); }
public async Task UpdateOutputFilesAutomaticallyReloadsOpenDocumentsFromDisk() { await UIThreadDispatcher.Invoke <Task>(async delegate { // Output file already exists and it is opened in text editor string outputFilePath = Path.Combine(Path.GetDirectoryName(this.input.FileNames[1]), this.output.File); ProjectItem outputItem = IntegrationTest.CreateTestProjectItemFromFile(this.input.ProjectItems, outputFilePath); Window window = outputItem.Open(Constants.vsViewKindTextView); // Code generation occurs this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); // Verify that document text has been reloads generated document from disk var textDocument = (TextDocument)window.Document.Object(); textDocument.Selection.StartOfDocument(Extend: true); textDocument.Selection.EndOfDocument(Extend: true); Assert.AreEqual(this.output.Content.ToString(), textDocument.Selection.Text); }); }
public void TestInitialize() { UIThreadDispatcher.Invoke(delegate { this.templatingService = (ITextTemplating)ServiceProvider.GetService(typeof(STextTemplating)); this.templatingHost = (ITextTemplatingEngineHost)this.templatingService; this.provider = (ITransformationContextProvider)ServiceProvider.GetService(typeof(ITransformationContextProvider)); this.project = this.CreateTestProject(); this.folder = this.project.ProjectItems.AddFolder(Path.GetRandomFileName()); this.input = this.CreateTestProjectItem(this.folder.ProjectItems, TextFileItemTemplate); this.output = new OutputFile { File = Path.GetRandomFileName() + ".txt" }; this.output.Content.Append(TestText); this.SimulateTransformation(); }); }
public async Task UpdateOutputFilesConfiguresDefaultOutputRecreatedAfterTransformation() { await UIThreadDispatcher.Invoke <Task>(async delegate { // Default output was created by previous transformation await this.SimulateCustomTool(); // New transformation changes extension of the default output this.SimulateTransformation(); this.templatingHost.SetFileExtension("new"); this.output.File = string.Empty; this.output.ItemType = ItemType.Content; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); ProjectItem outputItem = await this.SimulateCustomTool(); // Verify that output item was configured Assert.AreEqual(this.output.ItemType, outputItem.Properties.Item(ProjectItemProperty.ItemType).Value); }); }
public async Task UpdateOutputFilesCreatesNewProjectItemInTargetProjectLocatedInSolutionFolder() { await UIThreadDispatcher.Invoke <Task>(async delegate { // Create a new solution folder Project solutionFolderProject = Solution.AddSolutionFolder(Path.GetRandomFileName()); var solutionFolder = (SolutionFolder)solutionFolderProject.Object; // Create a new project in the solution folder string projectTemplate = Solution.GetProjectTemplate(this.TargetProject.Template, this.TargetProject.Language); string projectName = Path.GetRandomFileName(); string projectFolder = Path.Combine(SolutionDirectory, projectName); solutionFolder.AddFromTemplate(projectTemplate, projectFolder, projectName); Project project = solutionFolderProject.ProjectItems.Item(1).SubProject; // Generate output file in the new project this.output.Project = project.FullName; this.provider.UpdateOutputFiles(this.input.FileNames[1], new[] { this.output }); await this.SimulateCustomTool(); Assert.IsTrue(project.ProjectItems.Cast <ProjectItem>().Any(item => item.Name == this.output.File)); }); }
public void InvokeUIThread(DispatcherPriority priority, Action action) { if (this.CancellationPending) { return; } UIThreadDispatcher dispatcher = this.UIThreadDispatcher; if (dispatcher == null) { return; } dispatcher.Invoke(priority, (Action)(() => { dispatcher = this.UIThreadDispatcher; if (dispatcher == null || this.CancellationPending) { return; } action(); })); }