public void TestContinueWith2(AnalysisStrategy strategy) { var task = Task<string>.Factory.StartNew(() => { return "hello"; }); var task2 = task.ContinueWith((t) => t.Result + " ben"); task2.Wait(); Assert.IsTrue(task2.Result.Equals("hello ben")); }
public void AnalyzeSimpleSolution2(AnalysisStrategy strategy) { var callgraph = GenerateCallGraph(50); var syntax = GenerateCode(callgraph); var code = syntax.ToFullString(); Logger.Instance.Log("CallGraphGenerator", "AnalyzeSimpleSolution2", code); var solution = ReachingTypeAnalysis.Utils.CreateSolution(code); Logger.Instance.Log("CallGraphGenerator", "AnalyzeSimpleSolution2", solution.FilePath); var solAnalyzer = new SolutionAnalyzer(solution); solAnalyzer.Analyze(strategy); var resolved = solAnalyzer.GenerateCallGraph(); var resolvedNodes = resolved.GetNodes().Count(); var callgraphNodes = callgraph.GetNodes().Count(); Assert.IsTrue(resolvedNodes == callgraphNodes); var resolveEdgeCount = resolved.GetEdges().Count(); var callgraphEdgeCount = callgraph.GetEdges().Count(); foreach (var node in resolved.GetNodes()) { //var callees = callgraph.GetCallees(node.Name); var callees = callgraph.GetCallees(node.MethodName); var resolvedCallees = resolved.GetCallees(node); Assert.IsTrue(callees.Count() == resolvedCallees.Count(), "Mismatched callee counts for " + node); } Assert.IsTrue(resolved.GetEdges().Count() == callgraph.GetEdges().Count()); }
public IChartResults LoadChartsData(AnalysisParametersModel parameters, IAnalysisResult analysisResult) { SetAnalysisStrategy(parameters.AnalysisMethod); var data = ImportService.LoadDataByImportId(parameters.ImportIds); var headers = ImportService.LoadImportHeadersById(parameters.MainHeadersId); return(AnalysisStrategy.LoadChartsData(headers, data, analysisResult)); }
private void modifyBarButtonItem_ItemClick(object sender, ItemClickEventArgs e) { List <AnalysisStrategy> strategyList = this.controller.XMLDeserializeAnalysisStrategy(); int index = this.galleryItemGroup.Items.IndexOf(this.activatedGalleryItem); AnalysisStrategy strategy = strategyList[index]; InitStrategyOptionDialog(strategy, index); // modify both dropdown1 groups and strategy bar groups }
public AnalysisStrategyOptionForm(AnalysisStrategy strategy, int strategyIndex) { this.Strategy = strategy; this.strategyIndex = strategyIndex; InitializeComponent(); InitConfigureTabPanel(); InitTreeList(); InitGeneralData(strategy); InitFactorGridView(); InitController(); }
public void setDefaultStrategyList() { this.strategyList.Clear(); AnalysisStrategy strategy = new AnalysisStrategy(); string strategyName = StaticResource.defaultStrategyNameStr; string description = StaticResource.defaultStrategDescripStr; int testRounds = 1; strategy.initStrategyInfo(strategyName, description, testRounds); this.strategyList.Add(strategy); }
private void InitGeneralData(AnalysisStrategy strategy) { this.strategyNameTextEdit.Text = strategy.StrategyName; this.strategyDescTextEdit.Text = strategy.StrategyDescription; this.testRoudsSpinEdit.Value = strategy.TestRounds; // init the platform weight choose Type platformWeightSetType = strategy.PlatformWeightSetMethod.Value.GetType(); this.platformWeightRadioGroup.SelectedIndex = StrategyOptionMapping.PlatformWeightSetTypeDict[platformWeightSetType]; Type platformAssignType = strategy.PlatformAssignMethod.Value.GetType(); this.platformAssignRadioGroup.SelectedIndex = StrategyOptionMapping.PlatformAssignTypeDict[platformAssignType]; }
private void createBarButtonItem_ItemClick(object sender, ItemClickEventArgs e) { int index = this.controller.project.StrategyList.Count; AnalysisStrategy strategy = new AnalysisStrategy(); string strategyName = "Strategy" + index; string description = "Strategy" + index + " setting"; int testRounds = 1; strategy.initStrategyInfo(strategyName, description, testRounds); this.controller.project.StrategyList.Add(strategy); this.controller.XMLSerializeAnalysisStrategyList(this.controller.project.StrategyList); this.galleryItemGroup.Items.Add(new GalleryItem(null, strategyName, description)); updateDropDownGroups(); }
private void applayStrategy(int index) { if (!isTestSetGenerated) { isTestSetGenerated = true; this.chartTypeRibbenGroup.Enabled = true; this.iSave.Enabled = true; this.iSaveAs.Enabled = true; } List <AnalysisStrategy> strategyList = this.controller.XMLDeserializeAnalysisStrategy(); AnalysisStrategy strategy = strategyList[index]; List <Dictionary <string, Dictionary <string, string> > > testSet = strategy.startAnalysis(); this.testSetGridviewShow(); this.presentDataInTestSetGrid(testSet); isTestSetGenerated = false; }
public override void Flush(ReportAggregates reportAggregates) { if (reportAggregates.TestList == null || reportAggregates.TestList.Count == 0) { return; } this._reportAggregates = reportAggregates; var filter = Builders <BsonDocument> .Filter.Eq("_id", ReportId); var update = Builders <BsonDocument> .Update .Set("endTime", DateTime.Now) .Set("duration", (DateTime.Now - _startTime).Milliseconds) .Set("status", StatusHierarchy.GetHighestStatus(reportAggregates.StatusList).ToString().ToLower()) .Set("parentLength", reportAggregates.ReportStatusStats.ParentCount) .Set("passParentLength", reportAggregates.ReportStatusStats.ParentCountPass) .Set("failParentLength", reportAggregates.ReportStatusStats.ParentCountFail) .Set("fatalParentLength", reportAggregates.ReportStatusStats.ParentCountFatal) .Set("errorParentLength", reportAggregates.ReportStatusStats.ParentCountError) .Set("warningParentLength", reportAggregates.ReportStatusStats.ParentCountWarning) .Set("skipParentLength", reportAggregates.ReportStatusStats.ParentCountSkip) .Set("exceptionsParentLength", reportAggregates.ReportStatusStats.ParentCountExceptions) .Set("childLength", reportAggregates.ReportStatusStats.ChildCount) .Set("passChildLength", reportAggregates.ReportStatusStats.ChildCountPass) .Set("failChildLength", reportAggregates.ReportStatusStats.ChildCountFail) .Set("fatalChildLength", reportAggregates.ReportStatusStats.ChildCountFatal) .Set("errorChildLength", reportAggregates.ReportStatusStats.ChildCountError) .Set("warningChildLength", reportAggregates.ReportStatusStats.ChildCountWarning) .Set("skipChildLength", reportAggregates.ReportStatusStats.ChildCountSkip) .Set("infoChildLength", reportAggregates.ReportStatusStats.ChildCountInfo) .Set("exceptionsChildLength", reportAggregates.ReportStatusStats.ChildCountExceptions) .Set("grandChildLength", reportAggregates.ReportStatusStats.GrandChildCount) .Set("passGrandChildLength", reportAggregates.ReportStatusStats.GrandChildCountPass) .Set("failGrandChildLength", reportAggregates.ReportStatusStats.GrandChildCountFail) .Set("fatalGrandChildLength", reportAggregates.ReportStatusStats.GrandChildCountFatal) .Set("errorGrandChildLength", reportAggregates.ReportStatusStats.GrandChildCountError) .Set("warningGrandChildLength", reportAggregates.ReportStatusStats.GrandChildCountWarning) .Set("skipGrandChildLength", reportAggregates.ReportStatusStats.GrandChildCountSkip) .Set("exceptionsGrandChildLength", reportAggregates.ReportStatusStats.GrandChildCountExceptions) .Set("analysisStrategy", AnalysisStrategy.ToString().ToUpper()); _reportCollection.UpdateOne(filter, update); InsertUpdateSystemAttribute(); }
public IAnalysisResult AnalyzeData(AnalysisParametersModel parameters) { SetAnalysisStrategy(parameters.AnalysisMethod); var data = ImportService.LoadDataByImportId(parameters.ImportIds); var headers = ImportService.LoadImportHeadersById(parameters.MainHeadersId); var analysisHistory = new AnalysisHistory { AnalysisDate = DateTime.Now }; var analysisData = data.GroupBy(d => d.Header.Import).Select(g => new AnalysisData { AnalysisHistory = analysisHistory, Import = g.Key }).ToList(); AnalysisRepository.SaveAnalysis(analysisHistory, analysisData); return(AnalysisStrategy.AnalyzeData(headers, data, parameters.Args)); }
public List <AnalysisStrategy> XMLDeserializeAnalysisStrategy() { List <AnalysisStrategy> strategyList = new List <AnalysisStrategy>(); List <string> fileList = this.getXMLFileList(workFolder + strategyFileFoder); if (fileList.Count > 0) { foreach (string file in fileList) { try { Stream stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read); AnalysisStrategy strategy = analysisStrategySerializer.Deserialize(stream) as AnalysisStrategy; // we need to reload the variable relation in strategy if (this.project != null) { strategy.updateData(this.project); } strategyList.Add(strategy); stream.Close(); } catch (Exception e) { MessageBox.Show(e.StackTrace); } } } else { // configure file do not exsit ,just create and use the default strategy this.project.setDefaultStrategyList(); this.XMLSerializeAnalysisStrategyList(this.project.StrategyList); strategyList = this.project.StrategyList; } return(strategyList); }
public SessionStatusStats(AnalysisStrategy strategy) { _strategy = strategy; }
/// <summary> /// IMPORTANT: OnDemandSolvers need an OnDemand Dispatcher /// We cannot use the SyncronousDistacther because it doesn't look for the /// methods when they are not available. This only works with the entire solution /// analysis!!!! /// </summary> /// <param name="dispatcher"></param> public void Analyze(AnalysisStrategy strategy = AnalysisStrategy.NONE) { if (strategy == AnalysisStrategy.NONE) { strategy = ConvertToEnum(ConfigurationManager.AppSettings["Strategy"]); } // TOOD: hack -- set the global solution ProjectCodeProvider.Solution = this.Solution; switch (strategy) { case AnalysisStrategy.ONDEMAND_SYNC: { this.Dispatcher = new OnDemandSyncDispatcher(); AnalyzeOnDemand(); break; } case AnalysisStrategy.ENTIRE_SYNC: { this.Dispatcher = new SynchronousLocalDispatcher(); AnalyzeEntireSolution(); break; } case AnalysisStrategy.ONDEMAND_ASYNC: { //this.Dispatcher = new QueueingDispatcher(this.Solution); this.Dispatcher = new AsyncDispatcher(); AnalyzeOnDemandAsync(AnalysisStrategy.ONDEMAND_ASYNC).Wait(); break; } case AnalysisStrategy.ONDEMAND_ORLEANS: { //var applicationPath = AppDomain.CurrentDomain.BaseDirectory; var orleansPath = System.Environment.GetEnvironmentVariable("ORLEANSSDK"); //@"C:\Microsoft Project Orleans SDK v1.0\SDK\LocalSilo\Applications\ReachingTypeAnalysis"; var applicationPath = Path.Combine(Path.Combine(orleansPath, @"LocalSilo\Applications"), "ReachingTypeAnalysis"); var appDomainSetup = new AppDomainSetup { AppDomainInitializer = InitSilo, //ApplicationBase = AppDomain.CurrentDomain.BaseDirectory, ApplicationBase = applicationPath, ApplicationName = "ReachingTypeAnalysis", AppDomainInitializerArguments = new string[] { }, ConfigurationFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ReachingTypeAnalysis.exe.config") }; // set up the Orleans silo var hostDomain = AppDomain.CreateDomain("OrleansHost", null,appDomainSetup); var xmlConfig = "DevTestClientConfiguration.xml"; Contract.Assert(File.Exists(xmlConfig), "Can't find " + xmlConfig); try { GrainClient.Initialize(xmlConfig); Logger.Instance.Log("SolutionAnalyzer", "Analyze", "Orleans silo initialized"); } catch (Exception e) { Logger.Instance.Log("SolutionAnalyzer", "Analyze", e.Message); throw e; //break; } // Create a Grain for the solution ISolutionGrain solutionGrain = SolutionGrainFactory.GetGrain("Solution"); if (SourceCode != null) { solutionGrain.SetSolutionSource(SourceCode).Wait(); IProjectCodeProviderGrain projectGrain = ProjectCodeProviderGrainFactory.GetGrain("MyProject"); projectGrain.SetProjectSourceCode(SourceCode); } else { Contract.Assert(Solution.FilePath!=null); solutionGrain.SetSolutionPath(this.Solution.FilePath).Wait(); foreach(var project in this.Solution.Projects) { IProjectCodeProviderGrain projectGrain = ProjectCodeProviderGrainFactory.GetGrain(project.Name); projectGrain.SetProjectPath(project.FilePath).Wait(); } } // make a dispatcher this.Dispatcher = new OrleansDispatcher(); // run AnalyzeOnDemandAsync(AnalysisStrategy.ONDEMAND_ORLEANS).Wait(); break; } case AnalysisStrategy.ENTIRE_ASYNC: { //this.Dispatcher = new QueueingDispatcher(this.Solution); this.Dispatcher = new AsyncDispatcher(); AnalyzeEntireSolutionAsync(); break; } default: { throw new ArgumentException("Unknown value for Solver " + ConfigurationManager.AppSettings["Solver"]); } } }
private static void AnalyzeExample(string source, RunChecks checker, AnalysisStrategy strategy = AnalysisStrategy.NONE) { //var solution = ReachingTypeAnalysis.Utils.CreateSolution(source); //var solAnalyzer = new SolutionAnalyzer(solution); var solAnalyzer = new SolutionAnalyzer(source); solAnalyzer.Analyze(strategy); var callgraph = solAnalyzer.GenerateCallGraph(); checker(solAnalyzer, callgraph); }
private static void AnalizeSolution(Solution solution, RunChecks checker, AnalysisStrategy type = AnalysisStrategy.NONE) { var solAnalyzer = new SolutionAnalyzer(solution); solAnalyzer.Analyze(type); var callgraph = solAnalyzer.GenerateCallGraph(); checker(solAnalyzer, callgraph); }
void InitStrategyOptionDialog(AnalysisStrategy strategy, int index) { strategyOptionForm = new AnalysisStrategyOptionForm(strategy, index); strategyOptionForm.ShowDialog(this); }
protected void SetAnalysisStrategy(AnalysisStrategy strategy) { _strategy = strategy; _sessionStatusStats = new SessionStatusStats(strategy); }
/// <summary> /// Try to get the roslyn methods on the fly /// Currently works with one project. /// </summary> public async Task AnalyzeOnDemandAsync(AnalysisStrategy strategy) { Contract.Assert(this.Dispatcher != null); var cancellationSource = new CancellationTokenSource(); var triple = await ProjectCodeProvider.GetProviderContainingEntryPointAsync(this.Solution, cancellationSource.Token); if (triple != null) { // cancel out outstanding processing tasks //cancellationSource.Cancel(); var provider = triple.Item1; var mainSymbol = triple.Item2; var tree = triple.Item3; var model = provider.Compilation.GetSemanticModel(tree); var methodVisitor = new MethodSyntaxProcessor(model, tree, mainSymbol); //var mainMethodEntity = methodVisitor.ParseMethod(); var mainMethodDescriptor = Utils.CreateMethodDescriptor(mainSymbol); var mainMethodEntityDescriptor = EntityFactory.Create(mainMethodDescriptor, this.Dispatcher); IEntityProcessor mainMethodEntityProcessor = null; switch(strategy) { case AnalysisStrategy.ONDEMAND_ORLEANS: var methodEntityGrain = await OrleansDispatcher.CreateMethodEntityGrain((OrleansEntityDescriptor)mainMethodEntityDescriptor); // Option 1: Direcly using the Grain await methodEntityGrain.DoAnalysisAsync(); // Option 2: Using the processor (requires making the processor serializable) //mainMethodEntityProcessor = await methodEntityGrain.GetEntityWithProcessorAsync(); //await mainMethodEntityProcessor.DoAnalysisAsync(); break; case AnalysisStrategy.ONDEMAND_ASYNC: mainMethodEntityProcessor = await this.Dispatcher.GetEntityWithProcessorAsync(mainMethodEntityDescriptor); var mainMethodEntity = ((MethodEntityProcessor)mainMethodEntityProcessor).MethodEntity; this.Dispatcher.RegisterEntity(mainMethodEntity.EntityDescriptor, mainMethodEntity); await mainMethodEntityProcessor.DoAnalysisAsync(); break; } //await Task.WhenAll(mainMethodEntityProcessor.DoAnalysisAsync()); //Thread.Sleep(1000); Logger.Instance.Log("SolutionAnalyzer", "AnalyzeOnDemandAsync", "--- Done with propagation ---"); } }
public void AnalyzeLast <TPatientKey>(Patient <TPatientKey> patient) where TPatientKey : IEquatable <TPatientKey> { AnalysisResult = AnalysisStrategy.AnalyzeLast(patient); }
public void TestTaskStart(AnalysisStrategy strategy) { var task = Task<string>.Factory.StartNew(() => { return "hello"; }); Assert.IsTrue(task.Result.Equals("hello")); }
public void Analyze <TPatientKey>(HealthMeasurement <Guid, Guid> healthState, Patient <TPatientKey> patient) where TPatientKey : IEquatable <TPatientKey> { AnalysisResult = AnalysisStrategy.Analyze <Guid>(healthState, patient as Patient <Guid>); }