public void CacheSortPoaAscTest()
{
AddWords("fib bit ebay bitter drillbit abdiging", "cvc cvc vcvc cvccvc ccvcccvc vccvcvcc");
_sortOptions.SortType = PhoneticSortType.POA;
_sortOptions.SetPrimarySortField(_phoneticField, false, kAscending);
_cache.Sort(_sortOptions);
Assert.AreEqual(6, _cache.Count);
string[] words = { "bit", "bitter", "drillbit", "fib", "ebay", "abdiging" }; // expected answer
for (int i = 0; i < _cache.Count; i++)
{
Assert.AreEqual(words[i], _cache[i].WordCacheEntry["Phonetic"]);
}
}
public void AdvancedPOASortTest1()
{
AddWords("mappu sippu", null);
_query.Pattern = "p/*_*";
WordListCache cache = App.Search(_query);
Assert.IsNotNull(cache);
_sortOptions.SortType = PhoneticSortType.POA;
_sortOptions.AdvancedEnabled = true;
_sortOptions.AdvSortOrder = new[] { 1, 0, 2 };
_sortOptions.AdvRlOptions = new[] { true, false, false };
_sortOptions.SetPrimarySortField(_phoneticField, false, kAscending);
cache.Sort(_sortOptions);
Assert.AreEqual(4, cache.Count);
Assert.AreEqual("sippu", cache[0].PhoneticValue);
Assert.AreEqual(3, cache[0].SearchItemOffset);
Assert.AreEqual("mappu", cache[1].PhoneticValue);
Assert.AreEqual(3, cache[1].SearchItemOffset);
Assert.AreEqual("sippu", cache[2].PhoneticValue);
Assert.AreEqual(2, cache[2].SearchItemOffset);
Assert.AreEqual("mappu", cache[3].PhoneticValue);
Assert.AreEqual(2, cache[3].SearchItemOffset);
}
public void CacheSortCvcAscPoaDescTest()
{
AddWords("fib bit dig ebay bitter digger drillbit abdiging",
"cvc cvc cvc vcvv cvccvc cvccvc ccvcccvc vccvcvcc");
_query.Pattern = "b/*_*";
WordListCache cache = App.Search(_query);
_sortOptions.SortType = PhoneticSortType.POA;
_sortOptions.AdvancedEnabled = true;
_sortOptions.SetPrimarySortField(_phoneticField, false, kDescending); // 2nd sort
_sortOptions.SetPrimarySortField(_cvField, false, kAscending); // 1st sort
cache.Sort(_sortOptions);
System.Diagnostics.Debug.WriteLine("b = " + _prj.PhoneCache["b"].POAKey);
System.Diagnostics.Debug.WriteLine("f = " + _prj.PhoneCache["f"].POAKey);
System.Diagnostics.Debug.WriteLine("t = " + _prj.PhoneCache["t"].POAKey);
System.Diagnostics.Debug.WriteLine("d = " + _prj.PhoneCache["d"].POAKey);
System.Diagnostics.Debug.WriteLine("n = " + _prj.PhoneCache["n"].POAKey);
System.Diagnostics.Debug.WriteLine("r = " + _prj.PhoneCache["r"].POAKey);
System.Diagnostics.Debug.WriteLine("l = " + _prj.PhoneCache["l"].POAKey);
System.Diagnostics.Debug.WriteLine("g = " + _prj.PhoneCache["g"].POAKey);
System.Diagnostics.Debug.WriteLine("i = " + _prj.PhoneCache["i"].POAKey);
System.Diagnostics.Debug.WriteLine("e = " + _prj.PhoneCache["e"].POAKey);
System.Diagnostics.Debug.WriteLine("a = " + _prj.PhoneCache["a"].POAKey);
System.Diagnostics.Debug.WriteLine("y = " + _prj.PhoneCache["y"].POAKey);
Assert.AreEqual(6, cache.Count);
Assert.AreEqual("drillbit", cache[0].WordCacheEntry["Phonetic"]);
Assert.AreEqual("fib", cache[1].WordCacheEntry["Phonetic"]);
Assert.AreEqual("bit", cache[2].WordCacheEntry["Phonetic"]);
Assert.AreEqual("bitter", cache[3].WordCacheEntry["Phonetic"]);
Assert.AreEqual("abdiging", cache[4].WordCacheEntry["Phonetic"]);
Assert.AreEqual("ebay", cache[5].WordCacheEntry["Phonetic"]);
}
/// ------------------------------------------------------------------------------------
private WordListCache GetCIEResults(CIEOptions options)
{
var sortOptions = new SortOptions(true, _prj)
{
AdvancedEnabled = true
};
if (options.Type != CIEOptions.IdenticalType.After)
{
sortOptions.AdvSortOrder = new[] { 0, 1, 2 }
}
;
else
{
sortOptions.AdvSortOrder = new[] { 2, 1, 0 };
sortOptions.AdvRlOptions[2] = true;
}
_cache.Sort(sortOptions);
sortOptions = new SortOptions(true, _prj)
{
AdvancedEnabled = true
};
return(new CIEBuilder(_cache, sortOptions, options).FindMinimalPairs());
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Use a special sort to make sure the reference fields for word list cache entries
/// that come from audio files are taken from the word list cache entries and not the
/// record cache entries that own the word list entries.
/// </summary>
/// ------------------------------------------------------------------------------------
protected bool OnSortCache(object args)
{
object[] argArray = args as object[];
if (argArray == null || argArray.Length < 2)
{
return(false);
}
WordListCache wcache = argArray[0] as WordListCache;
SortOptions sortOptions = argArray[1] as SortOptions;
if (wcache == null || sortOptions == null)
{
return(false);
}
wcache.Sort(new SACacheSortComparer(sortOptions));
return(true);
}
public void CacheSortCvcDescMoaAscTest()
{
AddWords("fib bit dig ebay bitter digger drillbit abdiging",
"cvc cvc cvc vcvc cvccvc cvccvc ccvcccvc vccvcvcc");
_query.Pattern = "b/*_*";
WordListCache cache = App.Search(_query);
_sortOptions.SortType = PhoneticSortType.MOA;
_sortOptions.SetPrimarySortField(_phoneticField, false, kAscending); // 2nd sort
_sortOptions.SetPrimarySortField(_cvField, false, kDescending); // 1st sort
cache.Sort(_sortOptions);
Assert.AreEqual(6, cache.Count);
string[] words = { "ebay", "abdiging", "bitter", "fib", "bit", "drillbit" }; // expected answer
for (int i = 0; i < cache.Count; i++)
{
Assert.AreEqual(words[i], cache[i].WordCacheEntry["Phonetic"]);
}
}
public void CacheAdvSortMoaDescTest()
{
AddWords("rabbit bir fib bit dig ebay bitter digger drillbit abdiging",
"cvccvc cvc cvc cvc cvc vcvc cvccvc cvccvc ccvcccvc vccvcvcc");
_query.Pattern = "bi/*_*";
WordListCache cache = App.Search(_query);
_sortOptions.SortType = PhoneticSortType.MOA;
_sortOptions.AdvancedEnabled = true;
_sortOptions.AdvSortOrder = new[] { 0, 2, 1 };
_sortOptions.AdvRlOptions = new[] { true, true, true };
_sortOptions.SetPrimarySortField(_phoneticField, false, kDescending);
cache.Sort(_sortOptions);
Assert.AreEqual(5, cache.Count);
string[] words = { "rabbit", "drillbit", "bit", "bitter", "bir" }; // expected answer
for (int i = 0; i < cache.Count; i++)
{
Assert.AreEqual(words[i], cache[i].WordCacheEntry["Phonetic"]);
}
}
public void SimplePOASortTest1()
{
AddWords("b\u0324it bag", null);
var cache = new WordListCache();
foreach (var entry in _recCache.WordCache)
{
cache.Add(entry);
}
Assert.IsNotNull(cache);
_sortOptions.SortType = PhoneticSortType.POA;
_sortOptions.AdvancedEnabled = false;
_sortOptions.SetPrimarySortField(_phoneticField, false, kAscending);
cache.Sort(_sortOptions);
Assert.AreEqual(2, cache.Count);
Assert.AreEqual("bag", cache[0].WordCacheEntry["Phonetic"]);
Assert.AreEqual("b\u0324it", cache[1].WordCacheEntry["Phonetic"]);
}
public void CacheAdvSortPoaRLTest()
{
AddWords("pig big p\u02B0ig", null);
_query.Pattern = "[V]/*_*";
WordListCache cache = App.Search(_query);
Assert.IsNotNull(cache);
_sortOptions.SortType = PhoneticSortType.POA;
_sortOptions.AdvancedEnabled = true;
_sortOptions.AdvSortOrder = new[] { 1, 0, 2 };
_sortOptions.AdvRlOptions = new[] { true, false, false };
_sortOptions.SetPrimarySortField(_phoneticField, false, kAscending);
cache.Sort(_sortOptions);
Assert.AreEqual(3, cache.Count);
string[] words = { "pig", "p\u02B0ig", "big" }; // expected answer
for (int i = 0; i < cache.Count; i++)
{
Assert.AreEqual(words[i], cache[i].WordCacheEntry["Phonetic"]);
}
}
public void CacheAdvSortCvcAscPoaDescTest()
{
AddWords("pig fib bit dig ebay bitter digger drillbit abdiging",
"cvc cvc cvc cvc vcvc cvccvc cvccvc ccvcccvc vccvcvcc");
_query.Pattern = "i/*_*";
WordListCache cache = App.Search(_query);
_sortOptions.SortType = PhoneticSortType.POA;
_sortOptions.AdvancedEnabled = true;
_sortOptions.AdvSortOrder = new[] { 2, 0, 1 };
_sortOptions.AdvRlOptions = new[] { true, false, true };
_sortOptions.SetPrimarySortField(_phoneticField, false, kDescending); // 2nd sort
_sortOptions.SetPrimarySortField(_cvField, false, kAscending); // 1st sort
cache.Sort(_sortOptions);
Assert.AreEqual(10, cache.Count);
// Expected answer
string[] words = { "drillbit", "drillbit", "dig", "pig", "bit", "fib", "digger", "bitter", "abdiging", "abdiging" };
for (int i = 0; i < cache.Count; i++)
{
Assert.AreEqual(words[i], cache[i].WordCacheEntry["Phonetic"]);
}
}
/// ------------------------------------------------------------------------------------
public WordListCache FindMinimalPairs()
{
if (Cache == null || !Cache.IsForSearchResults)
{
return(null);
}
foreach (var entry in Cache)
{
entry.CIEGroupId = -1;
}
// First, send a message to see if there is an AddOn to find minimal pairs. If so,
// then return the cache it generated instead of the one built by this method.
object args = this;
if (App.MsgMediator.SendMessage("FindMinimalPairsAlternate", args))
{
if (args is WordListCache)
{
return(args as WordListCache);
}
}
var cieGroups = new Dictionary <string, List <WordListCacheEntry> >();
var noDups = new HashSet <string>();
foreach (var entry in Cache)
{
string pattern = GetCIEPattern(entry, _cieOptions);
List <WordListCacheEntry> entryList;
if (!cieGroups.TryGetValue(pattern, out entryList))
{
entryList = new List <WordListCacheEntry>();
cieGroups[pattern] = entryList;
}
var setItem = pattern + "+" + entry.SearchItem;
if (!noDups.Contains(setItem))
{
noDups.Add(setItem);
entryList.Add(entry);
}
}
noDups.Clear();
// The groups are not guaranteed to be in any particular order, just the words within groups.
// TODO: Sort groups by POA, or MOA, based on what's specified in _sortOptions.
// Create a new cache which is the subset containing minimal pair entries.
int cieGroupId = 0;
var cieGroupTexts = new SortedList <int, string>();
var cieCache = new WordListCache();
foreach (var grp in cieGroups.Where(g => g.Value.Count >= 2))
{
foreach (var entry in grp.Value)
{
entry.CIEGroupId = cieGroupId;
cieCache.Add(entry);
}
cieGroupTexts[cieGroupId++] = grp.Key;
}
cieCache.IsMinimalPair = true;
cieCache.CIEGroupTexts = cieGroupTexts;
cieCache.IsForSearchResults = true;
cieCache.Sort(_sortOptions);
cieCache.SearchQuery = Cache.SearchQuery.Clone();
return(cieCache);
}
