private void ReadMeasure(UUTReport unitTestReport, string[] columns)
{
NumericLimitStep numericLimitStep = unitTestReport.GetRootSequenceCall().AddNumericLimitStep(columns[3]);
double measure = double.Parse(columns[4], cultureInfo);
if (columns[8].Contains("/"))
{
string[] lim = columns[8].Split(new char[] { '/' });
double lowLim = double.Parse(lim[1], cultureInfo);
double hiLim = double.Parse(lim[0], cultureInfo);
numericLimitStep.AddTest(measure, CompOperatorType.GELE, lowLim, hiLim, columns[5]);
}
else
{
numericLimitStep.AddTest(measure, columns[5]);
}
numericLimitStep.Status = StepStatus(columns[6]);
}
private void ReadGraphData(UUTReport unitTestReport, string[] columns, string measureName, string xUnit, string yUnit, ref double[] xValues)
{
List <double> values = new List <double>();
for (int i = 3; i < columns.Length; i++)
{
if (!string.IsNullOrEmpty(columns[i]))
{
values.Add(double.Parse(columns[i], cultureInfo));
}
}
if (xValues == null)
{
xValues = values.ToArray();
return;
}
NumericLimitStep numericLimitStep = unitTestReport.GetRootSequenceCall().AddNumericLimitStep(measureName);
Chart chart = numericLimitStep.AddChart(ChartType.LineLogY, measureName, "X", xUnit, "Y", yUnit);
chart.AddSeries(measureName, xValues, values.ToArray());
xValues = null;
}
private void ReadDataFile(UUTReport uut, string fileName)
{
string[] seqName = Path.GetFileNameWithoutExtension(fileName).Split(new char[] { '-' });
if (currentSequence == null || currentSequence.Name != seqName[0])
{
currentSequence = uut.GetRootSequenceCall().AddSequenceCall(seqName[0]);
}
using (TextReader reader = new StreamReader(fileName))
{
string line = reader.ReadLine();
string[] headers = line.Split(new char[] { '\t' });
line = reader.ReadLine();
List <double> x = new List <double>();
List <double> y = new List <double>();
List <double> min = new List <double>();
List <double> max = new List <double>();
while (line != null)
{
if (headers[0] == "name") //Single measure
{
NumericLimitStep numericLimitStep = currentSequence.AddNumericLimitStep(line.Split(new char[] { '\t' }).First());
double[] values = ReadDoubles(line);
//Format: name value max min
if (double.IsNaN(values[2])) //No limits
{
numericLimitStep.AddTest(values[1], "");
}
else if (!double.IsNaN(values[3]) && !double.IsNaN(values[2]))
{
numericLimitStep.AddTest(values[1], CompOperatorType.GELE, values[3], values[2], "");
}
else
{
throw new NotImplementedException("Assumed no limits or max / min");
}
}
else if (headers[0] == "frq")
{
double[] values = ReadDoubles(line);
if (values.Length == 1)
{
} //No Y value, skip
else
{
x.Add(values[0]);
y.Add(values[1]);
if (values.Length == 4)
{
max.Add(values[2]);
min.Add(values[3]);
}
else if (values.Length == 3)
{
max.Add(values[2]);
}
else
{
throw new NotImplementedException("Assumed x,y,min,max or x,y,max");
}
}
}
else
{
throw new NotImplementedException("Assumed either name or frq in header");
}
line = reader.ReadLine();
}
if (headers[0] == "frq")
{
NumericLimitStep numericLimitStep = currentSequence.AddNumericLimitStep(headers[1]);
numericLimitStep.AddMultipleTest(y.Average(), "Hz", "avg");
if (min.Count > 0)
{
numericLimitStep.AddMultipleTest(y.Min(), "Hz", "min");
}
if (max.Count > 0)
{
numericLimitStep.AddMultipleTest(y.Max(), "Hz", "max");
}
int errorCount = 0;
for (int i = 0; i < y.Count; i++)
{
if (i < max.Count && double.IsNaN(max[i])) //Skip if limit is Nan or not exist
{
continue;
}
if (i < min.Count && double.IsNaN(min[i]))
{
continue;
}
if (y[i] > max[i])
{
errorCount++;
}
if (min.Count > 0 && y[i] < min[i])
{
errorCount++;
}
}
numericLimitStep.AddMultipleTest(errorCount, CompOperatorType.LT, 1, "#", "OutOfBounds");
Chart chart = numericLimitStep.AddChart(ChartType.LineLogX, headers[1], "Frequency", "Hz", "res", "");
chart.AddSeries("values", x.ToArray(), y.ToArray());
if (min.Count > 0)
{
chart.AddSeries("min", x.ToArray(), min.ToArray());
}
if (max.Count > 0)
{
chart.AddSeries("max", x.ToArray(), max.ToArray());
}
}
}
}
protected override bool ProcessMatchedLine(TextConverterBase.SearchFields.SearchMatch match, ref TextConverterBase.ReportReadState readState)
{
if (match == null)
{
//EOF
if (!String.IsNullOrEmpty(currentUUT.SerialNumber) && !String.IsNullOrEmpty(currentUUT.PartNumber))
{
if (uutStatusFromTester != currentUUT.Status)
{
//Log difference
currentUUT.AddMiscUUTInfo("UUTStatusDiff", String.Format("FPT={0}, WATS={1}", uutStatusFromTester, currentUUT.Status));
currentUUT.Status = uutStatusFromTester; //Use status from tester
}
//Adjust operation type to SW Debug if file name contains _debug
if (apiRef.ConversionSource.SourceFile.Name.ToLower().Contains("_debug"))
{
currentUUT.OperationType = apiRef.GetOperationType("10");
}
SubmitUUT(); //If EndTest was missing
readFirstHeader = false; //Prepare for next report
return(true);
}
else
{
ParseError("Missing SN/PN", apiRef.ConversionSource.SourceFile.FullName);
return(false);
}
}
switch (match.matchField.fieldName)
{
case "TestHeading":
if (readFirstHeader)
{
currentReportState = ReportReadState.InTest;
}
else
{
readFirstHeader = true;
}
break;
case "Serialnumber":
currentUUT.SerialNumber = (string)match.GetSubField("Revision") + (string)match.GetSubField("SerialNumber");
currentUUT.PartNumber = (string)match.GetSubField("PartNumber");
currentUUT.PartRevisionNumber = (string)match.GetSubField("Revision");
break;
case "PassFail":
uutStatusFromTester = (UUTStatusType)match.results[0];
break;
case "Step":
//Prepare the test step
NumericLimitStep step = currentUUT.GetRootSequenceCall().AddNumericLimitStep(
string.Format("{0}_{1}_{2}", match.GetSubField("Parts"), match.GetSubField("Value"), match.GetSubField("Function"))); //Use Parts_Value_Function as step name
step.ReportText = String.Format("#{0} H-pin:{1} L-pin:{2}", match.GetSubField("Step_number"), match.GetSubField("H-pin"), match.GetSubField("L-pin"));
if (match.ExistSubField("Net_Name_Hpin"))
{
step.ReportText += String.Format(" {0} {1}", match.GetSubField("Net_Name_Hpin"), match.GetSubField("Net_Name_Lpin"));
}
if (((string)match.GetSubField("Judgement")).Trim().ToLower() == "jump" ||
((string)match.GetSubField("Function")).Trim().ToLower() == "jp")
{
step.Status = StepStatusType.Skipped;
return(true);
}
double measure, refValue, highTolerance, lowTolerance, highLimit, lowLimit;
string refUnit = (string)match.GetSubField("RefUnit");
refUnit = refUnit.ToUpper();
//Calculate limits
highTolerance = double.Parse(((string)match.GetSubField("Tolerance+")).TrimEnd(new char[] { '%', ' ' })) / 100;
lowTolerance = double.Parse(((string)match.GetSubField("Tolerance-")).TrimEnd(new char[] { '%', ' ' })) / 100;
if (!IsNumeric((string)match.GetSubField("RefValue")))
{
break;
}
refValue = (double)ConvertStringToAny((string)match.GetSubField("RefValue"), typeof(double), null, currentCulture);
highLimit = refValue + (refValue * highTolerance);
lowLimit = refValue + (refValue * lowTolerance);
string measUnit = "";
if (IsNumeric((string)match.GetSubField("TestValue2"))) //Skip test value 1 if failed and measured again
{
measure = (double)ConvertStringToAny((string)match.GetSubField("TestValue2"), typeof(double), null, currentCulture);
measUnit = (string)match.GetSubField("Unit2");
}
else if (IsNumeric((string)match.GetSubField("TestValue1")))
{
measure = (double)ConvertStringToAny((string)match.GetSubField("TestValue1"), typeof(double), null, currentCulture);
measUnit = (string)match.GetSubField("Unit1");
}
else
{
measure = double.NaN;
}
measUnit = measUnit.ToUpper();
if (measUnit != refUnit) //If reference units differ from measure units, use measure units
{
double factorMeas = measUnit.Length <= 1 ? 1 :
measUnit[0] == 'K' ? 1000 : measUnit[0] == 'M' ? 1000000 : measUnit[0] == 'U' ? 0.000001 : measUnit[0] == 'N' ? 0.000000001 : 1;
double factorRef = refUnit.Length <= 1 ? 1 :
refUnit[0] == 'K' ? 1000 : refUnit[0] == 'M' ? 1000000 : refUnit[0] == 'U' ? 0.000001 : refUnit[0] == 'N' ? 0.000000001 : 1;
double factorAdjustRefWith = factorMeas * factorRef;
lowLimit = lowLimit * factorAdjustRefWith;
highLimit = highLimit * factorAdjustRefWith;
refUnit = measUnit;
}
//Check Function
switch ((string)match.GetSubField("Function"))
{
case "**":
step.AddTest(measure, CompOperatorType.GELE, lowLimit, highLimit, measUnit); break;
case "SH":
step.AddTest(measure, CompOperatorType.LT, 10, measUnit); break;
case "OP":
step.AddTest(measure, CompOperatorType.GT, 100, measUnit); break;
case "D":
step.AddTest(measure, CompOperatorType.LTGE, lowLimit, highLimit, measUnit); break;
case "E":
step.AddTest(measure, CompOperatorType.LE, refValue, measUnit); break;
case "F":
step.AddTest(measure, CompOperatorType.GE, refValue, measUnit); break;
}
break;
}
return(true);
}
