void ShouldCompressAndDecompress(IRunner runner, string streamName) { var inputFileName = WriteStreamToTempFile(streamName); var compressedFile = Path.GetTempFileName(); var decompressedFile = Path.GetTempFileName(); try { Options.TryParse(new[] { "compress", inputFileName, compressedFile }, Console.Out, out Options options).Should().BeTrue(); runner.Run(options); Options.TryParse(new[] { "decompress", compressedFile, decompressedFile }, Console.Out, out Options options2).Should().BeTrue(); runner.Run(options2); var inputBytes = File.ReadAllBytes(inputFileName); var decompressedBytes = File.ReadAllBytes(decompressedFile); CollectionAssert.AreEqual(inputBytes, decompressedBytes); } finally { DeleteFileIfExists(inputFileName); DeleteFileIfExists(compressedFile); DeleteFileIfExists(decompressedFile); } }
public async void SimpleFetchMultipleCriteriaTest(IRunner runner) { var inp = new SomeEntity { AnInt = 5, AString = "foo" }; await runner.Run(_logger, async db => { await db.InsertAsync(inp); var outp = await db.FetchAsync <SomeEntity>( Translator.ConjunctionWord.Or, x => x.AString == "foo2", x => x.AString == "foo"); Assert.Equal(new List <SomeEntity> { inp }, outp); }); await runner.Run(_logger, async db => { await db.InsertAsync(inp); var outp = await db.FetchAsync <SomeEntity>( Translator.ConjunctionWord.And, x => x.AString == "foo", x => x.AnInt == 5); Assert.Equal(new List <SomeEntity> { inp }, outp); }); }
private static FeatureResults Run(NBehaveConfiguration config) { IRunner runner = config.Build(); FeatureResults featureResults = runner.Run(); return(featureResults); }
static async Task Main(string[] args) { ServiceProvider serviceProvider = BuildServiceProvider(); IRunner runner = serviceProvider.GetService <IRunner>(); await runner.Run(CancellationToken.None); }
private void QueueStrategy(IRunner runner, string strategyPath, CancellationToken cancellationToken) { var ts = TaskScheduler.Default; var tco = TaskCreationOptions.LongRunning; Task.Factory.StartNew(() => runner.Run(strategyPath), cancellationToken, tco, ts); }
public async void FetchNothingWorksTest(IRunner runner) { await runner.Run(_logger, async db => { var outp = await db.FetchAsync <SomeEntity>(x => x.AString == "foo"); Assert.Equal(new List <SomeEntity>(), outp); }); }
public CmdDslTests() { _runner = Substitute.For <IRunner>(); _runner.Run(Arg.Any <IRunOptions>()).Returns("result"); _runner.GetCommand().Returns(new Commando(_runner)); cmd = new Cmd(_runner); }
protected T Parse <T>(IRunner runner, string data) where T : class { var captures = new List <Capture>(); var result = runner.Run(data, captures); if (result.IsSuccessful) { var iterator = new CaptureIterator <Expression>(data, captures); var output = BuildTree(iterator); if (output as T == null) { throw new PegParsingException($"Unable to parse PEG: {output}"); } return(output as T); } else { var near = data.Substring(result.InputPosition); if (near.Length > 10) { near = near.Substring(0, 10); } throw new PegParsingException($"Parsing error at character {result.InputPosition}. {runner.ExplainResult(result, data)} near {near}"); } }
/// <summary> /// Determines which analyzers to run, which rule sets to use (TODO) /// and invokes the runners. /// </summary> static IEnumerable <IViolation> RunAnalyzers(DotNetProject project, double work) { string dll = project.GetOutputFileName(ConfigurationSelector.Default); if (!File.Exists(dll)) { yield break; } LoadAnalyzersIfNeccessary(); if (analyzers.Count == 0) { yield break; } double analyzerWork = work / analyzers.Count; foreach (IAnalyzer analyzer in analyzers) { IEnumerable <IRule> ruleSet = GetRuleSet(project, analyzer.GetRuleLoader()); IRunner runner = analyzer.GetRunner(); IEnumerable <IViolation> violations = runner.Run(dll, ruleSet); foreach (IViolation vio in violations) { yield return(vio); } ResultsReporter.WorkComplete += analyzerWork; } }
public void Should_run_scenario() { var result = _runner.Run(); Assert.That(result.NumberOfFailingScenarios, Is.EqualTo(0)); Assert.That(result.NumberOfPendingScenarios, Is.EqualTo(0)); Assert.That(result.NumberOfPassingScenarios, Is.EqualTo(1)); }
public IActionResult Check(DescTraceTableViewModel viewModel) { viewModel.Row = viewModel.Row.Where(x => !string.IsNullOrEmpty(x)).ToList(); var answer = _runner.Run(viewModel.SourceCodeForCheck); answer = answer.Replace("\r\n", " ").Trim(); var userResult = string.Join(" ", viewModel.Row.Skip(viewModel.Variables.Count)).Trim(); var result = TestResults.WA; if (answer == userResult) { result = TestResults.Ok; } Guid.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier), out var userId); var solution = new Solution { Result = result, UserId = userId, Input = userResult, ProblemId = viewModel.Id, SendTime = DateTime.Now }; _solutionsService.Save(solution); return(RedirectToAction("Description", "Problems", new { viewModel.Id })); }
public IActionResult Check(DescCodeCorrectorViewModel viewModel) { var generator = _generators[viewModel.GeneratorType]; var input = generator.CreateData(); try { var problemId = viewModel.Id; Guid.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier), out var userId); var outPutRight = _runner.Run(viewModel.SourceCode, input).Trim('\n', '\r'); var result = TestResults.WA; var outPutUser = ""; try { outPutUser = _runner.Run(viewModel.IncorrectSourceCode, input).Trim('\n', '\r'); } catch { result = TestResults.CE; } if (result != TestResults.CE && outPutRight == outPutUser) { result = TestResults.Ok; } var solution = new Solution() { Result = result, UserId = userId, Input = viewModel.IncorrectSourceCode, ProblemId = problemId, SendTime = DateTime.Now }; _solutionsService.Save(solution); return(RedirectToAction("Description", "Problems", new { viewModel.Id })); } catch (Exception e) { return(View("Error", new ErrorViewModel() { RequestId = e.Message })); } }
public async void MultipleLinqConditions(IRunner runner) { var inp1 = new SomeEntity { AnInt = 5 }; var inp2 = new SomeEntity { AnInt = 6 }; var inp3 = new SomeEntity { AnInt = 7 }; var inp4 = new SomeEntity { AnInt = 8 }; var inp5 = new SomeEntity { AnInt = 9 }; await runner.Run(_logger, async db => { await db.InsertAsync(inp1); await db.InsertAsync(inp2); await db.InsertAsync(inp3); await db.InsertAsync(inp4); await db.InsertAsync(inp5); { int?minVal = 6; int?maxVal = 8; var outp = await db.FetchAsync <SomeEntity>(Translator.ConjunctionWord.And, x => !minVal.HasValue || x.AnInt >= minVal.Value, x => !maxVal.HasValue || x.AnInt <= maxVal.Value); Assert.Equal(new[] { 6, 7, 8 }, outp.Select(x => x.AnInt).OrderBy(x => x)); } { int?minVal = null; int?maxVal = 8; var outp = await db.FetchAsync <SomeEntity>(Translator.ConjunctionWord.And, x => !minVal.HasValue || x.AnInt >= minVal.Value, x => !maxVal.HasValue || x.AnInt <= maxVal.Value); Assert.Equal(new[] { 5, 6, 7, 8 }, outp.Select(x => x.AnInt).OrderBy(x => x)); } { int?minVal = 7; int?maxVal = null; var outp = await db.FetchAsync <SomeEntity>(Translator.ConjunctionWord.And, x => !minVal.HasValue || x.AnInt >= minVal.Value, x => !maxVal.HasValue || x.AnInt <= maxVal.Value); Assert.Equal(new[] { 7, 8, 9 }, outp.Select(x => x.AnInt).OrderBy(x => x)); } }); }
private void RunScriptIfNotEmpty(IRunner scriptRunner, LightScript script) { if (script.Commands.Count() > 0) { RunnerFactory.PassDependencies(TestData); scriptRunner.Run(script); } }
/// <summary> /// 根据模型定义参数执行存储过程进行查询,参数类型必须定义ReturnTypeAttribute特性 /// </summary> /// <typeparam name="TPrarmType">存储过程参数类型</typeparam> /// <param name="runner">执行器</param> /// <param name="db">数据上下文</param> /// <param name="data">存储过程参数</param> /// <returns>返回类型枚举FalconSPReturnTypeAttribute定义的类型枚举。</returns> public static IEnumerable <object> Run <TPrarmType>(this IRunner runner, DbContext db, TPrarmType data) { var dType = typeof(TPrarmType); var attr = dType.GetCustomAttribute <FalconSPReturnTypeAttribute>(); if (attr != null && attr is FalconSPReturnTypeAttribute pna && pna.ReturnType != null) { return(runner.Run(db, dType, pna.ReturnType, data)); }
private async Task Run(RunContext runContext, IDictionary <string, object> variables) { using (new DirectorySwitch(fileSystemOperations, runContext.WorkingDirectory)) { Message("Satisfying script requirements"); await SatisfyRequirements(runContext.Script, variables); await runner.Run(runContext.Script, variables); } }
private LockFile GetLockFile(string projectPath, string outputPath) { // Run the restore command string[] arguments = new[] { "restore", $"\"{projectPath}\"" }; var runStatus = runner.Run(Path.GetDirectoryName(projectPath), arguments); // Load the lock file string lockFilePath = Path.Combine(outputPath, "project.assets.json"); return(LockFileUtilities.GetLockFile(lockFilePath, NuGet.Common.NullLogger.Instance)); }
public bool Run(BehindCodeItem compileCode, string callModuleName, ISysDesign callModule, object sender, object eventArgs, string actName, string actTag, IBizDataItems sourceBizDatas, out IBizDataItems processBizDatas, bool isBuffer = true) { processBizDatas = null; if (_compilerObj == null) { _compilerObj = new Dictionary <string, IRunner>(); } if (_isAllowDebug) { _compilerObj.Remove(compileCode.FuncName); } IRunner runner = null; if (_compilerObj.ContainsKey(compileCode.FuncName)) { runner = _compilerObj[compileCode.FuncName]; } else { runner = CompilerCode(compileCode); if (isBuffer && _isAllowDebug == false) { //缓存编译对象 //调试状态不缓存编译对象 _compilerObj.Add(compileCode.FuncName, runner); } } if (runner != null) { IDBQuery thridDb = null; if (string.IsNullOrEmpty(compileCode.ThridDBAlias) == false) { string strErr = ""; thridDb = SqlHelper.GetThridDBHelper(compileCode.ThridDBAlias, _dbHelper, ref strErr); if (thridDb == null) { MessageBox.Show("动态方法 [" + compileCode.FuncName + "] 对应的数据源 [" + compileCode.ThridDBAlias + "] 链接对象创建失败," + strErr, "提示"); return(false); } } runner.Init(_winRelateModules, _dbHelper, thridDb, _userData, _stationInfo, _dataTransCenter, _owiner); return(runner.Run(callModuleName, callModule, sender, eventArgs, actName, actTag, sourceBizDatas, out processBizDatas)); } return(false); }
private void Check(IRunner runner, ToMemoryCheckNotifier toMemory) { try { runner.Run(Activator.RepositoryLocator, new FromCheckNotifierToDataLoadEventListener(toMemory), toMemory, new GracefulCancellationToken()); } catch (Exception e) { toMemory.OnCheckPerformed(new CheckEventArgs("Entire process crashed", CheckResult.Fail, e)); } }
public IActionResult Check(DescBlackBoxViewModel model) { var problemId = model.Id; Guid.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier), out var userId); var result = TestResults.WA; var userCode = model.Answer; var correctCode = model.SourceCode; var input = _generators[model.GeneratorType].CreateData(); var outPutRight = _runner.Run(correctCode, input).Trim('\n', '\r'); var outPutUser = ""; try { outPutUser = _runner.Run(userCode, input).Trim('\n', '\r'); } catch { result = TestResults.CE; } if (result != TestResults.CE && outPutRight == outPutUser) { result = TestResults.Ok; } var solution = new Solution { Result = result, UserId = userId, Input = userCode, ProblemId = problemId, SendTime = DateTime.Now }; _solutionsService.Save(solution); return(RedirectToAction("Description", "Problems", new { model.Id })); }
public IList <TRunDetail> Execute() { var stopwatch = Stopwatch.StartNew(); var iterationResults = new List <TRunDetail>(); do { var iterationStopwatch = Stopwatch.StartNew(); // get next pipeline var getPipelineStopwatch = Stopwatch.StartNew(); var pipeline = PipelineSuggester.GetNextInferredPipeline(_context, _history, _datasetColumnInfo, _task, _optimizingMetricInfo.IsMaximizing, _experimentSettings.CacheBeforeTrainer, _trainerAllowList); var pipelineInferenceTimeInSeconds = getPipelineStopwatch.Elapsed.TotalSeconds; // break if no candidates returned, means no valid pipeline available if (pipeline == null) { break; } // evaluate pipeline _logger.Trace($"Evaluating pipeline {pipeline.ToString()}"); (SuggestedPipelineRunDetail suggestedPipelineRunDetail, TRunDetail runDetail) = _runner.Run(pipeline, _modelDirectory, _history.Count + 1); _history.Add(suggestedPipelineRunDetail); WriteIterationLog(pipeline, suggestedPipelineRunDetail, iterationStopwatch); runDetail.RuntimeInSeconds = iterationStopwatch.Elapsed.TotalSeconds; runDetail.PipelineInferenceTimeInSeconds = getPipelineStopwatch.Elapsed.TotalSeconds; ReportProgress(runDetail); iterationResults.Add(runDetail); // if model is perfect, break if (_metricsAgent.IsModelPerfect(suggestedPipelineRunDetail.Score)) { break; } // If after third run, all runs have failed so far, throw exception if (_history.Count() == 3 && _history.All(r => !r.RunSucceeded)) { throw new InvalidOperationException($"Training failed with the exception: {_history.Last().Exception}"); } } while (_history.Count < _experimentSettings.MaxModels && !_experimentSettings.CancellationToken.IsCancellationRequested && stopwatch.Elapsed.TotalSeconds < _experimentSettings.MaxExperimentTimeInSeconds); return(iterationResults); }
public async void SimpleInsertTest(IRunner runner) { var inp = new SomeEntity { AnInt = 5, AString = "foo" }; await runner.Run(_logger, async db => { await db.InsertAsync(inp); Assert.Equal(1, await db.ExecuteScalarAsync <int>("select count(*) from SomeEntity")); Assert.NotEqual(0, inp.Id); }); }
public void SetUp() { var scenarioText = "Feature: Config file support" + Environment.NewLine + "Scenario: Reading values from a config file" + Environment.NewLine + "Given an assembly with a matching configuration file" + Environment.NewLine + "When the value of setting foo is read" + Environment.NewLine + "Then the value should be meeble"; SetupConfigFile(); runner = CreateTextRunner(new[] { Path.Combine(GetAssemblyLocation(), "TestLib.dll") }, scenarioText); results = runner.Run(); }
protected async Task Run(string path, IDictionary <string, object> variables) { var script = Compiler.Compile(path); var workingDirectory = Path.GetDirectoryName(path); using (new DirectorySwitch(FileSystemOperations, workingDirectory)) { Message("Satisfying script requirements"); await SatisfyRequirements(script, variables); await Runner.Run(script, variables); } }
public void SetUp() { var scenarioText = "Feature: Config file support\r\n" + "Scenario: Reading values from a config file\r\n" + "Given an assembly with a matching configuration file\r\n" + "When the value of setting foo is read\r\n" + "Then the value should be meeble"; SetupConfigFile(); runner = CreateTextRunner(new[] { "TestPlainTextAssembly.dll" }, scenarioText); results = runner.Run(); }
public async void SimpleNotExistsTest(IRunner runner) { var inp = new SomeEntity { AnInt = 5, AString = "foo1" }; await runner.Run(_logger, async db => { await db.InsertAsync(inp); Assert.False(await db.ExistsAsync <SomeEntity>(x => x.AString == "foo")); }); }
public void ShouldRunTheCommandAgainstCmd() { IRunOptions expectedRunOptions = null; _runner.Run(Arg.Any <IRunOptions>()) .ReturnsForAnyArgs("") .AndDoes(info => expectedRunOptions = info.Arg <IRunOptions>()); cmd.dir(); Assert.Equal("cmd", expectedRunOptions.Command); Assert.Equal("/c dir", expectedRunOptions.Arguments); }
public void ShouldBeAbleToGetOutputFromCommand() { _runner.Run(Arg.Any <IRunOptions>()).Returns("out"); var output = cmd.git(); Assert.Equal(output, "out"); }
public async void IsNullSingleTest(IRunner runner) { var inp = new SomeEntity { AnInt = 5, AString = "foo" }; await runner.Run(_logger, async db => { await db.InsertAsync(inp); var outp = await db.SingleAsync <SomeEntity>(x => x.NullableInt == null); Assert.Equal(inp, outp); }); }
public int CompareTo(IRunner runner) { float time1 = this.Run(100); float time2 = runner.Run(100); if (time1 > time2) { return(1); } else if (time1 < time2) { return(-1); } return(0); }
protected override void Because() { base.Because(); var statLightConfigurationFactory = new StatLightConfigurationFactory(_testLogger); var statLightConfiguration = statLightConfigurationFactory.GetStatLightConfigurationForXap( ClientTestRunConfiguration.UnitTestProviderType, _pathToIntegrationTestXap, MSTestVersion, ClientTestRunConfiguration.MethodsToTest, ClientTestRunConfiguration.TagFilter, 1, false, "", StatLight.Core.WebBrowser.WebBrowserType.SelfHosted, forceBrowserStart:true, showTestingBrowserHost:false); //bool showTestingBrowserHost = statLightConfiguration.Server.XapHostType == XapHostType.MSTestApril2010; _testLogger.Debug("Setting up xaphost {0}".FormatWith(statLightConfiguration.Server.XapHostType)); Runner = _statLightRunnerFactory.CreateOnetimeConsoleRunner(statLightConfiguration); TestReport = Runner.Run(); }
public void SetUp() { var writer = new XmlTextWriter(new MemoryStream(), Encoding.UTF8); var listener = new XmlOutputEventListener(writer); const string scenarioText = "Feature: " + FeatureTitle + "\r\n" + "Scenario: Reading values from a config file\r\n" + "Given an assembly with a matching configuration file\r\n" + "When the value of setting foo is read\r\n" + "Then the value should be bar"; SetupConfigFile(); runner = CreateTextRunner(new[] { "TestPlainTextAssembly.dll" }, listener, scenarioText); results = runner.Run(); xmlOut = new XmlDocument(); writer.BaseStream.Seek(0, SeekOrigin.Begin); xmlOut.Load(writer.BaseStream); }
public void SetUp() { var scenarioText = "Feature: Config file support\r\n" + "Scenario: Reading values from a config file\r\n" + "Given an assembly with a matching configuration file\r\n" + "When the value of setting foo is read\r\n" + "Then the value should be bar"; SetupConfigFile(); runner = CreateTextRunner(new[] { "TestPlainTextAssembly.dll" }, scenarioText); results = runner.Run(); }
private Task Start(IRunner runner) { return Task.Run(() => runner.Run(_tokenSource), CancellationToken.None); }