internal void Create_CanEvaluateTemplateToRun(string command, string templateSet, string?defaultLanguage, string?expectedIdentitiesStr) { TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(_testSets[templateSet], A.Fake <IHostSpecificDataLoader>())) .Single(); string[] expectedIdentities = expectedIdentitiesStr?.Split("|") ?? Array.Empty <string>(); var defaultParams = new Dictionary <string, string>(); if (defaultLanguage != null) { defaultParams["prefs:language"] = defaultLanguage; } ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new create {command}"); var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command; var args = new InstantiateCommandArgs(instantiateCommand, parseResult); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(expectedIdentities.Count(), templateCommands.Count); Assert.Equal(expectedIdentities.OrderBy(s => s), templateCommands.Select(templateCommand => templateCommand.Template.Identity).OrderBy(s => s)); }
public void HasTypeMismatch_HasGroupLanguageMatch() { List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>(); templatesToSearch.Add( new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T1", groupIdentity: "Console.App.Test") .WithTag("language", "L1") .WithTag("type", "project") .WithBaselineInfo("app", "standard")); templatesToSearch.Add( new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T2", groupIdentity: "Console.App.Test") .WithTag("language", "L2") .WithTag("type", "project") .WithBaselineInfo("app", "standard")); TemplateGroup templateGroup = TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templatesToSearch, A.Fake <IHostSpecificDataLoader>())).Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new console --language L2 --type item"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(0, matchingTemplates.Count()); }
public Task FailedToResolveTemplate_WhenMultipleLanguagesAreFound() { IReadOnlyList <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>() { new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L1", groupIdentity: "Console.App.Test").WithTag("language", "L1"), new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L2", groupIdentity: "Console.App.Test").WithTag("language", "L2"), new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L3", groupIdentity: "Console.App.Test").WithTag("language", "L3") }; TemplateGroup templateGroup = TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templatesToSearch, A.Fake <IHostSpecificDataLoader>())).Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new console"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(3, matchingTemplates.Count()); StringWriter output = new StringWriter(); Reporter reporter = new Reporter(new AnsiConsole(output)); Assert.False(InstantiateCommand.VerifyMatchingTemplates(settings, matchingTemplates, reporter, out _)); return(Verifier.Verify(output.ToString(), _verifySettings.Settings)); }
public Task CanShowTemplateOptions_MultipleTemplate_MultipleParams() { var template1 = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group", precedence: 0) .WithChoiceParameter("choice", new[] { "val1", "val2" }, description: "my description", defaultValue: "def-val-not-shown", defaultIfNoOptionValue: "def-val-not-shown") .WithParameter("bool", paramType: "boolean", description: "my bool", defaultValue: "false", defaultIfNoOptionValue: "false"); var template2 = new MockTemplateInfo("foo", identity: "foo.2", groupIdentity: "foo.group", precedence: 2) .WithChoiceParameter("choice", new[] { "val1", "val3" }, description: "my description", defaultValue: "def-val", defaultIfNoOptionValue: "def-val-no-arg") .WithParameter("int", paramType: "integer", description: "my int", defaultValue: "0", defaultIfNoOptionValue: "10"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template1, template2 }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); TemplateCommand templateCommand1 = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[0]); TemplateCommand templateCommand2 = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[1]); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw); InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand2, templateCommand1 }, helpContext); return(Verifier.Verify(sw.ToString(), _verifySettings.Settings)); }
public void DefaultLanguageDisambiguates() { List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>(); templatesToSearch.Add(new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L1", groupIdentity: "Console.App.Test").WithTag("language", "L1")); templatesToSearch.Add(new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L2", groupIdentity: "Console.App.Test").WithTag("language", "L2")); TemplateGroup templateGroup = TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templatesToSearch, A.Fake <IHostSpecificDataLoader>())).Single(); var defaultParams = new Dictionary <string, string>(); defaultParams["prefs:language"] = "L1"; ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new console"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(2, matchingTemplates.Count()); StringWriter output = new StringWriter(); Reporter reporter = new Reporter(new AnsiConsole(output)); Assert.True(InstantiateCommand.VerifyMatchingTemplates(settings, matchingTemplates, reporter, out IEnumerable <TemplateCommand>?filtered)); Assert.Equal(1, filtered?.Count()); Assert.Equal("Console.App.L1", filtered?.Single().Template.Identity); Assert.Empty(output.ToString()); }
public void CanShowUsage_ForMultipleShortNames() { ITemplateEngineHost host = TestHost.GetVirtualHost(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw); InstantiateCommand.ShowUsage(myCommand, new[] { "short-name1", "short-name2" }, helpContext); Assert.Equal($"Usage:{Environment.NewLine} new short-name1 [options] [template options]{Environment.NewLine} new short-name2 [options] [template options]{Environment.NewLine}{Environment.NewLine}", sw.ToString()); }
// invalid params: // [0] name / value - Kind // [1] canonical // [2] input format // [3] param value // [4] error message internal void CanEvaluateInvalidParameters(string command, MockTemplateInfo[] templates, string?[][] expectedInvalidParams) { TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(templates, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager templatePackageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new {command}"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Empty(templateCommands); var templateMatchInfos = InstantiateCommand.CollectTemplateMatchInfo(args, settings, templatePackageManager, templateGroup); var invalidOptions = InstantiateCommand.GetInvalidOptions(templateMatchInfos); Assert.Equal(expectedInvalidParams.Length, invalidOptions.Count); foreach (var invalidParam in expectedInvalidParams) { InvalidTemplateOptionResult.Kind expectedErrorKind = invalidParam[0] == "name" ? InvalidTemplateOptionResult.Kind.InvalidName : InvalidTemplateOptionResult.Kind.InvalidValue; string?expectedCanonicalName = invalidParam[1]; string expectedInputFormat = invalidParam[2] ?? throw new Exception("Input Format cannot be null"); string?expectedSpecifiedValue = invalidParam[3]; string?expectedErrorMessage = null; if (invalidParam.Length == 5) { expectedErrorMessage = invalidParam[4]; } var actualParam = invalidOptions.Single(param => param.InputFormat == expectedInputFormat); Assert.Equal(expectedErrorKind, actualParam.ErrorKind); Assert.Equal(expectedCanonicalName, actualParam.TemplateOption?.TemplateParameter.Name); Assert.Equal(expectedInputFormat, actualParam.InputFormat); Assert.Equal(expectedSpecifiedValue, actualParam.SpecifiedValue); Assert.Equal(expectedErrorMessage, actualParam.ErrorMessage); } }
public Task CanShowHintsForOtherTemplates() { var template1 = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group").WithTag("language", "Lang1").WithTag("type", "project"); var template2 = new MockTemplateInfo("foo", identity: "foo.2", groupIdentity: "foo.group").WithTag("language", "Lang2").WithTag("type", "item"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template1, template2 }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); ParseResult parseResult = myCommand.Parse("new -h"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); StringWriter sw = new StringWriter(); InstantiateCommand.ShowHintForOtherTemplates(templateGroup, templateGroup.Templates[0], args, sw); return(Verifier.Verify(sw.ToString(), _verifySettings.Settings)); }
#pragma warning restore SA1117 // Parameters should be on same line or separate lines public void CanShowTemplateDescription(string name, string?language, string?author, string?description, string expected) { MockTemplateInfo templateInfo = new MockTemplateInfo( "console2", name: name, identity: "Console.App2", author: author); templateInfo.WithDescription(description); if (language != null) { templateInfo.WithTag("language", language); } CliTemplateInfo cliTemplateInfo = new CliTemplateInfo(templateInfo, HostSpecificTemplateData.Default); StringWriter sw = new StringWriter(); InstantiateCommand.ShowTemplateDetailHeaders(cliTemplateInfo, sw); Assert.Equal(expected, sw.ToString()); }
internal void Create_CanEvaluateTemplateWithSubcommandShortName(string command, string?expectedIdentitiesStr) { MockTemplateInfo template = new MockTemplateInfo(command, identity: $"{command}Template"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); string[] expectedIdentities = expectedIdentitiesStr?.Split("|") ?? Array.Empty <string>(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new create {command}"); var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command; var args = new InstantiateCommandArgs(instantiateCommand, parseResult); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(expectedIdentities.Count(), templateCommands.Count); Assert.Equal(expectedIdentities.OrderBy(s => s), templateCommands.Select(templateCommand => templateCommand.Template.Identity).OrderBy(s => s)); }
public Task CanShowCommandOptions_Basic() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw); InstantiateCommand.ShowCommandOptions(new[] { templateCommand }, templateCommand, helpContext); return(Verifier.Verify(sw.ToString(), _verifySettings.Settings)); }
public void CanShowCommandOptions_NoOptions() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group").WithTag("type", "MyType"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw); InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand }, helpContext); Assert.Equal($"Template options:{Environment.NewLine} (No options){Environment.NewLine}", sw.ToString()); }
public void AllTemplatesInGroupUseAllShortNamesForResolution(string shortName) { TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(_testSets["MultiShortNameGroup"], A.Fake <IHostSpecificDataLoader>())) .Single(); var defaultParams = new Dictionary <string, string>() { { "prefs:language", "C#" } }; ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new {shortName}"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(1, templateCommands.Count); Assert.Equal("MultiName.Test.High.CSharp", templateCommands.Single().Template.Identity); }
public Task CanShowTemplateOptions_SingleTemplate_Choice_ShortenedUsage() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithChoiceParameter("choice", new[] { "val1", "val2", "val3", "val4", "val5", "val6" }, description: "my description", defaultValue: "def-val", defaultIfNoOptionValue: "def-val-no-arg"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance, maxWidth: 50), myCommand, sw); InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand }, helpContext); return(Verifier.Verify(sw.ToString(), _verifySettings.Settings)); }
public void CanShowTemplateOptions_RequiredIsNotShownWhenDefaultValueIsGiven() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithChoiceParameter("choice", new[] { "val1", "val2" }, description: "my description", defaultValue: "def-val", defaultIfNoOptionValue: "def-val-no-arg", isRequired: true); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw); InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand }, helpContext); Assert.DoesNotContain("(REQUIRED)", sw.ToString()); }
[InlineData("eee", "OnlyF", "someValue", "Multiname.Test.Only.FSharp")] // uses a short name from a different template in the group public void ParameterExistenceDisambiguatesMatchesWithMultipleShortNames(string name, string paramName, string paramValue, string expectedIdentity) { TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(_testSets["MultiShortNameGroup"], A.Fake <IHostSpecificDataLoader>())) .Single(); var defaultParams = new Dictionary <string, string>() { { "prefs:language", "C#" } }; ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); string command = $"new {name} --{paramName} {paramValue}"; var parseResult = myCommand.Parse($" new {command}"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(1, templateCommands.Count); Assert.Equal(expectedIdentity, templateCommands.Single().Template.Identity); }
public void UniqueNameMatchesCorrectly() { IReadOnlyList <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>() { new MockTemplateInfo("console2", name: "Long name for Console App #2", identity: "Console.App2") }; TemplateGroup templateGroup = TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templatesToSearch, A.Fake <IHostSpecificDataLoader>())).Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new console2"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(1, matchingTemplates.Count()); StringWriter output = new StringWriter(); Reporter reporter = new Reporter(new AnsiConsole(output)); Assert.True(InstantiateCommand.VerifyMatchingTemplates(settings, matchingTemplates, reporter, out _)); Assert.Empty(output.ToString()); }