public void CompositeActivityProcessor_BadArgs()
{
Assert.Throws <ArgumentNullException>(() => new CompositeProcessor <Activity>(null));
Assert.Throws <ArgumentException>(() => new CompositeProcessor <Activity>(Array.Empty <BaseProcessor <Activity> >()));
using var p1 = new TestActivityProcessor(null, null);
using var processor = new CompositeProcessor <Activity>(new[] { p1 });
Assert.Throws <ArgumentNullException>(() => processor.AddProcessor(null));
}
public void CompositeActivityProcessor_ShutsDownAll()
{
using var p1 = new TestActivityProcessor(null, null);
using var p2 = new TestActivityProcessor(null, null);
using var processor = new CompositeProcessor <Activity>(new[] { p1, p2 });
processor.Shutdown();
Assert.True(p1.ShutdownCalled);
Assert.True(p2.ShutdownCalled);
}
private void AddGeneralProcessor(CompositeProcessor <PeakList <Peak> > result)
{
result.Add(new PeakListMassRangeProcessor <Peak>(PrecursorMassRange.From, PrecursorMassRange.To, new int[] { 2, 3 }));
result.Add(new PeakListMinIonIntensityProcessor <Peak>(MinimumIonIntensity));
result.Add(new PeakListMinIonCountProcessor <Peak>(MinimumIonCount));
result.Add(new PeakListMinTotalIonIntensityProcessor <Peak>(MinimumTotalIonIntensity));
}
public void CompositeActivityProcessor_ForceFlush(int timeout)
{
using var p1 = new TestActivityProcessor(null, null);
using var p2 = new TestActivityProcessor(null, null);
using var processor = new CompositeProcessor <Activity>(new[] { p1, p2 });
processor.ForceFlush(timeout);
Assert.True(p1.ForceFlushCalled);
Assert.True(p2.ForceFlushCalled);
}
public void CompositeActivityProcessor_ProcessorThrows()
{
using var p1 = new TestActivityProcessor(
activity => { throw new Exception("Start exception"); },
activity => { throw new Exception("End exception"); });
var activity = new Activity("test");
using var processor = new CompositeProcessor <Activity>(new[] { p1 });
Assert.Throws <Exception>(() => { processor.OnStart(activity); });
Assert.Throws <Exception>(() => { processor.OnEnd(activity); });
}
public CompositeProcessor <PeakList <Peak> > GetProcessor(string fileName, IProgressCallback callBack)
{
CompositeProcessor <PeakList <Peak> > result = new CompositeProcessor <PeakList <Peak> >();
if (!this.OutputMzXmlFormat)
{
AddGeneralProcessor(result);
}
if (RemoveIons)
{
if (RemoveIsobaricIons)
{
result.Add(GetIsobaricProcessor());
}
if (RemoveSpecialIons)
{
var ranges = ParseRemoveMassRange();
foreach (var range in ranges)
{
result.Add(new PeakListRemoveMassRangeProcessor <Peak>(range.From, range.To));
}
}
}
if (Deisotopic)
{
result.Add(new PeakListDeisotopicByChargeProcessor <Peak>(ProductIonPPM));
}
if (PrecursorOptions.RemovePrecursor)
{
result.Add(new PeakListRemovePrecursorProcessor <Peak>(this.PrecursorOptions));
}
if (ChargeDeconvolution)
{
result.Add(new PeakListDeconvolutionByChargeProcessor <Peak>(ProductIonPPM));
if (Deisotopic)
{
result.Add(new PeakListDeisotopicByChargeProcessor <Peak>(ProductIonPPM));
}
}
if (KeepTopX)
{
result.Add(new PeakListTopXProcessor <Peak>(TopX));
}
return(result);
}
public Raw2MgfProcessor GetRaw2MgfProcessor()
{
PeakListMassRangeProcessor <Peak> p1 = new PeakListMassRangeProcessor <Peak>(MinimumMass, MaximumMass, new int[] { 2, 3 });
PeakListMinIonIntensityProcessor <Peak> p2 = new PeakListMinIonIntensityProcessor <Peak>(MinimumIonIntensity);
PeakListMinIonCountProcessor <Peak> p3 = new PeakListMinIonCountProcessor <Peak>(MinIonCount);
PeakListMinTotalIonIntensityProcessor <Peak> p4 = new PeakListMinTotalIonIntensityProcessor <Peak>(MinimumTotalIonCount);
CompositeProcessor <PeakList <Peak> > p = new CompositeProcessor <PeakList <Peak> >();
p.Add(p1);
p.Add(p2);
p.Add(p3);
p.Add(p4);
return(new Raw2MgfProcessor(null, GetMascotGenericFormatWriter(), GetRetentionTime(), PrecursorTolerance, PeakTolerance, p, new DirectoryInfo(TargetDirectory), GroupByScanMode));
}
public void CompositeActivityProcessor_CallsAllProcessorSequentially()
{
var result = string.Empty;
using var p1 = new TestActivityProcessor(
activity => { result += "1"; },
activity => { result += "3"; });
using var p2 = new TestActivityProcessor(
activity => { result += "2"; },
activity => { result += "4"; });
var activity = new Activity("test");
using (var processor = new CompositeProcessor <Activity>(new[] { p1, p2 }))
{
processor.OnStart(activity);
processor.OnEnd(activity);
}
Assert.Equal("1234", result);
}
public SimpleProteinGroupBuilder(string[] perferReferenceRegexString)
{
processor = new CompositeProcessor <IIdentifiedProteinGroup>();
processor.Add(new ProteinNameProcessor(perferReferenceRegexString));
processor.Add(new ProteinLengthProcessor(false));
}
public void TestComposite()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
Address addr1 = new Address("XI krajiske divizije", "Belgrade", "Serbia", "11000");
Address addr2 = new Address("Pere Velimirovica", "Belgrade", "Serbia", "11000");
Address addr3 = new Address("Rige od Fere", "Belgrade", "Serbia", "11000");
cache.Insert("addr1", addr1);
cache.Insert("addr2", addr2);
Assert.IsTrue(cache.Count == 2);
LikeFilter likeXI = new LikeFilter(new ReflectionExtractor("Street"), "XI%", '\\', true);
ExtractorProcessor extractStreet = new ExtractorProcessor(new ReflectionExtractor("Street"));
IEntryProcessor putAddr3 = new ConditionalPut(AlwaysFilter.Instance, addr3);
IEntryProcessor removeLikeXI = new ConditionalRemove(likeXI, false);
IEntryProcessor[] processors = new IEntryProcessor[] { extractStreet, removeLikeXI, putAddr3 };
CompositeProcessor processor = new CompositeProcessor(processors);
Object objResult = cache.Invoke("addr1", processor);
Assert.IsTrue(cache.Count == 2);
object[] objResultArr = objResult as object[];
Assert.IsNotNull(objResultArr);
Assert.AreEqual(addr1.Street, objResultArr[0]);
Address res = cache["addr1"] as Address;
Assert.IsNotNull(res);
Assert.AreEqual(addr3.City, res.City);
Assert.AreEqual(addr3.State, res.State);
Assert.AreEqual(addr3.Street, res.Street);
Assert.AreEqual(addr3.ZIP, res.ZIP);
res = cache["addr2"] as Address;
Assert.IsNotNull(res);
Assert.AreEqual(addr2.City, res.City);
Assert.AreEqual(addr2.State, res.State);
Assert.AreEqual(addr2.Street, res.Street);
Assert.AreEqual(addr2.ZIP, res.ZIP);
IDictionary dictResult = cache.InvokeAll(new ArrayList(new object[] { "addr1", "addr2" }), processor);
Assert.IsTrue(cache.Count == 2);
Address address = cache["addr1"] as Address;
Assert.IsNotNull(address);
Assert.AreEqual(addr3.Street, address.Street);
address = cache["addr2"] as Address;
Assert.IsNotNull(address);
Assert.AreEqual(addr3.Street, address.Street);
object[] objectArr = dictResult["addr1"] as object[];
Assert.IsNotNull(objectArr);
Assert.AreEqual(objectArr[0], addr3.Street);
objectArr = dictResult["addr2"] as object[];
Assert.IsNotNull(objectArr);
Assert.AreEqual(objectArr[0], addr2.Street);
CacheFactory.Shutdown();
}
