public void GetIntellisenseResultsWhereNothingPassedExpectListOfDrives()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 0,
InputText = "",
IsInCalculateMode = false,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
var intellisenseProvider = CreateIntellisenseProvider();
//------------Execute Test---------------------------
var intellisenseProviderResults = intellisenseProvider.GetIntellisenseResults(context);
//------------Assert Results-------------------------
Assert.AreEqual(8, intellisenseProviderResults.Count);
}
public void CalculateIntellisenseProvider_GetIntellisenseResults_DesiredResultsetIsDefaultExpressionIsIncomplete_AnError()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 3,
InputText = "sum",
IsInCalculateMode = true,
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var calculateIntellisenseProvider = GetCalculateProvider(true);
var results = calculateIntellisenseProvider.GetIntellisenseResults(context);
Assert.AreEqual(1, results.Count);
Assert.AreEqual("sum", results[0].Name);
}
public void GetIntellisenseResultsWhereDrivePassedExpectFoldersAndFilesOnDrive()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 2,
InputText = "C:",
IsInCalculateMode = false,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
var intellisenseProvider = CreateIntellisenseProvider();
//------------Execute Test---------------------------
var intellisenseProviderResults = intellisenseProvider.GetIntellisenseResults(context);
//------------Assert Results-------------------------
Assert.AreEqual(31, intellisenseProviderResults.Count);
}
public void GetIntellisenseResultsWhereNetworkPathHasFileExpectFileInformation()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 44,
InputText = @"\\RSAKLFSVRTFSBLD\DevelopmentDropOff\LoadTest",
IsInCalculateMode = false,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
//------------Setup for test--------------------------
var intellisenseProvider = CreateIntellisenseProvider();
//------------Execute Test---------------------------
var intellisenseProviderResults = intellisenseProvider.GetIntellisenseResults(context);
//------------Assert Results-------------------------
Assert.AreEqual(1, intellisenseProviderResults.Count);
}
public void GetIntellisenseResultsWhereNoNetworkExpectFolderNetworkShareInformation()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 2,
InputText = @"\\",
IsInCalculateMode = false,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
//------------Setup for test--------------------------
var intellisenseProvider = CreateIntellisenseProvider();
//------------Execute Test---------------------------
var intellisenseProviderResults = intellisenseProvider.GetIntellisenseResults(context);
//------------Assert Results-------------------------
Assert.AreEqual(40, intellisenseProviderResults.Count);
}
public void GetIntellisenseResultsWhereDriveAndFolderWithPartOfFileNamePassedExpectFileName()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 13,
InputText = @"C:\Users\skt",
IsInCalculateMode = false,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
//------------Setup for test--------------------------
var intellisenseProvider = CreateIntellisenseProvider();
//------------Execute Test---------------------------
var intellisenseProviderResults = intellisenseProvider.GetIntellisenseResults(context);
//------------Assert Results-------------------------
Assert.AreEqual(1, intellisenseProviderResults.Count);
}
public void GetIntellisenseResultsWhereNetworkPathHasFilesExpectFolderWithFilesNetworkShareInformation()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 36,
InputText = @"\\TFSBLD.premier.local\DevelopmentDropOff",
IsInCalculateMode = false,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
//------------Setup for test--------------------------
var intellisenseProvider = CreateIntellisenseProvider();
//------------Execute Test---------------------------
var intellisenseProviderResults = intellisenseProvider.GetIntellisenseResults(context);
//------------Assert Results-------------------------
Assert.AreEqual(16, intellisenseProviderResults.Count);
}
public void CalculateIntellisenseProvider_GetIntellisenseResults_DesiredResultsetIsDefaultExpressionIsIncomplete_AnError()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 3,
InputText = "sum",
IsInCalculateMode = true,
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
CalculateIntellisenseProvider calculateIntellisenseProvider = GetCalculateProvider(true);
IList <IntellisenseProviderResult> results = calculateIntellisenseProvider.GetIntellisenseResults(context);
Assert.AreEqual(1, results.Count);
Assert.AreEqual("Syntax Error", results[0].Name);
Assert.AreEqual("An error occurred while parsing { sum } It appears to be malformed", results[0].Description);
}
public void CalculateIntellisenseProvider_GetIntellisenseResults_DesiredResultsetIsClosestMatchAndInputTextIsFound_ResultPlusAnError()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 3,
InputText = "sum",
IsInCalculateMode = true,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
var calculateIntellisenseProvider = GetCalculateProvider(true);
var results = calculateIntellisenseProvider.GetIntellisenseResults(context);
Assert.AreEqual(1, results.Count);
Assert.AreEqual("sum", results[0].Name);
Assert.AreEqual("Sums all the numbers given as arguments and returns the sum.", results[0].Description);
}
public void CalculateIntellisenseProvider_GetIntellisenseResults_DesiredResultsetIsClosestMatchAndInputTextIsNotFound_AnError()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 2,
InputText = "cantbefound",
IsInCalculateMode = true,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
CalculateIntellisenseProvider calculateIntellisenseProvider = GetCalculateProvider(true);
IList <IntellisenseProviderResult> results = calculateIntellisenseProvider.GetIntellisenseResults(context);
Assert.AreEqual(1, results.Count);
Assert.AreEqual("Syntax Error", results[0].Name);
Assert.AreEqual("An error occurred while parsing { cantbefound } It appears to be malformed", results[0].Description);
}
public IList <IIntellisenseResult> GetIntellisenseResultsImpl(IntellisenseProviderContext context)
{
var searchText = context.FindTextToSearch();
var results = new List <IIntellisenseResult>();
if (context.DesiredResultSet == IntellisenseDesiredResultSet.EntireSet)
{
results.AddRange(IntellisenseResults);
}
else
{
if (!InLiteralRegion(context.InputText, context.CaretPosition))
{
var filteredResults = IntellisenseResults.Where(i => i.Option.DisplayValue.ToLower(System.Globalization.CultureInfo.CurrentCulture).StartsWith(searchText.ToLower(System.Globalization.CultureInfo.CurrentCulture)));
results.AddRange(filteredResults);
}
}
return(results);
}
public void CalculateIntellisenseProvider_GetIntellisenseResults_InputBeginsCaretPositonedAfterTwoCharacters_ResultsFilteredBasedOnCharacters()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 2,
InputText = "se",
IsInCalculateMode = true,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
var calculateIntellisenseProvider = GetCalculateProvider(false);
var results = calculateIntellisenseProvider.GetIntellisenseResults(context);
Assert.AreEqual(4, results.Count);
Assert.AreEqual("search", results[0].Name);
Assert.AreEqual("searchb", results[1].Name);
Assert.AreEqual("second", results[2].Name);
Assert.AreEqual("seriessum", results[3].Name);
}
static string PerformResultInsertionForRecordsets(string input, IntellisenseProviderContext context, Region region, string replace)
{
string updatedInputText;
var caretPosition = context.CaretPosition;
var inputText = context.InputText ?? string.Empty;
var name = region.Name ?? string.Empty;
var startIndex = region.StartIndex;
var indexOfStringToReplace = name.IndexOf(replace, StringComparison.Ordinal);
var recordsetIndex = DataListUtil.ExtractIndexRegionFromRecordset(name) ?? string.Empty;
if (indexOfStringToReplace + replace.Length == caretPosition)
{
if (DataListUtil.IsValueRecordsetWithFields(replace) && !DataListUtil.IsValueRecordset(replace))
{
var substitude = inputText.Replace(inputText, input);
if (DataListUtil.IsValueRecordset(input))
{
updatedInputText = DataListUtil.IsStarIndex(name) ? substitude : substitude.Insert(inputText.IndexOf(recordsetIndex, StringComparison.Ordinal), recordsetIndex);
context.CaretPosition = caretPosition + (updatedInputText.Length - inputText.Length);
return(updatedInputText);
}
if (input.Equals(substitude))
{
updatedInputText = inputText
.Remove(indexOfStringToReplace, replace.Length)
.Insert(indexOfStringToReplace, ")." + input);
context.CaretPosition = caretPosition + (updatedInputText.Length - inputText.Length);
return(updatedInputText);
}
}
}
updatedInputText = inputText.Remove(startIndex, name.Length)
.Insert(startIndex, input);
context.CaretPosition = caretPosition + (updatedInputText.Length - inputText.Length);
return(updatedInputText);
}
public void FileSystemIntellisenseProvider_GetIntellisenseResults_EntireSet_ExpectCorrectOutput()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 39,
InputText = @"\\RSAKLFSVRTFSBLD\DevelopmentDropOff\Runt",
IsInCalculateMode = false,
DesiredResultSet = IntellisenseDesiredResultSet.EntireSet
};
//------------Setup for test--------------------------
var intellisenseProvider = CreateIntellisenseProvider();
//------------Execute Test---------------------------
var intellisenseProviderResults = intellisenseProvider.GetIntellisenseResults(context);
//------------Assert Results-------------------------
Assert.AreEqual(8, intellisenseProviderResults.Count);
}
public void FileSystemIntellisenseProvider_ExecuteInsertion(int caretPosition, string inputText, string inserted, string expected)
{
//------------Setup for test--------------------------
var fileSystemIntellisenseProvider = new FileSystemIntellisenseProvider();
//------------Execute Test---------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = caretPosition,
InputText = inputText,
IsInCalculateMode = false,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
var resp = fileSystemIntellisenseProvider.PerformResultInsertion(inserted, context);
//------------Assert Results-------------------------
Assert.AreEqual(resp, expected);
}
public void DateTimeIntellisenseProvider_PerformInsertion_ExpectException()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 1,
InputText = "d",
IsInCalculateMode = false,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
var dateTimeIntellisenseProvider = new DateTimeIntellisenseProvider();
//------------Execute Test---------------------------
dateTimeIntellisenseProvider.PerformResultInsertion("blah", context);
//------------Assert Results-------------------------
}
public void CalculateIntellisenseProvider_GetIntellisenseResults_DesiredResultSetIsEntiresetAndInputIsInvalidText_EntiresetPlusAndError()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 2,
InputText = "XXXXX",
IsInCalculateMode = true,
DesiredResultSet = IntellisenseDesiredResultSet.EntireSet
};
CalculateIntellisenseProvider calculateIntellisenseProvider = GetCalculateProvider(true);
IList <IntellisenseProviderResult> results = calculateIntellisenseProvider.GetIntellisenseResults(context);
Assert.AreEqual(176, results.Count);
IntellisenseProviderResult intellisenseProviderResult = results.Last();
Assert.AreEqual("Syntax Error", intellisenseProviderResult.Name);
Assert.AreEqual("An error occurred while parsing { XXXXX } It appears to be malformed", intellisenseProviderResult.Description);
}
public void CalculateIntellisenseProvider_GetIntellisenseResults_DesiredResultsetIsClosestMatchAndInputTextIsFound_ResultPlusAnError()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 3,
InputText = "sum",
IsInCalculateMode = true,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
CalculateIntellisenseProvider calculateIntellisenseProvider = GetCalculateProvider(true);
IList <IntellisenseProviderResult> results = calculateIntellisenseProvider.GetIntellisenseResults(context);
Assert.AreEqual(2, results.Count);
Assert.AreEqual("sum", results[0].Name);
Assert.AreEqual("Sums all the numbers given as arguments and returns the sum.", results[0].Description);
Assert.AreEqual("Syntax Error", results[1].Name);
Assert.AreEqual("An error occurred while parsing { sum } It appears to be malformed", results[1].Description);
}
public void DateTimeIntellisenseProvider_GetIntellisenseResultsImpl_EntireResultSet()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 1,
InputText = "d",
IsInCalculateMode = false,
DesiredResultSet = IntellisenseDesiredResultSet.EntireSet
};
var dateTimeIntellisenseProvider = new DateTimeIntellisenseProvider();
var count = dateTimeIntellisenseProvider.IntellisenseResults.Count;
//------------Execute Test---------------------------
var results = dateTimeIntellisenseProvider.GetIntellisenseResultsImpl(context);
//------------Assert Results-------------------------
Assert.AreEqual(count, results.Count);
}
public IList <IntellisenseProviderResult> GetIntellisenseResults(IntellisenseProviderContext context)
{
if (context == null)
{
return(new List <IntellisenseProviderResult>());
}
var caretPosition = context.CaretPosition;
var inputText = context.InputText ?? string.Empty;
var parseEventLog = _syntaxTreeBuilderHelper.EventLog;
var intellisenseDesiredResultSet = context.DesiredResultSet;
if (context.IsInCalculateMode)
{
if (intellisenseDesiredResultSet == IntellisenseDesiredResultSet.EntireSet && (caretPosition == 0 || string.IsNullOrEmpty(inputText)))
{
parseEventLog?.Clear();
if (_syntaxTreeBuilderHelper.EventLog != null && _syntaxTreeBuilderHelper.HasEventLogs)
{
List <IntellisenseProviderResult> tResults = new List <IntellisenseProviderResult>();
tResults.AddRange(IntellisenseResult);
return(EvaluateEventLogs(tResults, inputText));
}
return(IntellisenseResult);
}
Token[] tokens;
var searchText = context.FindTextToSearch();
_syntaxTreeBuilderHelper.Build(searchText, true, out tokens);
string sub = string.IsNullOrEmpty(searchText) ? inputText : searchText;
List <IntellisenseProviderResult> subResults = IntellisenseResult.Where(t => t.Name.StartsWith(sub)).ToList();
return(subResults);
}
return(EmptyResults);
}
void AppendText(ref string appendText, bool isInsert, ref int index, IIntellisenseProvider currentProvider)
{
var currentText = Text;
var foundLength = 0;
if (isInsert)
{
if (currentProvider.HandlesResultInsertion)
{
var context = new IntellisenseProviderContext {
CaretPosition = index, InputText = currentText
};
try
{
Text = currentProvider.PerformResultInsertion(appendText, context);
}
catch
{
//This try catch is to prevent the intellisense box from ever being crashed from a provider.
//This catch is intentionally blanks since if a provider throws an exception the intellisense
//box should simply ignore that provider.
}
TextBox?.Select(context.CaretPosition, 0);
IsDropDownOpen = false;
appendText = null;
}
else
{
PerformResultInsertion(appendText, ref index, ref currentText, ref foundLength);
}
}
if (appendText != null)
{
AppendText(currentText, index, appendText);
}
}
public string PerformResultInsertion(string input, IntellisenseProviderContext context)
{
VerifyArgument.IsNotNull("Context", context);
var inputText = context.InputText ?? string.Empty;
var caretPosition = context.CaretPosition;
if (caretPosition < 0 || caretPosition > inputText.Length)
{
return(string.Empty);
}
var regions = inputText.Split(' '); // we can safely do this because the default provider handles the language features
var sum = 0;
var items = 0;
var regionsText = regions.Select(a => new { a, a.Length }).TakeWhile(a =>
{
sum = sum + a.Length;
items++;
return(sum <= caretPosition || items == 1);
}).Select(a => a.a).ToList();
regionsText[regionsText.Count - 1] = input; // set caret region to replacement text
var prefix = regionsText.Aggregate("", (a, b) => a + " " + b).TrimStart(' '); // fold back together
context.CaretPositionOnPopup = prefix.Length;
context.CaretPosition = prefix.Length;
var i = 0;
var inner = regions.SkipWhile(a =>
{
i = i + 1;
return(i < regionsText.Count + 1);
}).Aggregate("", (a, b) => a + " " + b);
return((prefix + inner).TrimEnd());
}
public void ThenTheResultHasErrors(string p0)
{
var calc = ScenarioContext.Current.Get <bool>("IsInCalculate");
var context = new IntellisenseProviderContext
{
CaretPosition = ScenarioContext.Current.Get <int>("cursorIndex"),
CaretPositionOnPopup = ScenarioContext.Current.Get <int>("cursorIndex"),
InputText = ScenarioContext.Current.Get <string>("inputText"),
DesiredResultSet = calc ? IntellisenseDesiredResultSet.ClosestMatch : IntellisenseDesiredResultSet.Default,
FilterType = ScenarioContext.Current.Get <enIntellisensePartType>("filterType"),
IsInCalculateMode = calc
};
ScenarioContext.Current.Add("context", context);
IIntellisenseProvider provider = ScenarioContext.Current.Get <IIntellisenseProvider>("provider");
var getResults = provider.GetIntellisenseResults(context);
var actualist = getResults.Where(i => i.IsError);
Assert.AreEqual(!actualist.Any(), bool.Parse(p0));
}
public IList <IntellisenseProviderResult> GetIntellisenseResults(IntellisenseProviderContext context)
{
var results = new List <IntellisenseProviderResult>();
if (context.DesiredResultSet == IntellisenseDesiredResultSet.EntireSet)
{
FileSystemQuery.QueryList("");
FileSystemQuery.QueryCollection.ForEach(s => _intellisenseResults.Add(new IntellisenseProviderResult(this, s, string.Empty, string.Empty, false)));
results.AddRange(_intellisenseResults);
}
else
{
if (!InLiteralRegion(context.InputText, context.CaretPosition))
{
_intellisenseResults.Clear();
string searchText = context.InputText; //context.InputText.Substring(context.CaretPositionOnPopup, (context.CaretPosition - context.CaretPositionOnPopup));
FileSystemQuery.QueryList(searchText);
FileSystemQuery.QueryCollection.ForEach(s => _intellisenseResults.Add(new IntellisenseProviderResult(this, s, string.Empty, string.Empty, false)));
results.AddRange(_intellisenseResults);
}
}
return(results);
}
public override IActionableErrorInfo Check()
{
var value = GetValue();
bool isValid = true;
string calculationExpression;
if (DataListUtil.IsCalcEvaluation(value, out calculationExpression))
{
IntellisenseProviderContext context = new IntellisenseProviderContext
{
CaretPosition = value.Length,
InputText = value,
IsInCalculateMode = true,
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
var results = _intellisenseProvider.GetIntellisenseResults(context);
if (results.Any(e => e.IsError))
{
isValid = false;
ErrorText = results.First(e => e.IsError).Description;
}
}
if (!isValid)
{
return(new ActionableErrorInfo(DoError)
{
Message = string.Format("{0} {1}", LabelText, ErrorText)
});
}
return(null);
}
public IList <IntellisenseProviderResult> GetIntellisenseResults(IntellisenseProviderContext context) => new List <IntellisenseProviderResult>();
public string PerformResultInsertion(string input, IntellisenseProviderContext context) => string.Empty;
public IList <IntellisenseProviderResult> GetIntellisenseResults(IntellisenseProviderContext context)
{
return(new List <IntellisenseProviderResult>());
}
public string PerformResultInsertion(string input, IntellisenseProviderContext context)
{
throw new NotSupportedException();
}
public static string FindTextToSearch(this IntellisenseProviderContext context)
{
VerifyArgument.IsNotNull("context", context);
string searchString = string.Empty;
int foundMinimum = -1;
int foundLength = 0;
string inputText = context.InputText ?? string.Empty;
int caretPosition = context.CaretPosition;
int maxStringLength = Math.Min(caretPosition, inputText.Length);
bool closedBraceFound = false;
for (int i = maxStringLength - 1; i >= 0; i--)
{
char currentChar = inputText[i];
if (currentChar == ')')
{
closedBraceFound = true;
}
if (Char.IsWhiteSpace(currentChar))
{
i = -1;
}
else
{
if (currentChar == '[' && i > 0 && inputText[i - 1] == '[')
{
foundMinimum = i - 1;
foundLength = maxStringLength - foundMinimum;
i = -1;
}
else if (currentChar == ']')
{
i = -1;
}
else if (Char.IsSymbol(currentChar))
{
i = -1;
}
else if (currentChar == '(' && !closedBraceFound)
{
i = -1;
}
else if (currentChar == '(')
{
if (inputText.Length > i && i < inputText.Length && inputText[i + 1] == ')')
{
i = -1;
}
}
else
{
if (!Char.IsLetterOrDigit(currentChar))
{
if (currentChar == '(' ||
currentChar == ')' ||
currentChar == '[' ||
currentChar == ']' ||
currentChar == '_' ||
currentChar == '.')
{
foundMinimum = i;
foundLength = maxStringLength - i;
}
else
{
i = -1;
}
}
else
{
foundMinimum = i;
foundLength = maxStringLength - i;
}
}
}
}
if (foundMinimum != -1)
{
searchString = inputText.Substring(foundMinimum, foundLength);
}
var charArray = searchString.ToCharArray().ToList();
if (!charArray.ToList().Any(c => Char.IsLetter(c) || c == '[' || c == '.' || c == ')'))
{
return(string.Empty);
}
var indexOfOpenBrace = inputText.IndexOf('(');
if (indexOfOpenBrace > 0 && inputText[indexOfOpenBrace - 1] == '[')
{
return(string.Empty);
}
if (charArray.Count == 1)
{
if (!Char.IsLetterOrDigit(charArray[0]))
{
return(string.Empty);
}
if (charArray[0] == '(')
{
return(string.Empty);
}
}
return(searchString);
}
