internal void GetHighestPrecedenceInvokableTemplatesTest(MockNewCommandInput command, MockTemplateInfo[] templates, string defaultLanguage, string[] expectedTemplates)
{
TemplateResolutionResult matchedTemplates = TemplateResolver.GetTemplateResolutionResult(templates, new MockHostSpecificDataLoader(), command, defaultLanguage);
TemplateGroup templateGroup = matchedTemplates.UnambiguousTemplateGroup;
bool useDefaultLanguage = string.IsNullOrWhiteSpace(command.Language) && !string.IsNullOrWhiteSpace(defaultLanguage);
IEnumerable <ITemplateMatchInfo> selectedTemplates = templateGroup.GetHighestPrecedenceInvokableTemplates(useDefaultLanguage);
var identitiesToCheck = selectedTemplates.Select(t => t.Info.Identity);
Assert.Equal(expectedTemplates.Length, selectedTemplates.Count());
foreach (string exp in expectedTemplates)
{
Assert.Single(selectedTemplates.Where(t => t.Info.Identity == exp));
}
bool success = templateGroup.TryGetHighestPrecedenceInvokableTemplate(out ITemplateMatchInfo selectedTemplate, useDefaultLanguage);
if (expectedTemplates.Length == 1)
{
Assert.Equal(expectedTemplates[0], selectedTemplate.Info.Identity);
Assert.True(success);
}
else
{
Assert.Null(selectedTemplate);
Assert.False(success);
}
}
private void EnsureTemplateResolutionResult()
{
if (_resolutionResultInitialized)
{
return;
}
_templateResolutionResult = TemplateResolver.GetTemplateResolutionResult(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
_singleMatchStatus = Status.NotEvaluated;
// If any template in the group has any ambiguous params, it's not invokable.
// The check for HasAmbiguousParameterValueMatch is for an example like:
// "dotnet new mvc -f netcore"
// - '-f netcore' is ambiguous in the 1.x version (2 begins-with matches)
// - '-f netcore' is not ambiguous in the 2.x version (1 begins-with match)
if (!_templateResolutionResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousTemplateGroup) ||
!_templateResolutionResult.TryGetSingularInvokableMatch(out _templateToInvoke, out _singleMatchStatus) ||
unambiguousTemplateGroup.Any(x => x.HasParameterMismatch()) ||
unambiguousTemplateGroup.Any(x => x.HasAmbiguousParameterValueMatch()))
{
_templateToInvoke = null;
if (_singleMatchStatus == Status.AmbiguousChoice)
{
_environment.Host.LogDiagnosticMessage(LocalizableStrings.Authoring_AmbiguousChoiceParameterValue, "Authoring");
}
else if (_singleMatchStatus == Status.AmbiguousPrecedence)
{
_environment.Host.LogDiagnosticMessage(LocalizableStrings.Authoring_AmbiguousBestPrecedence, "Authoring");
}
}
_resolutionResultInitialized = true;
}
public void MultipleTemplatesInGroupHavingSingularStartMatchesOnDifferentParams_HighPrecedenceIsChosen()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test_1", groupIdentity: "foo.test.template", precedence: 100)
.WithTag("MyChoice", "value_1", "other_value")
.WithTag("OtherChoice", "foo_"));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test_2", groupIdentity: "foo.test.template", precedence: 200)
.WithTag("MyChoice", "value_")
.WithTag("OtherChoice", "foo_", "bar_1"));
INewCommandInput userInputs = new MockNewCommandInput("foo").WithTemplateOption("MyChoice", "value_").WithTemplateOption("OtherChoice", "foo_");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
// make sure there's an unambiguous group, otherwise the singular match check is meaningless
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(2, unambiguousGroup.Count);
Assert.Equal(2, matchResult.GetBestTemplateMatchList().Count);
Assert.True(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo singularInvokableMatch, out Status resultStatus));
Assert.Equal(Status.SingleMatch, resultStatus);
Assert.Equal("foo.test_2", singularInvokableMatch.Info.Identity);
}
public void AllTemplatesInGroupUseAllShortNamesForResolution()
{
IReadOnlyList <string> shortNamesForGroup = new List <string>()
{
"aaa", "bbb", "ccc", "ddd", "eee", "fff"
};
string defaultLanguage = "C#";
foreach (string testShortName in shortNamesForGroup)
{
INewCommandInput userInputs = new MockNewCommandInput(testShortName);
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), userInputs, defaultLanguage);
Assert.Equal(TemplateResolutionResult.UnambiguousTemplateGroupStatus.SingleMatch, matchResult.GroupResolutionStatus);
Assert.Equal(3, matchResult.UnambiguousTemplateGroup.Templates.Count);
Assert.True(matchResult.UnambiguousTemplateGroup.Templates.All(t => WellKnownSearchFilters.MatchesAllCriteria(t)));
foreach (ITemplateMatchInfo templateMatchInfo in matchResult.UnambiguousTemplateGroup.Templates)
{
Assert.Equal("MultiName.Test", templateMatchInfo.Info.GroupIdentity);
if (templateMatchInfo.Info.GetLanguage().Equals(defaultLanguage, StringComparison.OrdinalIgnoreCase))
{
//default language match is part of MatchDisposition collection
Assert.Equal(2, templateMatchInfo.MatchDisposition.Count);
}
else
{
Assert.Equal(1, templateMatchInfo.MatchDisposition.Count);
}
Assert.True(templateMatchInfo.MatchDisposition[0].Name == MatchInfo.BuiltIn.ShortName && templateMatchInfo.MatchDisposition[0].Kind == MatchKind.Exact);
}
}
}
[InlineData("eee", "Y", "Multiname.Test.Only.FSharp")] // uses a short name from a different template in the group
public void ChoiceValueDisambiguatesMatchesWithMultipleShortNames(string name, string fooChoice, string expectedIdentity)
{
INewCommandInput commandInput = new MockNewCommandInput(name).WithTemplateOption("foo", fooChoice);
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), commandInput, "C#");
Assert.Equal(TemplateResolutionResult.Status.SingleMatch, matchResult.ResolutionStatus);
Assert.Equal(expectedIdentity, matchResult.TemplateToInvoke.Info.Identity);
}
[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)
{
INewCommandInput commandInput = new MockNewCommandInput(name).WithTemplateOption(paramName, paramValue);
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), commandInput, "C#");
Assert.True(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo invokableTemplate, out TemplateResolutionResult.Status resultStatus));
Assert.Equal(TemplateResolutionResult.Status.SingleMatch, resultStatus);
Assert.Equal(expectedIdentity, invokableTemplate.Info.Identity);
}
internal void GetAmbiguousSingleStartsWithParametersTest(MockNewCommandInput command, MockTemplateInfo[] templates, MockInvalidParameterInfo[] expectedInvalidParams)
{
TemplateResolutionResult matchedTemplates = TemplateResolver.GetTemplateResolutionResult(templates, new MockHostSpecificDataLoader(), command, null);
TemplateGroup templateGroup = matchedTemplates.UnambiguousTemplateGroup;
IEnumerable <InvalidParameterInfo> invalidParameters = templateGroup.GetAmbiguousSingleStartsWithParameters();
Assert.Equal(expectedInvalidParams.Length, invalidParameters.Count());
foreach (MockInvalidParameterInfo exp in expectedInvalidParams)
{
Assert.Single(invalidParameters.Where(param => param.ErrorKind == exp.Kind && param.InputFormat == exp.InputFormat && param.SpecifiedValue == exp.SpecifiedValue));
}
}
private async Task <CreationResultStatus> EnterTemplateManipulationFlowAsync()
{
if (_commandInput.IsListFlagSpecified || _commandInput.IsHelpFlagSpecified)
{
TemplateListResolutionResult listingTemplateResolutionResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
return(HelpForTemplateResolution.CoordinateHelpAndUsageDisplay(listingTemplateResolutionResult, EnvironmentSettings, _commandInput, _hostDataLoader, _telemetryLogger, _templateCreator, _defaultLanguage, showUsageHelp: _commandInput.IsHelpFlagSpecified));
}
TemplateResolutionResult templateResolutionResult = TemplateResolver.GetTemplateResolutionResult(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
TemplateInvocationAndAcquisitionCoordinator invocationCoordinator = new TemplateInvocationAndAcquisitionCoordinator(_settingsLoader, _commandInput, _templateCreator, _hostDataLoader, _telemetryLogger, _defaultLanguage, CommandName, _inputGetter, _callbacks);
return(await invocationCoordinator.CoordinateInvocationOrAcquisitionAsync());
}
internal void TemplateResolution_TemplateToInvoke_Test(MockNewCommandInput command, MockTemplateInfo[] templateSet, string defaultLanguage, int expectedStatus, string expectedIdentity)
{
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templateSet, new MockHostSpecificDataLoader(), command, defaultLanguage);
Assert.Equal(expectedStatus, (int)matchResult.ResolutionStatus);
if (expectedStatus == (int)TemplateResolutionResult.Status.SingleMatch)
{
Assert.Equal(expectedIdentity, matchResult.TemplateToInvoke.Info.Identity);
}
else
{
Assert.Null(matchResult.TemplateToInvoke);
}
}
public void TestPerformCoreTemplateQuery_ParameterValueDisambiguates()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template old", identity: "foo.test.old", groupIdentity: "foo.test.template", precedence: 100).WithTag("framework", "netcoreapp1.0", "netcoreapp1.1"));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template new", identity: "foo.test.new", groupIdentity: "foo.test.template", precedence: 200).WithTag("framework", "netcoreapp2.0"));
INewCommandInput userInputs = new MockNewCommandInput("foo").WithTemplateOption("framework", "netcoreapp1.0");
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.Equal("foo.test.old", unambiguousGroup[0].Info.Identity);
}
public void ExplicitLanguageChoiceIsHonoredWithMultipleShortNames()
{
IReadOnlyList <string> shortNamesForGroup = new List <string>()
{
"aaa", "bbb", "ccc", "ddd", "eee", "fff"
};
foreach (string testShortName in shortNamesForGroup)
{
INewCommandInput userInputs = new MockNewCommandInput(testShortName, "F#");
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), userInputs, "C#");
Assert.Equal(TemplateResolutionResult.Status.SingleMatch, matchResult.ResolutionStatus);
Assert.Equal("Multiname.Test.Only.FSharp", matchResult.TemplateToInvoke.Info.Identity);
}
}
public void HighestPrecedenceWinsWithMultipleShortNames()
{
IReadOnlyList <string> shortNamesForGroup = new List <string>()
{
"aaa", "bbb", "ccc", "ddd", "eee", "fff"
};
foreach (string testShortName in shortNamesForGroup)
{
INewCommandInput userInputs = new MockNewCommandInput(testShortName);
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), userInputs, "C#");
Assert.True(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo invokableTemplate, out TemplateResolutionResult.Status resultStatus));
Assert.Equal(TemplateResolutionResult.Status.SingleMatch, resultStatus);
Assert.Equal("MultiName.Test.High.CSharp", invokableTemplate.Info.Identity);
}
}
public void TestPerformCoreTemplateQuery_UniqueNameMatchesCorrectly()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("Template1", name: "Long name of Template1", identity: "Template1"));
templatesToSearch.Add(new MockTemplateInfo("Template2", name: "Long name of Template2", identity: "Template2"));
INewCommandInput userInputs = new MockNewCommandInput("Template2");
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.Equal(1, matchResult.GetBestTemplateMatchList().Count);
Assert.Equal("Template2", matchResult.GetBestTemplateMatchList()[0].Info.Identity);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.Equal("Template2", unambiguousGroup[0].Info.Identity);
}
public void TestPerformCoreTemplateQuery_GroupIsFound()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template old", identity: "foo.test.old", groupIdentity: "foo.test.template", precedence: 100));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template new", identity: "foo.test.new", groupIdentity: "foo.test.template", precedence: 200));
templatesToSearch.Add(new MockTemplateInfo("bar", name: "Bar template", identity: "bar.test", groupIdentity: "bar.test.template", precedence: 100));
INewCommandInput userInputs = new MockNewCommandInput("foo");
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, null);
Assert.Equal(2, matchResult.GetBestTemplateMatchList().Count);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(2, unambiguousGroup.Count);
Assert.Contains(unambiguousGroup, x => string.Equals(x.Info.Identity, "foo.test.old"));
Assert.Contains(unambiguousGroup, x => string.Equals(x.Info.Identity, "foo.test.new"));
}
public void TestPerformCoreTemplateQuery_InputLanguageIsPreferredOverDefault()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Description of foo Perl template", identity: "foo.test.Perl", groupIdentity: "foo.test.template")
.WithTag("language", "Perl"));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Description of foo LISP template", identity: "foo.test.Lisp", groupIdentity: "foo.test.template")
.WithTag("language", "LISP"));
INewCommandInput userInputs = new MockNewCommandInput("foo", "LISP");
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, new MockHostSpecificDataLoader(), userInputs, "Perl");
Assert.Equal(1, matchResult.GetBestTemplateMatchList().Count);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.Equal("foo.test.Lisp", unambiguousGroup[0].Info.Identity);
}
public void TestPerformCoreTemplateQuery_UnknownParameterNameInvalidatesMatch()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test", groupIdentity: "foo.test.template", precedence: 100).WithParameters("bar"));
INewCommandInput userInputs = new MockNewCommandInput("foo").WithTemplateOption("baz");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.False(TemplateResolver.ValidateRemainingParameters(unambiguousGroup[0], out IReadOnlyList <string> invalidParams));
Assert.Equal(1, invalidParams.Count);
Assert.Equal("baz", invalidParams[0]);
}
internal void TemplateResolution_UnambiguousGroup_Test(MockNewCommandInput command, MockTemplateInfo[] templateSet, string defaultLanguage, int expectedStatus, string[] expectedIdentities)
{
var matchResult = TemplateResolver.GetTemplateResolutionResult(templateSet, new MockHostSpecificDataLoader(), command, defaultLanguage);
Assert.Equal(expectedStatus, (int)matchResult.GroupResolutionStatus);
if (expectedStatus == (int)TemplateResolutionResult.UnambiguousTemplateGroupStatus.SingleMatch)
{
var identities = matchResult.UnambiguousTemplateGroup.Templates.Select(t => t.Info.Identity);
Assert.Equal(expectedIdentities.Length, identities.Count());
foreach (string identity in expectedIdentities)
{
Assert.Single(identities.Where(i => i == identity));
}
}
else
{
Assert.Null(matchResult.UnambiguousTemplateGroup);
}
}
public void TestPerformCoreTemplateQuery_InvalidChoiceValueInvalidatesMatch()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test.1x", groupIdentity: "foo.test.template", precedence: 100).WithTag("framework", "netcoreapp1.0", "netcoreapp1.1"));
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test.2x", groupIdentity: "foo.test.template", precedence: 200).WithTag("framework", "netcoreapp2.0"));
INewCommandInput userInputs = new MockNewCommandInput("foo").WithTemplateOption("framework", "netcoreapp3.0");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(2, unambiguousGroup.Count);
Assert.Equal(2, matchResult.GetBestTemplateMatchList().Count);
Assert.Contains(unambiguousGroup[0].MatchDisposition, x => x.Kind == MatchKind.InvalidParameterValue);
Assert.Contains(unambiguousGroup[1].MatchDisposition, x => x.Kind == MatchKind.InvalidParameterValue);
}
private Task <CreationResultStatus> EnterTemplateManipulationFlowAsync()
{
if (_commandInput.IsListFlagSpecified || _commandInput.IsHelpFlagSpecified)
{
TemplateListResolutionResult listingTemplateResolutionResult = TemplateResolver.GetTemplateResolutionResultForListOrHelp(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
return(Task.FromResult(HelpForTemplateResolution.CoordinateHelpAndUsageDisplay(listingTemplateResolutionResult, EnvironmentSettings, _commandInput, _hostDataLoader, _telemetryLogger, _templateCreator, _defaultLanguage, showUsageHelp: _commandInput.IsHelpFlagSpecified)));
}
TemplateResolutionResult templateResolutionResult = TemplateResolver.GetTemplateResolutionResult(_settingsLoader.UserTemplateCache.TemplateInfo, _hostDataLoader, _commandInput, _defaultLanguage);
if (templateResolutionResult.ResolutionStatus == TemplateResolutionResult.Status.SingleMatch)
{
TemplateInvocationCoordinator invocationCoordinator = new TemplateInvocationCoordinator(_settingsLoader, _commandInput, _telemetryLogger, CommandName, _inputGetter, _callbacks);
return(invocationCoordinator.CoordinateInvocationOrAcquisitionAsync(templateResolutionResult.TemplateToInvoke));
}
else
{
return(Task.FromResult(HelpForTemplateResolution.CoordinateAmbiguousTemplateResolutionDisplay(templateResolutionResult, EnvironmentSettings, _commandInput, _defaultLanguage, _settingsLoader.InstallUnitDescriptorCache.Descriptors.Values)));
}
}
public void GivenOneInvokableTemplateWithNonDefaultLanguage_ItIsChosen()
{
List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>();
templatesToSearch.Add(new MockTemplateInfo("foo", name: "Foo template", identity: "foo.test_1", groupIdentity: "foo.test.template", precedence: 100)
.WithTag("language", "F#"));
INewCommandInput userInputs = new MockNewCommandInput("foo");
IHostSpecificDataLoader hostSpecificDataLoader = new MockHostSpecificDataLoader();
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(templatesToSearch, hostSpecificDataLoader, userInputs, null);
// make sure there's an unambiguous group, otherwise the singular match check is meaningless
Assert.True(matchResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousGroup));
Assert.Equal(1, unambiguousGroup.Count);
Assert.Equal(1, matchResult.GetBestTemplateMatchList().Count);
Assert.True(matchResult.TryGetSingularInvokableMatch(out ITemplateMatchInfo singularInvokableMatch, out Status resultStatus));
Assert.Equal(Status.SingleMatch, resultStatus);
Assert.Equal("foo.test_1", singularInvokableMatch.Info.Identity);
}
public void AllTemplatesInGroupUseAllShortNamesForResolution()
{
IReadOnlyList <string> shortNamesForGroup = new List <string>()
{
"aaa", "bbb", "ccc", "ddd", "eee", "fff"
};
foreach (string testShortName in shortNamesForGroup)
{
INewCommandInput userInputs = new MockNewCommandInput(testShortName);
TemplateResolutionResult matchResult = TemplateResolver.GetTemplateResolutionResult(MultiShortNameGroupTemplateInfo, new MockHostSpecificDataLoader(), userInputs, "C#");
matchResult.TryGetCoreMatchedTemplatesWithDisposition(x => x.IsMatch, out IReadOnlyList <ITemplateMatchInfo> matchedTemplateList);
Assert.Equal(3, matchedTemplateList.Count);
foreach (ITemplateMatchInfo templateMatchInfo in matchedTemplateList)
{
Assert.Equal("MultiName.Test", templateMatchInfo.Info.GroupIdentity);
Assert.Equal(1, templateMatchInfo.MatchDisposition.Count);
Assert.True(templateMatchInfo.MatchDisposition[0].Location == MatchLocation.ShortName && templateMatchInfo.MatchDisposition[0].Kind == MatchKind.Exact);
}
}
}