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); } }