public void MutateNodeWithCount(string expression, int expectedCount)
{
var node = new NodeAnalyzer().Parse(expression);
var optimizedNode = new OptimizationMutator().MutateNodeWithCount(node);
optimizedNode.Count.Should().Be(expectedCount);
}
public void simple_test(string expression)
{
var theoreticalNode = new NodeAnalyzer().Parse(expression);
var theoreticalResultSet = new double[_bound.StepCount + 1, _bound.StepCount + 1];
_inRangeExpressionComputer.Compute(theoreticalNode, theoreticalResultSet, _bound);
Node best = null;
_geneticExpressionGenerator
.Invoking
(
sut => best = sut.Generate
(
theoreticalResultSet,
_bound,
_bound,
Population,
GenerationCount,
GenerationDepth
)
)
.Should()
.NotThrow();
best.Should().NotBeNull();
var printer = new PrettyPrintVisitor();
printer.VisitNode(best);
Console.WriteLine(printer.Output);
}
public void index_visitor_can_access_nodes_at_given_index()
{
var analyzer = new NodeAnalyzer();
var tree = analyzer.Parse("x + y");
var lookupIndex = 0;
var indexVisitor = new IndexVisitor(() => lookupIndex);
lookupIndex = -1;
indexVisitor
.Invoking(sut => sut.VisitNode(tree))
.Should()
.Throw <ArgumentException>();
lookupIndex = 10;
indexVisitor
.Invoking(sut => sut.VisitNode(tree))
.Should()
.Throw <ArgumentException>();
lookupIndex = 3;
indexVisitor.VisitNode(tree);
var expected = indexVisitor.NodeAtIndex as IdentifierNode;
expected.Should().NotBeNull();
expected?.Identifier.Should().Be("y");
}
void Analyze(CompilationStartAnalysisContext compilationContext)
{
var compilation = compilationContext.Compilation;
compilationContext.RegisterSyntaxTreeAction(delegate(SyntaxTreeAnalysisContext context)
{
try
{
if (!compilation.SyntaxTrees.Contains(context.Tree))
{
return;
}
var semanticModel = compilation.GetSemanticModel(context.Tree);
var root = context.Tree.GetRoot(context.CancellationToken);
var model = compilationContext.Compilation.GetSemanticModel(context.Tree);
if (model.IsFromGeneratedCode(compilationContext.CancellationToken))
{
return;
}
var usageVisitor = new GetDelgateUsagesVisitor(semanticModel, context.CancellationToken);
usageVisitor.Visit(root);
var analyzer = new NodeAnalyzer(context, model, usageVisitor);
analyzer.Visit(root);
}
catch (OperationCanceledException) {}
});
}
public void count_with_optimize_mutator(string expression, int expected)
{
var tree = new NodeAnalyzer().Parse(expression);
var mutator = new OptimizationMutator();
var(_, count) = mutator.MutateNodeWithCount(tree);
count.Should().Be(expected);
}
public static void OnCodeBlockStarted(CodeBlockStartAnalysisContext <SyntaxKind> context)
{
Action <Action <SyntaxNodeAnalysisContext>, ImmutableArray <SyntaxKind> > registerMethod =
(action, Kinds) => context.RegisterSyntaxNodeAction(action, Kinds);
var analyzer = new NodeAnalyzer();
analyzer.Initialize(registerMethod);
}
public void compute_visitor(string expression, double expected)
{
var analyzer = new NodeAnalyzer();
var tree = analyzer.Parse(expression);
var computeVisitor = new ComputeVisitor();
computeVisitor.VisitNode(tree);
computeVisitor.ComputedResult.Should().Be(expected);
}
public void optimizer_in_action(string input, string optimized)
{
var node = new NodeAnalyzer().Parse(input);
var optimizedNode = new OptimizationMutator().MutateNode(node);
var printer = new PrettyPrintVisitor();
printer.VisitNode(optimizedNode);
printer.ToString().Should().Be(optimized);
}
private void OnFixMisc(object sender, RoutedEventArgs e)
{
if (this.SelectedNode == null)
{
return;
}
if (this.SelectedNode.ContainsMiscErrors)
{
NodeAnalyzer.CleanMesh(this.SelectedNode);
}
}
public void plus_to_minus_mutator(string expression, double expected)
{
var analyzer = new NodeAnalyzer();
var tree = analyzer.Parse(expression);
var mutator = new PlusToMinusMutator();
tree = mutator.MutateNode(tree);
var computeVisitor = new ComputeVisitor();
computeVisitor.VisitNode(tree);
computeVisitor.ComputedResult.Should().Be(expected);
}
public void pretty_print_visitor(string expression)
{
var analyzer = new NodeAnalyzer();
var tree = analyzer.Parse(expression);
var computeVisitor = new PrettyPrintVisitor();
computeVisitor.VisitNode(tree);
var output = computeVisitor.Output;
computeVisitor.Output.Should().NotBeNullOrEmpty();
Console.WriteLine(output);
}
public override void Initialize(AnalysisContext context)
{
if (_isCodeBlockAnalyzer)
{
context.RegisterCodeBlockStartAction <SyntaxKind>(OnCodeBlockStarted);
context.RegisterCodeBlockAction(OnCodeBlockEnded);
}
else
{
Action <Action <SyntaxNodeAnalysisContext>, ImmutableArray <SyntaxKind> > registerMethod =
(action, Kinds) => context.RegisterSyntaxNodeAction(action, Kinds);
var analyzer = new NodeAnalyzer();
analyzer.Initialize(registerMethod);
}
}
void Analyze(CompilationStartAnalysisContext compilationContext)
{
var compilation = compilationContext.Compilation;
compilationContext.RegisterSyntaxTreeAction(async delegate (SyntaxTreeAnalysisContext context)
{
try
{
if (!compilation.SyntaxTrees.Contains(context.Tree))
return;
var semanticModel = compilation.GetSemanticModel(context.Tree);
var root = await context.Tree.GetRootAsync(context.CancellationToken).ConfigureAwait(false);
var model = compilationContext.Compilation.GetSemanticModel(context.Tree);
if (model.IsFromGeneratedCode(compilationContext.CancellationToken))
return;
var usageVisitor = new GetDelgateUsagesVisitor(semanticModel, context.CancellationToken);
usageVisitor.Visit(root);
var analyzer = new NodeAnalyzer(context, model, usageVisitor);
analyzer.Visit(root);
}
catch (OperationCanceledException) {}
});
}
public void Initialize()
{
_computer = new InRangeExpressionComputer();
_nodeAnalyzer = new NodeAnalyzer();
}
public override void Initialize(AnalysisContext context)
{
if (_isCodeBlockAnalyzer)
{
context.RegisterCodeBlockStartAction<SyntaxKind>(OnCodeBlockStarted);
context.RegisterCodeBlockAction(OnCodeBlockEnded);
}
else
{
Action<Action<SyntaxNodeAnalysisContext>, ImmutableArray<SyntaxKind>> registerMethod =
(action, Kinds) => context.RegisterSyntaxNodeAction(action, Kinds);
var analyzer = new NodeAnalyzer();
analyzer.Initialize(registerMethod);
}
}
public static void OnCodeBlockStarted(CodeBlockStartAnalysisContext<SyntaxKind> context)
{
Action<Action<SyntaxNodeAnalysisContext>, ImmutableArray<SyntaxKind>> registerMethod =
(action, Kinds) => context.RegisterSyntaxNodeAction(action, Kinds);
var analyzer = new NodeAnalyzer();
analyzer.Initialize(registerMethod);
}
public void parsing_simple_expression(string toParse, string toString)
{
var a = new NodeAnalyzer();
a.Parse(toParse).ToString().Should().Be(toString);
}
