public void RankTest()
{
// "it ranks full-word > start-of-word > end-of-word > middle-of-word > split > scattered letters"
var candidates = new List <string>
{
"controller x",
"0_co_re_00 x",
"0core0_000 x",
"0core_0000 x",
"0_core0_00 x",
"0_core_000 x"
};
var result = StringScorer.Filter(candidates, "core");
Assert.Equal(result[0].Word, candidates[5]);
Assert.Equal(result[1].Word, candidates[4]);
Assert.Equal(result[2].Word, candidates[3]);
Assert.Equal(result[3].Word, candidates[2]);
Assert.Equal(result[4].Word, candidates[1]);
Assert.Equal(result[5].Word, candidates[0]);
var result2 = StringScorer.Filter(candidates, "core x");
Assert.Equal(result2[0].Word, candidates[5]);
Assert.Equal(result2[1].Word, candidates[4]);
Assert.Equal(result2[2].Word, candidates[3]);
Assert.Equal(result2[3].Word, candidates[2]);
Assert.Equal(result2[4].Word, candidates[1]);
Assert.Equal(result2[5].Word, candidates[0]);
}
public void PreferCaseSensitivesMatchesTest()
{
Assert.Equal(new int[] { 0, 1, 2 }, StringScorer.Match("ccc CCC cCc CcC CCc", "ccc"));
Assert.Equal(new int[] { 4, 5, 6 }, StringScorer.Match("ccc CCC cCc CcC CCc", "CCC"));
Assert.Equal(new int[] { 8, 9, 10 }, StringScorer.Match("ccc CCC cCc CcC CCc", "cCc"));
Assert.Equal(new int[] { 12, 13, 14 }, StringScorer.Match("ccc CCC cCc CcC CCc", "CcC"));
Assert.Equal(new int[] { 16, 17, 18 }, StringScorer.Match("ccc CCC cCc CcC CCc", "CCc"));
}
public void PathMatcherTest()
{
Assert.Equal(new int[] { 0, 1, 2 }, StringScorer.Match(@"X\Y", @"X\Y"));
Assert.Equal(new int[] { 0, 2 }, StringScorer.Match(@"X\X-x", @"X"));
Assert.Equal(new int[] { 0, 2 }, StringScorer.Match(@"X\Y", @"XY"));
Assert.Equal(new int[] { 2 }, StringScorer.Match(@"-\X", @"X"));
Assert.Equal(new int[] { 0, 1, 3, 4 }, StringScorer.Match(@"XY\XY", @"XY"));
Assert.Equal(new int[] { 2, 4, 8, 11 }, StringScorer.Match(@"--X-Y-\-X--Y", @"XY"));
}
public void HelloWordScoreTest()
{
Assert.True(StringScorer.Score("Hello Word", "he") < StringScorer.Score("Hello Word", "Hello"));
Assert.Equal(0, StringScorer.Score("Hello Word", ""));
Assert.Equal(0, StringScorer.Score("Hello Word", null));
Assert.Equal(0, StringScorer.Score(" ", "he"));
Assert.Equal(0, StringScorer.Score(null, "he"));
Assert.Equal(0, StringScorer.Score("", ""));
Assert.Equal(0, StringScorer.Score(null, null));
Assert.Equal(0, StringScorer.Score("", "abc"));
}
public void HelloWorldMatcherTest()
{
Assert.Equal(new int[] { 0, 1 }, StringScorer.Match("Hello World", "he"));
Assert.Equal(new int[] { 6, 7, 8 }, StringScorer.Match("Hello World", "wor"));
Assert.Equal(new int[] { 10 }, StringScorer.Match("Hello World", "d"));
Assert.Equal(new int[] { 1, 2, 6, 7, 8 }, StringScorer.Match("Hello World", "elwor"));
Assert.Equal(new int[] {}, StringScorer.Match("Hello World", ""));
Assert.Equal(new int[] {}, StringScorer.Match(null, "he"));
Assert.Equal(new int[] {}, StringScorer.Match("", ""));
Assert.Equal(new int[] {}, StringScorer.Match("", "abc"));
}
public void GlobalAlign()
{
var scorer = new StringScorer();
var msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "car", "bar", GetChars);
msa.Compute();
Alignment<string, char>[] alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"| c a r |",
"| b a r |"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.66).Within(0.01));
msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "cart", "bar", GetChars);
msa.Compute();
alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"| c a r t |",
"| b a r - |"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.25).Within(0.01));
msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "cart", "art", GetChars);
msa.Compute();
alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"| c a r t |",
"| - a r t |"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.50).Within(0.01));
msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "start", "tan", GetChars);
msa.Compute();
alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(2));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"| s t a r t |",
"| - t a - n |"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.00).Within(0.01));
AssertAlignmentsEqual(alignments[1], CreateAlignment(
"| s t a r t |",
"| - t a n - |"
));
Assert.That(alignments[1].NormalizedScore, Is.EqualTo(0.00).Within(0.01));
}
public void ExpansionCompressionAlign()
{
var scorer = new StringScorer();
var msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "car", "bar", GetChars) {ExpansionCompressionEnabled = true};
msa.Compute();
Alignment<string, char>[] alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"| c a r |",
"| b a r |"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.66).Within(0.01));
msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "cart", "bar", GetChars) {ExpansionCompressionEnabled = true};
msa.Compute();
alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"| c a rt |",
"| b a r |"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.50).Within(0.01));
msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "cart", "art", GetChars) {ExpansionCompressionEnabled = true};
msa.Compute();
alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"| ca r t |",
"| a r t |"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.75).Within(0.01));
msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "start", "tan", GetChars) {ExpansionCompressionEnabled = true};
msa.Compute();
alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(2));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"| st ar t |",
"| t a n |"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.40).Within(0.01));
AssertAlignmentsEqual(alignments[1], CreateAlignment(
"| st a rt |",
"| t a n |"
));
Assert.That(alignments[1].NormalizedScore, Is.EqualTo(0.40).Within(0.01));
}
public void ReturnMostAccurateLimitedResultTest()
{
var opts = new StringScorerOptions(maxResults: 1);
var candidates = new List <string> {
"GruntFile", "filter", "bile"
};
var result = StringScorer.Filter(candidates, "file", opts);
var words = result.Select(x => x.Word).ToList();
Assert.Single(result);
Assert.Equal(new [] { "GruntFile" }, words);
}
public void AlignEmptySequence()
{
var scorer = new StringScorer();
var msa = new MultipleAlignmentAlgorithm<string, char>(scorer, new[] {"car", "", "bar"}, GetChars) {UseInputOrder = true};
msa.Compute();
Alignment<string, char> alignment = msa.GetAlignment();
AssertAlignmentsEqual(alignment, CreateAlignment(
"| c a r |",
"| - - - |",
"| b a r |"
));
}
public void ReturnMostAccurateResultTest()
{
var candidates = new List <string> {
"GruntFile", "filter", "bile"
};
var result = StringScorer.Filter(candidates, "file");
var words = result.Select(x => x.Word).ToList();
Assert.Equal(2, result.Length);
Assert.Contains("GruntFile", words);
Assert.Contains("filter", words);
}
public void AlignLessThanThreeSequences()
{
var scorer = new StringScorer();
Assert.Throws<ArgumentException>(() =>
{
var msa = new MultipleAlignmentAlgorithm<string, char>(scorer, Enumerable.Empty<string>(), GetChars);
});
Assert.Throws<ArgumentException>(() =>
{
var msa = new MultipleAlignmentAlgorithm<string, char>(scorer, new[] {"bar"}, GetChars);
});
Assert.Throws<ArgumentException>(() =>
{
var msa = new MultipleAlignmentAlgorithm<string, char>(scorer, new[] {"car", "bar"}, GetChars);
});
}
public void PreferWholeWordToScatteredLettersTest()
{
Assert.Equal(new int[] { 12, 13, 14, 15 }, StringScorer.Match("fiddle gruntfile filler", @"file"));
Assert.Equal(new int[] { 7, 8, 9, 10 }, StringScorer.Match("fiddle file", @"file"));
Assert.Equal(new int[] { 8, 9, 10, 11 }, StringScorer.Match("find le file", @"file"));
}
private IResultSubject[] Filter(List <string> candidates, string query, StringScorerOptions options = null)
{
return(StringScorer.Filter(candidates, query, options));
}
public void AlignMoreThanTwoSequences()
{
var scorer = new StringScorer();
var msa = new MultipleAlignmentAlgorithm<string, char>(scorer, new[] {"car", "bar", "carp"}, GetChars) {UseInputOrder = true};
msa.Compute();
Alignment<string, char> alignment = msa.GetAlignment();
AssertAlignmentsEqual(alignment, CreateAlignment(
"| c a r - |",
"| b a r - |",
"| c a r p |"
));
msa = new MultipleAlignmentAlgorithm<string, char>(scorer, new[] {"car", "bar", "star"}, GetChars) {UseInputOrder = true};
msa.Compute();
alignment = msa.GetAlignment();
AssertAlignmentsEqual(alignment, CreateAlignment(
"| - c a r |",
"| - b a r |",
"| s t a r |"
));
msa = new MultipleAlignmentAlgorithm<string, char>(scorer, new[] {"car", "bar", "stare"}, GetChars) {UseInputOrder = true};
msa.Compute();
alignment = msa.GetAlignment();
AssertAlignmentsEqual(alignment, CreateAlignment(
"| - c a r - |",
"| - b a r - |",
"| s t a r e |"
));
msa = new MultipleAlignmentAlgorithm<string, char>(scorer, new[] {"scar", "car", "bar", "stare"}, GetChars) {UseInputOrder = true};
msa.Compute();
alignment = msa.GetAlignment();
AssertAlignmentsEqual(alignment, CreateAlignment(
"| s c a r - |",
"| - c a r - |",
"| - b a r - |",
"| s t a r e |"
));
msa = new MultipleAlignmentAlgorithm<string, char>(scorer, new[] {"sane", "scar", "car", "bar", "stare"}, GetChars) {UseInputOrder = true};
msa.Compute();
alignment = msa.GetAlignment();
AssertAlignmentsEqual(alignment, CreateAlignment(
"| s - a n e |",
"| s c a r - |",
"| - c a r - |",
"| - b a r - |",
"| s t a r e |"
));
msa = new MultipleAlignmentAlgorithm<string, char>(scorer, new[] {"sane", "scar", "she", "car", "bar", "stare"}, GetChars) {UseInputOrder = true};
msa.Compute();
alignment = msa.GetAlignment();
AssertAlignmentsEqual(alignment, CreateAlignment(
"| s - a n e |",
"| s c a r - |",
"| s - - h e |",
"| - c a r - |",
"| - b a r - |",
"| s t a r e |"
));
}
public void AccountForCaseInSelectingCamelCaseVsConsecutiveTest()
{
Assert.Equal(new int[] { 10, 15, 22 }, StringScorer.Match("0xACACAC: CamelControlClass.ccc", "CCC"));
Assert.Equal(new int[] { 28, 29, 30 }, StringScorer.Match("0xACACAC: CamelControlClass.ccc", "ccc"));
}
public void PreferAcronymToScatteredLettersTest()
{
Assert.Equal(new int[] { 0, 7, 8, 9 }, StringScorer.Match("action_config", "acon"));
Assert.Equal(new int[] { 0, 12, 13, 14 }, StringScorer.Match("application_control", "acon"));
}
public void PreferCamelCaseToScatteredLettersTest()
{
Assert.Equal(new int[] { 0, 10, 15 }, StringScorer.Match("ImportanceTableCtrl", "itc"));
}
public void SemiGlobalAlign()
{
var scorer = new StringScorer();
var msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "car", "bar", GetChars) {Mode = AlignmentMode.SemiGlobal};
msa.Compute();
Alignment<string, char>[] alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"| c a r |",
"| b a r |"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.66).Within(0.01));
msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "cart", "bar", GetChars) {Mode = AlignmentMode.SemiGlobal};
msa.Compute();
alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"| c a r | t",
"| b a r | "
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.57).Within(0.01));
msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "cart", "art", GetChars) {Mode = AlignmentMode.SemiGlobal};
msa.Compute();
alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"c | a r t |",
" | a r t |"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.86).Within(0.01));
msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "start", "tan", GetChars) {Mode = AlignmentMode.SemiGlobal};
msa.Compute();
alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"s | t a r | t",
" | t a n | "
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0.50).Within(0.01));
}
public void PreferWholeWordToScatteredLettersEventWithouthMatchesTest()
{
Assert.Equal(new int[] { 12, 13, 14, 15, 17 }, StringScorer.Match("fiddle gruntfile xfiller", @"filex"));
Assert.Equal(new int[] { 7, 8, 9, 10, 12 }, StringScorer.Match("fiddle file xfiller", @"filex"));
Assert.Equal(new int[] { 8, 9, 10, 11, 13 }, StringScorer.Match("find le file xfiller", @"filex"));
}
public void PreferExactMatchesTest()
{
Assert.Equal(new int[] { 12, 13, 14, 15 }, StringScorer.Match("filter gruntfile filler", @"file"));
}
public void SemiGlobalAlign_EmptySequence()
{
var scorer = new StringScorer();
var msa = new PairwiseAlignmentAlgorithm<string, char>(scorer, "", "", GetChars) {Mode = AlignmentMode.SemiGlobal};
msa.Compute();
Alignment<string, char>[] alignments = msa.GetAlignments().ToArray();
Assert.That(alignments.Length, Is.EqualTo(1));
AssertAlignmentsEqual(alignments[0], CreateAlignment(
"||",
"||"
));
Assert.That(alignments[0].NormalizedScore, Is.EqualTo(0));
}
