protected void Ex02()
{
Filter.Accept(Arg.Any <FixtureDescriptor>()).Returns(true);
var result = Fixture.Run(Filter, Substitute.For <IFixtureStepRunnerFactory>());
Expect("the fixture method should be called", () => TestFixtures.CalledFixtureMethods.Count == 1 && TestFixtures.CalledFixtureMethods.Contains(TargetFixtureType));
Expect("the Dispose method should be called", () => TestFixtures.DisposeCalled);
ExpectedFixtureDescriptor = FixtureDescriptorAssertion.Of(TargetFixtureDescription, TargetMethodDescription, TargetMethodFullName, typeof(ExampleAttribute));
Expect($"the descriptor of the result should be as follows:{ExpectedFixtureDescriptor.ToDescription()}", () => result != null && FixtureDescriptorAssertion.Of(result.FixtureDescriptor) == ExpectedFixtureDescriptor);
ExpectedFixtureResult = FixtureResultAssertion.ForNullException(true, true, true, 0, 0, FixtureStatus.Passed);
Expect($"the result should be as follows:{ExpectedFixtureResult.ToDescription()}", () => result != null && FixtureResultAssertion.Of(result) == ExpectedFixtureResult);
Expect("FixtureRunning event should be raised", () => FixtureRunningResult != null);
ExpectedFixtureRunningDescriptor = FixtureDescriptorAssertion.Of(TargetFixtureDescription, TargetMethodDescription, TargetMethodFullName, typeof(ExampleAttribute));
Expect($"the descriptor of the result on FixtureRunning event should be as follows:{ExpectedFixtureRunningDescriptor.ToDescription()}", () => FixtureRunningResult != null && FixtureDescriptorAssertion.Of(FixtureRunningResult.FixtureDescriptor) == ExpectedFixtureRunningDescriptor);
ExpectedFixtureRunningResult = FixtureResultAssertion.ForNullException(true, false, false, 0, 0, FixtureStatus.Running);
Expect($"the result on FixtureRunning event should be as follows:{ExpectedFixtureRunningResult.ToDescription()}", () => FixtureRunningResult != null && FixtureResultAssertion.Of(FixtureRunningResult) == ExpectedFixtureRunningResult);
Expect("FixtureRun event should be raised", () => FixtureRunResult != null);
Expect("the result on FixtureRun event should be the result that is returned by Run method", () => FixtureRunResult == result);
Expect("FixtureStepRunning event should not be raised", () => FixtureStepRunningResult == null);
Expect("FixtureStepRun event should not be raised", () => FixtureStepRunResult == null);
}
internal virtual SortedSet <ConnectorObject> Search(ObjectClass objectClass, Filter query, SortKey[] sortKeys)
{
ConcurrentDictionary <string, Pair <ConnectorObject, DateTime> > storage = GetStore(objectClass);
SortKey[] s;
if (null == sortKeys || !sortKeys.Any())
{
s = new[] { new SortKey(Name.NAME, true) };
}
else
{
s = sortKeys;
}
// Rebuild the full result set.
var resultSet = new SortedSet <ConnectorObject>(new ResourceComparator(s));
foreach (var co in storage.Values)
{
if (null == query || query.Accept(co.First))
{
resultSet.Add(co.First);
}
}
return(resultSet);
}
void Ex02()
{
Filter.Accept(Arg.Any <FixtureDescriptor>()).Returns(true);
var result = Container.Run(Filter, new FixtureStepRunnerFactory());
Expect(
"all inner fixture methods should be called",
() => TestFixtures.CalledFixtureMethods.Count == 3 &&
TestFixtures.CalledFixtureMethods.Contains(typeof(TestFixtures.SimpleFixture)) &&
TestFixtures.CalledFixtureMethods.Contains(typeof(TestFixtures.SimpleDisposableFixture)) &&
TestFixtures.CalledFixtureMethods.Contains(typeof(TestFixtures.SimpleFixtureSteppable))
);
ExpectedFixtureDescriptor = FixtureDescriptorWithBackgroundAssertion.Of("Simple Fixture", "SimpleFixture", "Carna.TestFixtures+SimpleFixture", typeof(ContextAttribute), "Simple Fixture Background");
Expect($"the descriptor of the result should be as follows:{ExpectedFixtureDescriptor.ToDescription()}", () => result != null && FixtureDescriptorWithBackgroundAssertion.Of(result.FixtureDescriptor) == ExpectedFixtureDescriptor);
ExpectedFixtureResult = FixtureResultAssertion.ForNullException(true, true, true, 0, 3, FixtureStatus.Passed);
Expect($"the result should be as follows:{ExpectedFixtureResult.ToDescription()}", () => result != null && FixtureResultAssertion.Of(result) == ExpectedFixtureResult);
Expect("FixtureRunning event should be raised", () => FixtureRunningResult != null);
ExpectedFixtureRunningDescriptor = FixtureDescriptorAssertion.Of("Simple Fixture", "SimpleFixture", "Carna.TestFixtures+SimpleFixture", typeof(ContextAttribute));
Expect($"the descriptor of the result on FixtureRunning should be as follows:{ExpectedFixtureRunningDescriptor.ToDescription()}", () => FixtureRunningResult != null && FixtureDescriptorAssertion.Of(FixtureRunningResult.FixtureDescriptor) == ExpectedFixtureRunningDescriptor);
ExpectedFixtureRunningResult = FixtureResultAssertion.ForNullException(true, false, false, 0, 0, FixtureStatus.Running);
Expect($"the result on FixtureRunning should be as follows:{ExpectedFixtureRunningResult.ToDescription()}", () => FixtureRunningResult != null && FixtureResultAssertion.Of(FixtureRunningResult) == ExpectedFixtureRunningResult);
Expect("FixtureRun event should be raised", () => FixtureRunResult != null);
Expect("the result on FixtureRun event should be the result that is returned by Run method", () => FixtureRunResult == result);
}
void Ex03()
{
Filter.Accept(Arg.Any <FixtureDescriptor>()).Returns(false);
var result = Container.Run(Filter, new FixtureStepRunnerFactory());
Expect("all inner fixture methods should not be called", () => TestFixtures.CalledFixtureMethods.Count == 0);
Expect("the result should be null", () => result == null);
Expect("FixtureRunning event should not be raised", () => FixtureRunningResult == null);
Expect("FixtureRun event should not be raised", () => FixtureRunResult == null);
}
protected void Ex03()
{
Filter.Accept(Arg.Any <FixtureDescriptor>()).Returns(false);
var result = Fixture.Run(Filter, Substitute.For <IFixtureStepRunnerFactory>());
Expect("the fixture method should not be called", () => TestFixtures.CalledFixtureMethods.Count == 0);
Expect("the result should be null", () => result == null);
Expect("FixtureRunning event should not be raised", () => FixtureRunningResult == null);
Expect("FixtureRun event should not be raised", () => FixtureRunResult == null);
Expect("FixtureStepRunning event should not be raised", () => FixtureStepRunningResult == null);
Expect("FixtureStepRun event should not be raised", () => FixtureStepRunResult == null);
}
protected void Ex02()
{
Filter.Accept(Arg.Any <FixtureDescriptor>()).Returns(true);
var result = Fixture.Run(Filter, new TestFixtures.SimpleFixtureStepRunnerFactory());
Expect("the fixture method should be called", () => TestFixtures.CalledFixtureMethods.Count == 1 && TestFixtures.CalledFixtureMethods.Contains(TargetFixtureType));
ExpectedFixtureDescriptor = FixtureDescriptorAssertion.Of(TargetFixtureDescription, TargetMethodDescription, TargetMethodFullName, typeof(ExampleAttribute));
Expect($"the descriptor of the result should be as follows:{ExpectedFixtureDescriptor.ToDescription()}", () => result != null && FixtureDescriptorAssertion.Of(result.FixtureDescriptor) == ExpectedFixtureDescriptor);
ExpectedFixtureResult = FixtureResultAssertion.ForNullException(true, true, true, 1, 0, FixtureStatus.Passed);
Expect($"the result should be as follows:{ExpectedFixtureResult.ToDescription()}", () => result != null && FixtureResultAssertion.Of(result) == ExpectedFixtureResult);
if (result is null)
{
return;
}
var stepResult = result.StepResults.ElementAt(0);
ExpectedFixtureStepResult = FixtureStepResultAssertion.Of("Description", null, FixtureStepStatus.Passed, typeof(ExpectStep));
Expect($"the result of the step should be as follows:{ExpectedFixtureStepResult.ToDescription()}", () => FixtureStepResultAssertion.Of(stepResult) == ExpectedFixtureStepResult);
Expect("FixtureRunning event should be raised", () => FixtureRunningResult != null);
ExpectedFixtureRunningDescriptor = FixtureDescriptorAssertion.Of(TargetFixtureDescription, TargetMethodDescription, TargetMethodFullName, typeof(ExampleAttribute));
Expect($"the descriptor of the result on FixtureRunning event should be as follows:{ExpectedFixtureRunningDescriptor.ToDescription()}", () => FixtureRunningResult != null && FixtureDescriptorAssertion.Of(FixtureRunningResult.FixtureDescriptor) == ExpectedFixtureRunningDescriptor);
ExpectedFixtureRunningResult = FixtureResultAssertion.ForNullException(true, false, false, 0, 0, FixtureStatus.Running);
Expect($"the result on FixtureRunning event should be as follows:{ExpectedFixtureRunningResult.ToDescription()}", () => FixtureRunningResult != null && FixtureResultAssertion.Of(FixtureRunningResult) == ExpectedFixtureRunningResult);
Expect("FixtureRun event should be raised", () => FixtureRunResult != null);
Expect("the result on FixtureRun event should be the result that is returned by Run method", () => FixtureRunResult == result);
Expect("FixtureStepRunning event should be raised", () => FixtureStepRunningResult != null);
ExpectedFixtureStepRunningResult = FixtureStepRunningResultAssertion.Of(stepResult.Step, true, false, false, null, FixtureStepStatus.Running);
Expect("the result of the step on FixtureStepRunning event should be as follows", () => FixtureStepRunningResult != null && FixtureStepRunningResultAssertion.Of(FixtureStepRunningResult) == ExpectedFixtureStepRunningResult);
Expect("FixtureStepRun event should be raised", () => FixtureStepRunResult != null);
Expect("the result on FixtureStepRun event should be the result that is returned by Run method", () => FixtureStepRunResult == stepResult);
}
protected override SAMAlignedItem GetAlignedSequence()
{
var array = new byte[4];
ReadUnCompressedData(array, 0, 4);
int blockLen = Helper.GetInt32(array, 0);
var alignmentBlock = new byte[blockLen];
ReadUnCompressedData(alignmentBlock, 0, blockLen);
if (!Filter.Accept(alignmentBlock))
{
return(null);
}
var result = new SAMAlignedItem();
var loc = new SAMAlignedLocation(result);
int value;
// 0-4 bytes
var refSeqIndex = Helper.GetInt32(alignmentBlock, 0);
loc.Seqname = refSeqIndex == -1 ? "*" : RefSeqNames[refSeqIndex];
// 4-8 bytes
loc.Start = Helper.GetInt32(alignmentBlock, 4) + 1;
// 8 - 12 bytes "bin<<16|mapQual<<8|read_name_len"
var unsignedValue = Helper.GetUInt32(alignmentBlock, 8);
// 10 -12 bytes
//alignedSeq.Bin = (int)(UnsignedValue & 0xFFFF0000) >> 16;
// 9th bytes
loc.MapQ = (int)(unsignedValue & 0x0000FF00) >> 8;
// 8th bytes
var queryNameLen = (int)(unsignedValue & 0x000000FF);
// 12 - 16 bytes
unsignedValue = Helper.GetUInt32(alignmentBlock, 12);
// 14-16 bytes
var flagValue = (int)(unsignedValue & 0xFFFF0000) >> 16;
loc.Flag = (SAMFlags)flagValue;
// 12-14 bytes
var cigarLen = (int)(unsignedValue & 0x0000FFFF);
// 16-20 bytes
var readLen = Helper.GetInt32(alignmentBlock, 16);
// 32-(32+readLen) bytes
result.Qname = Encoding.ASCII.GetString(alignmentBlock, 32, queryNameLen - 1);
var strbuilder = new StringBuilder();
var startIndex = 32 + queryNameLen;
for (var i = startIndex; i < (startIndex + cigarLen * 4); i += 4)
{
// Get the CIGAR operation length stored in first 28 bits.
var cigarValue = Helper.GetUInt32(alignmentBlock, i);
strbuilder.Append(((cigarValue & 0xFFFFFFF0) >> 4).ToString(CultureInfo.InvariantCulture));
// Get the CIGAR operation stored in last 4 bits.
value = (int)cigarValue & 0x0000000F;
// MIDNSHP=>0123456
strbuilder.Append(GetCigarChar(value, result.Qname));
}
var cigar = strbuilder.ToString();
loc.Cigar = string.IsNullOrWhiteSpace(cigar) ? "*" : cigar;
startIndex += cigarLen * 4;
var sequence = new StringBuilder();
var index = startIndex;
for (; index < (startIndex + (readLen + 1) / 2) - 1; index++)
{
// Get first 4 bit value
value = (alignmentBlock[index] & 0xF0) >> 4;
sequence.Append(GetSeqChar(value, result.Qname));
// Get last 4 bit value
value = alignmentBlock[index] & 0x0F;
sequence.Append(GetSeqChar(value, result.Qname));
}
value = (alignmentBlock[index] & 0xF0) >> 4;
sequence.Append(GetSeqChar(value, result.Qname));
if (readLen % 2 == 0)
{
value = alignmentBlock[index] & 0x0F;
sequence.Append(GetSeqChar(value, result.Qname));
}
startIndex = index + 1;
var qualValues = new StringBuilder();
if (alignmentBlock[startIndex] != 0xFF)
{
for (var i = startIndex; i < (startIndex + readLen); i++)
{
qualValues.Append((char)(alignmentBlock[i] + 33));
}
}
else
{
qualValues.Append(SAMParser.AsteriskAsByte);
}
loc.Sequence = sequence.ToString();
loc.Qual = qualValues.ToString();
loc.Strand = loc.Flag.HasFlag(SAMFlags.QueryOnReverseStrand) ? '-' : '+';
if (!loc.Flag.HasFlag(SAMFlags.UnmappedQuery))
{
startIndex += readLen;
if (alignmentBlock.Length > startIndex + 4 && alignmentBlock[startIndex] != 0x0 &&
alignmentBlock[startIndex + 1] != 0x0)
{
var options = new List <string>();
for (int i = 0; i < SAMFormat.OptionStartIndex; i++)
{
options.Add(string.Empty);
}
for (index = startIndex; index < alignmentBlock.Length;)
{
var tag = Encoding.ASCII.GetString(alignmentBlock, index, 2);
index += 2;
var vType = (char)alignmentBlock[index++];
// SAM format supports [AifZH] for value type.
// In BAM, an integer may be stored as a signed 8-bit integer (c), unsigned 8-bit integer (C), signed short (s), unsigned
// short (S), signed 32-bit (i) or unsigned 32-bit integer (I), depending on the signed magnitude of the integer. However,
// in SAM, all types of integers are presented as type ʻiʼ.
//NOTE: Code previously here checked for valid value and threw an exception here, but this exception/validation is checked for in this method below, as while as when the value is set.
var tValue = GetOptionalValue(vType, alignmentBlock, ref index);
// Convert to SAM format, where all integers are represented the same way
if ("cCsSI".IndexOf(vType) >= 0)
{
vType = 'i';
}
options.Add(string.Format("{0}:{1}:{2}", tag, vType, tValue));
}
var optionarrays = options.ToArray();
loc.AlignmentScore = Format.GetAlignmentScore(optionarrays);
loc.NumberOfMismatch = Format.GetNumberOfMismatch(optionarrays);
loc.MismatchPositions = Format.GetMismatchPositions(optionarrays);
}
}
return(result);
}
//protected override void SetSelectedObject(AppObject obj)
//{
// m_selectedObject = obj;
// if (m_frame != null) m_frame.SetSelectedObject(obj);
//}
public override bool SuitableFor(AppObject appobj)
{
var props = appobj.GetAppObjectProperties();
return(Filter.Accept(props));
}
protected override SAMAlignedSequence GetAlignedSequence()
{
byte[] array = new byte[4];
ReadUnCompressedData(array, 0, 4);
int blockLen = Helper.GetInt32(array, 0);
byte[] alignmentBlock = new byte[blockLen];
ReadUnCompressedData(alignmentBlock, 0, blockLen);
if (!Filter.Accept(alignmentBlock))
{
return(null);
}
SAMAlignedSequence alignedSeq = new SAMAlignedSequence();
int value;
UInt32 UnsignedValue;
// 0-4 bytes
int refSeqIndex = Helper.GetInt32(alignmentBlock, 0);
if (refSeqIndex == -1)
{
alignedSeq.SetPreValidatedRName("*");
}
else
{
alignedSeq.SetPreValidatedRName(RefSeqNames[refSeqIndex]);
}
// 4-8 bytes
alignedSeq.Pos = Helper.GetInt32(alignmentBlock, 4) + 1;
// 8 - 12 bytes "bin<<16|mapQual<<8|read_name_len"
UnsignedValue = Helper.GetUInt32(alignmentBlock, 8);
// 10 -12 bytes
//alignedSeq.Bin = (int)(UnsignedValue & 0xFFFF0000) >> 16;
// 9th bytes
alignedSeq.MapQ = (int)(UnsignedValue & 0x0000FF00) >> 8;
// 8th bytes
int queryNameLen = (int)(UnsignedValue & 0x000000FF);
// 12 - 16 bytes
UnsignedValue = Helper.GetUInt32(alignmentBlock, 12);
// 14-16 bytes
int flagValue = (int)(UnsignedValue & 0xFFFF0000) >> 16;
alignedSeq.Flag = (SAMFlags)flagValue;
// 12-14 bytes
int cigarLen = (int)(UnsignedValue & 0x0000FFFF);
// 16-20 bytes
int readLen = Helper.GetInt32(alignmentBlock, 16);
// 20-24 bytes
int mateRefSeqIndex = Helper.GetInt32(alignmentBlock, 20);
if (mateRefSeqIndex != -1)
{
alignedSeq.SetPreValidatedMRNM(RefSeqNames[mateRefSeqIndex]);
}
else
{
alignedSeq.SetPreValidatedMRNM("*");
}
// 24-28 bytes
alignedSeq.MPos = Helper.GetInt32(alignmentBlock, 24) + 1;
// 28-32 bytes
alignedSeq.ISize = Helper.GetInt32(alignmentBlock, 28);
// 32-(32+readLen) bytes
alignedSeq.QName = System.Text.ASCIIEncoding.ASCII.GetString(alignmentBlock, 32, queryNameLen - 1);
StringBuilder strbuilder = new StringBuilder();
int startIndex = 32 + queryNameLen;
for (int i = startIndex; i < (startIndex + cigarLen * 4); i += 4)
{
// Get the CIGAR operation length stored in first 28 bits.
UInt32 cigarValue = Helper.GetUInt32(alignmentBlock, i);
strbuilder.Append(((cigarValue & 0xFFFFFFF0) >> 4).ToString(CultureInfo.InvariantCulture));
// Get the CIGAR operation stored in last 4 bits.
value = (int)cigarValue & 0x0000000F;
// MIDNSHP=>0123456
switch (value)
{
case 0:
strbuilder.Append("M");
break;
case 1:
strbuilder.Append("I");
break;
case 2:
strbuilder.Append("D");
break;
case 3:
strbuilder.Append("N");
break;
case 4:
strbuilder.Append("S");
break;
case 5:
strbuilder.Append("H");
break;
case 6:
strbuilder.Append("P");
break;
case 7:
strbuilder.Append("=");
break;
case 8:
strbuilder.Append("X");
break;
default:
throw new Exception("Invalid CIGAR of query " + alignedSeq.QName);
}
}
string cigar = strbuilder.ToString();
if (string.IsNullOrWhiteSpace(cigar))
{
alignedSeq.SetPreValidatedCIGAR("*");
}
else
{
alignedSeq.SetPreValidatedCIGAR(cigar);
}
startIndex += cigarLen * 4;
var sequence = new byte[readLen];
int sequenceIndex = 0;
int index = startIndex;
for (; index < (startIndex + (readLen + 1) / 2) - 1; index++)
{
// Get first 4 bit value
value = (alignmentBlock[index] & 0xF0) >> 4;
sequence[sequenceIndex++] = GetSeqCharAsByte(value);
// Get last 4 bit value
value = alignmentBlock[index] & 0x0F;
sequence[sequenceIndex++] = GetSeqCharAsByte(value);
}
value = (alignmentBlock[index] & 0xF0) >> 4;
sequence[sequenceIndex++] = GetSeqCharAsByte(value);
if (readLen % 2 == 0)
{
value = alignmentBlock[index] & 0x0F;
sequence[sequenceIndex++] = GetSeqCharAsByte(value);
}
startIndex = index + 1;
byte[] qualValues = new byte[readLen];
if (alignmentBlock[startIndex] != 0xFF)
{
for (int i = startIndex; i < (startIndex + readLen); i++)
{
qualValues[i - startIndex] = (byte)(alignmentBlock[i] + 33);
}
//validate quality scores here
byte badVal;
bool ok = QualitativeSequence.ValidateQualScores(qualValues, SAMParser.QualityFormatType, out badVal);
if (!ok)
{
string message = string.Format("Invalid encoded quality score found: {0}", (char)badVal);
throw new ArgumentOutOfRangeException("encodedQualityScores", message);
}
}
else
{
qualValues = new byte[] { SAMParser.AsteriskAsByte };
}
//Values have already been validated when first parsed at this point so no need to again
SAMParser.ParseQualityNSequence(alignedSeq, Alphabet, sequence, qualValues, false);
startIndex += readLen;
if (alignmentBlock.Length > startIndex + 4 && alignmentBlock[startIndex] != 0x0 && alignmentBlock[startIndex + 1] != 0x0)
{
for (index = startIndex; index < alignmentBlock.Length;)
{
SAMOptionalField optionalField = new SAMOptionalField();
optionalField.Tag = System.Text.ASCIIEncoding.ASCII.GetString(alignmentBlock, index, 2);
index += 2;
char vType = (char)alignmentBlock[index++];
// SAM format supports [AifZH] for value type.
// In BAM, an integer may be stored as a signed 8-bit integer (c), unsigned 8-bit integer (C), signed short (s), unsigned
// short (S), signed 32-bit (i) or unsigned 32-bit integer (I), depending on the signed magnitude of the integer. However,
// in SAM, all types of integers are presented as type ʻiʼ.
//NOTE: Code previously here checked for valid value and threw an exception here, but this exception/validation is checked for in this method below, as while as when the value is set.
optionalField.Value = GetOptionalValue(vType, alignmentBlock, ref index).ToString();
// Convert to SAM format, where all integers are represented the same way
if ("cCsSI".IndexOf(vType) >= 0)
{
vType = 'i';
}
optionalField.VType = vType.ToString();
alignedSeq.OptionalFields.Add(optionalField);
}
}
return(alignedSeq);
}
protected override SAMItemSlim GetAlignedSequence()
{
var array = new byte[4];
ReadUnCompressedData(array, 0, 4);
var blockLen = Helper.GetInt32(array, 0);
var alignmentBlock = new byte[blockLen];
ReadUnCompressedData(alignmentBlock, 0, blockLen);
if (!Filter.Accept(alignmentBlock))
{
return(null);
}
int value;
// 8 - 12 bytes "bin<<16|mapQual<<8|read_name_len"
var unsignedValue = Helper.GetUInt32(alignmentBlock, 8);
// 8th bytes
var queryNameLen = (int)(unsignedValue & 0x000000FF);
// 32-(32+readLen) bytes
var qname = Encoding.ASCII.GetString(alignmentBlock, 32, queryNameLen - 1);
if (IgnoreQuery.Contains(qname))
{
return(null);
}
var result = new SAMItemSlim()
{
Qname = qname
};
// 12 - 16 bytes
unsignedValue = Helper.GetUInt32(alignmentBlock, 12);
// 14-16 bytes
var flagValue = (int)(unsignedValue & 0xFFFF0000) >> 16;
var flag = (SAMFlags)flagValue;
// 12-14 bytes
var cigarLen = (int)(unsignedValue & 0x0000FFFF);
// 16-20 bytes
var readLen = Helper.GetInt32(alignmentBlock, 16);
// 32-(32+readLen) bytes
var startIndex = 32 + queryNameLen + cigarLen * 4;
var sequence = new StringBuilder();
var index = startIndex;
for (; index < (startIndex + (readLen + 1) / 2) - 1; index++)
{
// Get first 4 bit value
value = (alignmentBlock[index] & 0xF0) >> 4;
sequence.Append(GetSeqChar(value, result.Qname));
// Get last 4 bit value
value = alignmentBlock[index] & 0x0F;
sequence.Append(GetSeqChar(value, result.Qname));
}
value = (alignmentBlock[index] & 0xF0) >> 4;
sequence.Append(GetSeqChar(value, result.Qname));
if (readLen % 2 == 0)
{
value = alignmentBlock[index] & 0x0F;
sequence.Append(GetSeqChar(value, result.Qname));
}
startIndex = index + 1;
var qualValues = new StringBuilder();
if (alignmentBlock[startIndex] != 0xFF)
{
for (var i = startIndex; i < (startIndex + readLen); i++)
{
qualValues.Append((char)(alignmentBlock[i] + 33));
}
}
else
{
qualValues.Append(SAMParser.AsteriskAsByte);
}
if (flag.HasFlag(SAMFlags.QueryOnReverseStrand))
{
result.Sequence = SequenceUtils.GetReverseComplementedSequence(sequence.ToString());
result.Qual = qualValues.ToString().Reverse();
}
else
{
result.Sequence = sequence.ToString();
result.Qual = qualValues.ToString();
}
return(result);
}
