protected override void Process(ProcessingContext context) { if (IsEnabled) { if (!_isEnabled || _interval != Interval) { _isEnabled = true; _interval = Interval; _disposable.Dispose(); _disposable = new NewThreadScheduler(start => new Thread(start) {IsBackground = true}).SchedulePeriodic(Interval, TimerCallback); context.DoNotPulseFurther = true; } else { if (_needUpdate) { Output = Input; _needUpdate = false; } else { context.DoNotPulseFurther = true; } } } else if (_isEnabled) { _isEnabled = false; _disposable.Dispose(); context.DoNotPulseFurther = true; } }
protected override void Process(ProcessingContext context) { using (var httpClient = new HttpClient()) { try { Result = httpClient.GetStringAsync(Uri).Result; } catch (Exception) { } } }
public IProcessingContextCollection GenerateProcessingContexts(KraftGlobalConfigurationSettings kraftGlobalConfigurationSettings, string kraftRequestFlagsKey, ISecurityModel securityModel = null) { InputModelParameters inputModelParameters = new InputModelParameters(); inputModelParameters.KraftGlobalConfigurationSettings = kraftGlobalConfigurationSettings; inputModelParameters.SecurityModel = securityModel; inputModelParameters.Module = _InputModel.Module; inputModelParameters.Nodeset = _InputModel.Nodeset; inputModelParameters.Nodepath = _InputModel.Nodepath; inputModelParameters.IsWriteOperation = _InputModel.IsWriteOperation; inputModelParameters.QueryCollection = _InputModel.QueryCollection; inputModelParameters.Data = _InputModel.Data; inputModelParameters.LoaderType = ELoaderType.DataLoader; IProcessingContext processingContext = new ProcessingContext(this); processingContext.InputModel = new InputModel(inputModelParameters); List <IProcessingContext> processingContexts = new List <IProcessingContext>(1); processingContexts.Add(processingContext); return(new ProcessingContextCollection(processingContexts)); }
public async Task ProcessAsync(ProcessingContext context) { _logger.LogDebug( $"Collecting expired data from collection [{_options.PublishedCollection}]."); var publishedCollection = _database.GetCollection <CapPublishedMessage>(_options.PublishedCollection); var receivedCollection = _database.GetCollection <CapReceivedMessage>(_options.ReceivedCollection); await publishedCollection.BulkWriteAsync(new[] { new DeleteManyModel <CapPublishedMessage>( Builders <CapPublishedMessage> .Filter.Lt(x => x.ExpiresAt, DateTime.Now)) }); await receivedCollection.BulkWriteAsync(new[] { new DeleteManyModel <CapReceivedMessage>( Builders <CapReceivedMessage> .Filter.Lt(x => x.ExpiresAt, DateTime.Now)) }); await context.WaitAsync(_waitingInterval); }
public override IProcessingContextCollection GenerateProcessingContexts(KraftGlobalConfigurationSettings kraftGlobalConfigurationSettings, string kraftRequestFlagsKey, ISecurityModel securityModel = null) { if (securityModel == null) { if (kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection.RequireAuthorization) { securityModel = new SecurityModel(_HttpContext); } else { securityModel = new SecurityModelMock(kraftGlobalConfigurationSettings.GeneralSettings.AuthorizationSection); } } InputModelParameters inputModelParameters = CreateBaseInputModelParameters(kraftGlobalConfigurationSettings, securityModel); inputModelParameters = ExtendInputModelParameters(inputModelParameters); inputModelParameters.Data = GetBodyJson <Dictionary <string, object> >(_HttpContext.Request); inputModelParameters.FormCollection = _FormCollection; inputModelParameters.LoaderType = GetLoaderType(kraftRequestFlagsKey); if (inputModelParameters.LoaderType == ELoaderType.None) { inputModelParameters.LoaderType = ELoaderType.ViewLoader; } RouteData routeData = _HttpContext.GetRouteData(); if (routeData != null) { inputModelParameters.BindingKey = routeData.Values[Constants.RouteSegmentConstants.RouteBindingkey] as string; } IProcessingContext processingContext = new ProcessingContext(this); processingContext.InputModel = new InputModel(inputModelParameters); List <IProcessingContext> processingContexts = new List <IProcessingContext>(1); processingContexts.Add(processingContext); _ProcessingContextCollection = new ProcessingContextCollection(processingContexts); return(_ProcessingContextCollection); }
public async Task Preprocessor_Go_Should_Add_BotProperties_For_Each_Bot() { // Arrange var arena = new ArenaDto { Width = 4, Height = 6 }; var bot = new BotDto { Id = Guid.NewGuid() }; var bots = new List <BotDto>(new[] { bot }); var processingContext = ProcessingContext.Build(arena, bots); var preprocessor = new Preprocessor(); // Act await preprocessor.Go(processingContext); // Assert var botProperties = processingContext.GetBotProperties(bot.Id); botProperties.Should().NotBeNull(); botProperties.BotId.Should().Be(bot.Id); processingContext.GetOrderedBotProperties().Should().HaveCount(1); }
public ShoreLineFillerTests() { var testData = new TestData(); _data = testData.GetData(); var shoreline1 = new List <Shoreline>() { new Shoreline() { GpsLat = 67.247207M, GpsLng = 22.887933M }, new Shoreline() { GpsLat = 67.248397M, GpsLng = 22.875103M } }; var shoreline2 = new List <Shoreline>() { }; _data.LocationSettings.Shoreline1 = shoreline1; _data.LocationSettings.Shoreline2 = shoreline2; }
public MainWindowViewModel(IUIVisualizerService uiVisualizerService, IPleaseWaitService pleaseWaitService, IMessageService messageService) { _uiVisualizerService = uiVisualizerService; _pleaseWaitService = pleaseWaitService; _messageService = messageService; ProvidersCollection = new ObservableCollection <ProviderModel>(); using (var db = new ProcessingContext()) { var res = from ap in db.AccessProviders join p in db.Providers on ap.Provider_id equals p.Id join u in db.Users on ap.User_id equals u.Id select new { p.Name, p.Logo }; foreach (var t in res) { ProvidersCollection.Add(new ProviderModel() { Name = t.Name, Logo = ConfigurationManager.AppSettings["images_folder"] + t.Logo }); } } }
private void OverwriteRequestedContent(ProcessingContext context) { StringBuilder pageContentBuilder = new StringBuilder("<!DOCTYPE html>"); pageContentBuilder.AppendLine("<html>"); pageContentBuilder.AppendLine("<head>"); pageContentBuilder.AppendLine(" <title>Hello</title>"); pageContentBuilder.AppendLine("</head>"); pageContentBuilder.AppendLine("<body>"); pageContentBuilder.AppendLine(" <h3>Hello, world!</h3>"); pageContentBuilder.AppendLine("</body>"); pageContentBuilder.AppendLine("</html>"); string pageContent = pageContentBuilder.ToString(); context.StopProcessing(); MemoryStream responseStream = new MemoryStream(Encoding.UTF8.GetBytes(pageContent)); var responseHeader = new BenderProxy.Headers.HttpResponseHeader(200, "OK", "1.1"); responseHeader.EntityHeaders.ContentType = "text/html"; responseHeader.EntityHeaders.ContentEncoding = "utf-8"; responseHeader.EntityHeaders.ContentLength = responseStream.Length; new HttpResponseWriter(context.ClientStream).Write(responseHeader, responseStream, responseStream.Length); }
public async Task ProcessCoreAsync(ProcessingContext context) { try { var worked = await Step(context); context.ThrowIfStopping(); Waiting = true; if (!worked) { var token = GetTokenToWaitOn(context); } await WaitHandleEx.WaitAnyAsync(WaitHandleEx.PulseEvent, context.CancellationToken.WaitHandle, _pollingDelay); } finally { Waiting = false; } }
public override void Process(ProcessingContext processingContext) { foreach (var sheet in processingContext.AvailableSheets) { foreach (var row in sheet.GetRows()) { foreach (var indicator in sheet.Indicators) { var groupKey = indicator.GroupColumn.GetCleanCell(row); var indicatorValue = indicator.GetGroupValue(groupKey); if (indicator.IsInclud(row, processingContext.ReferenceYear)) { indicatorValue.Increment(); if (indicator.AgregateFunction == AgregateFunction.Avg) { var value = decimal.Parse(indicator.ColumnToAgregate.GetCell(row)); indicatorValue.AddTotal(value); } } } } } }
public override void Process(ProcessingContext context) { var pixels = context.Result ?? context.Source; var result = new Color[pixels.Height(), pixels.Width()]; var energies = new int[pixels.Height(), pixels.Width()]; for (int y = 0; y < pixels.Height(); y++) { for (int x = 0; x < pixels.Width(); x++) { var pixel = pixels[y, x]; var neighbours = GetNeighbourPixels(pixels, x, y); energies[y, x] = CalculateEnergy(pixel, neighbours); } } var maxEnergy = energies.Cast <int>().Max(); for (int y = 0; y < pixels.Height(); y++) { for (int x = 0; x < pixels.Width(); x++) { var rgb = energies[y, x] * 255 / maxEnergy; var color = Color.FromArgb(rgb, rgb, rgb); result[y, x] = color; } } context.Result = result; ProcessNextIfNotNull(context); }
public void BasicPublish( ) { Solution solution = TestHelper.CreateSolution( ); using (var ctx = DatabaseContext.GetContext(true, preventPostSaveActionsPropagating: true)) { solution.Save(); ctx.CommitTransaction(); } List <IEntity> entities = TestHelper.PopulateBasicSolution(solution); var context = new ProcessingContext( ); AppManager.PublishApp(RunAsDefaultTenant.DefaultTenantName, TestHelper.DefaultSolutionName, context); Assert.IsNotNull(context); Assert.AreEqual(context.Report.FailedEntity.Count, 0); Assert.AreEqual(context.Report.FailedRelationship.Count, 0); Assert.AreEqual(context.Report.FailedEntityData.Count, 0); Assert.AreEqual(GetCount(context.Report, "SourceEntityCount"), GetCount(context.Report, "TargetEntityCount")); Assert.AreEqual(GetCount(context.Report, "SourceRelationshipCount"), GetCount(context.Report, "TargetRelationshipCount")); Assert.AreEqual(GetSourceDataCount(context.Report), GetTargetDataCount(context.Report)); Assert.Greater(GetCount(context.Report, "SourceEntityCount"), 4); // Solution + DummyType + 2 Instances Assert.Greater(GetCount(context.Report, "SourceRelationshipCount"), 23); // ( isOfType, inSolution, createdBy, modifiedBy, createdDate, modifiedDate ) * 4 - resourceInFolder Assert.Greater(GetCount(context.Report, "SourceEntityDataCount_NVarChar"), 8); // ( name, description ) * 4 List <Guid> addedEntities = context.Report.AddedEntities.Select(e => e.EntityId).ToList( ); foreach (IEntityInternal entity in entities.Select(e => e as IEntityInternal)) { Assert.Contains(entity.UpgradeId, addedEntities); } }
protected override void Process(ProcessingContext context) { if (IsEnabled) { var interval = Interval >= TimeSpan.FromMilliseconds(1) ? Interval : TimeSpan.FromMilliseconds(1); if (!_isEnabled || _interval != interval || _highPrecision != HighPrecision) { _isEnabled = true; _interval = interval; _highPrecision = HighPrecision; _disposable.Dispose(); if (HighPrecision) { _disposable = new NewThreadScheduler(start => new Thread(start) {IsBackground = true}).SchedulePeriodic(interval, TimerCallback); } else { Debug.WriteLine("Enable Timer"); _disposable = new Timer(state => TimerCallback(), null, interval, interval); } context.DoNotPulseFurther = true; } else { Counter++; TickTime = DateTimeOffset.Now; } } else if (_isEnabled) { Debug.WriteLine("Disable Timer"); _isEnabled = false; _disposable.Dispose(); context.DoNotPulseFurther = true; } }
public async Task Processor_Go_Should_Call_Into_The_BotProcessingFactory_For_Every_Bot_Provided() { // Arrange var botProcessingFactory = new Mock <IBotProcessingFactory>(); var processor = new Processor.Middleware.Processor(botProcessingFactory.Object); var arena = new ArenaDto(4, 6); var bot1 = new BotDto { Id = Guid.NewGuid() }; var bot2 = new BotDto { Id = Guid.NewGuid() }; var bot3 = new BotDto { Id = Guid.NewGuid() }; var bots = new List <BotDto>(new[] { bot1, bot2, bot3 }); var processingContext = ProcessingContext.Build(arena, bots); // Act await processor.Go(processingContext); // Assert botProcessingFactory.Verify(x => x.Process(It.IsAny <BotDto>(), It.IsAny <ProcessingContext>()), Times.Exactly(3)); }
public async Task BotProcessingFactory_Process_Without_Valid_Script_Should_Register_ScriptError() { // Arrange var botLogic = new Mock <IBotLogic>(); var botScriptCompiler = new Mock <IBotScriptCompiler>(); var botScriptCache = new Mock <IBotScriptCache>(); var logger = new Mock <ILogger>(); var botProcessingFactory = new BotProcessingFactory( botLogic.Object, botScriptCompiler.Object, botScriptCache.Object, logger.Object); var arena = new ArenaDto(4, 3); var bot = new BotDto { Id = Guid.NewGuid() }; var bots = new List <BotDto>(new[] { bot }); var context = ProcessingContext.Build(arena, bots); context.AddBotProperties(bot.Id, BotProperties.Build(bot, arena, bots)); // Act await botProcessingFactory.Process(bot, context); // Assert context.GetBotProperties(bot.Id).CurrentMove.Should().Be(PossibleMoves.ScriptError); }
public override void Process(ProcessingContext processingContext) { var allIndicators = this.indicatorProvider.GetAll() .ToList(); foreach (var sheet in processingContext.AvailableSheets) { var availableIndicators = new List <Indicator>(); var availableColumn = sheet.AvailableColumns.ToDictionary(x => x.Header.ToLowerInvariant()); foreach (var indicator in allIndicators) { if (this.TryMapIndicatorColumns(availableColumn, indicator, out var missingColumn)) { sheet.Indicators.Add(indicator); processingContext.Request.Indicators.Add(indicator); } else { this.PublishWarning($"L'indicateur '{indicator.Name}' ne sera pas calculé, il se base sur la colonne '{missingColumn}' qui est manquante dans l'onglet '{sheet.Name}'."); } } } }
public override void Execute(ProcessingContext context) { if (context.Range.RowCount() <= 1) { return; } var summ = GetFunc(); /*var lastAddress = Range.RangeAddress.LastAddress; * var summRow = Range.Worksheet.Range(lastAddress.RowNumber + 1, Range.RangeAddress.FirstAddress.ColumnNumber, * lastAddress.RowNumber + 1, lastAddress.ColumnNumber).Unsubscribed();*/ var summRow = context.Range.LastRow().Unsubscribed(); if (summ.FuncNum == 0) { summRow.Cell(summ.Column).Value = summ.Calculate((IDataSource)context.Value); } else if (summ.FuncNum > 0) { var funcRngAddr = context.Range.Offset(0, summ.Column - 1, context.Range.RowCount() - 1, 1).Unsubscribed().Column(1).Unsubscribed().RangeAddress; summRow.Cell(summ.Column).FormulaA1 = string.Format("Subtotal({0},{1})", summ.FuncNum, funcRngAddr.ToStringRelative()); } }
private ActionResult Processing_Uniteller(int claim, PaymentMode payment) { if (payment == null) { throw new ArgumentNullException("payment"); } PaymentBeforeProcessingResult result = BookingProvider.BeforePaymentProcessing(UrlLanguage.CurrentLanguage, payment.paymentparam); if (result == null) { throw new Exception("cannot get payment details"); } if (!result.success) { throw new Exception("payment details fail"); } ProcessingContext model = new ProcessingContext { Reservation = BookingProvider.GetReservationState(UrlLanguage.CurrentLanguage, claim), PaymentMode = payment, BeforePaymentResult = result }; return(base.View(@"PaymentSystems\Uniteller", model)); }
public async Task Process() { using var stopwatch = new SimpleStopwatch(); var arena = await _arenaLogic.GetArena(); var elapsedArena = stopwatch.ElapsedMilliseconds; var bots = await _botLogic.GetAllLiveBots(); var elapsedBots = stopwatch.ElapsedMilliseconds - elapsedArena; var context = ProcessingContext.Build(arena, bots); await _preprocessor.Go(context); var elapsedPreprocessing = stopwatch.ElapsedMilliseconds - elapsedBots - elapsedArena; await _processor.Go(context); var elapsedProcessing = stopwatch.ElapsedMilliseconds - elapsedPreprocessing - elapsedBots - elapsedArena; await _postprocessor.Go(context); var elapsedPostprocessing = stopwatch.ElapsedMilliseconds - elapsedProcessing - elapsedPreprocessing - elapsedBots - elapsedArena; await _botLogic.UpdateBots(context.Bots); var elapsedUpdateBots = stopwatch.ElapsedMilliseconds - elapsedPostprocessing - elapsedProcessing - elapsedPreprocessing - elapsedBots - elapsedArena; //await _messageLogic.CreateMessages(context.Messages); var elapsedCreateMessages = stopwatch.ElapsedMilliseconds - elapsedUpdateBots - elapsedPostprocessing - elapsedProcessing - elapsedPreprocessing - elapsedBots - elapsedArena; _logger.LogInformation("{elapsedArena}ms, {elapsedBots}ms, {elapsedPreprocessing}ms, {elapsedProcessing}ms, {elapsedPostprocessing}ms, {elapsedUpdateBots}ms, {elapsedCreateMessages}ms", elapsedArena, elapsedBots, elapsedPreprocessing, elapsedProcessing, elapsedPostprocessing, elapsedUpdateBots, elapsedCreateMessages); }
public void Execute(ProcessingContext context) { while (true) { var t = this.FirstOrDefault(x => x.Enabled); if (t == null) { break; } try { t.Execute(context); } catch (TemplateParseException ex) { _errors.Add(new TemplateError(ex.Message, ex.Range)); } finally { t.Enabled = false; } } }
protected override void Process(ProcessingContext context) { Value = $"{In0}{In1}{In2}{In3}{In4}{In5}{In6}{In7}{In8}{In9}"; }
public void Execute(ProcessingContext context) { context.Registers[X] = context.GetValue(X) % context.GetValue(Y); context.PC++; }
public RenderReportYukonInitial(ProcessingContext pc, RenderingContext rc, DateTime executionTimeStamp, ReportProcessing processing, IChunkFactory yukonCompiledDefinition) : base(pc, rc, processing) { this.m_executionTimeStamp = executionTimeStamp; this.m_yukonCompiledDefinition = yukonCompiledDefinition; }
private void SaveContext(ProcessingContext context) { Stage = context.Stage; ClientStream = context.ClientStream; ServerStream = context.ServerStream; RequestHeader = context.RequestHeader; ResponseHeader = context.ResponseHeader; ServerEndPoint = context.ServerEndPoint; _callbackWaitHandle.Set(); }
public override Resultset Get(QueryContext queryContext, object[] parameters) { DbDataReader reader = _dataTable.CreateDataReader(); ProcessingContext context = new ProcessingContext(reader); return new Resultset(new RowType(reader.GetSchemaTable()), context); }
public RenderReportYukon(ProcessingContext pc, RenderingContext rc, ReportProcessing processing) : base(pc, rc) { m_processing = processing; }
private Resultset CreateResultset(Stream stream, out string fileName, QueryContext queryContext) { DataTable dt = null; TextFileDataFormat format = queryContext.GetTextFileDataFormat(); fileName = null; if (stream is FileStream) { fileName = ((FileStream)stream).Name; dt = CreateRowType(fileName, ref format); } StreamReader reader = new StreamReader(stream, format.Encoding); if (dt == null || dt.Rows.Count == 0) { switch (format.TextFormat) { case TextDataFormat.Delimited: dt = CreateRowType(reader, format.Delimiter[0], format.ColumnNameHeader); break; case TextDataFormat.TabDelimited: dt = CreateRowType(reader, '\t', format.ColumnNameHeader); break; default: throw new ArgumentException("Delimiter"); } stream.Seek(0, SeekOrigin.Begin); reader = new StreamReader(stream, format.Encoding); } ProcessingContextBase context; if (format.SequentialProcessing) { if (format.TextFormat == TextDataFormat.FixedLength) context = new ProcessingContext(reader, format.Width, format.NullValue, format.ColumnNameHeader, GetNumberFormatInfo(format), GetDateTimeFormatInfo(format)); else context = new ProcessingContext(reader, format.Delimiter[0], format.NullValue, format.ColumnNameHeader, GetNumberFormatInfo(format), GetDateTimeFormatInfo(format)); } else { if (format.TextFormat == TextDataFormat.FixedLength) context = new ParallelProcessingContext(reader, format.Width, format.NullValue, format.ColumnNameHeader, GetNumberFormatInfo(format), GetDateTimeFormatInfo(format)); else context = new ParallelProcessingContext(reader, format.Delimiter[0], format.NullValue, format.ColumnNameHeader, GetNumberFormatInfo(format), GetDateTimeFormatInfo(format)); } return new Resultset(new RowType(dt), context); }
protected override void Process(ProcessingContext context) { Value = Left + Right; }
public override Resultset Get(QueryContext queryContext, object[] parameters) { RowType rt = CreateRowType(); ProcessingContext context = new ProcessingContext(this, parameters); return new Resultset(rt, context); }
/// <summary> /// Adds itself as an XML content into the WiX source being generated from the <see cref="WixSharp.Project"/>. /// See 'Wix#/samples/Extensions' sample for the details on how to implement this interface correctly. /// </summary> /// <param name="context">The context.</param> public void Process(ProcessingContext context) { context.Project.Include(WixExtension.Bal); context.XParent.Add(this.ToXElement("Variable")); }
/// <summary> /// Methods call when the node is activated. /// The other node connected to the input connector has activated his output link. /// </summary> /// <param name="context_"></param> /// <param name="slot_"></param> /// <returns></returns> public abstract ProcessingInfo ActivateLogic(ProcessingContext context_, NodeSlot slot_);
public async Task <IEnumerable <long> > GetIdsAsync(long startAfterId, int count, ProcessingContext processingContext) { return(await _accountRepository.GetAccountLegalEntitiesWithoutPublicHashId( startAfterId + 1, count)); }
public void Execute(ProcessingContext context) { context.Sound = context.GetValue(X); context.PC++; }
public ProcessReportOdpStreaming(IConfiguration configuration, ProcessingContext pc, AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, ErrorContext errorContext, ReportProcessing.StoreServerParameters storeServerParameters, GlobalIDOwnerCollection globalIDOwnerCollection, ExecutionLogContext executionLogContext, DateTime executionTime, IAbortHelper abortHelper) : base(configuration, pc, report, errorContext, storeServerParameters, globalIDOwnerCollection, executionLogContext, executionTime) { this.m_abortHelper = abortHelper; }
protected override void Process(ProcessingContext context) { }
protected override void Process(ProcessingContext context) { Result = Left + Right; }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="slot"></param> /// <returns></returns> public ProcessingInfo Activate(ProcessingContext context, NodeSlot slot) { State = ActivateLogic(context, slot); return(State); }
protected override void Process(ProcessingContext context) { Output = Input?.ToString(); Console.Out.WriteLine(Output); }
public async Task Postprocessor_Go_Should_Allow_A_Bot_To_Teleport_Onto_Another_Idling_Bot() { // Arrange var randomHelper = new Mock <IRandomHelper>(); var postprocessor = new Postprocessor(randomHelper.Object); var arena = new ArenaDto { Width = 4, Height = 1 }; var bot1 = new BotDto { Id = Guid.NewGuid(), X = 0, Y = 0, Orientation = PossibleOrientations.East, CurrentStamina = 15, CurrentHealth = 1 }; var bot2 = new BotDto { Id = Guid.NewGuid(), X = 3, Y = 0, Orientation = PossibleOrientations.West, CurrentStamina = 1, CurrentHealth = 1 }; var bots = new List <BotDto>(new[] { bot1, bot2 }); var context = ProcessingContext.Build(arena, bots); var bot1Properties = BotProperties.Build(bot1, arena, bots); var bot2Properties = BotProperties.Build(bot2, arena, bots); bot1Properties.CurrentMove = PossibleMoves.Teleport; bot1Properties.MoveDestinationX = 3; bot1Properties.MoveDestinationY = 0; bot2Properties.CurrentMove = PossibleMoves.Idling; context.AddBotProperties(bot1.Id, bot1Properties); context.AddBotProperties(bot2.Id, bot2Properties); // Act await postprocessor.Go(context); // Assert context.Bots.Should().HaveCount(2); context.Bots.Should().ContainEquivalentOf(new BotDto { X = 3, Y = 0, FromX = 0, FromY = 0, Orientation = PossibleOrientations.East, CurrentStamina = 15 - Constants.STAMINA_ON_TELEPORT, Move = PossibleMoves.Teleport }, c => c .Including(p => p.X) .Including(p => p.Y) .Including(p => p.FromX) .Including(p => p.FromY) .Including(p => p.Orientation) .Including(p => p.CurrentStamina) .Including(p => p.Move)); context.Bots.Should().ContainEquivalentOf(new BotDto { X = 0, Y = 0, Orientation = PossibleOrientations.West, CurrentStamina = 1, Move = PossibleMoves.Idling }, c => c.Including(p => p.X) .Including(p => p.Y) .Including(p => p.Orientation) .Including(p => p.CurrentStamina) .Including(p => p.Move)); }
public AstNode(ProcessingContext context, object o) { Context = context; Object = o; }
public void Process(ProcessingContext context) { Console.WriteLine("Generating complete shoreline..."); context.LocationSettings.Shoreline1 = GenerateCompleteShoreLine(context.LocationSettings.Shoreline1); context.LocationSettings.Shoreline2 = GenerateCompleteShoreLine(context.LocationSettings.Shoreline2); }
protected override void Process(ProcessingContext context) { Debug.WriteLine(I++); Value = _random.Next().ToString(); }