protected override void Visit(MethodDefinition method)
{
if (method.HasBody)
{
var body = method.Body;
var il = body.GetILProcessor();
il.Body.SimplifyMacros();
Analysis = null;
Instruction instruction = body.Instructions[0];
while (instruction != null)
{
if (ShouldVisit(instruction))
{
if (Analysis == null)
{
Analysis = Analyser.Analyse(method);
}
instruction = Visit(il, instruction);
}
else
{
instruction = instruction.Next;
}
}
il.Body.OptimizeMacros();
}
}
public void FrameworkFuncBindingTest()
{
const string Code =
@"
Output(""4"");
";
Compilation tree = Analyser.Analyse(Code);
Assert.NotNull(tree);
Assert.AreEqual(1, tree !.Program.TopLevelStatementNodes.Count);
Assert.IsInstanceOf <FunctionCallStatementNode>(tree.Program.TopLevelStatementNodes[0]);
var fcsn = (FunctionCallStatementNode)tree.Program.TopLevelStatementNodes[0];
Assert.IsInstanceOf <IdentifierExpressionNode>(fcsn.FunctionExpressionNode);
var idex = (IdentifierExpressionNode)fcsn.FunctionExpressionNode;
Assert.IsInstanceOf <BoundIdentifierNode>(idex.IdentifierNode);
var bdid = (BoundIdentifierNode)idex.IdentifierNode;
Assert.IsInstanceOf <FrameworkFunctionSymbolNode>(bdid.Symbol);
var func = (FrameworkFunctionSymbolNode)bdid.Symbol;
Assert.AreEqual("Output", func.Identifier);
}
public bool Analyse(QLNode node)
{
var result = true;
var expression = GetExpression(node);
if (expression != null && AnalyseExpression(expression) == StatementType.Unknown)
{
Analyser.AddMessage(string.Format("{0} - This expression isn't valid.", node.Location), Language.QL, MessageType.ERROR);
return(false);
}
switch (node)
{
case QLCollectionNode collectionNode:
foreach (QLNode child in collectionNode.Children)
{
if (!Analyse(child))
{
result = false;
}
}
break;
default:
return(true);
}
return(result);
}
private void doAnalysisBackground(object sender, DoWorkEventArgs e)
{
var worker = sender as BackgroundWorker;
bool canceled = false;
for (_currentAnalysisindexPath = 0;
_currentAnalysisindexPath < Analyser.Config.Paths.Count();
_currentAnalysisindexPath++)
{
var di = new DirectoryInfo(Analyser.Config.Paths[_currentAnalysisindexPath]);
//find files sizes
canceled = Analyser.AnalyseFolder(di, false, worker, e, true);
if (canceled)
{
return;
}
}
Analyser.Stats.DeletedFiles = Analyser.Dset.Tables[0].Select("status=0").Length;
Analyser.Stats.NewFiles = Analyser.Dset.Tables[0].Select("status=" + ((int)Analyser.status.New)).Length;
//find files with same size and get hash
if (Analyser.Config.Duplicate)
{
Analyser.AnalyseFileSet(worker, e);
}
canceled = e.Cancel;
worker.ReportProgress(0, new WaitingFormProperties(Resources.Languages.Resources.Txt_Analyse_des_résultats));
EndAnalyse(canceled);
}
public void FrameworkTypeBindingTest()
{
const string Code =
@"
Var x As String;
";
Compilation tree = Analyser.Analyse(Code);
Assert.NotNull(tree);
Assert.AreEqual(1, tree !.Program.TopLevelStatementNodes.Count);
Assert.IsInstanceOf <VariableDeclarationStatementNode>(tree.Program.TopLevelStatementNodes[0]);
var vdecl = (VariableDeclarationStatementNode)tree.Program.TopLevelStatementNodes[0];
Assert.AreEqual("x", vdecl.VariableIdentifier);
Assert.IsInstanceOf <IdentifierTypeSpecNode>(vdecl.TypeSpecNode);
var idtype = (IdentifierTypeSpecNode)vdecl.TypeSpecNode !;
Assert.IsInstanceOf <BoundIdentifierNode>(idtype.IdentifierNode);
var bdid = (BoundIdentifierNode)idtype.IdentifierNode;
Assert.IsInstanceOf <FrameworkTypeSymbolNode>(bdid.Symbol);
var bitsn = (FrameworkTypeSymbolNode)bdid.Symbol;
Assert.AreEqual(FrameworkType.String, bitsn.FrameworkType);
}
public static void Main(string[] args)
{
if (args.Length != 1)
{
Usage();
return;
}
Console.WriteLine($"Analysing [{args[0]}] ...");
var sw = Stopwatch.StartNew();
var sql = File.ReadAllText(args[0]);
var analyser = new Analyser(sql);
analyser.Analyse();
var allNodes = analyser.AllNodes;
var leafNodes = analyser.LeafNodes;
foreach (var node in leafNodes)
{
var nodeDepth = node.GetDepth();
var padding = new string(' ', nodeDepth);
Console.WriteLine($"{padding} [{nodeDepth}@{node.GetType().Name}] {node} ${analyser.GetWeightedCost(node):0}");
}
Console.WriteLine($"Analysed [{args[0]}] in {sw.ElapsedMilliseconds} ms");
Console.WriteLine($" MaxDepth = {analyser.MaxDepth}");
Console.WriteLine($" Height = {allNodes.Count()}");
Console.WriteLine($" Leaves = {leafNodes.Count()}");
Console.WriteLine($" TotalDepth = {analyser.TotalDepth}");
Console.WriteLine($" TotalWeightedCost = ${analyser.TotalWeightedCost:0}");
}
public new void Init(
Dictionary <string, Actor> actors, Analyser analyser,
Parser parser, Visualizer visualizer, string[] script)
{
// Method is protected.
base.Init(actors, analyser, parser, visualizer, script);
}
public void factors_with_addition()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("8+12*12"));
Assert.That(node.ToString(), Is.EqualTo("(8 + (12 * 12))"));
}
public void factors_with_minus()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("8-12*12+5"));
Assert.That(node.ToString(), Is.EqualTo("((8 - (12 * 12)) + 5)"));
}
public void ReadSpectrogramFrame()
{
double curAudioPos = app.AudioSource.AudioStream.CurrentTime.TotalMilliseconds;
SpectrogramFrame curFrame = SpectrogramHandler.Spectrogram.Frames.Aggregate((x, y) => Math.Abs(x.Timestamp - curAudioPos) < Math.Abs(y.Timestamp - curAudioPos) ? x : y); // Gets the frame with a timestamp closest to curAudioPos
// Converts byte valued spectrogram data to double valued spectrum data
double[] doubleData = new double[curFrame.SpectrumData.Length];
for (int i = 0; i < doubleData.Length; i++)
{
doubleData[i] = curFrame.SpectrumData[i];
}
spectrumData = doubleData;
foreach (Note note in curFrame.Notes)
{
Analyser.BufferNote(note.NoteIndex);
Analyser.GetMusic().CountNote(note.Name + "0");
}
// Directly assigns analyser properties from current spectrogram frame
Analyser.Notes = curFrame.Notes.ToList();
Analyser.Chords = curFrame.Chords.ToList();
Analyser.CurrentKey = curFrame.KeySignature;
Analyser.CalculateNotePercentages();
FrequencyAnalysisToSpectrum(SpectrogramHandler.Spectrogram.FrequencyScale);
curFrame = null;
doubleData = null;
spectrumData = null;
GC.Collect();
}
public void simple_factors()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("8*12/5*12"));
Assert.That(node.ToString(), Is.EqualTo("(((8 * 12) / 5) * 12)"));
}
public void RunFrequencyAnalysis()
{
scriptVals["SAMPLE_RATE"] = app.AudioSource.AudioAnalysis.WaveFormat.SampleRate;
scriptVals["TUNING_PERCENT"] = Analyser.GetMusic().GetTuningPercent();
object audio = ReadAudioStream();
foreach (int key in processors.Keys)
{
if (key < detectorIndex)
{
processors[key].InputBuffer = audio;
processors[key].InputArgs = scriptVals;
processors[key].OutputArgs = new Dictionary <string, object>();
processors[key].Process();
audio = processors[key].OutputBuffer;
foreach (var arg in processors[key].OutputArgs)
{
scriptVals[arg.Key] = arg.Value;
}
}
else
{
break;
}
}
spectrumData = (double[])audio;
if (!Double.IsInfinity(spectrumData[0]) && !Double.IsNaN(spectrumData[0]) && app.Mode != 1)
{
spectrumData = SmoothSignal(spectrumData, Prefs.SMOOTH_FACTOR);
}
}
private void PerfectFilterButton_Click(object sender, EventArgs e)
{
var flag = true;
flag &= double.TryParse(FilterstextBox.Text.Replace('.', ','), out var alpha);
if (!flag)
{
MessageBox.Show("Не все данные в правильном формате!", "Ошибка", MessageBoxButtons.OK);
return;
}
var ppl = Analyser.GetH();
var curve = _controlZgcList[(int)numericUpDownGraphNo.Value - 1].GraphPane.CurveList[0];
var x = new PointPairList();
for (var i = 0; i < curve.Points.Count; i++)
{
x.Add(curve.Points[i]);
}
Plotter.Clear(_controlZgcList[(int)numericUpDownGraphNo.Value - 1]);
if (alpha == 0)
{
var result = Analyser.PerfectFilter(x, ppl);
Plotter.Draw(_controlZgcList[(int)numericUpDownGraphNo.Value - 1], result, "Исходная функция");
}
else
{
var result = Analyser.PerfectFilterNoise(x, ppl, alpha);
Plotter.Draw(_controlZgcList[(int)numericUpDownGraphNo.Value - 1], result, "Исходная функция");
}
}
private void applyBsPotterButton_Click(object sender, EventArgs e)
{
var flag = true;
flag &= double.TryParse(bs_fc1.Text.Replace('.', ','), out var fc);
flag &= double.TryParse(bs_fc_2.Text.Replace('.', ','), out var fc2);
flag &= int.TryParse(bs_m.Text, out var m);
flag &= double.TryParse(dtTextBox.Text.Replace('.', ','), out var dt);
if (!flag)
{
MessageBox.Show("Не все данные в правильном формате!", "Ошибка", MessageBoxButtons.OK);
return;
}
var curve = _controlZgcList[(int)numericUpDownGraphNo.Value - 1].GraphPane.CurveList[0];
var x = new PointPairList();
for (var i = 0; i < curve.Points.Count; i++)
{
x.Add(curve.Points[i]);
}
var h = Analyser.GetHarryPotter_BS(fc, fc2, m, dt);
var y = Analyser.GetConvolution(x, h);
Plotter.Clear(_controlZgcList[(int)numericUpDownGraphNo.Value - 1]);
Plotter.Draw(_controlZgcList[(int)numericUpDownGraphNo.Value - 1], y, "Pottered");
}
public void CanAnalyseSetupAttribute()
{
var code =
@"using System;
using MiniBench.Core;
namespace MiniBench.Tests
{
public class SimpleTest
{
[Setup]
public void SetupMethod() {}
[Benchmark]
public void SimpleBenchmark() {}
}
}";
Console.WriteLine(code);
var syntaxTree = CSharpSyntaxTree.ParseText(code, options: parseOptions, encoding: defaultEncoding);
var results = new Analyser().AnalyseBenchmark(syntaxTree, "TestFile").ToList();
Assert.Equal(1, results.Count());
var benchmarkInfo = results.FirstOrDefault();
Assert.NotNull(benchmarkInfo);
Assert.Equal("SetupMethod", benchmarkInfo.SetupMethod);
}
public void addition_and_factors()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("8*12+12"));
Assert.That(node.ToString(), Is.EqualTo("((8 * 12) + 12)"));
}
static void Main(string[] args)
{
Console.WriteLine("---- Start parsing the QL ----");
FormNode ql = QLParserHelper.Parse(Util.FileToString(QLFile));
QLPrinter.Print(ql);
Console.WriteLine();
Console.WriteLine("---- Start parsing QLS ----");
QLSNode qls = QLSParserHelper.Parse(Util.FileToString(QLSFile));
QLSPrinter.Print(qls);
Analyser.Analyse(ql, qls);
var errors = Analyser.GetErrors();
Console.WriteLine("\n\n---- Errors and/or warnings: {0} ----", errors.Count);
foreach (string error in errors)
{
Console.WriteLine(error);
}
Console.ReadLine();
}
public void unary_minus_at_work()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("12*-7"));
Assert.That(node.ToString(), Is.EqualTo("(12 * -(7))"));
}
/// <summary>
/// A recursive function to find out if the AST contains multiple FormNode
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public bool Analyse(QLNode node)
{
//Reset the formNodeCount
formNodeCount = 0;
if (node.Type == NodeType.Form)
{
this.Visit(node as FormNode);
}
else
{
this.Visit(node);
}
this.Visit(node);
if (formNodeCount == 0)
{
Analyser.AddMessage("There has no form been defined", Language.QL, MessageType.ERROR);
}
else if (formNodeCount > 1)
{
Analyser.AddMessage("There can only be one form", Language.QL, MessageType.ERROR);
}
return(formNodeCount == 1);
}
public void with_variables()
{
var a = new Analyser();
var node = a.Analyse(new StringTokenizer("12*-X+9"));
Assert.That(node.ToString(), Is.EqualTo("((12 * -(X)) + 9)"));
}
/**
* Get a list of winners
*
* @param {List} players all players
* @return {List} winner list
*/
public static List <Player> GetWinners(List <Player> players)
{
if (players == null || players.Count == 0)
{
throw new InvalidGameException("no player is added");
}
if (players.Any(player => player.PlayerHand == null))
{
throw new InvalidPlayerException("player hand");
}
Analyser analyser = new Analyser(rules);
players.ForEach((player) =>
{
analyser.SetHandRank(player.PlayerHand);
});
Player highest = players
.OrderByDescending((player) => player.PlayerHand)
.FirstOrDefault();
List <Player> winners = players
.Where((player) => player.PlayerHand.CompareTo(highest.PlayerHand) == 0)
.ToList();
return(winners);
}
public void CanAnalyseWhenBlackholeIsNeededIdentifier()
{
var code =
@"using System;
using MiniBench.Core;
namespace MiniBench.Tests
{
public class BlackholeTest
{
[Benchmark]
public DateTime SimpleBenchmark()
{
return new DateTime(42);
}
}
}";
Console.WriteLine(code);
var syntaxTree = CSharpSyntaxTree.ParseText(code, options: parseOptions, encoding: defaultEncoding);
var results = new Analyser().AnalyseBenchmark(syntaxTree, "TestFile").ToList();
Assert.Equal(1, results.Count());
var benchmarkInfo = results.FirstOrDefault();
Assert.NotNull(benchmarkInfo);
Assert.Equal(true, benchmarkInfo.GenerateBlackhole);
}
private static int Run(Options opts)
{
Console.CancelKeyPress += Console_CancelKeyPress;
_logger = LogManager.GetCurrentClassLogger();
var buildVersion = Assembly.GetEntryAssembly().GetName().Version.ToString();
LogSetup.ConfigureLogger("tsanalyser", opts.OrganizationId, opts.DescriptorTags, "https://telemetry.cinegy.com", opts.TelemetryEnabled, false, "TSAnalyser", buildVersion);
_analyser = new Analyser(_logger);
var location = Assembly.GetEntryAssembly().Location;
_logger.Info($"Cinegy Transport Stream Monitoring and Analysis Tool (Built: {File.GetCreationTime(location)})");
try
{
Console.CursorVisible = false;
Console.SetWindowSize(120, 50);
Console.OutputEncoding = Encoding.Unicode;
}
catch
{
Console.WriteLine("Failed to increase console size - probably screen resolution is low");
}
_options = opts;
GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency;
WorkLoop();
return(0);
}
public void CanAnalyseInjectedParams()
{
var code =
@"using System;
using MiniBench.Core;
namespace MiniBench.Tests
{
public class BlackholeTest
{
[Benchmark]
public double SimpleBenchmark(IterationParams iteration)
{
return 42.0;
}
}
}";
Console.WriteLine(code);
var syntaxTree = CSharpSyntaxTree.ParseText(code, options: parseOptions, encoding: defaultEncoding);
var results = new Analyser().AnalyseBenchmark(syntaxTree, "TestFile").ToList();
Assert.Equal(1, results.Count());
var benchmarkInfo = results.FirstOrDefault();
Assert.NotNull(benchmarkInfo);
Assert.Equal(true, benchmarkInfo.GenerateBlackhole);
Assert.Equal(new[] { "IterationParams" }, benchmarkInfo.ParametersToInject);
}
public void SimpleBindingTest()
{
const string Code =
@"
Var x = 1;
x = 2;
";
Compilation tree = Analyser.Analyse(Code);
Assert.NotNull(tree);
Assert.IsInstanceOf <VariableDeclarationStatementNode>(tree !.Program.TopLevelStatementNodes[0]);
Assert.IsInstanceOf <VariableAssignmentStatementNode>(tree.Program.TopLevelStatementNodes[1]);
var decl = (VariableDeclarationStatementNode)tree !.Program.TopLevelStatementNodes[0];
var assg = (VariableAssignmentStatementNode)tree !.Program.TopLevelStatementNodes[1];
Assert.IsInstanceOf <BoundIdentifierNode>(decl.VariableIdentifierNode);
Assert.IsInstanceOf <BoundIdentifierNode>(assg.VariableIdentifierNode);
var var1 = ((BoundIdentifierNode)decl.VariableIdentifierNode).Symbol;
var var2 = ((BoundIdentifierNode)assg.VariableIdentifierNode).Symbol;
Assert.IsTrue(ReferenceEquals(var1, var2));
}
public void CanAnalyseParamsWithStepsForProperty()
{
var code =
@"using System;
using MiniBench.Core;
namespace MiniBench.Tests
{
public class BlackholeTest
{
[ParamsWithSteps(start:1, end:10, step:1)]
public int SomeProperty { get; set; };
[Benchmark]
public void SimpleBenchmark() { }
}
}";
Console.WriteLine(code);
var syntaxTree = CSharpSyntaxTree.ParseText(code, options: parseOptions, encoding: defaultEncoding);
var results = new Analyser().AnalyseBenchmark(syntaxTree, "TestFile").ToList();
Assert.Equal(1, results.Count());
var benchmarkInfo = results.FirstOrDefault();
Assert.NotNull(benchmarkInfo);
Assert.Equal(new ParamsWithStepsAttribute(1, 10, 1), benchmarkInfo.ParamsWithSteps);
Assert.Null(benchmarkInfo.Params);
Assert.Equal("SomeProperty", benchmarkInfo.ParamsFieldName);
}
public void MultibleVariablesBindingTest()
{
const string Code =
@"
Var x = 1; ... decl1
Var y = x; ... decl2
";
Compilation tree = Analyser.Analyse(Code);
Assert.NotNull(tree);
var decl1 = tree !.Program.TopLevelStatementNodes[0] as VariableDeclarationStatementNode;
var decl2 = tree !.Program.TopLevelStatementNodes[1] as VariableDeclarationStatementNode;
Assert.NotNull(decl1);
Assert.NotNull(decl2);
var varX = decl1 !.VariableIdentifierNode as BoundIdentifierNode;
var varY = decl2 !.VariableIdentifierNode as BoundIdentifierNode;
Assert.NotNull(varX);
Assert.NotNull(varY);
var idX = decl2.AssignedExpressionNode as IdentifierExpressionNode;
Assert.NotNull(idX);
var boundIdX = idX !.IdentifierNode as BoundIdentifierNode;
Assert.IsTrue(ReferenceEquals(varX !.Symbol, boundIdX !.Symbol));
}
public void CanAnalyseSimpleBenchmark()
{
var code =
@"using System;
using MiniBench.Core;
namespace MiniBench.Tests
{
public class SimpleTest
{
[Benchmark]
public void SimpleBenchmark() {}
}
}";
Console.WriteLine(code);
var syntaxTree = CSharpSyntaxTree.ParseText(code, options: parseOptions, encoding: defaultEncoding);
var results = new Analyser().AnalyseBenchmark(syntaxTree, "TestFile").ToList();
Assert.Equal(1, results.Count());
var benchmarkInfo = results.FirstOrDefault();
Assert.NotNull(benchmarkInfo);
Assert.Equal("MiniBench.Tests", benchmarkInfo.NamespaceName);
Assert.Equal("SimpleTest", benchmarkInfo.ClassName);
Assert.Equal("SimpleBenchmark", benchmarkInfo.MethodName);
Assert.Equal("TestFile_MiniBench_Tests_SimpleTest_SimpleBenchmark", benchmarkInfo.GeneratedClassName);
Assert.Equal(false, benchmarkInfo.GenerateBlackhole);
Assert.Empty(benchmarkInfo.ParametersToInject);
Assert.Null(benchmarkInfo.ParamsWithSteps);
Assert.Null(benchmarkInfo.ParamsFieldName);
Assert.Null(benchmarkInfo.SetupMethod);
}
public void Test_ThreeOfAKind()
{
List <HandRank> rules = new List <HandRank>
{
HandRank.ThreeOfAKind,
HandRank.OnePair,
HandRank.Flush,
HandRank.HighCard,
};
Analyser analyser = new Analyser(rules);
List <Card> cards = new List <Card>
{
new Card(CardRank.Five, CardSuit.SPADE),
new Card(CardRank.Six, CardSuit.DIAMOND),
new Card(CardRank.Five, CardSuit.HEART),
new Card(CardRank.Five, CardSuit.CLUB),
new Card(CardRank.Queen, CardSuit.DIAMOND),
};
CardRank[] expected = { CardRank.Five, CardRank.Five, CardRank.Five,
CardRank.Queen, CardRank.Six };
PlayerHand playerHand = new PlayerHand(cards);
analyser.SetHandRank(playerHand);
Assert.IsTrue(playerHand.HandRank == HandRank.ThreeOfAKind);
for (int i = 0; i < playerHand.Cards.Count; i++)
{
Assert.IsTrue(playerHand.Cards[i].Rank == expected[i]);
}
}
public async Task RegisterSearchTextIsURLFalse()
{
try
{
var newGuid = Guid.NewGuid();
var testAnalyser = new Analyser()
{
SearchText = "oo",
IsURL = true,
IsPageFilterStopWords = true
};
_processManagerMock.Setup(x => x.IsURLValidAsync(It.IsAny <string>())).Returns(Task.FromResult <bool>(false))
.Verifiable();
var controller = new AnalyserController(_dataProviderMock.Object, _processManagerMock.Object, _exceptionManagerMock.Object, _logProviderMock.Object, _analysisManager);
_dataProviderMock.Verify();
IActionResult result = await controller.RegisterSearchText(testAnalyser);
var okObjectResult = result as OkObjectResult;
Assert.Null(okObjectResult);
}
catch (Exception)
{
Assert.True(false);
}
}
