private void animatePaths(IterationContext itCtx)
{
int tmp, tmp1;
double width, prev;
for (int i = 0; i < itCtx.pheromoneMatrix.size; ++i)
{
tmp = cityControler.activeCitysIndex[i];
for (int j = i + 1; j < itCtx.pheromoneMatrix.size; ++j)
{
tmp1 = cityControler.activeCitysIndex[j];
if (!pathControler.pathMatrix[tmp, tmp1])
{
continue;
}
if (pheromons != null)
{
prev = pheromons[i, j];
}
else
{
prev = 0;
}
width = Mathf.Lerp((float)prev, (float)itCtx.pheromoneMatrix[i, j],
(lengthOfAnimation - timeLeft) / lengthOfAnimation);
pathControler.pathMatrix[tmp, tmp1].startWidth = (float)width;
pathControler.pathMatrix[tmp, tmp1].endWidth = (float)width;
}
}
}
private static Dictionary <string, string> BuildResponse(
IterationContext context,
string description,
HttpRequestMessage request,
DateTime startTime,
DateTime endTime,
Stopwatch timer,
string statusCode,
string content,
string errorMessage = "")
{
return(new Dictionary <string, string>
{
{ "WorkerIndex", context.WorkerIndex.ToString() },
{ "IterationIndex", context.IterationIndex.ToString() },
{ "Description", description },
{ "StartTime", startTime.ToLongTimeString() },
{ "EndTime", endTime.ToLongTimeString() },
{ "RequestUrl", request.RequestUri.AbsoluteUri },
{ "StatusCode", statusCode },
{ "ResponseTime", timer.ElapsedMilliseconds.ToString() },
{ "Content", content },
{ "ErrorMessage", errorMessage }
});
}
public static void Run(
IterationContext context,
Step step,
CancellationToken cancellationToken)
{
var client = context.Environment["HttpClient"] as HttpClient;
var httpRequestStep = step as HttpRequestsStep;
var requestTasks = httpRequestStep.Requests
.Select(r => Task.Run(
() =>
{
var response = HttpRequestsStepRunner.RunHttpRequest(
context,
client,
r.Description,
r.GetHttpRequest(context),
cancellationToken);
var extractedContent = r.ExtractContentToEnvironment(context, response);
return(new
{
Response = response,
ExtractedContent = extractedContent
});
}))
.ToArray();
Task.WaitAll(requestTasks);
AddContentExtractsToEnvironment(
context,
requestTasks
.Select(r => r.Result.ExtractedContent));
}
public override string GetComponentVariableName(IIteratorStackModel query, TypeHandle componentVariableType)
{
// TODO forward to parent if necessary
return(query == IterationContext.Query
? IterationContext.GetComponentDataName(componentVariableType.Resolve(IterationContext.Stencil))
: Parent.GetComponentVariableName(query, componentVariableType));
}
protected override IDictionary <string, string> GetFormParameters(IterationContext context)
{
var formParameters = base.GetFormParameters(context);
formParameters.SafeAdd(RequestVerificationTokenName,
context.Environment[LoadTestEnvironmentKeys.RequestVerificationToken] as string);
return(formParameters);
}
private static void AddContentExtractsToEnvironment(IterationContext context, IEnumerable <IDictionary <string, object> > contentExtracts)
{
foreach (var contentExtract in contentExtracts)
{
foreach (var key in contentExtract.Keys)
{
context.Environment.SafeAdd(key, contentExtract[key]);
}
}
}
public override HttpRequestMessage GetHttpRequest(IterationContext context)
{
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = this.GetRequestUri(context),
Content = this.GetContent(context)
};
ModifyRequestBeforeSending(request);
return(request);
}
private static HttpClient BuildClient(IterationContext context)
{
var handler = new HttpClientHandler
{
CookieContainer = new CookieContainer()
};
var client = new HttpClient(handler)
{
Timeout = new TimeSpan(0, 20, 0),
BaseAddress = new Uri(context.Environment[LoadTestEnvironmentKeys.BaseUrl] as string, UriKind.Absolute)
};
client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("Firefox", "33"));
client.DefaultRequestHeaders.Add("X-MK6LoadTest", "1");
return(client);
}
// TODO: Redesign validator so it uses actual handlers.
/// <summary>
/// Validates ILoadTest scenario correctness by executing single test iteration
/// from ScenarioSetup to ScenarioTearDown on the same thread.
/// Exceptions are not handled on purpose to ease problem identification while developing.
/// </summary>
/// <param name="scenario">ILoadTestScenario object</param>
/// <param name="threadId">TheardId to set in TestContext</param>
/// <param name="threadIterationId">ThreadIterationId to set in TestContext</param>
/// <param name="globalIterationId">GlobalIterationId to set in TestContext</param>
/// <returns>Raw result from single iteration</returns>
public static IterationResult Validate(this IScenario scenario, int threadId = 0, int threadIterationId = 0, int globalIterationId = 0)
{
ExecutionTimer timer = new ExecutionTimer();
ThreadSafeCounter errorsCounter = new ThreadSafeCounter();
GlobalCounters globalCounters = new GlobalCounters(errorsCounter, new MockedIdGenerator(globalIterationId));
IIterationControl context = new IterationContext(threadId, timer);
ScenarioHandler handler = new ScenarioHandler(globalCounters, new MockedIdGenerator(threadIterationId), scenario, context);
timer.Start();
handler.Init();
handler.PrepareNext();
handler.Execute();
IterationResult result = new IterationResult(context, new WorkerThreadStats());
handler.Cleanup();
timer.Stop();
return(result);
}
public IEnumerator waitForIterCtx()
{
IterationContext iterCtx = null;
while (true)
{
lock (iterations)
{
if (iterations.Count > 0)
{
iterCtx = iterations.Dequeue();
}
}
if (iterCtx != null)
{
StartCoroutine(animationControler.animateIterCtx(iterCtx));
yield break;
}
yield return(new WaitForSeconds(5));
}
}
public static IterationResult Validate <TData>(this IReplayScenario <TData> scenario, DataItem data, int threadId = 0, int threadIterationId = 0, int globalIterationId = 0)
{
ExecutionTimer timer = new ExecutionTimer();
ThreadSafeCounter errorsCounter = new ThreadSafeCounter();
GlobalCounters globalCounters = new GlobalCounters(errorsCounter, new MockedIdGenerator(globalIterationId));
IIterationControl context = new IterationContext(threadId, timer);
ReplayScenarioHandler <TData> handler = new ReplayScenarioHandler <TData>(globalCounters, new MockedIdGenerator(threadIterationId), scenario, context);
timer.Start();
handler.Init();
handler.PrepareNext();
handler.SetData(data.Value, data.TimeStamp);
handler.Execute();
IterationResult result = new IterationResult(context, new WorkerThreadStats());
handler.Cleanup();
timer.Stop();
return(result);
}
StatementSyntax BuildInner()
{
const string eventBufferName = "eventBuffer";
Type eventType = IterationContext.UpdateMode == UpdateMode.OnEvent
? ((OnEventNodeModel)IterationContext.Query).EventTypeHandle.Resolve(IterationContext.Stencil)
: null;
List <ParameterSyntax> parameters = new List <ParameterSyntax>
{
Parameter(
Identifier(EntityName))
.WithType(typeof(Entity).ToTypeSyntax())
};
var stateComponentName = IterationContext.UpdateMode == UpdateMode.OnUpdate || IterationContext.UpdateMode == UpdateMode.OnEvent
? null
: IncludeTrackingSystemStateComponent(IterationContext.Query.ComponentQueryDeclarationModel, IterationContext.UpdateMode == UpdateMode.OnEnd);
var stateComponentParameterName = stateComponentName?.ToLowerInvariant();
switch (IterationContext.UpdateMode)
{
case UpdateMode.OnUpdate:
break;
case UpdateMode.OnEvent:
// Add it at the end
break;
case UpdateMode.OnStart:
m_UpdateStatements.AddRange(GetEntityManipulationTranslator().AddComponent(
this,
IdentifierName(EntityName),
DefaultExpression(IdentifierName(stateComponentName)),
IdentifierName(stateComponentName),
false));
break;
case UpdateMode.OnEnd:
parameters.Add(MakeLambdaParameter(
stateComponentParameterName,
IdentifierName(stateComponentName),
false,
false));
m_UpdateStatements.AddRange(GetEntityManipulationTranslator().RemoveComponent(
this,
IdentifierName(EntityName),
IdentifierName(stateComponentName)));
break;
default:
throw new ArgumentOutOfRangeException();
}
// SharedComponents should be inserted first in ForEach
var sortedComponents = IterationContext.FlattenedComponentDefinitions()
.OrderBy(d =>
!typeof(ISharedComponentData).IsAssignableFrom(d.TypeHandle.Resolve(IterationContext.Stencil)))
.ToList();
foreach (ComponentDefinition definition in sortedComponents)
{
if (!RoslynEcsTranslatorExtensions.ShouldGenerateComponentAccess(
definition.TypeHandle,
true,
out Type componentType,
IterationContext.Stencil,
out bool _,
out bool isGameObjectComponent))
{
continue;
}
if (!m_WrittenComponents.TryGetValue(definition.TypeHandle, out RoslynEcsTranslator.AccessMode mode))
{
mode = RoslynEcsTranslator.AccessMode.None;
}
if (mode == RoslynEcsTranslator.AccessMode.None)
{
continue;
}
string componentDataName = IterationContext.GetComponentDataName(componentType);
parameters.Add(MakeLambdaParameter(
componentDataName,
componentType.ToTypeSyntax(),
isGameObjectComponent,
typeof(ISharedComponentData).IsAssignableFrom(componentType)));
}
switch (IterationContext.UpdateMode)
{
case UpdateMode.OnEvent:
parameters.Add(MakeLambdaParameter(
eventBufferName,
GenericName("DynamicBuffer").WithTypeArgumentList(TypeArgumentList(SingletonSeparatedList(eventType.ToTypeSyntax()))),
false,
true));
break;
}
ExpressionSyntax baseQuery = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("Entities"),
IdentifierName("With")))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
IdentifierName(IterationContext.UpdateMode == UpdateMode.OnEvent
? SendEventTranslator.MakeQueryIncludingEventName(IterationContext, eventType)
: IterationContext.GroupName)))));
if (IterationContext.UpdateMode == UpdateMode.OnEnd)
{
// REPLACE query
baseQuery = IdentifierName("Entities");
m_UpdateStatements.Insert(0, IfStatement(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(stateComponentParameterName),
IdentifierName("Processed")),
ReturnStatement()));
}
BlockSyntax innerLambdaBody;
if (IterationContext.UpdateMode == UpdateMode.OnEvent)
{
//for (int event_index = 0; event_index < eventBuffer.Length; event_index++) { T ev = eventBuffer[event_index]; ... }
var eventIndexName = "event_index";
m_UpdateStatements.Insert(0, RoslynBuilder.DeclareLocalVariable(eventType, "ev",
ElementAccessExpression(
IdentifierName(eventBufferName))
.WithArgumentList(
BracketedArgumentList(
SingletonSeparatedList(
Argument(
IdentifierName(eventIndexName)))))
.NormalizeWhitespace()));
innerLambdaBody = Block(ForStatement(
Block(m_UpdateStatements))
.WithDeclaration(
VariableDeclaration(
PredefinedType(
Token(SyntaxKind.IntKeyword)))
.WithVariables(
SingletonSeparatedList <VariableDeclaratorSyntax>(
VariableDeclarator(
Identifier(eventIndexName))
.WithInitializer(
EqualsValueClause(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(0)))))))
.WithCondition(
BinaryExpression(
SyntaxKind.LessThanExpression,
IdentifierName(eventIndexName),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(eventBufferName),
IdentifierName("Length"))))
.WithIncrementors(
SingletonSeparatedList <ExpressionSyntax>(
PostfixUnaryExpression(
SyntaxKind.PostIncrementExpression,
IdentifierName(eventIndexName))))
.NormalizeWhitespace());
}
else
{
innerLambdaBody = Block(m_UpdateStatements);
}
var parenthesizedLambdaExpressionSyntax = ParenthesizedLambdaExpression(
innerLambdaBody)
.WithParameterList(
ParameterList().AddParameters(parameters.ToArray()));
var updateCall = ExpressionStatement(
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
baseQuery,
IdentifierName("ForEach")))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
parenthesizedLambdaExpressionSyntax)))));
if (IterationContext.UpdateMode == UpdateMode.OnEnd)
{
var addMissingStateComponents = ExpressionStatement(
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("EntityManager"),
IdentifierName("AddComponent")))
.WithArgumentList(
ArgumentList(
SeparatedList(
new [] {
Argument(
IdentifierName(RootContext.GetQueryAddStateName(IterationContext.GroupName))),
Argument(
TypeOfExpression(
IdentifierName(stateComponentName)))
}))));
var foreachClearProcessed = ExpressionStatement(
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("Entities"),
IdentifierName("ForEach")))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
ParenthesizedLambdaExpression(
MakeProcessed(false))
.WithParameterList(
ParameterList(
SingletonSeparatedList(
Parameter(
Identifier(stateComponentParameterName))
.WithModifiers(
TokenList(
Token(SyntaxKind.RefKeyword)))
.WithType(
IdentifierName(stateComponentName))))))))));
var foreachQueryMarkProcessed = ExpressionStatement(
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("Entities"),
IdentifierName("With")))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
IdentifierName(IterationContext.GroupName))))),
IdentifierName("ForEach")))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
ParenthesizedLambdaExpression(MakeProcessed(true))
.WithParameterList(
ParameterList(
SeparatedList(parameters))))))));
return(Block(
addMissingStateComponents,
foreachClearProcessed,
foreachQueryMarkProcessed,
updateCall
));
}
return(updateCall);
ParameterSyntax MakeLambdaParameter(string componentDataName, TypeSyntax typeSyntax,
bool isGameObjectComponent, bool isSharedComponent)
{
var modifiers = new List <SyntaxToken>();
if (!isSharedComponent)
{
modifiers.Add(Token(SyntaxKind.RefKeyword));
}
var parameterSyntax = Parameter(
Identifier(componentDataName))
.WithType(
typeSyntax);
if (!isGameObjectComponent)
{
parameterSyntax = parameterSyntax
.WithModifiers(TokenList(modifiers));
}
return(parameterSyntax);
}
AssignmentExpressionSyntax MakeProcessed(bool processed)
{
return(AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(stateComponentParameterName),
IdentifierName("Processed")),
LiteralExpression(processed
? SyntaxKind.TrueLiteralExpression
: SyntaxKind.FalseLiteralExpression)));
}
}
public override HttpRequestMessage GetHttpRequest(IterationContext context)
{
return(new HttpRequestMessage(HttpMethod.Get, this._mainRequestUrl));
}
protected virtual IDictionary <string, string> GetFormParameters(IterationContext context)
{
return(new Dictionary <string, string>());
}
protected override Uri GetRequestUri(IterationContext context)
{
return(new Uri(context.Environment[LoadTestEnvironmentKeys.FormAction] as string));
}
protected override HttpContent GetContent(IterationContext context)
{
return(new FormUrlEncodedContent(GetFormParameters(context)));
}
private static IDictionary <string, string> RunHttpRequest(
IterationContext context,
HttpClient client,
string description,
HttpRequestMessage request,
CancellationToken cancellationToken)
{
var requestId = Guid.NewGuid();
request.Headers.Add("X-MK6LoadTest", "true");
request.Headers.Add("X-MK6LoadTest-Description", description);
request.Headers.Add("X-MK6LoadTest-RequestId", requestId.ToString());
var originalUrl = request.RequestUri.ToString();
var startTime = DateTime.Now;
var timer = new Stopwatch();
try
{
timer.Start();
Log.Information("Starting request {Data}",
new
{
RequestId = requestId,
WorkerId = context.WorkerIndex,
WorkerCount = context.Environment["Workers"],
Iteration = context.IterationIndex,
Description = description,
OriginalUrl = originalUrl
});
var response = client.SendAsync(request, cancellationToken).Result;
timer.Stop();
var endTime = DateTime.Now;
Log.Information("Finished request {Data}",
new
{
RequestId = requestId,
WorkerId = context.WorkerIndex,
WorkerCount = context.Environment["Workers"],
Iteration = context.IterationIndex,
Description = description,
FinalUrl = response.RequestMessage.RequestUri.AbsolutePath,
Status = response.StatusCode,
ResponseTime = timer.ElapsedMilliseconds,
ResponseSize = response.Content.ReadAsByteArrayAsync().Result.Count()
});
return(BuildResponse(
context,
description,
request,
startTime,
endTime,
timer,
response.StatusCode.ToString(),
response.Content.ReadAsStringAsync().Result));
}
catch (AggregateException ex)
{
timer.Stop();
Log.Information("Request was cancelled");
return(BuildResponse(
context,
description,
request,
startTime,
DateTime.UtcNow,
timer,
"Cancelled",
string.Empty,
ex.Message));
}
catch (Exception ex)
{
timer.Stop();
Log.Error(ex, "Error during timed request to '{0}'", request.RequestUri.ToString());
return(BuildResponse(
context,
description,
request,
startTime,
DateTime.UtcNow,
timer,
"Error",
string.Empty,
ex.Message));
}
}
protected abstract HttpContent GetContent(IterationContext context);
public IEnumerator animateIterCtx(IterationContext itCtx)
{
lengthOfAnimation = 5;
timeLeft = lengthOfAnimation;
antsFinished = false;
numAntsFinished = 0;
if (itCtx.currIter == 0)
{
pheromons = null;
}
pathControler.color = pathControler.color;
double min, max;
findMinMax(itCtx.pheromoneMatrix, out min, out max);
double a, b;
findLinarScale(min, max, 0.01, 1, out a, out b);
applyLinearScale(a, b, itCtx.pheromoneMatrix);
List <AntData> ants = new List <AntData>();
AntData antData;
for (int i = 0; i < itCtx.antsRoutes.Count; ++i)
{
antData = new AntData();
antData.currentDest = 0;
antData.timePerPath = lengthOfAnimation / itCtx.antsRoutes[i].Count;
antData.timeLeftOnPath = 0;
antData.antGameObject = GameObject.Instantiate(antPefab, Vector3.zero, Quaternion.identity);
antData.finished = false;
ants.Add(antData);
}
int tmp, tmp1;
for (int i = 0; i + 1 < itCtx.iterShortestPath.Count; ++i)
{
tmp = cityControler.activeCitysIndex[itCtx.iterShortestPath[i]];
tmp1 = cityControler.activeCitysIndex[itCtx.iterShortestPath[i + 1]];
if (pathControler.pathMatrix[tmp, tmp1])
{
pathControler.pathMatrix[tmp, tmp1].startColor = new Color(1, 1, 1, 1);
pathControler.pathMatrix[tmp, tmp1].endColor = new Color(1, 1, 1, 1);
}
}
StartCoroutine(animateAllAnts(ants, itCtx.antsRoutes));
while (timeLeft > 0)
{
timeLeft -= Time.deltaTime;
animatePaths(itCtx);
//animateAllAnts(ants, itCtx.antsRoutes);
yield return(null);
}
pheromons = itCtx.pheromoneMatrix;
while (!antsFinished)
{
yield return(null);
}
for (int i = 0; i < itCtx.antsRoutes.Count; ++i)
{
GameObject.Destroy(ants[i].antGameObject);
}
if (itCtx.currIter < itCtx.numOfIters - 1 && !acoControler.stoped)
{
StartCoroutine(acoControler.waitForIterCtx());
}
else
{
acoControler.stopAlgorithm();
reset();
if (!acoControler.stoped)
{
for (int i = 0; i + 1 < itCtx.iterShortestPath.Count; ++i)
{
tmp = cityControler.activeCitysIndex[itCtx.iterShortestPath[i]];
tmp1 = cityControler.activeCitysIndex[itCtx.iterShortestPath[i + 1]];
if (pathControler.pathMatrix[tmp, tmp1])
{
pathControler.pathMatrix[tmp, tmp1].startColor = new Color(1, 1, 1, 1);
pathControler.pathMatrix[tmp, tmp1].startWidth = 0.7f;
pathControler.pathMatrix[tmp, tmp1].endColor = new Color(1, 1, 1, 1);
pathControler.pathMatrix[tmp, tmp1].endWidth = 0.7f;
}
}
}
}
// Debug.Log("animateItCtxt finished");
yield break;
}
protected override StatementSyntax OnPopContext()
{
BlockSyntax forBody = Block();
var loopIndexName = IterationContext.IndexVariableName;
List <StatementSyntax> reassignComponentDataArrays = new List <StatementSyntax>();
BlockSyntax blockSyntax = Block();
// foreach in a job: the entity array will be declared as a job field, initialized at job creation
StatementSyntax initEntitiesArray = GetOrDeclareEntityArray(IterationContext, out var disposeEntitiesArray);
foreach (ComponentDefinition definition in IterationContext.FlattenedComponentDefinitions())
{
if (!RoslynEcsTranslatorExtensions.ShouldGenerateComponentAccess(definition.TypeHandle, true, out var componentType, IterationContext.Stencil, out bool isShared, out bool isGameObjectComponent) ||
isGameObjectComponent)
{
continue;
}
if (!m_WrittenComponents.TryGetValue(definition.TypeHandle, out var mode))
{
mode = RoslynEcsTranslator.AccessMode.None;
}
if (mode == RoslynEcsTranslator.AccessMode.None)
{
continue;
}
ExpressionSyntax initValue;
if (isShared)
{
initValue = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(nameof(EntityManager)),
GenericName(
Identifier(nameof(EntityManager.GetSharedComponentData)))
.WithTypeArgumentList(
TypeArgumentList(
SingletonSeparatedList(
TypeSystem.BuildTypeSyntax(componentType))))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
IdentifierName(EntityName)))));
}
else
{
string compArrayName = GetOrDeclareComponentArray(IterationContext, definition,
out var componentDataArrayInitialization,
out var componentDataArrayDisposal);
if (componentDataArrayInitialization != null)
{
m_InitComponentDataArrays.Add(componentDataArrayInitialization);
}
if (componentDataArrayDisposal != null)
{
m_DisposeComponentDataArrays.Add(componentDataArrayDisposal);
}
initValue = ElementAccessExpression(IdentifierName(compArrayName))
.WithArgumentList(
BracketedArgumentList(
SingletonSeparatedList(
Argument(
IdentifierName(loopIndexName)))));
}
// per-entity component variable
StatementSyntax componentVarDeclaration = RoslynBuilder.DeclareLocalVariable(
componentType,
IterationContext.GetComponentDataName(componentType),
initValue,
RoslynBuilder.VariableDeclarationType.InferredType);
forBody = forBody.AddStatements(componentVarDeclaration);
if (mode == RoslynEcsTranslator.AccessMode.Write)
{
reassignComponentDataArrays.Add(ExpressionStatement(
GetEntityManipulationTranslator().SetComponent(
this,
ElementAccessExpression(IdentifierName(IterationContext.EntitiesArrayName))
.WithArgumentList(
BracketedArgumentList(
SingletonSeparatedList(
Argument(
IdentifierName(IterationContext.IndexVariableName))))),
componentType,
IdentifierName(IterationContext.GetComponentDataName(componentType)))
.Cast <ExpressionSyntax>()
.Single())
);
}
}
forBody = forBody.AddStatements(m_UpdateStatements.ToArray());
forBody = forBody.AddStatements(reassignComponentDataArrays.ToArray());
if (forBody.Statements.Count != 0) // strip the iteration loop if empty
{
forBody = forBody.WithStatements(forBody.Statements.Insert(0, m_EntityDeclaration));
if (initEntitiesArray != null)
{
blockSyntax = blockSyntax.AddStatements(initEntitiesArray);
}
blockSyntax = blockSyntax
.AddStatements(m_InitComponentDataArrays.ToArray())
.AddStatements(RoslynEcsTranslatorExtensions.ComponentQueryForLoop(forBody, loopIndexName, IterationContext.EntitiesArrayName))
.AddStatements(m_DisposeComponentDataArrays.ToArray());
if (disposeEntitiesArray != null)
{
blockSyntax = blockSyntax.AddStatements(disposeEntitiesArray);
}
}
return(AddMissingEventBuffers(IterationContext, blockSyntax));
}
public static void PostScriptHook(IterationContext context)
{
var client = context.Environment[LoadTestEnvironmentKeys.HttpClient] as HttpClient;
client.Dispose();
}
public virtual User Choose(IterationContext context)
{
return(this.Users[context.WorkerIndex % this.Users.Count]);
}
public static void PreScriptHook(IterationContext context)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
context.Environment.Add(LoadTestEnvironmentKeys.HttpClient, BuildClient(context));
}
public abstract HttpRequestMessage GetHttpRequest(IterationContext context);
protected abstract Uri GetRequestUri(IterationContext context);
public virtual IDictionary <string, object> ExtractContentToEnvironment(
IterationContext context,
IDictionary <string, string> result)
{
return(new Dictionary <string, object>());
}
public virtual IEnumerable <ComponentDefinition> GetComponentDefinitions()
{
return(IterationContext.FlattenedComponentDefinitions());
}
public override string GetComponentVariableName(IIteratorStackModel groupDeclaration, TypeHandle componentVariableType1)
{
Assert.AreEqual(groupDeclaration, IterationContext.Query);
return(IterationContext.GetComponentDataName(componentVariableType1.Resolve(IterationContext.Stencil)));
}
