public void FilterByClassFromDifferentNamespaces()
{
var suggestedNames = new CorrectionsSuggester(new[] { typeof(MyClassA), typeof(NamespaceA.MyClassA) })
.SuggestFor("MyClasA");
Assert.Equal(new[] { "*MyClassA*" }, suggestedNames);
}
public void FilterGeneric_LevenshteinOrdering()
{
var suggestedNames = new CorrectionsSuggester(new[]
{
typeof(Generics.GenericA <int>),
typeof(Generics.GenericB <int>)
}).SuggestFor("GeneriA<Int32>");
Assert.Equal(new[] { "*GenericA<Int32>*" }, suggestedNames);
}
public void FilterByClass_LevenshteinOrdering()
{
var suggestedNames = new CorrectionsSuggester(new[]
{
typeof(MyClassA), typeof(MyClassB), typeof(MyClassC), typeof(MyClassZ), typeof(NamespaceB.NamespaceC.MyClassA),
typeof(MyClassZ.MyClassY)
}).SuggestFor("MyClasZ");
Assert.Equal(new[] { "*MyClassZ*" }, suggestedNames);
}
public void FilterByInnerNamespace_LevenshteinOrdering()
{
var suggestedNames = new CorrectionsSuggester(new[]
{
typeof(AnotherNamespace.InnerNamespaceA.MyClassA),
typeof(AnotherNamespace.InnerNamespaceB.MyClassA),
typeof(Lexicographical.MyClassLexicAACDE)
}).SuggestFor("InerNamespaceB");
Assert.Equal(new[] { "*InnerNamespaceB*" }, suggestedNames);
}
public void FilterByCompositeNamespace_LevenshteinOrdering()
{
var suggestedNames = new CorrectionsSuggester(new[]
{
typeof(NamespaceA.NamespaceC.MyClassA),
typeof(NamespaceB.NamespaceC.MyClassC),
typeof(AnotherNamespace.InnerNamespaceA.MyClassA)
}).SuggestFor("NmespaceB.NamespaceC");
Assert.Equal(new[] { "NamespaceB.NamespaceC*", "NamespaceA.NamespaceC*" }, suggestedNames);
}
public void FilterUnknownBenchmark_CollectionIsEmpty()
{
var suggestedNames = new CorrectionsSuggester(new[]
{
typeof(NamespaceA.MyClassA),
typeof(NamespaceB.MyClassB),
typeof(AnotherNamespace.MyClassZ),
typeof(NamespaceB.NamespaceC.MyClassC)
}).SuggestFor("Anything");
Assert.Empty(suggestedNames);
}
public void FilterByNamespace_LevenshteinOrdering()
{
var suggestedNames = new CorrectionsSuggester(new[]
{
typeof(NamespaceA.MyClassA),
typeof(NamespaceB.MyClassB),
typeof(AnotherNamespace.MyClassZ),
typeof(NamespaceB.NamespaceC.MyClassC)
}).SuggestFor("Nmespace");
Assert.Equal(new[] { "NamespaceA", "NamespaceB", "NamespaceC" }, suggestedNames);
}
public void FilterByNamespaceClassMethod_LevenshteinOrdering()
{
var suggestedNames = new CorrectionsSuggester(new[]
{
typeof(NamespaceB.MyClassA),
typeof(NamespaceA.MyClassA),
typeof(NamespaceB.NamespaceC.MyClassA)
}).SuggestFor("NamespaceA.MyClasA.MethodA");
Assert.Equal(new[]
{
"NamespaceA.MyClassA.MethodA",
"NamespaceA.MyClassA.MethodB",
"NamespaceB.MyClassA.MethodA",
}, suggestedNames);
}
public void CheckLexicographicalOrder()
{
var suggestedNames = new CorrectionsSuggester(new[]
{
typeof(AnotherNamespace.MyClassZ),
typeof(NamespaceA.MyClassA),
typeof(NamespaceB.MyClassB),
typeof(NamespaceB.NamespaceC.MyClassC)
}).GetAllBenchmarkNames();
Assert.Equal(new[]
{
"AnotherNamespace.MyClassZ.MethodZ",
"NamespaceA.MyClassA.MethodA",
"NamespaceA.MyClassA.MethodB",
"NamespaceB.MyClassB.MethodB",
"NamespaceB.MyClassB.MethodC",
"NamespaceB.NamespaceC.MyClassC.MethodC"
}, suggestedNames);
}
