public async Task OutputPrefixSuffix(string output) { // Arrange var prefix = $"preprefix-{output.Replace("\\", "-")}-"; var suffix = $"-{output.Replace("\\", "-")}-suffixfix"; // Act var options = new CombineOptions() { Prefix = prefix, Suffix = suffix, Output = output, OverWrite = true, Input = InputDir }; var exitCode = await new Combiner(options).Run(); // Assert Assert.Equal(0, exitCode); var path = string.IsNullOrEmpty(Path.GetDirectoryName(output)) ? InputDir : Path.GetDirectoryName(output) !; var existingFiles = Directory.GetFiles(path); var csGeneratedFiles = existingFiles.Where(f => Path.GetFileNameWithoutExtension(f).StartsWith(prefix) && Path.GetFileNameWithoutExtension(f).EndsWith(suffix) && Path.GetExtension(f) == Combiner.OutputExtension); Assert.Single(csGeneratedFiles); }
public async Task NoOutputAndInputFile() { // Arrange var options = new CombineOptions() { Input = $"{InputDir}/ParsingException.cs", Suffix = CombinerTestsFixture.DefaultSuffix, Prefix = nameof(NoOutputAndInputFile), OverWrite = true, }; // Act var exitCode = await new Combiner(options).Run(); // Assert Assert.Equal(0, exitCode); var existingFiles = Directory.GetFiles(InputDir); var zipFiles = existingFiles.Where(f => Path.GetExtension(f) == Combiner.OutputExtension && Path.GetFileNameWithoutExtension(f).Contains(options.Suffix) && Path.GetFileNameWithoutExtension(f).Contains(options.Prefix)); Assert.NotEmpty(zipFiles); }
public async Task ExcludeFileAndDir() { // Arrange var expectedOutputFile = Path.Combine(DefaultOutputDir, nameof(ExcludeFileAndDir), nameof(ExcludeFileAndDir)) + Combiner.OutputExtension; var excludes = new[] { "TConverter.cs", "Interfaces/" }; // Act var options = new CombineOptions() { ExcludedItems = excludes, Output = expectedOutputFile, OverWrite = true, Input = InputDir, }; var exitCode = await new Combiner(options).Run(); // Assert - excluded file is not included in the zip Assert.Equal(0, exitCode); Assert.True(File.Exists(expectedOutputFile)); var fileContent = await File.ReadAllTextAsync(expectedOutputFile); Assert.Contains("ParsingException", fileContent); Assert.DoesNotContain("class TConverter", fileContent); Assert.DoesNotContain("interface IParsedFile", fileContent); Assert.DoesNotContain("interface IParsedLine", fileContent); }
public async Task NoOutputFileName_GeneratesUniqueFileName(string outputDir) { // Arrange var timeBefore = ParseDateTimeFromFileName(UniqueIdGenerator.UniqueId()); // Act var options = new CombineOptions() { Output = outputDir, OverWrite = true, Input = InputDir, Suffix = CombinerTestsFixture.DefaultSuffix }; var exitCode = await new Combiner(options).Run(); // Assert Assert.Equal(0, exitCode); var existingFiles = Directory.GetFiles(outputDir); var timeAfter = ParseDateTimeFromFileName(UniqueIdGenerator.UniqueId()); var csGeneratedFiles = existingFiles.Where(f => { if (Path.GetExtension(f) == Combiner.OutputExtension) { var fileDate = ParseDateTimeFromFileName(Path.GetFileNameWithoutExtension(f).Replace(options.Suffix, string.Empty)); return(fileDate is not null && fileDate >= timeBefore && fileDate <= timeAfter); } return(false); }); Assert.Single(csGeneratedFiles); }
public async Task NoInput_ShouldFail() { // Arrange var options = new CombineOptions(); // Act and assert Assert.Equal(1, await new Combiner(options).Run()); }
public async Task NonExistingFileInput_ShouldFail() { // Arrange var options = new CombineOptions() { Input = "./___non_existing_file___" }; // Act and assert Assert.Equal(1, await new Combiner(options).Run()); }
bool GetCombine(XmlNode itemNode, XmlNode valueNode, out string separator, out CombineOptions options, out bool isCombineValue) { separator = itemNode.GetAttributeValue <string>("combine", null); options = itemNode.GetAttributeValue <CombineOptions>("combineOptions", CombineOptions.None); isCombineValue = IsCombineValue(valueNode); if (itemNode.HasAttribute("combine")) { return(true); } return(false); }
public async Task Parse(CombineOptions options) { var syntaxTree = CSharpSyntaxTree.ParseText(await File.ReadAllTextAsync(Filepath)); CheckDiagnostics(syntaxTree.GetDiagnostics()); var originalRoot = syntaxTree.GetCompilationUnitRoot(); var pathToTrim = Directory.Exists(options.Input) ? options.Input.ReplaceEndingDirectorySeparatorWithProperEndingDirectorySeparator() : string.Empty; var syntaxNode = new AnnotateNamespacesRewriter(Filepath[pathToTrim.Length..]).Visit(originalRoot);
public async Task NoOutputDir_UsesInputDirAndOutputFileName(string fileName, string extension) { // Act var options = new CombineOptions() { Output = fileName + extension, OverWrite = true, Input = InputDir, Suffix = CombinerTestsFixture.DefaultSuffix }; var exitCode = await new Combiner(options).Run(); // Assert Assert.Equal(0, exitCode); var existingFiles = Directory.GetFiles(InputDir); var csGeneratedFiles = existingFiles.Where(f => Path.GetFileNameWithoutExtension(f) == fileName + options.Suffix && Path.GetExtension(f) == Combiner.OutputExtension); Assert.Single(csGeneratedFiles); }
public async Task OutputFileCompilation() { // Arrange const string input = "TestsInput/Combiner/ComplexScenario/"; _outputPath = Path.Combine("ComplexScenarioTestsOutput", nameof(OutputFileCompilation) + Combiner.OutputExtension); var options = new CombineOptions { Input = input, Output = _outputPath, OverWrite = true }; // Act var exitCode = await new Combiner(options).Run(); // Assert Assert.Equal(0, exitCode); Assert.True(File.Exists(_outputPath)); await CheckCompilationResults(_outputPath); }
public async Task OverWrite_CreatesANewFile() { // Arrange - create a pre-existing 'output' file var initialCsFile = Path.Combine(DefaultOutputDir, nameof(OverWrite_CreatesANewFile)) + Combiner.OutputExtension; CreateFile(initialCsFile); Assert.True(File.Exists(initialCsFile)); // Act var options = new CombineOptions() { OverWrite = true, Input = InputDir, Output = initialCsFile }; var exitCode = await new Combiner(options).Run(); // Assert - final file isn't initial file Assert.Equal(0, exitCode); Assert.True(File.Exists(initialCsFile)); Assert.NotEmpty(File.ReadAllLines(initialCsFile)); }
public async Task OutPut(string output) { // Act var options = new CombineOptions() { Output = output, OverWrite = true, Input = InputDir, Suffix = CombinerTestsFixture.DefaultSuffix }; var exitCode = await new Combiner(options).Run(); // Assert Assert.Equal(0, exitCode); var path = string.IsNullOrEmpty(Path.GetDirectoryName(output)) ? InputDir : Path.GetDirectoryName(output) !; var existingFiles = Directory.GetFiles(path); var zipFiles = existingFiles.Where(f => Path.GetFileNameWithoutExtension(f) == $"OutPutfilename{options.Suffix}" && Path.GetExtension(f) == Combiner.OutputExtension); Assert.Single(zipFiles); }
public async Task NoOverwrite_ThrowsAnException() { // Arrange - create a pre-existing 'output' file var initialCsFile = Path.Combine(DefaultOutputDir, nameof(NoOverwrite_ThrowsAnException)) + Combiner.OutputExtension; CreateFile(initialCsFile); Assert.True(File.Exists(initialCsFile)); // Act var options = new CombineOptions() { OverWrite = false, Input = InputDir, Output = initialCsFile }; var exitCode = await new Combiner(options).Run(); // Assert - final file is initial file Assert.Equal(1, exitCode); Assert.True(File.Exists(initialCsFile)); Assert.Empty(File.ReadAllLines(initialCsFile)); }
public FilterExpression(string filter, CombineOptions options) { this.Filter = filter; this.Options = options; }
void SetCombine(XmlNode itemNode, XmlNode valueNode, string separator, CombineOptions options) { itemNode.SetOrAddAttributeValue("combine", separator); itemNode.SetOrAddAttributeValue("combineOptions", options.ToString()); valueNode.SetOrAddAttributeValue("combineValue", true.ToString()); }
public Combiner(CombineOptions options) { _options = options; }
public static bool HasFlagNonAlloc(this CombineOptions self, CombineOptions flag) { return((self & flag) == flag); }