public void ShouldWriteSummary()
{
var example = new ExampleResult {
Reason = Resources.TestReason,
ElapsedTime = 1000,
Message = "Test Exception",
StackTrace = "System.InvalidOperationException: Test Exception",
Status = ResultStatus.Error
};
var results = new Collection<ExpressionResult>();
var expression = new ExpressionResult();
var group = new ExampleGroupResult();
group.Examples.Add(example);
expression.Examples.Add(group);
results.Add(expression);
this.consoleFormatter.WriteError(example);
this.consoleFormatter.WriteSummary(results);
this.stringWriter.Flush();
var value = "F" + Environment.NewLine + Environment.NewLine +
"Failures:" + Environment.NewLine + Environment.NewLine +
"1) test" + Environment.NewLine +
" Failure/Error: System.InvalidOperationException: Test Exception" + Environment.NewLine + Environment.NewLine +
"Finished in 1 seconds" + Environment.NewLine +
"1 examples, 1 failures" + Environment.NewLine;
this.stringWriter.ToString().Should().Be(value);
}
public void Indexer1()
{
const string program = @"using System;
class Main {
public int this[" ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(CSharpExpressionContext.ParameterType, result.Context);
}
public void MultipleFieldsWithInitializers()
{
const string program = @"using System;
class MyClass {
int field1 = 1, ";
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(null, result.Expression);
Assert.AreEqual(ExpressionContext.IdentifierExpected, result.Context);
}
public void FieldArrayInitializer()
{
const string program = @"using System;
class Main {
int[] myField = { " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(ExpressionContext.Default, result.Context);
}
public void GenericMethodTest6()
{
const string program = @"using System; class T {
void Test<T>(ref T name) where ";
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual("where ", result.Expression);
Assert.AreEqual(CSharpExpressionContext.Constraints, result.Context);
}
public void FieldInGenericClass()
{
const string program = @"using System;
class MyList<T> where T : IComparable<T> {
List<T> ";
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual("List<T> ", result.Expression);
Assert.AreEqual(ExpressionContext.IdentifierExpected, result.Context);
}
public void GenericMethodTest3()
{
const string program = @"using System; class T {
void Test<T>(ref ";
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.IsNull(result.Expression);
Assert.AreEqual(CSharpExpressionContext.ParameterType, result.Context);
}
public void GenericMethodTest4()
{
const string program = @"using System; class T {
void Test<T>(ref T ";
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual("T ", result.Expression);
Assert.AreEqual(ExpressionContext.IdentifierExpected, result.Context);
}
public void GenericDelegateTest5()
{
const string program = @"using System;
delegate void Test<T>(ref T name) ";
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual("Test<T>(ref T name) ", result.Expression);
Assert.AreEqual(CSharpExpressionContext.ConstraintsStart, result.Context);
}
public void GenericDelegateTest2()
{
const string program = @"using System;
delegate void Test<T>(";
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.IsNull(result.Expression);
Assert.AreEqual(CSharpExpressionContext.ParameterType, result.Context);
}
public void GenericDelegateTest1()
{
const string program = @"using System;
delegate void Test<";
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.IsNull(result.Expression);
Assert.AreEqual(ExpressionContext.IdentifierExpected, result.Context);
}
public void BlockLambdaInField()
{
const string program = @"using System;
class Main {
Func<int, int> f = a => { " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(ExpressionContext.MethodBody, result.Context);
}
public void Indexer2()
{
const string program = @"using System;
class Main {
public int this[int index] { " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(CSharpExpressionContext.PropertyDeclaration, result.Context);
}
public void DelegateTest1()
{
const string program = @"using System;
delegate ";
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual("delegate ", result.Expression);
Assert.AreEqual(ExpressionContext.Type, result.Context);
}
public override string FormatLogicalExpression(ExpressionBuilderParams p, ExpressionResult left, IOperator op,
ExpressionResult right,
EvaluationStatement template)
{
return(FormatLogicalExpression(p,
left.TypeDescriptor, left.Expression,
op,
right.TypeDescriptor, right.Expression,
template));
}
/// <inheritdoc/>
public override ICompletionItemList GenerateCompletionList(ITextEditor editor)
{
if (editor == null)
{
throw new ArgumentNullException("textEditor");
}
ExpressionResult expression = GetExpression(editor);
return(GenerateCompletionListForExpression(editor, expression));
}
public ExpressionResult FindExpression(string inText, int offset)
{
ExpressionResult r = FindExpressionInternal(inText, offset);
if (string.IsNullOrEmpty(r.Expression))
{
r.Expression = null;
}
return(r);
}
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
{
IClass matchingClass = GetClass(resolverContext, expressionResult.Expression);
if (matchingClass != null)
{
return(CreateTypeResolveResult(matchingClass));
}
return(null);
}
public void MultipleLinesWithImportAndNamespace()
{
string text =
"# Line to ignore\r\n" +
"import System";
ExpressionResult result = expressionFinder.FindExpression(text, text.Length);
Assert.AreEqual("import System", result.Expression);
Assert.IsNotNull(result.Context as PythonImportExpressionContext);
}
public IActionResult Index()
{
var anyExample = new AnyExpression().GetExampleQuery(_context);
var includeExample = new IncludeExpression().GetExampleQuery(_context);
var andOrExample = new AndOrExpression().GetExampleQuery(_context);
var result = new ExpressionResult(anyExample.ToList(), includeExample.ToList(), andOrExample.ToList());
return(View(result));
}
protected override void GenerateCompletionData(TextArea textArea, char charTyped)
{
if (forceNewExpression)
{
preSelection = "";
if (charTyped != '\0')
{
preSelection = null;
}
ExpressionContext context = overrideContext;
if (context == null)
{
context = ExpressionContext.Default;
}
AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, context), context);
return;
}
ExpressionResult expressionResult = GetExpression(textArea);
string expression = expressionResult.Expression;
preSelection = null;
if (expression == null || expression.Length == 0)
{
preSelection = "";
if (charTyped != '\0')
{
preSelection = null;
}
AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, expressionResult.Context), expressionResult.Context);
return;
}
int idx = expression.LastIndexOf('.');
if (idx > 0)
{
preSelection = expression.Substring(idx + 1);
expressionResult.Expression = expression.Substring(0, idx);
if (charTyped != '\0')
{
preSelection = null;
}
GenerateCompletionData(textArea, expressionResult);
}
else
{
preSelection = expression;
if (charTyped != '\0')
{
preSelection = null;
}
AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, expressionResult.Context), expressionResult.Context);
}
}
public void TestGetResultAsBoolean(object value, bool expectedValue)
{
// Arrange
var sut = new ExpressionResult(value);
// Act
var result = sut.GetValueAsBoolean();
// Assert
Assert.AreEqual(expectedValue, result);
}
ExpressionResult GetExpressionAt(ITextEditor editor, int caretLine, int caretColumn)
{
ExpressionResult expr = ParserService.FindFullExpression(caretLine, caretColumn, editor.Document, editor.FileName);
// if no expression, look one character back (works better with method calls, e.g. Foo()(*caret*))
if (string.IsNullOrWhiteSpace(expr.Expression) && caretColumn > 1)
{
expr = ParserService.FindFullExpression(caretLine, caretColumn - 1, editor.Document, editor.FileName);
}
return(expr);
}
public void InsideStringLiteral()
{
const string program = @"using System;
class Main {
string a = ""hello, " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.IsNull(result.Expression);
Assert.AreEqual(ExpressionContext.Default, result.Context);
}
public override ResolveResult Resolve(ITextEditor editor, ExpressionResult expressionResult)
{
// bypass ParserService.Resolve and set resolver.LimitMethodExtractionUntilCaretLine
ParseInformation parseInfo = ParserService.GetParseInformation(editor.Document.Text, ProjectContent);
var resolver = new NRefactoryResolver(LanguageProperties.CSharp)
{
LimitMethodExtractionUntilLine = editor.Caret.Line
};
return(resolver.Resolve(expressionResult, parseInfo, editor.Document.Text));
}
public void BlockLambdaInCondition()
{
const string program = @"using System;
class Main {
void M() {
if (Method(a => { " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(ExpressionContext.MethodBody, result.Context);
}
public void IndexerAccessInObjectInitializer()
{
const string program = @"using System;
class Main {
void M() {
a = new SomeObject { b = c[ " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(ExpressionContext.Default, result.Context);
}
public void ContextInCall()
{
const string program = @"using System;
class Main {
void M() {
MethodCall( " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(ExpressionContext.Default, result.Context);
}
public void ArrayInitializer2()
{
const string program = @"using System;
class Main {
void M() {
a = new SomeType [] { " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(ExpressionContext.MethodBody, result.Context);
}
public void ObjectInitializer8b()
{
const string program = @"using System;
class Main {
void M() {
a = new SomeType { SomeProperty = new SomeOtherType { " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(CSharpExpressionContext.ObjectInitializer, result.Context);
}
public void ObjectInitializer7()
{
const string program = @"using System;
class Main {
void M() {
a = new { a.B, " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(CSharpExpressionContext.ObjectInitializer, result.Context);
}
public void ObjectInitializer5b()
{
const string program = @"using System;
class Main {
void M() {
a = new MyType { P1 = someBoolean == " ;
ExpressionResult result = ef.FindExpression(program, program.Length);
Assert.AreEqual(ExpressionContext.Default, result.Context);
}
/// <summary>
/// Evaluate the specified expression and return the result.
/// </summary>
/// <remarks>
/// <para>
/// This implementation is hard-coded to return an <see cref="ExpressionResult"/> which indicates an evaluation
/// failure.
/// </para>
/// </remarks>
/// <param name="expression">The expression to evaluate.</param>
/// <param name="element">The element for which we are evaluating a result.</param>
public override ExpressionResult Evaluate(string expression, IRenderingContext context)
{
object result;
ExpressionResult output;
if(this.TryGetItem(expression, context, out result))
{
output = new ExpressionResult(result);
}
else
{
string message = String.Format("The item '{0}' was not found in the model.",
expression);
throw new InvalidOperationException(message);
}
return output;
}
/// <summary>
/// Coerces an expression result to a boolean value.
/// </summary>
/// <returns><c>true</c>, if the expression result indicates truth, <c>false</c> otherwise.</returns>
/// <param name="result">An expression result.</param>
private bool CoerceToBoolean(ExpressionResult result)
{
if(result == null)
{
throw new ArgumentNullException(nameof(result));
}
bool output;
if(result.CancelsAction)
{
output = false;
}
else if(result.Value == null)
{
output = false;
}
else if(result.Value is bool)
{
output = (bool) result.Value;
}
else if(result.Value.Equals(0))
{
output = false;
}
else if(result.Value is IEnumerable)
{
var enumerableValue = ((IEnumerable) result.Value).Cast<object>();
output = enumerableValue.Any();
}
else if(result.Value is ITalesConvertible)
{
var convertibleValue = (ITalesConvertible) result.Value;
output = convertibleValue.AsBoolean();
}
else
{
output = true;
}
return output;
}
public override ExpressionResult Evaluate(string expression, IRenderingContext context)
{
object result;
ExpressionResult output;
if(this.TryGetItem(expression, context, out result))
{
output = new ExpressionResult(result);
}
else
{
string message = String.Format(Resources.ExceptionMessages.ModelDoesNotContainItem, expression);
throw new ModelEvaluationException(message) {
ElementName = context.Element.Name,
ExpressionText = expression.ToString(),
};
}
return output;
}
private static void CreateExamples(ExpressionResult expression, ICollection<testsuiteType> groupTypes)
{
foreach (var group in expression.Examples) {
var hasGroupErrors = group.Examples.HasErrors();
var groupType = new testsuiteType
{
name = group.Reason,
type = "TestFixture",
result = hasGroupErrors ? "Failure" : "Success",
executed = bool.TrueString,
time = ConvertToSeconds(group.Examples.ElapsedTime()).ToString(CultureInfo.InvariantCulture),
asserts = "0",
success = hasGroupErrors ? bool.FalseString : bool.TrueString
};
var cases = new Collection<testcaseType>();
CreateErrors(group, cases);
CreateSuccesses(group, cases);
groupType.results = cases.ToArray();
groupTypes.Add(groupType);
}
}
public ExpressionResult Execute(Expression expression, string exampleText)
{
var expressionResult = new ExpressionResult { Name = expression.Name };
foreach (var exampleGroup in expression.FindExampleGroup(exampleText)) {
expressionResult.Examples.Add(ExecuteExampleGroup(exampleGroup));
return expressionResult;
}
foreach (var example in expression.FindExample(exampleText)) {
var exampleResult = new ExampleGroupResult { Reason = example.ExampleGroup.Reason };
exampleResult.Examples.Add(ExecuteExample(example.ExampleGroup, example.Example));
expressionResult.Examples.Add(exampleResult);
return expressionResult;
}
expression.Examples.ForEach(group => expressionResult.Examples.Add(ExecuteExampleGroup(group)));
return expressionResult;
}
IEnumerable<ICompletionData> HandleMemberReferenceCompletion(ExpressionResult expr)
{
if (expr == null)
return null;
// do not auto select <number>. (but <number>.<number>.) (0.ToString() is valid)
if (expr.Node is PrimitiveExpression) {
var pexpr = (PrimitiveExpression)expr.Node;
if (!(pexpr.Value is string || pexpr.Value is char) && !pexpr.LiteralValue.Contains('.')) {
AutoSelect = false;
}
}
var resolveResult = ResolveExpression(expr);
if (resolveResult == null) {
return null;
}
if (expr.Node is AstType) {
// check for namespace names
if (expr.Node.AncestorsAndSelf
.TakeWhile(n => n is AstType)
.Any(m => m.Role == NamespaceDeclaration.NamespaceNameRole))
return null;
// need to look at paren.parent because of "catch (<Type>.A" expression
if (expr.Node.Parent != null && expr.Node.Parent.Parent is CatchClause)
return HandleCatchClauseType(expr);
return CreateTypeAndNamespaceCompletionData(
location,
resolveResult.Result,
expr.Node,
resolveResult.Resolver
);
}
return CreateCompletionData(
location,
resolveResult.Result,
expr.Node,
resolveResult.Resolver
);
}
IEnumerable<ICompletionData> DefaultControlSpaceItems(ref bool isComplete, ExpressionResult xp = null, bool controlSpace = true)
{
var wrapper = new CompletionDataWrapper(this);
if (offset >= document.TextLength) {
offset = document.TextLength - 1;
}
while (offset > 1 && char.IsWhiteSpace(document.GetCharAt(offset))) {
offset--;
}
location = document.GetLocation(offset);
if (xp == null) {
xp = GetExpressionAtCursor();
}
AstNode node;
SyntaxTree unit;
ExpressionResolveResult rr;
if (xp != null) {
node = xp.Node;
rr = ResolveExpression(node);
unit = xp.Unit;
} else {
unit = ParseStub("foo", false);
node = unit.GetNodeAt(
location.Line,
location.Column + 2,
n => n is Expression || n is AstType || n is NamespaceDeclaration || n is Attribute
);
rr = ResolveExpression(node);
}
var ifvisitor = new IfVisitor(location, CompletionContextProvider);
unit.AcceptVisitor(ifvisitor);
ifvisitor.End();
if (!ifvisitor.IsValid)
return null;
// namespace name case
var ns = node as NamespaceDeclaration;
if (ns != null) {
var last = ns.NamespaceName;
if (last != null && location < last.EndLocation)
return null;
}
if (node is Identifier && node.Parent is ForeachStatement) {
var foreachStmt = (ForeachStatement)node.Parent;
foreach (var possibleName in GenerateNameProposals (foreachStmt.VariableType)) {
if (possibleName.Length > 0) {
wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString()));
}
}
AutoSelect = false;
AutoCompleteEmptyMatch = false;
isComplete = true;
return wrapper.Result;
}
if (node is Identifier && node.Parent is ParameterDeclaration) {
if (!controlSpace) {
return null;
}
// Try Parameter name case
var param = node.Parent as ParameterDeclaration;
if (param != null) {
foreach (var possibleName in GenerateNameProposals (param.Type)) {
if (possibleName.Length > 0) {
wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString()));
}
}
AutoSelect = false;
AutoCompleteEmptyMatch = false;
isComplete = true;
return wrapper.Result;
}
}
var pDecl = node as ParameterDeclaration;
if (pDecl != null && pDecl.Parent is LambdaExpression) {
return null;
}
/* if (Unit != null && (node == null || node is TypeDeclaration)) {
var constructor = Unit.GetNodeAt<ConstructorDeclaration>(
location.Line,
location.Column - 3
);
if (constructor != null && !constructor.ColonToken.IsNull && constructor.Initializer.IsNull) {
wrapper.AddCustom("this");
wrapper.AddCustom("base");
return wrapper.Result;
}
}*/
var initializer = node != null ? node.Parent as ArrayInitializerExpression : null;
if (initializer != null) {
var result = HandleObjectInitializer(unit, initializer);
if (result != null)
return result;
}
CSharpResolver csResolver = null;
if (rr != null) {
csResolver = rr.Resolver;
}
if (csResolver == null) {
if (node != null) {
csResolver = GetState();
//var astResolver = new CSharpAstResolver (csResolver, node, xp != null ? xp.Item1 : CSharpUnresolvedFile);
try {
//csResolver = astResolver.GetResolverStateBefore (node);
Console.WriteLine(csResolver.LocalVariables.Count());
} catch (Exception e) {
Console.WriteLine("E!!!" + e);
}
} else {
csResolver = GetState();
}
}
if (node is Attribute) {
// add attribute properties.
var astResolver = CompletionContextProvider.GetResolver(csResolver, unit);
var resolved = astResolver.Resolve(node);
AddAttributeProperties(wrapper, resolved);
}
if (node == null) {
// try lambda
unit = ParseStub("foo) => {}", true);
var pd = unit.GetNodeAt<ParameterDeclaration>(
location.Line,
location.Column
);
if (pd != null) {
var astResolver = unit != null ? CompletionContextProvider.GetResolver(GetState(), unit) : null;
var parameterType = astResolver.Resolve(pd.Type);
// Type <name> is always a name context -> return null
if (parameterType != null && !parameterType.IsError)
return null;
}
}
AddContextCompletion(wrapper, csResolver, node);
return wrapper.Result;
}
IEnumerable<ICompletionData> HandleCatchClauseType(ExpressionResult identifierStart)
{
Func<IType, IType> typePred = delegate (IType type) {
if (type.GetAllBaseTypes().Any(t => t.ReflectionName == "System.Exception"))
return type;
return null;
};
if (identifierStart.Node.Parent is CatchClause) {
var wrapper = new CompletionDataWrapper(this);
AddTypesAndNamespaces(
wrapper,
GetState(),
identifierStart.Node,
typePred,
m => false
);
return wrapper.Result;
}
var resolveResult = ResolveExpression(identifierStart);
return CreateCompletionData(
location,
resolveResult.Result,
identifierStart.Node,
resolveResult.Resolver,
typePred
);
}
IEnumerable<ICompletionData> HandleMemberReferenceCompletion(ExpressionResult expr)
{
if (expr == null)
return null;
// do not complete <number>. (but <number>.<number>.)
if (expr.Node is PrimitiveExpression) {
var pexpr = (PrimitiveExpression)expr.Node;
if (!(pexpr.Value is string || pexpr.Value is char) && !pexpr.LiteralValue.Contains('.')) {
return null;
}
}
var resolveResult = ResolveExpression(expr);
if (resolveResult == null) {
return null;
}
if (expr.Node is AstType) {
// need to look at paren.parent because of "catch (<Type>.A" expression
if (expr.Node.Parent != null && expr.Node.Parent.Parent is CatchClause)
return HandleCatchClauseType(expr);
return CreateTypeAndNamespaceCompletionData(
location,
resolveResult.Item1,
expr.Node,
resolveResult.Item2
);
}
return CreateCompletionData(
location,
resolveResult.Item1,
expr.Node,
resolveResult.Item2
);
}
IEnumerable<ICompletionData> DefaultControlSpaceItems(ExpressionResult xp = null, bool controlSpace = true)
{
var wrapper = new CompletionDataWrapper(this);
if (offset >= document.TextLength) {
offset = document.TextLength - 1;
}
while (offset > 1 && char.IsWhiteSpace (document.GetCharAt (offset))) {
offset--;
}
location = document.GetLocation(offset);
if (xp == null) {
xp = GetExpressionAtCursor();
}
AstNode node;
CompilationUnit unit;
Tuple<ResolveResult, CSharpResolver> rr;
if (xp != null) {
node = xp.Node;
rr = ResolveExpression(node, xp.Unit);
unit = xp.Unit;
} else {
unit = ParseStub("foo", false);
node = unit.GetNodeAt(
location.Line,
location.Column + 2,
n => n is Expression || n is AstType
);
rr = ResolveExpression(node, unit);
}
if (node is Identifier && node.Parent is ForeachStatement) {
var foreachStmt = (ForeachStatement)node.Parent;
foreach (var possibleName in GenerateNameProposals (foreachStmt.VariableType)) {
if (possibleName.Length > 0) {
wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString()));
}
}
AutoSelect = false;
AutoCompleteEmptyMatch = false;
return wrapper.Result;
}
if (node is Identifier && node.Parent is ParameterDeclaration) {
if (!controlSpace) {
return null;
}
// Try Parameter name case
var param = node.Parent as ParameterDeclaration;
if (param != null) {
foreach (var possibleName in GenerateNameProposals (param.Type)) {
if (possibleName.Length > 0) {
wrapper.Result.Add(factory.CreateLiteralCompletionData(possibleName.ToString()));
}
}
AutoSelect = false;
AutoCompleteEmptyMatch = false;
return wrapper.Result;
}
}
if (Unit != null && (node == null || node is TypeDeclaration)) {
var constructor = Unit.GetNodeAt<ConstructorDeclaration>(
location.Line,
location.Column - 3
);
if (constructor != null && !constructor.ColonToken.IsNull && constructor.Initializer.IsNull) {
wrapper.AddCustom("this");
wrapper.AddCustom("base");
return wrapper.Result;
}
}
var initializer = node != null ? node.Parent as ArrayInitializerExpression : null;
if (initializer != null) {
var result = HandleObjectInitializer(unit, initializer);
if (result != null)
return result;
}
CSharpResolver csResolver = null;
if (rr != null) {
csResolver = rr.Item2;
}
if (csResolver == null) {
if (node != null) {
csResolver = GetState();
//var astResolver = new CSharpAstResolver (csResolver, node, xp != null ? xp.Item1 : CSharpParsedFile);
try {
//csResolver = astResolver.GetResolverStateBefore (node);
Console.WriteLine(csResolver.LocalVariables.Count());
} catch (Exception e) {
Console.WriteLine("E!!!" + e);
}
} else {
csResolver = GetState();
}
}
AddContextCompletion(wrapper, csResolver, node, unit);
return wrapper.Result;
}
protected Tuple<ResolveResult, CSharpResolver> ResolveExpression (ExpressionResult tuple)
{
return ResolveExpression (tuple.Node);
}
public void ShouldWriteSummaryWithOneSuccess()
{
var results = new Collection<ExpressionResult>();
var result = new ExpressionResult();
var group = new ExampleGroupResult();
var example = new ExampleResult { ElapsedTime = 1000 };
group.Examples.Add(example);
result.Examples.Add(group);
results.Add(result);
consoleFormatter.WriteSummary(results);
stringWriter.Flush();
var value = Environment.NewLine + Resources.TestReason + Environment.NewLine + Environment.NewLine +
"Finished in 1 seconds" + Environment.NewLine +
"1 examples, 0 failures" + Environment.NewLine;
stringWriter.ToString().Should().Be(value);
}
IEnumerable<ICompletionData> HandleMemberReferenceCompletion(ExpressionResult expr)
{
if (expr == null)
return null;
// do not complete <number>. (but <number>.<number>.)
if (expr.Node is PrimitiveExpression) {
var pexpr = (PrimitiveExpression)expr.Node;
if (!(pexpr.Value is string || pexpr.Value is char) && !pexpr.LiteralValue.Contains('.')) {
return null;
}
}
var resolveResult = ResolveExpression (expr);
if (resolveResult == null) {
return null;
}
if (expr.Node is AstType) {
return CreateTypeAndNamespaceCompletionData(location, resolveResult.Item1, expr.Node, resolveResult.Item2);
}
return CreateCompletionData(location, resolveResult.Item1, expr.Node, resolveResult.Item2);
}
protected ExpressionResolveResult ResolveExpression (ExpressionResult tuple)
{
return ResolveExpression (tuple.Node);
}
