public void TestSolveSum()
{
SumParser sumParser = new SumParser();
Assert.Equal(12, sumParser.SolveSum("8+4"));
Assert.Equal(200, sumParser.SolveSum("182+18"));
Assert.Equal(18, sumParser.SolveSum("8+10"));
Assert.Equal(42, sumParser.SolveSum("12+30"));
Assert.Equal(0, sumParser.SolveSum("0+0"));
}
private static Variable handleNumberVariable(Logic[] cloneLogicOrder, int lineNumber, Variable tempSum, Scope currentScope)
{
Logic[] calcSum = new Logic[3];
calcSum [0] = cloneLogicOrder [0];
calcSum [1] = cloneLogicOrder [1];
calcSum [2] = new NumberValue(tempSum.getNumber().ToString());
Variable tempVar = SumParser.parseIntoSum(calcSum, lineNumber, currentScope);
tempVar.name = (calcSum [0] as Variable).name;
return(tempVar);
}
public static Logic checkForVariableDecleration(Logic[] logicOrder, int lineNumber, Scope currentScope)
{
//We use a shallow copy because we alter logicOrder in case of speciall operators
Logic[] cloneLogicOrder = (Logic[])logicOrder.Clone();
if (couldBeVariableDec(cloneLogicOrder, lineNumber) == false)
{
return(new UnknownLogic(lineNumber));
}
Logic[] afterEqualSign = getAfterEqualSign(cloneLogicOrder, lineNumber, currentScope);
if (afterEqualSign == null || afterEqualSign.Length == 0)
{
return(new UnknownLogic(lineNumber));
}
Variable afterEqualSignSum = SumParser.parseIntoSum(afterEqualSign, lineNumber, currentScope);
//Determine whether to use speciallOperators or not
if (cloneLogicOrder [1].currentType != WordTypes.equalSign)
{
afterEqualSignSum = SpeciallVariableDeclareParser.speciallVariableDeclare(cloneLogicOrder, lineNumber, afterEqualSignSum, currentScope);
}
else
{
afterEqualSignSum.name = (cloneLogicOrder[0] as Variable).name;
}
//Add the newly declared variable
if (afterEqualSignSum.variableType != VariableTypes.unknown)
{
currentScope.scopeVariables.addVariable(afterEqualSignSum, currentScope.scopeParser, lineNumber);
return(afterEqualSignSum);
}
ErrorHandler.ErrorMessage.sendErrorMessage(lineNumber, "Något gick fel i variabeldeklareringen");
return(new UnknownLogic(lineNumber));
}
/// <summary>
/// Builds the sorter.
/// </summary>
/// <returns>a <see cref="Sorter{T}"/></returns>
private Sorter <byte[]> BuildSorter()
{
Logger.Debug("Building sorter");
var sorter = new Sorter <byte[]>();
var formatterParser = new FormatterParser {
Encoding = Encoding
};
sorter.InputFiles = Input.Select(r => r.GetFileInfo()).ToList();
if (Output.Count == 1)
{
var outputFiles = new List <IOutputFile <byte[]> >();
var outputFile = new LegacyOutputFile {
Output = Output[0].GetFileInfo()
};
if (!string.IsNullOrWhiteSpace(Outrec))
{
outputFile.Formatter = formatterParser.GetFormatter(Outrec);
}
outputFiles.Add(outputFile);
sorter.OutputFiles = outputFiles;
}
if (Output.Count > 1)
{
var outfilParser = new OutfilParser {
Encoding = Encoding, SortEncoding = SortEncoding
};
var outputFiles = outfilParser.GetOutputFiles(Outfils);
if (Output.Count != outputFiles.Count)
{
throw new SortException("The number of output files must match the number of outfil configurations.");
}
for (var i = 0; i < Output.Count; i++)
{
outputFiles[i].Output = Output[i].GetFileInfo();
}
sorter.OutputFiles = outputFiles;
}
if (RecordLength > 0 || Separator == null)
{
sorter.RecordAccessorFactory = new BlockAccessorFactory {
RecordLength = RecordLength
};
}
else
{
sorter.RecordAccessorFactory = new SeparatorAccessorFactory {
Separator = Encoding.GetBytes(Separator)
};
}
if (!string.IsNullOrWhiteSpace(SortCard))
{
var comparerParser = new ComparerParser {
Encoding = Encoding, SortEncoding = SortEncoding
};
sorter.Comparer = comparerParser.GetComparer(SortCard);
}
if (!string.IsNullOrWhiteSpace(Include) || !string.IsNullOrWhiteSpace(Omit))
{
var filterParser = new FilterParser {
Encoding = Encoding, SortEncoding = SortEncoding
};
sorter.Filter = filterParser.GetFilter(Include, Omit);
}
if (SkipDuplicates)
{
sorter.Sum = new SkipSum <byte[]>();
}
if (!string.IsNullOrWhiteSpace(Sum))
{
var sumParser = new SumParser {
Encoding = Encoding
};
sorter.Sum = sumParser.GetSum(Sum);
}
if (!string.IsNullOrWhiteSpace(Inrec))
{
sorter.InputFormatter = formatterParser.GetFormatter(Inrec);
}
if (MaxInMemorySize > 0)
{
sorter.MaxInMemorySize = MaxInMemorySize;
}
sorter.HeaderSize = HeaderSize;
return(sorter);
}
/// <summary>
/// Builds the sorter.
/// </summary>
/// <returns>a <see cref="Sorter{T}"/></returns>
private Sorter <byte[]> BuildSorter()
{
Logger.Debug("Building sorter");
var sorter = new Sorter <byte[]>();
if (RecordLength > 0 || Separator == null)
{
sorter.RecordAccessorFactory = new BlockAccessorFactory {
RecordLength = RecordLength
};
}
else
{
sorter.RecordAccessorFactory = new SeparatorAccessorFactory {
Separator = Encoding.GetBytes(Separator)
};
}
if (!string.IsNullOrWhiteSpace(SortCard))
{
var comparerParser = new ComparerParser {
Encoding = Encoding, SortEncoding = SortEncoding
};
sorter.Comparer = comparerParser.GetComparer(SortCard);
}
if (!string.IsNullOrWhiteSpace(Include) || !string.IsNullOrWhiteSpace(Omit))
{
var filterParser = new FilterParser {
Encoding = Encoding, SortEncoding = SortEncoding
};
sorter.Filter = filterParser.GetFilter(Include, Omit);
}
if (SkipDuplicates)
{
sorter.Sum = new SkipSum <byte[]>();
}
if (!string.IsNullOrWhiteSpace(Sum))
{
var sumParser = new SumParser {
Encoding = Encoding
};
sorter.Sum = sumParser.GetSum(Sum);
}
var formatterParser = new FormatterParser {
Encoding = Encoding
};
if (!string.IsNullOrWhiteSpace(Inrec))
{
sorter.InputFormatter = formatterParser.GetFormatter(Inrec);
}
if (!string.IsNullOrWhiteSpace(Outrec))
{
sorter.OutputFormatter = formatterParser.GetFormatter(Outrec);
}
if (MaxInMemorySize > 0)
{
sorter.MaxInMemorySize = MaxInMemorySize;
}
sorter.HeaderSize = HeaderSize;
return(sorter);
}
