public void ExtractActualIntellisenseOptions_GivenValidArgs_ShouldExecuteCorrectly() { //---------------Set up test pack------------------- var parser = new Dev2DataLanguageParser(); var parseTO = new ParseTO { Parent = new ParseTO { Payload = "Name" } }; var parseTORecSet = new ParseTO { Parent = new ParseTO { Payload = "rec().Name" }, Payload = "rec().Name" }; var intellisenseParts = new List <IDev2DataLanguageIntellisensePart>(); var privateObject = new PrivateObject(parser); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- try { privateObject.Invoke("TryExtractActualIntellisenseOptions", parseTO, intellisenseParts, true); privateObject.Invoke("TryExtractActualIntellisenseOptions", parseTORecSet, intellisenseParts, false); } catch (Exception e) { //---------------Test Result ----------------------- Assert.Fail(e.Message); } }
public IList <IParseTO> MakeParts(string payload, bool addCompleteParts) { if (string.IsNullOrEmpty(payload)) { return(new List <IParseTO>()); } var prev = '\0'; var region = new StringBuilder(); var openRegion = false; IParseTO currentNode = new ParseTO { Parent = null, HangingOpen = true }; var root = currentNode; int i; payload = payload.Replace("]].[[", "]][["); IList <IParseTO> result = new List <IParseTO>(); for (i = 0; i < payload.Length; i++) { var cur = payload[i]; var shouldAddToRegion = ShouldAddToRegion(payload, cur, prev, i, true, '['); shouldAddToRegion = ShouldAddToRegion(payload, cur, prev, i, shouldAddToRegion, ']'); if (cur == '[' && prev == '[') { currentNode = openRegion ? CurrentNode(currentNode, region, i) : ParseTO(currentNode, i, result, ref root, ref openRegion); cur = '\0'; } if (cur == ']' && prev == ']') { openRegion = ProcessOpenRegion(payload, openRegion, i, ref currentNode, ref region, ref cur); } if (openRegion && shouldAddToRegion && cur != '\0') { region.Append(cur); } prev = cur; } if (openRegion) { currentNode.EndIndex = i - 1; currentNode.Payload = region.ToString(); } if (!result.Contains(root)) { result.Add(root); } if (root.HangingOpen && addCompleteParts) { throw new Dev2DataLanguageParseError(ErrorResource.InvalidCloseRegion, 0, payload.Length, enIntellisenseErrorCode.SyntaxError); } return(result); }
public void ProcessForOnlyOpenRegion_GivenValidationArgsAndHasChildrenAndISRecordSet_ShouldProcessCorrectly() { //---------------Set up test pack------------------- var parser = new Dev2DataLanguageParser(); var privateObject = new PrivateObject(parser); var refParts = new List <IDev2DataLanguageIntellisensePart>(); var children = new List <IDev2DataLanguageIntellisensePart> { new Dev2DataLanguageIntellisensePart("name", "name", new List <IDev2DataLanguageIntellisensePart>()) }; refParts.Add(new Dev2DataLanguageIntellisensePart("Rec().Name", "rec", children)); var result = new List <IIntellisenseResult>(); var parseTO = new ParseTO { Parent = new ParseTO { Payload = "Name" }, }; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- bool invoke; try { privateObject.Invoke("ProcessForOnlyOpenRegion", parseTO, refParts, result); invoke = true; } catch (Exception) { invoke = false; } //---------------Test Result ----------------------- Assert.IsTrue(invoke, "Cannot invoke new Dev2DataLanguageParser PrivateObject."); }
public void ProcessRecordSetFields_GivenAddCompletePartsFalse_ShouldThrowValidException() { //---------------Set up test pack------------------- //ProcessRecordSetFields(ParseTO payload, bool addCompleteParts, IList<IIntellisenseResult> result, IDev2DataLanguageIntellisensePart t1) var parser = new Dev2DataLanguageParser(); var parseTO = new ParseTO { Parent = new ParseTO { Payload = "Name" }, }; var languageIntellisensePart = new Dev2DataLanguageIntellisensePart("Name", "Desc", new List <IDev2DataLanguageIntellisensePart>()); var results = new List <IIntellisenseResult>(); var privateObject = new PrivateObject(parser); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- try { privateObject.Invoke("ProcessRecordSetFields", parseTO, false, results, languageIntellisensePart); } catch (Exception e) { Assert.Fail(e.Message); } //---------------Test Result ----------------------- }
public void ProcessForOnlyOpenRegion_GivenValidationArgs_ShouldProcessCorrectly() { //---------------Set up test pack------------------- //ProcessForOnlyOpenRegion(ParseTO payload, IEnumerable<IDev2DataLanguageIntellisensePart> refParts, IList<IIntellisenseResult> result) var parser = new Dev2DataLanguageParser(); var privateObject = new PrivateObject(parser); var refParts = new List <IDev2DataLanguageIntellisensePart> { new Dev2DataLanguageIntellisensePart("Rec().Name", "rec", null) }; var result = new List <IIntellisenseResult>(); var parseTO = new ParseTO { Parent = new ParseTO { Payload = "rec().Name" } }; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- bool invoke; try { privateObject.Invoke("ProcessForOnlyOpenRegion", parseTO, refParts, result); invoke = true; } catch (Exception) { invoke = false; } //---------------Test Result ----------------------- Assert.IsTrue(invoke); }
void MatchFieldVariables(IParseTO payload, IList <IDev2DataLanguageIntellisensePart> refParts, bool addCompleteParts, IList <IIntellisenseResult> result, string[] parts, bool isRs, string rawSearch, string search, bool emptyOk) { var tmpTo = new ParseTO { Payload = parts[0], StartIndex = 0, EndIndex = parts[0].Length - 1 }; var isRecName = isRs && rawSearch.Contains(DataListUtil.RecordsetIndexOpeningBracket) && rawSearch.EndsWith(DataListUtil.RecordsetIndexClosingBracket); const string DisplayString = "Recordset"; if ((!isRecName || parts[1] == string.Empty) && payload.Child == null) { if (ValidateName(rawSearch, DisplayString, result, out IList <IIntellisenseResult> intellisenseResults)) { return; } } else { if (ValidateName(search, DisplayString, result, out IList <IIntellisenseResult> intellisenseResults)) { return; } } try { IsValidIndex(tmpTo); } catch (Dev2DataLanguageParseError e) { result.Add(AddErrorToResults(isRs, parts[0], e, !payload.HangingOpen)); } var recordsetPart = refParts.FirstOrDefault(c => c.Name.ToLower() == search && c.Children != null); var display = parts[0]; var partName = parts[0]; var start = display.IndexOf(DataListUtil.RecordsetIndexOpeningBracket, StringComparison.Ordinal); if (start >= 0 && recordsetPart == null) { display = display.Substring(0, start); display += "()"; } if (partName.IndexOf(' ') < 0) { search = ProcessValidPartNameContainingFields(payload, addCompleteParts, result, parts, search, emptyOk, partName, recordsetPart, display); } else { var part = IntellisenseFactory.CreateDataListValidationRecordsetPart(parts[0], "." + parts[1], true); result.Add(IntellisenseFactory.CreateErrorResult(payload.StartIndex, payload.EndIndex, part, " [[" + display + "]] contains a space, this is an invalid character for a variable name", enIntellisenseErrorCode.SyntaxError, !payload.HangingOpen)); } }
static void AddPart(ParseTO part, List <string> allValidRegions) { if (string.IsNullOrEmpty(part.Payload) && part.Child == null) { allValidRegions.Add(string.Concat("[[", part.Payload, "]]")); } if (!string.IsNullOrEmpty(part.Payload)) { allValidRegions.Add(string.Concat("[[", part.Payload, "]]")); } }
public IParseTO CurrentNode(IParseTO currentNode, StringBuilder region, int i) { currentNode.Payload = region.ToString(); region.Clear(); IParseTO child = new ParseTO(); currentNode.Child = child; child.HangingOpen = true; child.Parent = currentNode; child.EndIndex = -1; child.StartIndex = i; currentNode = child; return(currentNode); }
private static IEnumerable <string> AddChildrenPartForFindMissing(ParseTO child) { List <string> results = new List <string>(); if (child != null) { results.Add(DataListUtil.AddBracketsToValueIfNotExist(child.Payload)); if (child.Child != null) { results.AddRange(AddChildrenPart(child.Child).Select(DataListUtil.AddBracketsToValueIfNotExist)); } } return(results); }
public void IsValidIndex_GivenInvalidIndex_ShouldThrowException() { //---------------Set up test pack------------------- //IsValidIndex(ParseTO to) var parser = new Dev2DataLanguageParser(); PrivateObject privateObject = new PrivateObject(parser); // CheckCurrentIndex(ParseTO to, int start, string raw, int end) var parseTO = new ParseTO() { Payload = "rec(-1)", EndIndex = "rec(-1)".Length, StartIndex = 3 }; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- try { //---------------Test Result ----------------------- privateObject.Invoke("IsValidIndex", parseTO); } catch (Exception ex) { Assert.AreEqual("Recordset index -1 is not greater than zero", ex.Message); try { parseTO = new ParseTO() { Payload = "rec(-1", EndIndex = "rec(-1".Length, StartIndex = 3 }; //---------------Test Result ----------------------- privateObject.Invoke("IsValidIndex", parseTO); } catch (Exception ex1) { Assert.AreEqual("Recordset index [ -1 ] is not greater than zero", ex1.Message); try { parseTO = new ParseTO() { Payload = "rec(1", EndIndex = "rec(1".Length, StartIndex = 3 }; //---------------Test Result ----------------------- privateObject.Invoke("IsValidIndex", parseTO); } catch (Exception ex2) { Assert.AreEqual("Recordset [ rec(1 ] does not contain a matching ')'", ex2.Message); } } } }
static IParseTO ParseTO(IParseTO currentNode, int i, IList <IParseTO> result, ref IParseTO root, ref bool openRegion) { if (currentNode == root && !root.HangingOpen) { IParseTO newRoot = new ParseTO { HangingOpen = true, Parent = null, StartIndex = i, EndIndex = -1 }; result.Add(root); root = newRoot; currentNode = root; } openRegion = true; currentNode.StartIndex = i + 1; return(currentNode); }
public void CheckCurrentIndex_GivenInvalid_ShouldThrowValidException() { //---------------Set up test pack------------------- var parser = new Dev2DataLanguageParser(); PrivateObject privateObject = new PrivateObject(parser); // CheckCurrentIndex(ParseTO to, int start, string raw, int end) var parseTO = new ParseTO() { }; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- try { privateObject.Invoke("CheckCurrentIndex", parseTO, 0, "rec(a).name", "a".Length); } catch (Exception ex) { //---------------Test Result ----------------------- Assert.AreEqual("Recordset index (ec(a).nam) contains invalid character(s)", ex.Message); try { privateObject.Invoke("CheckCurrentIndex", parseTO, 3, "rec(-1)", "rec(-1)".Length); } catch (Exception ex1) { Assert.AreEqual("Recordset index -1 is not greater than zero", ex1.Message); try { var invoke = privateObject.Invoke("CheckCurrentIndex", parseTO, 3, "rec(1)", "rec(1)".Length); Assert.IsTrue(bool.Parse(invoke.ToString())); } catch (Exception) { throw; } } } }
public void CheckValidIndex_GivenNwegetiveIndex_ShouldThrowError() { //---------------Set up test pack------------------- var parser = new Dev2DataLanguageParser(); PrivateObject privateObject = new PrivateObject(parser); //CheckValidIndex(ParseTO to, string part, int start, int end) var parseTO = new ParseTO() { }; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- try { privateObject.Invoke("CheckValidIndex", parseTO, "a", 1, 2); } catch (Exception ex) { Assert.AreEqual("Recordset index (a) contains invalid character(s)", ex.Message); try { privateObject.Invoke("CheckValidIndex", parseTO, "-1", 1, 2); } catch (Exception ex1) { Assert.AreEqual("Recordset index [ -1 ] is not greater than zero", ex1.Message); try { //---------------Test Result ----------------------- var valid = privateObject.Invoke("CheckValidIndex", parseTO, "1", 1, 2); Assert.IsTrue(bool.Parse(valid.ToString())); } catch (Exception ex2) { Assert.Fail(ex2.Message); } } } }
public IList <IParseTO> MakeParts(string payload, bool addCompleteParts) { if (string.IsNullOrEmpty(payload)) { return(new List <IParseTO>()); } IList <IParseTO> result = new List <IParseTO>(); var region = new StringBuilder(); var openRegion = false; IParseTO currentNode = new ParseTO { Parent = null, HangingOpen = true }; var root = currentNode; var methodPayload = payload.Replace("]].[[", "]][["); var payloadIndex = RetrievePayloadIndex(payload, result, ref region, ref openRegion, ref currentNode, ref root, methodPayload); if (openRegion) { currentNode.EndIndex = payloadIndex - 1; currentNode.Payload = region.ToString(); } if (!result.Contains(root)) { result.Add(root); } if (root.HangingOpen && addCompleteParts) { throw new Dev2DataLanguageParseError(ErrorResource.InvalidCloseRegion, 0, methodPayload.Length, enIntellisenseErrorCode.SyntaxError); } return(result); }