static IIntellisenseProvider GetProvider(string providerName)
{
IIntellisenseProvider provider = new DefaultIntellisenseProvider();
switch (providerName.Trim())
{
case "Calculate":
provider = new CalculateIntellisenseProvider();
break;
case "File":
var fileSystemIntellisenseProvider = new FileSystemIntellisenseProvider {
FileSystemQuery = ScenarioContext.Current.Get <IFileSystemQuery>("fileQueryHelper")
};
provider = fileSystemIntellisenseProvider;
ScenarioContext.Current.Add("isFileProvider", true);
break;
case "DateTime":
provider = new DateTimeIntellisenseProvider();
break;
}
return(provider);
}
public static string GetJsonIntellisenseResults(string searchTerm, int caretPosition)
{
var provider = new DefaultIntellisenseProvider();
var context = new IntellisenseProviderContext {
InputText = searchTerm, CaretPosition = caretPosition
};
return("[" + string.Join(",", provider.GetIntellisenseResults(context).Where(c => !c.IsError).Select(r => string.Format("\"{0}\"", r.ToString()))) + "]");
}
public void DefaultIntellisenseProvider_Dispose_IsDisposedIsSetToTrue()
{
var provider = new DefaultIntellisenseProvider();
var isDiposedAferConstruction = provider.IsDisposed;
provider.Dispose();
Assert.IsFalse(isDiposedAferConstruction);
Assert.IsTrue(provider.IsDisposed);
Assert.IsFalse(provider.Optional);
Assert.AreEqual(null, provider.CachedDataList);
}
public void DefaultIntellisenseProvider_Construct_DefaultPropertiesAreSet()
{
var provider = new DefaultIntellisenseProvider();
Assert.IsTrue(provider.HandlesResultInsertion);
Assert.AreEqual(IntellisenseProviderType.Default, provider.IntellisenseProviderType);
Assert.IsFalse(provider.Optional);
Assert.IsFalse(provider.IsDisposed);
Assert.IsFalse(provider.IsUpdated);
Assert.AreEqual(string.Empty, provider.FilterCondition);
}
public void InsertItem(object item, bool force)
{
var isOpen = IsDropDownOpen;
string appendText = null;
var isInsert = false;
var index = CaretIndex;
IIntellisenseProvider currentProvider = new DefaultIntellisenseProvider();
if (isOpen || force)
{
currentProvider = PerformInsertFromDropDown(item, currentProvider, ref appendText, ref isInsert);
}
if (appendText != null)
{
AppendText(ref appendText, isInsert, ref index, currentProvider);
}
UpdateErrorState();
EnsureErrorStatus();
}
public void WhenISelectTheFollowingOption(string option)
{
var context = ScenarioContext.Current.Get <IntellisenseProviderContext>("context");
string result;
if (ScenarioContext.Current.TryGetValue("isFileProvider", out bool isFileProvider))
{
if (DataListUtil.IsEvaluated(option) || string.IsNullOrEmpty(option))
{
result = new DefaultIntellisenseProvider().PerformResultInsertion(option, context);
}
else
{
result = new FileSystemIntellisenseProvider().PerformResultInsertion(option, context);
}
}
else
{
result = new DefaultIntellisenseProvider().PerformResultInsertion(option, context);
}
ScenarioContext.Current.Add("result", result);
}
public void GetIntellisenseResultsWhereCarretPositionLessThanZeroExpectedNoResultsAndException()
{
var context = new IntellisenseProviderContext
{
CaretPosition = -1,
InputText = "Sum([[Scalar]],",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(0, getResults.Count);
}
public void GetIntellisenseResultsWhereCommaEnteredForInfragisticsFunctonExpectedNoResultsAndException()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 15,
InputText = "Sum([[Scalar]],",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(0, getResults.Count);
}
public void GetIntellisenseResultsWithSumAndAfterCommaAndBeforeBraceExpectedAllVarsInResults()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 17,
InputText = "Sum([[Scalar]],[[)",
DesiredResultSet = IntellisenseDesiredResultSet.EntireSet
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(9, getResults.Count);
Assert.AreEqual("[[Scalar]]", getResults[0].ToString());
Assert.AreEqual("[[Country]]", getResults[1].ToString());
Assert.AreEqual("[[State]]", getResults[2].ToString());
Assert.AreEqual("[[City(", getResults[3].ToString());
Assert.AreEqual("[[City().Name]]", getResults[4].ToString());
Assert.AreEqual("[[City(*).Name]]", getResults[5].ToString());
Assert.AreEqual("[[City().GeoLocation]]", getResults[6].ToString());
Assert.AreEqual("[[City(*).GeoLocation]]", getResults[7].ToString());
Assert.AreEqual("Invalid Expression", getResults[8].ToString());
}
public void GetIntellisenseResultsWithCommaSeperatedRegionsAndNumberIndexExpectedNoResults()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 19,
InputText = "[[Scalar]],[[City(5).Name]],[[Country]]",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(0, getResults.Count);
}
public void GetIntellisenseResultsWithOpenRegionAndAfterNumberIndexAndWithPartialFieldExpectedScalarVarInResults()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 12,
InputText = "[[City(6).Na",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(2, getResults.Count);
Assert.AreEqual("[[City().Name]]", getResults[0].ToString());
Assert.AreEqual("Invalid Expression", getResults[1].ToString());
}
public void GetIntellisenseResultsWithInRegionAndNumberIndexAndWithFieldExpectedNoResults()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 9,
InputText = "[[City(33).Name]]",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(0, getResults.Count);
}
// ReSharper disable InconsistentNaming
public void PerformResultInsertion_With_PartialRecset_AndRegion_Expected_ResultInsertsText()
// ReSharper restore InconsistentNaming
{
var context = new IntellisenseProviderContext
{
CaretPosition = 14,
InputText = "[[recset([[ano).field]]",
DesiredResultSet = 0,
State = true
};
var actual = new DefaultIntellisenseProvider().PerformResultInsertion("[[anotherRecset().newfield]]", context);
Assert.AreEqual("[[recset([[anotherRecset().newfield]]).field]]", actual);
}
public void InsertItem(object item, bool force)
{
bool isOpen = IsDropDownOpen;
string appendText = null;
bool isInsert = false;
int index = CaretIndex;
IIntellisenseProvider currentProvider = new DefaultIntellisenseProvider();
if (isOpen || force)
{
currentProvider = PerformInsertFromDropDown(item, currentProvider, ref appendText, ref isInsert);
}
if (appendText != null)
{
string currentText = Text;
int foundLength = 0;
if (isInsert)
{
if (currentProvider.HandlesResultInsertion)
{
var context = new IntellisenseProviderContext {
CaretPosition = index, InputText = currentText
};
try
{
Text = currentProvider.PerformResultInsertion(appendText, context);
}
// ReSharper disable EmptyGeneralCatchClause
catch
// ReSharper restore EmptyGeneralCatchClause
{
//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
{
int foundMinimum = -1;
for (int i = index - 1; i >= 0; i--)
{
if (appendText.StartsWith(currentText.Substring(i, index - i), StringComparison.OrdinalIgnoreCase))
{
foundMinimum = i;
foundLength = index - i;
}
else if (foundMinimum != -1 || appendText.IndexOf(currentText[i].ToString(CultureInfo.InvariantCulture), StringComparison.OrdinalIgnoreCase) == -1)
{
i = -1;
}
}
if (foundMinimum != -1)
{
index = foundMinimum;
Text = currentText = currentText.Remove(foundMinimum, foundLength);
}
}
}
if (appendText != null)
{
AppendText(currentText, index, appendText);
}
}
UpdateErrorState();
EnsureErrorStatus();
}
public void GetIntellisenseResultsWithInRecSetIndexAndWithFieldAndWithClosingSquareBraceExpectedNoResults()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 13,
InputText = "[[City([[sca]).Name]]",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual("Invalid expression: Opening and closing brackets dont match.", getResults[0].Description);
}
public void GetIntellisenseResultsWithOpenRegionAndInRecSetIndexAndWithFieldExpectedAllResults()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 9,
InputText = "[[City([[).Name]]",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(9, getResults.Count);
Assert.AreEqual("[[Scalar]]", getResults[0].ToString());
Assert.AreEqual("[[Country]]", getResults[1].ToString());
Assert.AreEqual("[[State]]", getResults[2].ToString());
Assert.AreEqual("[[City(", getResults[3].ToString());
Assert.AreEqual("[[City().Name]]", getResults[4].ToString());
Assert.AreEqual("[[City(*).Name]]", getResults[5].ToString());
Assert.AreEqual("[[City().GeoLocation]]", getResults[6].ToString());
Assert.AreEqual("[[City(*).GeoLocation]]", getResults[7].ToString());
Assert.AreEqual("Invalid Expression", getResults[8].ToString());
}
// ReSharper disable InconsistentNaming
public void PerformResultInsertion_With_PartialScalar_AndRegion_AtDeepWithinExtaIndex_Expected_ResultInsertsText()
// ReSharper restore InconsistentNaming
{
var context = new IntellisenseProviderContext
{
CaretPosition = 23,
InputText = "[[recset([[recset([[sca).field]]).field]]",
DesiredResultSet = 0,
State = true
};
var performResultInsertion = new DefaultIntellisenseProvider().PerformResultInsertion("[[scalar]]", context);
Assert.AreEqual("[[recset([[recset([[scalar]]).field]]).field]]", performResultInsertion);
}
// ReSharper restore InconsistentNaming
public void GetIntellisenseResultsWithOpenRegionAndOpenRegionStarIndexExpectedNoResults()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 10,
InputText = "[[City([[*",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(1, getResults.Count);
Assert.AreEqual("Invalid Expression", getResults[0].ToString());
}
// ReSharper disable InconsistentNaming
public void PerformResultInsertion_With_PartialScalar_AndRegion_AndWithinPluses_Expected_ResultInsertsText()
// ReSharper restore InconsistentNaming
{
var context = new IntellisenseProviderContext
{
CaretPosition = 32,
InputText = "[[recset().field]]+[[Scalar]]+[[+[[fail]]",
DesiredResultSet = 0
};
var actual = new DefaultIntellisenseProvider().PerformResultInsertion("[[Car]]", context);
Assert.AreEqual("[[recset().field]]+[[Scalar]]+[[Car]]+[[fail]]", actual);
}
public void GetIntellisenseResultsWithNoRegionAndStarNumberAndWithFieldExpectedNoResults()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 6,
InputText = "City(4).Name",
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(0, getResults.Count);
}
public void PerformResultInsertionWithPartialScalarAndFullRegionExpectedResultInsertsText()
{
DefaultIntellisenseProvider defaultIntellisenseProvider = new DefaultIntellisenseProvider();
IntellisenseProviderContext intellisenseProviderContext = new IntellisenseProviderContext
{
CaretPosition = 3,
InputText = "[[S]]",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
const string exprected = "[[Scalar]]";
string actual = defaultIntellisenseProvider.PerformResultInsertion("[[Scalar]]", intellisenseProviderContext);
Assert.AreEqual(exprected, actual);
}
// ReSharper disable InconsistentNaming
public void GetIntellisenseResults_With_OpenRegion_AndInRecSetIndex_AndWithField_Expected_RecSetVarInResults()
// ReSharper restore InconsistentNaming
{
var context = new IntellisenseProviderContext
{
CaretPosition = 12,
InputText = "[[City([[Cit).Name]]",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(6, getResults.Count);
Assert.AreEqual("[[City(", getResults[0].ToString());
Assert.AreEqual("[[City().Name]]", getResults[1].ToString());
Assert.AreEqual("[[City(*).Name]]", getResults[2].ToString());
Assert.AreEqual("[[City().GeoLocation]]", getResults[3].ToString());
Assert.AreEqual("[[City(*).GeoLocation]]", getResults[4].ToString());
Assert.AreEqual("Invalid Expression", getResults[5].ToString());
}
public void PerformResultInsertionWithPartialRecordsetWithClosedBracketsAndFullRegionAnStarIndexExpectedResultInsertsText()
{
DefaultIntellisenseProvider defaultIntellisenseProvider = new DefaultIntellisenseProvider();
IntellisenseProviderContext intellisenseProviderContext = new IntellisenseProviderContext
{
CaretPosition = 10,
InputText = "[[City(*).]]",
DesiredResultSet = IntellisenseDesiredResultSet.ClosestMatch
};
const string exprected = "[[City(*).GeoLocation]]";
string actual = defaultIntellisenseProvider.PerformResultInsertion("[[City(*).GeoLocation]]", intellisenseProviderContext);
Assert.AreEqual(exprected, actual);
}
// ReSharper disable InconsistentNaming
public void GetIntellisenseResults_With_Sum_AndAfterComma_Expected_AllVarsInResults()
// ReSharper restore InconsistentNaming
{
var context = new IntellisenseProviderContext
{
CaretPosition = 17,
InputText = "Sum([[Scalar]],[[",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(9, getResults.Count);
Assert.AreEqual("[[Scalar]]", getResults[0].ToString());
Assert.AreEqual("[[Country]]", getResults[1].ToString());
Assert.AreEqual("[[State]]", getResults[2].ToString());
Assert.AreEqual("[[City(", getResults[3].ToString());
Assert.AreEqual("[[City().Name]]", getResults[4].ToString());
Assert.AreEqual("[[City(*).Name]]", getResults[5].ToString());
Assert.AreEqual("[[City().GeoLocation]]", getResults[6].ToString());
Assert.AreEqual("[[City(*).GeoLocation]]", getResults[7].ToString());
Assert.AreEqual("Invalid Expression", getResults[8].ToString());
}
public void PerformResultInsertionWithPartialRecordsetExpectedResultInsertsText()
{
DefaultIntellisenseProvider defaultIntellisenseProvider = new DefaultIntellisenseProvider();
IntellisenseProviderContext intellisenseProviderContext = new IntellisenseProviderContext
{
CaretPosition = 4,
InputText = "City",
DesiredResultSet = IntellisenseDesiredResultSet.Default,
State = true
};
const string exprected = "[[City()]]";
string actual = defaultIntellisenseProvider.PerformResultInsertion("[[City()]]", intellisenseProviderContext);
Assert.AreEqual(exprected, actual);
}
public void GetIntellisenseResultsWhereBracketOfRecordsetIsClosedAndThereIsAFieldAfterClosedBracketAndStarIndexExpectedNoResultsAndException()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 9,
InputText = "[[City(*).Name]]",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(0, getResults.Count);
}
public void PerformResultInsertionWithRecordsetAfterScalarExpectedCompleteResult()
{
const string currentText = "[[index1]][[rec";
DefaultIntellisenseProvider defaultIntellisenseProvider = new DefaultIntellisenseProvider();
IntellisenseProviderContext intellisenseProviderContext = new IntellisenseProviderContext
{
CaretPosition = currentText.Length,
InputText = currentText,
DesiredResultSet = IntellisenseDesiredResultSet.Default,
State = true
};
const string exprected = "[[index1]][[rec().field]]";
string actual = defaultIntellisenseProvider.PerformResultInsertion("[[rec().field]]", intellisenseProviderContext);
Assert.AreEqual(exprected, actual, "Inserting a recordset after a scalar from intellisense results performs an incorrect insertion");
}
public void GetIntellisenseResultsWithAdjacentRegionsInParamaterOfInfragisticsFunctionExpectedAllVarsInResults()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 27,
InputText = "Sum([[Scalar]],[[Scalar]][[",
DesiredResultSet =
IntellisenseDesiredResultSet.EntireSet
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(9, getResults.Count);
Assert.AreEqual("[[Scalar]]", getResults[0].ToString());
Assert.AreEqual("[[Country]]", getResults[1].ToString());
Assert.AreEqual("[[State]]", getResults[2].ToString());
Assert.AreEqual("[[City(", getResults[3].ToString());
Assert.AreEqual("[[City().Name]]", getResults[4].ToString());
Assert.AreEqual("[[City(*).Name]]", getResults[5].ToString());
Assert.AreEqual("[[City().GeoLocation]]", getResults[6].ToString());
Assert.AreEqual("[[City(*).GeoLocation]]", getResults[7].ToString());
Assert.AreEqual("Invalid Expression", getResults[8].ToString());
}
public void IntellisenseProvider_GetIntellisenseResults_RequestIsNotFromProviderTextBox_ProviderTextBoxIsSetToTheRequestTextBox()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 7,
InputText = "city().",
DesiredResultSet = IntellisenseDesiredResultSet.Default,
FilterType = enIntellisensePartType.RecordsetFields,
TextBox = new IntellisenseTextBox(true)
};
var provider = new DefaultIntellisenseProvider();
var initialTextbox = provider.TextBox;
provider.GetIntellisenseResults(context);
Assert.AreEqual(null, initialTextbox);
Assert.AreEqual(context.TextBox, provider.TextBox);
}
public void GetIntellisenseResultsWhereInputTextContainsSpecialCharactersExpectedNoResultsAndException()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 30,
InputText = "!@#$%^&*()_+[]{}\\|;:'\",./?><",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(0, getResults.Count);
}
public void IntellisenseProvider_GetIntellisenseResults_WhenNoOpeningBracketsAndOpenRecordset_ValidResults()
{
//------------Setup for test--------------------------
// vs Rs().
var context = new IntellisenseProviderContext
{
CaretPosition = 4,
InputText = "city(",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
//------------Execute Test---------------------------
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
//------------Assert Results-------------------------
Assert.AreEqual(5, getResults.Count);
Assert.AreEqual("[[City(", getResults[0].ToString());
Assert.AreEqual("[[City().Name]]", getResults[1].ToString());
Assert.AreEqual("[[City(*).Name]]", getResults[2].ToString());
Assert.AreEqual("[[City().GeoLocation]]", getResults[3].ToString());
Assert.AreEqual("[[City(*).GeoLocation]]", getResults[4].ToString());
}
public void GetIntellisenseResultsWithClosingSquareBraceExpectedInvalidExpressionResult()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 9,
InputText = "[[scalar]",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual("Invalid expression: Opening and closing brackets dont match.", getResults[0].Description);
}
public void IntellisenseProvider_GetIntellisenseResults_WhenOpeningBracketsAndNoRecordset_ValidResults()
{
//------------Setup for test--------------------------
var context = new IntellisenseProviderContext
{
CaretPosition = 9,
InputText = "[[city().",
DesiredResultSet = IntellisenseDesiredResultSet.Default,
FilterType = enIntellisensePartType.RecordsetFields
};
//------------Execute Test---------------------------
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
//------------Assert Results-------------------------
Assert.AreEqual(6, getResults.Count);
Assert.AreEqual("[[City(", getResults[0].ToString());
Assert.AreEqual("[[City().Name]]", getResults[1].ToString());
Assert.AreEqual("[[City(*).Name]]", getResults[2].ToString());
Assert.AreEqual("[[City().GeoLocation]]", getResults[3].ToString());
Assert.AreEqual("[[City(*).GeoLocation]]", getResults[4].ToString());
Assert.AreEqual("Invalid Expression", getResults[5].ToString());
}
//2013.06.11: Ashley Lewis for bug 8759 - intellisense for partial field
public void GetIntellisenseResultsWithPartialFieldAndScalarsInIndexExpectedVarInResultIndices()
{
var context = new IntellisenseProviderContext
{
CaretPosition = 22,
InputText = "[[City([[Scalar]]).Nam",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(1, getResults.Count);
Assert.AreEqual("[[City([[Scalar]]).Name]]", getResults[0].ToString());
}
// ReSharper disable InconsistentNaming
public void GetIntellisenseResultsWithNumberExpectedErrorInResults()
// ReSharper restore InconsistentNaming
{
var context = new IntellisenseProviderContext
{
CaretPosition = 3,
InputText = "[[4]]",
DesiredResultSet = IntellisenseDesiredResultSet.Default
};
var getResults = new DefaultIntellisenseProvider().GetIntellisenseResults(context);
Assert.AreEqual(1, getResults.Count);
Assert.AreEqual("Variable name [[4]] begins with a number", getResults[0].Description);
}
