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);
}
