/// <summary>
/// Initializes static members of the Alphabets class.
/// </summary>
static Alphabets()
{
// get the registered alphabets.
IList <IAlphabet> registeredAlphabets = RegisteredAddIn.GetAlphabets(true);
if (null != registeredAlphabets && registeredAlphabets.Count > 0)
{
foreach (IAlphabet alphabet in registeredAlphabets)
{
if (alphabet != null && all.FirstOrDefault(IA => string.Compare(IA.Name, alphabet.Name, StringComparison.OrdinalIgnoreCase) == 0) == null)
{
all.Add(alphabet);
}
}
registeredAlphabets.Clear();
}
AmbiguousAlphabetMap = new Dictionary <IAlphabet, IAlphabet>();
MapAlphabetToAmbiguousAlphabet(DnaAlphabet.Instance, AmbiguousDnaAlphabet.Instance);
MapAlphabetToAmbiguousAlphabet(RnaAlphabet.Instance, AmbiguousRnaAlphabet.Instance);
MapAlphabetToAmbiguousAlphabet(ProteinAlphabet.Instance, AmbiguousProteinAlphabet.Instance);
MapAlphabetToAmbiguousAlphabet(AmbiguousDnaAlphabet.Instance, AmbiguousDnaAlphabet.Instance);
MapAlphabetToAmbiguousAlphabet(AmbiguousRnaAlphabet.Instance, AmbiguousRnaAlphabet.Instance);
AlphabetToBaseAlphabetMap = new Dictionary <IAlphabet, IAlphabet>();
MapAlphabetToBaseAlphabet(AmbiguousDnaAlphabet.Instance, DnaAlphabet.Instance);
MapAlphabetToBaseAlphabet(AmbiguousRnaAlphabet.Instance, RnaAlphabet.Instance);
MapAlphabetToBaseAlphabet(AmbiguousProteinAlphabet.Instance, ProteinAlphabet.Instance);
MapAlphabetToBaseAlphabet(Bio.Algorithms.MUMmer.MummerDnaAlphabet.Instance, DnaAlphabet.Instance);
MapAlphabetToBaseAlphabet(Bio.Algorithms.MUMmer.MummerRnaAlphabet.Instance, RnaAlphabet.Instance);
MapAlphabetToBaseAlphabet(Bio.Algorithms.MUMmer.MummerProteinAlphabet.Instance, ProteinAlphabet.Instance);
}
/// <summary>
/// Gets all registered specified classes in core folder and addins (optional) folders
/// </summary>
/// <param name="includeAddinFolder">include add-ins folder or not</param>
/// <returns>List of registered classes</returns>
private static IList <T> GetClasses <T>(bool includeAddinFolder)
{
IList <T> registeredAligners = new List <T>();
if (includeAddinFolder)
{
IList <T> addInAligners;
if (null != RegisteredAddIn.AddinFolderPath)
{
addInAligners =
RegisteredAddIn.GetInstancesFromAssemblyPath <T>(RegisteredAddIn.AddinFolderPath,
RegisteredAddIn.DLLFilter);
if (null != addInAligners && addInAligners.Count > 0)
{
foreach (T aligner in addInAligners)
{
if (aligner != null)
{
registeredAligners.Add(aligner);
}
}
}
}
}
return(registeredAligners);
}
/// <summary>
/// Gets all registered sequence alignment formatters in core folder and addins (optional) folders
/// </summary>
/// <param name="includeAddinFolder">include add-ins folder or not</param>
/// <returns>List of registered formatters</returns>
private static IList <ISequenceAlignmentFormatter> GetAlignmentFormatters(bool includeAddinFolder)
{
IList <ISequenceAlignmentFormatter> registeredFormatters = new List <ISequenceAlignmentFormatter>();
if (includeAddinFolder)
{
IList <ISequenceAlignmentFormatter> addInFormatters;
if (null != RegisteredAddIn.AddinFolderPath)
{
addInFormatters = RegisteredAddIn.GetInstancesFromAssemblyPath <ISequenceAlignmentFormatter>(RegisteredAddIn.AddinFolderPath, RegisteredAddIn.DLLFilter);
if (null != addInFormatters && addInFormatters.Count > 0)
{
foreach (ISequenceAlignmentFormatter formatter in addInFormatters)
{
if (formatter != null && registeredFormatters.FirstOrDefault(IA => string.Compare(
IA.Name, formatter.Name, StringComparison.OrdinalIgnoreCase) == 0) == null)
{
registeredFormatters.Add(formatter);
}
}
}
}
}
return(registeredFormatters);
}
public void TestAddinsRegisterAssembler()
{
var assemblers = RegisteredAddIn.GetInstancesFromAssembly <IDeNovoAssembler>(
Assembly.GetExecutingAssembly().CodeBase.Substring(8));
Assert.AreEqual(1, assemblers.Count);
Assert.AreEqual(typeof(TestAutomationSequenceAssembler), assemblers[0].GetType());
}
public void TestAddinsSequenceAligners()
{
List <ISequenceAligner> expectedAligners = new List <ISequenceAligner>
{
new TestAutomationSequenceAligner(),
new TestAutomationPairwiseSequenceAligner()
};
// Gets the registered Instances for the path passed
IList <ISequenceAligner> actualAligners = RegisteredAddIn.GetInstancesFromAssembly <ISequenceAligner>(
typeof(TestAutomationSequenceAligner).Assembly.FullName);
CompareAlignerElements(expectedAligners, actualAligners);
}
public void RegisterAddinsGetInstancesFilter()
{
CreateAddinsFolder();
IList <ISequenceAligner> finalValue = new List <ISequenceAligner>();
finalValue.Add(new TestAutomationSequenceAligner());
finalValue.Add(new TestAutomationPairwiseSequenceAligner());
// Gets the registered Instances for the path passed and the filter
IList <ISequenceAligner> registeredAligners =
RegisteredAddIn.GetInstancesFromAssemblyPath <ISequenceAligner>(
RegisteredAddIn.AddinFolderPath, "*.dll");
RegisterAlignGeneralTestCases(registeredAligners, finalValue);
DeleteAddinsFolder();
}
/// <summary>
/// Gets all registered aligners in core folder and addins (optional) folders
/// </summary>
/// <returns>List of registered aligners</returns>
private static IEnumerable <ISequenceAligner> GetAligners()
{
IList <ISequenceAligner> registeredAligners = new List <ISequenceAligner>();
IList <ISequenceAligner> addInAligners = RegisteredAddIn.GetComposedInstancesFromAssemblyPath <ISequenceAligner>(
"NetBioSequenceAlignersExport", RegisteredAddIn.AddinFolderPath, RegisteredAddIn.DLLFilter);
if (null != addInAligners && addInAligners.Count > 0)
{
foreach (ISequenceAligner aligner in addInAligners.Where(
aligner => aligner != null && registeredAligners.All(sa => string.Compare(sa.Name, aligner.Name, StringComparison.OrdinalIgnoreCase) != 0)))
{
registeredAligners.Add(aligner);
}
}
return(registeredAligners);
}
public void RegisterAddinsGetInstances()
{
CreateAddinsFolder();
IList <ISequenceAligner> finalValue = new List <ISequenceAligner>();
finalValue.Add(new TestAutomationSequenceAligner());
finalValue.Add(new TestAutomationPairwiseSequenceAligner());
// Gets the registered Instances for the path passed
string assemblyPath = string.Concat(RegisteredAddIn.AddinFolderPath,
BioTestAutomationDll);
IList <ISequenceAligner> registeredAligners =
RegisteredAddIn.GetInstancesFromAssembly <ISequenceAligner>(assemblyPath);
RegisterAlignGeneralTestCases(registeredAligners, finalValue);
DeleteAddinsFolder();
}
/// <summary>
/// Static constructor
/// </summary>
static Alphabets()
{
//get the registered alphabets
IList <IAlphabet> registeredAlphabets = RegisteredAddIn.GetAlphabets(true);
if (null != registeredAlphabets && registeredAlphabets.Count > 0)
{
foreach (IAlphabet alphabet in registeredAlphabets)
{
if (alphabet != null && all.FirstOrDefault(IA => string.Compare(IA.Name,
alphabet.Name, StringComparison.InvariantCultureIgnoreCase) == 0) == null)
{
all.Add(alphabet);
}
}
registeredAlphabets.Clear();
}
}
public void RegisterAddinsGetInstancesExecutingAssembly()
{
CreateAddinsFolder();
IList <ISequenceAligner> finalValue = new List <ISequenceAligner>();
finalValue.Add(new TestAutomationSequenceAligner());
finalValue.Add(new TestAutomationPairwiseSequenceAligner());
// Gets the registered Instances for the path passed
IList <ISequenceAligner> registeredAligners =
RegisteredAddIn.GetInstancesFromExecutingAssembly <ISequenceAligner>();
if (0 == registeredAligners.Count)
{
Console.WriteLine("Referring from the Bio.dll, hence validation is not required.");
ApplicationLog.WriteLine("Referring from the Bio.dll, hence validation is not required.");
}
DeleteAddinsFolder();
}
/// <summary>
/// Gets all registered alphabets in core folder and addins (optional) folders.
/// </summary>
/// <returns>List of registered alphabets.</returns>
private static IList <IAlphabet> GetAlphabets()
{
IList <IAlphabet> registeredAlphabets = new List <IAlphabet>();
IList <IAlphabet> addInAlphabets = RegisteredAddIn.GetComposedInstancesFromAssemblyPath <IAlphabet>(
"NetBioAlphabetsExport", RegisteredAddIn.AddinFolderPath, RegisteredAddIn.DLLFilter);
if (null != addInAlphabets)
{
foreach (IAlphabet alphabet in addInAlphabets.Where(
alphabet => alphabet != null && !registeredAlphabets.Any(
ra => String.Compare(ra.Name, alphabet.Name, StringComparison.OrdinalIgnoreCase) == 0)))
{
registeredAlphabets.Add(alphabet);
}
}
return(registeredAlphabets);
}
public void GetAlphabetsTest()
{
//IMPORTANT: To pass this test case, it required two folders under...\MBF\MBF.Test\bin
// 1. ...\MBF\MBF.Test\bin\Core
// 2. ...\MBF\MBF.Test\bin\Add-ins
// MBF.Test.dll needs to be copied under Add-ins folder.
IList <IAlphabet> finalValue = new List <IAlphabet>();
finalValue.Add(new NewAlphabet4TestingRegistration());
IList <IAlphabet> registeredAlphabets = RegisteredAddIn.GetAlphabets(true);
if (null != registeredAlphabets && registeredAlphabets.Count > 0)
{
foreach (IAlphabet alphabet in finalValue)
{
string name = null;
registeredAlphabets.FirstOrDefault(IA => string.Compare(name = IA.Name, alphabet.Name, StringComparison.InvariantCultureIgnoreCase) == 0);
Assert.AreSame(alphabet.Name, name);
}
}
}
public void RegisterAddinsRegisterAlphabet()
{
CreateAddinsFolder();
IList <IAlphabet> finalValue = new List <IAlphabet>();
finalValue.Add(new TestAutomationAlphabet());
// Gets the registered Alphabets
IList <IAlphabet> registeredAlphabets = RegisteredAddIn.GetAlphabets(true);
if (null != registeredAlphabets && registeredAlphabets.Count > 0)
{
foreach (IAlphabet alphabet in finalValue)
{
string name = string.Empty;
registeredAlphabets.FirstOrDefault(IA => string.Compare(name = IA.Name,
alphabet.Name, StringComparison.OrdinalIgnoreCase) == 0);
// Validates the Name
Assert.AreEqual(alphabet.Name, name);
Console.WriteLine(
string.Format((IFormatProvider)null, @"Successfully validated the Registered components for Alphabet '{0}'.",
name));
ApplicationLog.WriteLine(
string.Format((IFormatProvider)null, @"Successfully validated the Registered components for Alphabet '{0}'.",
name));
}
}
else
{
Console.WriteLine("No Components to Register.");
ApplicationLog.WriteLine("No Components to Register.");
Assert.Fail();
}
DeleteAddinsFolder();
}
