public void TestTeenager(int input, bool expectedResult) { ArrayFunctions af = new ArrayFunctions(); bool actualResult = af.IsTeenager(input); Assert.Equal(expectedResult, actualResult); }
/// <summary>Processes raw data to populate the resource</summary> /// <param name="raw">Raw byte data</param> /// <param name="containsHeader">Whether or not <i>raw</i> contains the resource Header information</param> /// <exception cref="ArgumentException">Header-defined <see cref="Type"/> is not <see cref="Resource.ResourceType.Film"/></exception> public override void DecodeResource(byte[] raw, bool containsHeader) { //System.Diagnostics.Debug.WriteLine("Decode FILM"); _decodeResource(raw, containsHeader); if (_type != ResourceType.Film) { throw new ArgumentException("Raw header is not for a Film resource"); } _numberOfFrames = BitConverter.ToInt16(_rawData, 2); _blocks = new Block[BitConverter.ToInt16(_rawData, 4) + 1]; int offset = 6; for (int i = 0; i < _blocks.Length; i++) { //System.Diagnostics.Debug.WriteLine("Block " + (i + 1) + " of " + _blocks.Length); Block.BlockType type = (Block.BlockType)BitConverter.ToInt32(_rawData, offset + TypeOffset); string name = ArrayFunctions.ReadStringFromArray(_rawData, offset + NameOffset, 8); int len = BitConverter.ToInt32(_rawData, offset + LengthOffset); //System.Diagnostics.Debug.WriteLine(type + name + ", " + len); short[] block = new short[(len - 0x12) / 2]; //System.Diagnostics.Debug.WriteLine("block len: " + block.Length); //System.Diagnostics.Debug.WriteLine("copying raw..."); ArrayFunctions.TrimArray(_rawData, offset + 0x12, block); //for (int i = 0; i < block.Length; i++) block[i] = BitConverter.ToInt16(_rawData, offset + HeaderLength + 2 + i * 2); //System.Diagnostics.Debug.WriteLine("copied, creating block..."); _blocks[i] = new Block(type, name, block); offset += len; } }
private void btnTest_Click(object sender, EventArgs e) { double[] a = null; if (!string.IsNullOrWhiteSpace(tbA.Text)) { a = MatlabCompat.CreateArray(tbA.Text); } double[] b = null; if (!string.IsNullOrWhiteSpace(TbB.Text)) { b = MatlabCompat.CreateArray(TbB.Text); } if (b.Length < a.Length && b.Length == 1) { double holder = b[0]; b = new double[a.Length]; for (int index = 0; index < b.Length; index++) { b[index] = holder; } } if (!(a == null || b == null)) { double[] m = null; double[] v = null; GplBetastat.betastat(a, b, out m, out v); tbM.Text = ArrayFunctions.JoinDoublesToDelimitedString(m); tbV.Text = ArrayFunctions.JoinDoublesToDelimitedString(v); } }
/// <summary>Initializes a new Trigger from raw data</summary> /// <remarks>If <paramref name="raw"/>.Length is 6 or greater, reads six bytes. If the length is 4 or 5, reads only four bytes</remarks> /// <param name="raw">Raw data, minimum Length of 4</param> /// <param name="startIndex">Offset within <paramref name="raw"/> to begin reading</param> /// <exception cref="ArgumentException">Invalid <paramref name="raw"/> Length</exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="startIndex"/> results in reading outside the bounds of <paramref name="raw"/></exception> public Trigger(byte[] raw, int startIndex) { if (raw.Length < 4) { throw new ArgumentException("Minimum length of raw is 4", "raw"); } _items = new byte[6]; if (raw.Length >= 6) { if (raw.Length - startIndex < 6 || startIndex < 0) { throw new ArgumentOutOfRangeException("For provided value of raw, startIndex must be 0-" + (raw.Length - 6)); } ArrayFunctions.TrimArray(raw, startIndex, _items); } else { if (raw.Length - startIndex < 4 || startIndex < 0) { throw new ArgumentOutOfRangeException("For provided value of raw, startIndex must be 0-" + (raw.Length - 4)); } for (int i = 0; i < 4; i++) { _items[i] = raw[startIndex + i]; } } }
/// <summary>Initlialize a new Order from raw data</summary> /// <remarks><see cref="SkipTriggers"/> sets to <b>"never (FALSE)"</b><br/> /// If <i>raw</i>.Length is 19 or greater, reads 19 bytes. Otherwise reads 18 bytes.</remarks> /// <param name="raw">Raw byte data, minimum Length of 18</param> /// <param name="startIndex">Offset within <i>raw</i> to begin reading</param> /// <exception cref="ArgumentException">Invalid <i>raw</i>.Length value</exception> /// <exception cref="ArgumentOutOfRangeException"><i>startIndex</i> results in reading outside the bounds of <i>raw</i></exception> public Order(byte[] raw, int startIndex) { if (raw.Length < 18) { throw new ArgumentException("Minimum length of raw is 18", "raw"); } _items = new byte[19]; if (raw.Length >= 19) { if (raw.Length - startIndex < 19 || startIndex < 0) { throw new ArgumentOutOfRangeException("For provided value of raw, startIndex must be 0-" + (raw.Length - 19)); } ArrayFunctions.TrimArray(raw, startIndex, _items); } else { if (startIndex != 0) { throw new ArgumentOutOfRangeException("For provided value of raw, startIndex must be 0"); } ArrayFunctions.WriteToArray(raw, _items, 0); } initialize(); }
public void TestContains() { var mixed = new object[] { "hi", 1, TestEnum.First }; Assert.True(ArrayFunctions.Contains(mixed, "hi")); Assert.True(ArrayFunctions.Contains(mixed, 1)); Assert.True(ArrayFunctions.Contains(mixed, TestEnum.First)); Assert.True(ArrayFunctions.Contains(mixed, "First")); Assert.True(ArrayFunctions.Contains(mixed, 100)); TestParser.AssertTemplate("true", "{{ value | array.contains 'First' }}", model: new ObjectModel { Value = mixed }); TestParser.AssertTemplate("true", "{{ value | array.contains 100 }}", model: new ObjectModel { Value = mixed }); TestParser.AssertTemplate("false", "{{ value | array.contains 'Second' }}", model: new ObjectModel { Value = mixed }); TestParser.AssertTemplate("false", "{{ value | array.contains 101 }}", model: new ObjectModel { Value = mixed }); TestParser.AssertTemplate("false", "{{ value | array.contains 'Third' }}", model: new ObjectModel { Value = mixed }); }
/// <summary>Prepares the resource for writing and updates <see cref="Resource.RawData"/></summary> public override void EncodeResource() { System.Diagnostics.Debug.WriteLine("bit width: " + _bitsPerScanLine + ", height: " + _height + "num glyphs: " + _glyphs.Length); byte[] raw = new byte[12 + (_bitsPerScanLine / 8 * _height + 1) * _glyphs.Length]; ArrayFunctions.WriteToArray(_startingChar, raw, 0); ArrayFunctions.WriteToArray((short)_glyphs.Length, raw, 2); ArrayFunctions.WriteToArray(_bitsPerScanLine, raw, 4); ArrayFunctions.WriteToArray(_height, raw, 6); ArrayFunctions.WriteToArray(BaseLine, raw, 8); for (int i = 0; i < _glyphs.Length; i++) { raw[12 + i] = (byte)_glyphs[i].Width; } for (int i = 0, offset = 12 + _glyphs.Length; i < _glyphs.Length; i++) { BitmapData bd1 = GraphicsFunctions.GetBitmapData(_glyphs[i]); byte[] pix1 = new byte[bd1.Stride * bd1.Height]; GraphicsFunctions.CopyImageToBytes(bd1, pix1); // BitmapData.Stride rounds up to 4, so we have to trim off the excess bytes byte[] trimmed = new byte[_height * _bitsPerScanLine / 8]; for (int y = 0; y < _height; y++) { for (int x = 0; x < (_bitsPerScanLine / 8); x++) { trimmed[x + y * (_bitsPerScanLine / 8)] = pix1[x + y * bd1.Stride]; } } System.Diagnostics.Debug.WriteLine("pix1.Length: " + pix1.Length + ", trimmed.Length: " + trimmed.Length + ", offset: " + offset); ArrayFunctions.WriteToArray(trimmed, raw, ref offset); _glyphs[i].UnlockBits(bd1); } _rawData = raw; }
internal Base64Encoding(char[] alphabet, char padding, string encodingName, bool verify) { if (verify) { if (alphabet == null) { throw new ArgumentNullException("alphabet", "alphabet is null"); } if (encodingName == null) { throw new ArgumentNullException("encodingName", "encodingName is null"); } if (alphabet.Length != 64) { throw new ArgumentOutOfRangeException("alphabet", "size of alphabet is not 64"); } if (ArrayFunctions.IsArrayDuplicate(alphabet)) { throw new ArgumentException("alphabet", "alphabet contains duplicated items"); } if (ArrayFunctions.IsArrayContains(alphabet, padding)) { throw new ArgumentException("padding", "padding already existed in alphabet"); } } this.alphabet = (char[])alphabet.Clone(); this.padding = padding; this.encodingName = encodingName; this.InitAlgorithm(this.alphabet, this.padding); }
public void WriteActiveReference(string reference) { var data = ModbusTcpHelper.AsciiStringToByteArray(reference); var dataWord = ModbusTcpHelper.ByteArrayToWordArray(data); ArrayFunctions.InsertArray(_memory, dataWord, ActiveReferenceStartAddress); }
public void TC(int[] input, bool expectedResult) { ArrayFunctions af = new ArrayFunctions(); bool actualResult = af.IsUnique(input); Assert.Equal(expectedResult, actualResult); }
public void TestMethod4() { ArrayFunctions af = new ArrayFunctions(); int[] a = { 1, 2, 1 }; Assert.IsFalse(af.IsUnique(a)); }
/// <summary>Processes raw data to populate the resource</summary> /// <param name="raw">Raw byte data</param> /// <param name="containsHeader">Whether or not <i>raw</i> contains the resource Header information</param> /// <exception cref="ArgumentException">Header-defined <see cref="Type"/> from the LFD is not <see cref="Resource.ResourceType.Panl"/></exception> /// <remarks>If resource was created from a *.PNL file, <i>containsHeader</i> is ignored.</remarks> public override void DecodeResource(byte[] raw, bool containsHeader) { if (!_isPnl) { _decodeResource(raw, containsHeader); if (_type != ResourceType.Panl) { throw new ArgumentException("Raw header is not for a Panl resource"); } _images = new Bitmap[1]; decodeImage(_rawData, 0); } else { _rawData = raw; int count = 0, offset, pos = 0; for (offset = 0; offset < _rawData.Length;) { if (_rawData[offset++] == 0xFF) { count++; } } _images = new Bitmap[count]; offset = 0; for (int i = 0; i < count; i++) { byte[] remainder = new byte[_rawData.Length - offset]; ArrayFunctions.TrimArray(_rawData, offset, remainder); panlInfo pi = decodeImage(remainder, i); pos += pi.RawLength; offset = pos; } } }
internal Base16Encoding(char[] alphabet, string encodingName, bool verify) { if (verify) { if (alphabet == null) { throw new ArgumentNullException("alphabet", "alphabet is null"); } if (encodingName == null) { throw new ArgumentNullException("encodingName", "encodingName is null"); } if (alphabet.Length != 16) { throw new ArgumentOutOfRangeException("alphabet", "size of alphabet is not 16"); } if (ArrayFunctions.IsArrayDuplicate(alphabet)) { throw new ArgumentException("alphabet", "alphabet contains duplicated items"); } } this.alphabet = (char[])alphabet.Clone(); this.encodingName = encodingName; this.InitAlgorithm(this.alphabet); }
/// <summary>Prepares the resource for writing and updates <see cref="Resource.RawData"/></summary> public override void EncodeResource() { int length = 4; for (int b = 0; b < NumberOfBlocks; b++) { length += _blocks[b].Length; } byte[] raw = new byte[length]; int position = 0; ArrayFunctions.WriteToArray(NumberOfFrames, raw, ref position); ArrayFunctions.WriteToArray(NumberOfBlocks, raw, ref position); foreach (Block b in Blocks) { ArrayFunctions.WriteToArray((int)b.Type, raw, ref position); ArrayFunctions.WriteToArray(b.Name, raw, position); position += 8; ArrayFunctions.WriteToArray(b.Length, raw, ref position); ArrayFunctions.WriteToArray(b.TypeNum, raw, ref position); ArrayFunctions.WriteToArray(b.NumberOfChunks, raw, ref position); ArrayFunctions.WriteToArray((short)(b.Length - 22), raw, ref position); foreach (Chunk c in b.Chunks) { ArrayFunctions.WriteToArray(c.Length, raw, ref position); ArrayFunctions.WriteToArray((short)c.Code, raw, ref position); if (c.Vars != null) { ArrayFunctions.WriteToArray(c.Vars, raw, ref position); } } } _rawData = raw; }
public void WriteProductInUnloading(string dataMatrix) { var data = ModbusTcpHelper.AsciiStringToByteArray(dataMatrix); var dataWord = ModbusTcpHelper.ByteArrayToWordArray(data); ArrayFunctions.InsertArray(_memory, dataWord, UnloadingStartAddress); }
public void DoublesArraySize() { var array = new float[4]; var doubled = ArrayFunctions.DoubleArraySizeAndKeepContents <float>(array); Assert.Equal(8, doubled.Length); }
private void CheckAndUpsizeIndexArray(int numToAdd) { while (Data.NumIndicesUsed + numToAdd >= Data.QueueSizeIndex) { Data.Indices = ArrayFunctions.DoubleArraySizeAndKeepContents <int>(Data.Indices); Data.QueueSizeIndex *= 2; } }
public void DoubledArrayReturnsNullIfNullArrayProvided() { int[] array = null; var doubled = ArrayFunctions.DoubleArraySizeAndKeepContents <int>(array); Assert.Null(doubled); }
private void CheckAndUpsizeVertexArray(int numToAdd) { while (Data.NumVerticesUsed + numToAdd >= Data.QueueSizeVertex) { Data.Vertices = ArrayFunctions.DoubleArraySizeAndKeepContents <Vertex2D>(Data.Vertices); Data.QueueSizeVertex *= 2; } }
public void TestDuplicates() { ArrayFunctions af = new ArrayFunctions(); int[] a = { 1, 2, 3, 4, 4 }; Assert.IsFalse(af.IsUnique(a)); }
/// <summary>Initializes the Goals from raw data</summary> /// <param name="raw">Raw byte data, must have Length of 9</param> /// <exception cref="ArgumentException">Invalid <i>raw</i>.Length</exception> public FGGoals(byte[] raw) { if (raw.Length < 9) { throw new ArgumentException("Minimum length of raw is 9", "raw"); } _items = new byte[9]; ArrayFunctions.TrimArray(raw, 0, _items); }
/// <summary>Initlialize a new Goal from raw data</summary> /// <param name="raw">Raw byte data, minimum Length of 16</param> /// <exception cref="ArgumentException">Invalid <i>raw</i>.Length</exception> public Goal(byte[] raw) { if (raw.Length < 16) { throw new ArgumentException("Minimum length of raw is 16", "raw"); } _items = new byte[16]; ArrayFunctions.TrimArray(raw, 0, _items); }
public void Test1() { ArrayFunctions af = new ArrayFunctions(); int[] a = { 2, 3, 4 }; Assert.True(af.IsUnique(a)); Assert.True(af.IsUnique(new int[0])); }
public void TestMethod1() { ArrayFunctions af = new ArrayFunctions(); int[] a = { 1, 2 }; Assert.IsTrue(af.IsUnique(a)); int[] b = { }; Assert.IsTrue(af.IsUnique(b)); }
/// <summary>Initializes a new Trigger from raw data</summary> /// <param name="raw">Raw data, minimum Length of 4</param> /// <exception cref="ArgumentException">Invalid <i>raw</i>.Length value<br/><b>-or-</b><br/>Invalid member values</exception> public Trigger(byte[] raw) { if (raw.Length < 4) { throw new ArgumentException("Minimum length of raw is 4", "raw"); } _items = new byte[4]; ArrayFunctions.TrimArray(raw, 0, _items); _checkValues(this); }
/// <summary>Gets the ResourceType specified by <i>type</i></summary> /// <param name="type">32-bit definition of the Type</param> /// <returns>Known resource type, otherwise <see cref="ResourceType.Undefined"/></returns> public static ResourceType ParseResourceType(int type) { try { return((ResourceType)type); } catch { string typeText = ArrayFunctions.ReadStringFromArray(BitConverter.GetBytes(type), 0, 4); System.Diagnostics.Debug.WriteLine("ResourceType Parse failure: " + typeText + "(0x" + type.ToString("X") + ")"); return(ResourceType.Undefined); } }
/// <summary>Initializes the order from raw data.</summary> /// <param name="raw">Raw byte data, minimum Length of 18.</param> /// <exception cref="ArgumentException">Invalid <paramref name="raw"/> Length value<br/><b>-or-</b><br/>Invalid member values.</exception> public Order(byte[] raw) { if (raw.Length < 18) { throw new ArgumentException("Minimum length of raw is 18", "raw"); } _items = new byte[18]; ArrayFunctions.TrimArray(raw, 0, _items); checkValues(this); }
private void tbContourLevels_TextChanged(object sender, EventArgs e) { if (!_mIgnoreXyzChangeEvent) { var contourLevels = ArrayFunctions.ExtractFloatArrayFromDelimitedString(tbContourLevels.Text, ','); QraStateContainer.Instance.Parameters["FlameWrapper.contour_levels"] = new NdConvertibleValue(StockConverters.UnitlessConverter, UnitlessUnit.Unitless, contourLevels, 0.0); } }
/// <summary>Prepares the resource for writing and updates <see cref="Resource.RawData"/></summary> public override void EncodeResource() { byte[] image = EncodeImage(_image, _left, _top); byte[] raw = new byte[image.Length + 8]; ArrayFunctions.WriteToArray(_left, raw, 0); ArrayFunctions.WriteToArray(_top, raw, 2); ArrayFunctions.WriteToArray(_right, raw, 4); ArrayFunctions.WriteToArray(_bottom, raw, 6); ArrayFunctions.WriteToArray(image, raw, 8); _rawData = raw; }
/// <summary>Prepares the resource for writing and updates <see cref="Resource.RawData"/></summary> public override void EncodeResource() { byte[] raw = new byte[_headers.Length * HeaderLength]; for (int i = 0; i < _headers.Length; i++) { ArrayFunctions.WriteToArray((int)_headers[i].Type, raw, i * HeaderLength + TypeOffset); ArrayFunctions.WriteToArray(_headers[i].Name, raw, i * HeaderLength + NameOffset); ArrayFunctions.WriteToArray(_headers[i].Length, raw, i * HeaderLength + LengthOffset); } _rawData = raw; }
//Calcuation Controller Action public void CalculateAction(List<CategoryViewModel> jCategory) { foreach (var group in jCategory) { foreach (var item in group.Functions) { if (item.Function == "Input") { item.Output = InputFunctions.Output(item.Type, item.Output); OutputList.Add(new OutputList { ID = Convert.ToString(item.ID), Field = item.Name, Value = item.Output, Group = group.Name }); } else { //Logic check at Column Level string colLogic = null; bool colLogicParse = true; if(group.Logic != null) { foreach (var bit in group.Logic) { var grouplastLogic = group.Logic.Last(); string grouplastLogicOperator = grouplastLogic.Operator; Logic Logic = new Logic(); colLogic = Logic.Output(jCategory, bit, group.ID, 0); Expression ex = new Expression(colLogic); try { colLogicParse = Convert.ToBoolean(ex.Evaluate()); } catch (Exception exception) { logger.Error(exception); throw new HttpException(exception.ToString()); } if (grouplastLogicOperator == "AND" && colLogicParse == false) { break; } else if (grouplastLogicOperator == "OR" && colLogicParse == true) { colLogicParse = true; break; } } } if (item.Parameter.Count > 0) { string logic = null; bool logicparse = true; string MathString = null; bool PowOpen = false; //Logic check at column level if (colLogicParse == true) { foreach (var bit in item.Logic) { var lastLogic = item.Logic.Last(); string lastLogicOperator = lastLogic.Operator; Logic Logic = new Logic(); logic = Logic.Output(jCategory, bit, group.ID, item.ID); Expression ex = new Expression(logic); try { logicparse = Convert.ToBoolean(ex.Evaluate()); } catch (Exception exception) { logger.Error(exception); throw new HttpException(exception.ToString()); } if (lastLogicOperator == "AND" && logicparse == false) { break; } else if (lastLogicOperator == "OR" && logicparse == true) { logicparse = true; break; } } } else { logicparse = false; } //Run code if logic if met at column and row level if (logicparse == true) { int paramCount = 1; foreach (var param in item.Parameter) { string jparameters = Newtonsoft.Json.JsonConvert.SerializeObject(param); logger.Debug("Column Name(" + group.ID + ") - " + group.Name + " || Row Name(" + item.ID +") - " + item.Name); if (item.Function == "Maths") { Maths Maths = new Maths(); Maths parameters = (Maths)javaScriptSerializer.Deserialize(jparameters, typeof(Maths)); MathString = Maths.Output(jparameters,jCategory,group.ID,item.ID,MathString,PowOpen); PowOpen = Maths.PowOpen(jparameters, PowOpen); if (paramCount == item.Parameter.Count) { Expression e = new Expression(MathString); var Calculation = e.Evaluate(); bool DeciParse; decimal CalculationDeci; string Rounding; DeciParse = decimal.TryParse(Convert.ToString(Calculation), out CalculationDeci); Rounding = Convert.ToString(parameters.Rounding); if (Rounding == null || Rounding == "") { Rounding = "2"; } if (DeciParse == true) { decimal Output = CalculationDeci; MathematicalFunctions MathematicalFunctions = new MathematicalFunctions(); try { Output = MathematicalFunctions.Rounding(Convert.ToString(parameters.RoundingType), Rounding, Output); } catch (Exception ex) { logger.Error(ex); throw new HttpException(ex.ToString()); } item.Output = Convert.ToString(Output); } else { item.Output = "0"; } } paramCount = paramCount + 1; } else if (item.Function == "ErrorsWarnings") { ErrorsWarnings Errors = new ErrorsWarnings(); ErrorsWarnings parameters = (ErrorsWarnings)javaScriptSerializer.Deserialize(jparameters, typeof(ErrorsWarnings)); item.Name = parameters.Type; item.Output = parameters.String1; } else if (item.Function == "Comments") { Comments Errors = new Comments(); Comments parameters = (Comments)javaScriptSerializer.Deserialize(jparameters, typeof(Comments)); item.Output = parameters.String1; } else if (item.Function == "Period") { DateFunctions DateFunctions = new DateFunctions(); Period Periods = new Period(); try { item.Output = Periods.Output(jparameters, jCategory, group.ID, item.ID); } catch (Exception ex) { logger.Error(ex); throw new HttpException(ex.ToString()); } } else if (item.Function == "Factors") { Factors Factors = new Factors(); Factors parameters = (Factors)javaScriptSerializer.Deserialize(jparameters, typeof(Factors)); try { item.Output = Factors.Output(jparameters, jCategory, group.ID, item.ID); } catch (Exception ex) { logger.Error(ex); throw new HttpException(ex.ToString()); } item.Type = parameters.OutputType; } else if (item.Function == "DateAdjustment") { Dates Dates = new Dates(); try { item.Output = Dates.Output(jparameters, jCategory, group.ID, item.ID); } catch (Exception ex) { logger.Error(ex); throw new HttpException(ex.ToString()); } } else if (item.Function == "DatePart") { DatePart DateParts = new DatePart(); try { item.Output = DateParts.Output(jparameters, jCategory, group.ID, item.ID); } catch (Exception ex) { logger.Error(ex); throw new HttpException(ex.ToString()); } } else if (item.Function == "MathsFunctions") { MathsFunctions MathsFunctions = new MathsFunctions(); try { item.Output = MathsFunctions.Output(jparameters, jCategory, group.ID, item.ID); } catch (Exception ex) { logger.Error(ex); throw new HttpException(ex.ToString()); } } else if (item.Function == "ArrayFunctions") { ArrayFunctions ArrayFunctions = new ArrayFunctions(); ArrayFunctions parameters = (ArrayFunctions)javaScriptSerializer.Deserialize(jparameters, typeof(ArrayFunctions)); try { item.Output = ArrayFunctions.Output(jparameters, jCategory, group.ID, item.ID); } catch (Exception ex) { logger.Error(ex); throw new HttpException(ex.ToString()); } if(parameters.Function == "Count") { item.Type = "Decimal"; } else { item.Type = parameters.LookupType; } } else if (item.Function == "StringFunctions") { StringFunctions StringFunctions = new StringFunctions(); StringFunctions parameters = (StringFunctions)javaScriptSerializer.Deserialize(jparameters, typeof(StringFunctions)); try { item.Output = StringFunctions.Output(jparameters, jCategory, group.ID, item.ID); } catch (Exception ex) { logger.Error(ex); throw new HttpException(ex.ToString()); } if(parameters.Type == "Len") { item.Type = "Decimal"; } else { item.Type = "String"; } } } //Expected results on the builder this sets the required ones if (item.ExpectedResult == null || item.ExpectedResult == "") { item.Pass = "******"; } else if (item.ExpectedResult == item.Output) { item.Pass = "******"; } else { item.Pass = "******"; } OutputList.Add(new OutputList { ID = Convert.ToString(item.ID), Field = item.Name, Value = item.Output, Group = group.Name }); } else { //Ignores the row if logic is not met dynamic LogicReplace = Config.VariableReplace(jCategory, item.Name, group.ID, item.ID); if(Convert.ToString(LogicReplace) == Convert.ToString(item.Name)) { item.Output = null; } else { item.Output = Convert.ToString(LogicReplace); } item.Pass = "******"; OutputList.Add(new OutputList { ID = Convert.ToString(item.ID), Field = item.Name, Value = item.Output, Group = group.Name }); } } } } } }