public async Task PageWaitForSelectorAsyncIsShortcutForMainFrame()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var otherFrame = Page.FirstChildFrame();
var watchdog = Page.WaitForSelectorAsync("div");
await otherFrame.EvaluateAsync(AddElement, "div");
await Page.EvaluateAsync(AddElement, "div");
var eHandle = await watchdog;
Assert.Equal(Page.MainFrame, await eHandle.GetOwnerFrameAsync());
}
public async Task ShouldReportFrameName()
{
await FrameUtils.AttachFrameAsync(Page, "theFrameId", TestConstants.EmptyPage);
await Page.EvaluateFunctionAsync(@"url => {
const frame = document.createElement('iframe');
frame.name = 'theFrameName';
frame.src = url;
document.body.appendChild(frame);
return new Promise(x => frame.onload = x);
}", TestConstants.EmptyPage);
Assert.Equal(string.Empty, Page.Frames.ElementAt(0).Name);
Assert.Equal("theFrameId", Page.Frames.ElementAt(1).Name);
Assert.Equal("theFrameName", Page.Frames.ElementAt(2).Name);
}
public async Task ShouldClickTheButtonWithDeviceScaleFactorSet()
{
await Page.SetViewportAsync(new ViewPortOptions { Width = 400, Height = 400, DeviceScaleFactor = 5 });
Assert.Equal(5, await Page.EvaluateExpressionAsync <int>("window.devicePixelRatio"));
await Page.SetContentAsync("<div style=\"width:100px;height:100px\">spacer</div>");
await FrameUtils.AttachFrameAsync(Page, "button-test", TestConstants.ServerUrl + "/input/button.html");
var frame = Page.FirstChildFrame();
var button = await frame.QuerySelectorAsync("button");
await button.ClickAsync();
Assert.Equal("Clicked", await frame.EvaluateExpressionAsync <string>("window.result"));
}
public async Task PageWaitForSelectorAsyncIsShortcutForMainFrame()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var otherFrame = Page.Frames.ElementAt(1);
var watchdog = Page.WaitForSelectorAsync("div");
await otherFrame.EvaluateFunctionAsync(AddElement, "div");
await Page.EvaluateFunctionAsync(AddElement, "div");
var eHandle = await watchdog;
Assert.Equal(Page.MainFrame, eHandle.ExecutionContext.Frame);
}
public async Task ShouldRunInSpecifiedFrame()
{
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame2", TestConstants.EmptyPage);
var frame1 = Page.Frames.First(f => f.Name == "frame1");
var frame2 = Page.Frames.First(f => f.Name == "frame2");
var waitForXPathPromise = frame2.WaitForSelectorAsync("//div");
await frame1.EvaluateAsync(AddElement, "div");
await frame2.EvaluateAsync(AddElement, "div");
var eHandle = await waitForXPathPromise;
Assert.Equal(frame2, await eHandle.GetOwnerFrameAsync());
}
public async Task ShouldRunInSpecifiedFrame()
{
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame2", TestConstants.EmptyPage);
var frame1 = Page.FirstChildFrame();
var frame2 = Page.Frames.ElementAt(2);
var waitForSelectorPromise = frame2.WaitForSelectorAsync("div");
await frame1.EvaluateFunctionAsync(AddElement, "div");
await frame2.EvaluateFunctionAsync(AddElement, "div");
var eHandle = await waitForSelectorPromise;
Assert.Equal(frame2, eHandle.ExecutionContext.Frame);
}
public string BasisBladeName(int grade, int index, BasisBladeFormat nameFormat)
{
switch (nameFormat)
{
case BasisBladeFormat.Canonical:
return(BasisBladeName(grade, index));
case BasisBladeFormat.BinaryIndexed:
return(FrameUtils.BasisBladeBinaryIndexedName(VSpaceDimension, grade, index));
case BasisBladeFormat.GradePlusIndex:
return(FrameUtils.BasisBladeGradeIndexName(grade, index));
default:
return(FrameUtils.BasisBladeIndexedName(grade, index));
}
}
public async Task ShouldWorkInCrossProcessIframe()
{
await using var context = await Browser.NewContextAsync(new BrowserContextOptions
{
ColorScheme = ColorScheme.Dark,
});
var page = await context.NewPageAsync();
await page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(page, "frame1", TestConstants.CrossProcessHttpPrefix + "/empty.html");
var frame = page.Frames[1];
Assert.True(await frame.EvaluateAsync <bool>("() => matchMedia('(prefers-color-scheme: dark)').matches"));
}
public async Task ShouldRunInSpecifiedFrame()
{
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame2", TestConstants.EmptyPage);
var frame1 = Page.Frames.First(f => f.Name == "frame1");
var frame2 = Page.Frames.First(f => f.Name == "frame2");
var waitForXPathPromise = frame2.WaitForXPathAsync("//div");
await frame1.EvaluateFunctionAsync(addElement, "div");
await frame2.EvaluateFunctionAsync(addElement, "div");
var eHandle = await waitForXPathPromise;
Assert.Equal(frame2, eHandle.ExecutionContext.Frame);
}
public async Task ShouldReturnMatchingResponses()
{
// Disable cache: otherwise, chromium will cache similar requests.
await Page.SetCacheEnabledAsync(false);
await Page.GoToAsync(TestConstants.EmptyPage);
// Attach three frames.
var frameTasks = new List <Task <Frame> >
{
FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage),
FrameUtils.AttachFrameAsync(Page, "frame2", TestConstants.EmptyPage),
FrameUtils.AttachFrameAsync(Page, "frame3", TestConstants.EmptyPage)
};
await Task.WhenAll(frameTasks);
// Navigate all frames to the same URL.
var serverResponses = new List <TaskCompletionSource <string> >();
Server.SetRoute("/one-style.html", async(context) =>
{
var tcs = new TaskCompletionSource <string>();
serverResponses.Add(tcs);
await context.Response.WriteAsync(await tcs.Task);
});
var navigations = new List <Task <Response> >();
for (var i = 0; i < 3; ++i)
{
var waitRequestTask = Server.WaitForRequest("/one-style.html");
navigations.Add(frameTasks[i].Result.GoToAsync(TestConstants.ServerUrl + "/one-style.html"));
await waitRequestTask;
}
// Respond from server out-of-order.
var serverResponseTexts = new string[] { "AAA", "BBB", "CCC" };
for (var i = 0; i < 3; ++i)
{
serverResponses[i].TrySetResult(serverResponseTexts[i]);
var response = await navigations[i];
Assert.Same(frameTasks[i].Result, response.Frame);
Assert.Equal(serverResponseTexts[i], await response.TextAsync());
}
}
private void GenerateTransposeOutermorphismMacro(AstFrame frameInfo)
{
var inputsText = ComposeMacroInputs(
"om", DefaultStructure.Outermorphism
);
var commandsList = GMacDslSyntaxFactory.SyntaxElementsList(
GMacDslSyntaxFactory.DeclareLocalVariable(DefaultStructure.Outermorphism, "newOm"),
GMacDslSyntaxFactory.EmptyLine()
);
var componentsText = new ListComposer("," + Environment.NewLine);
for (var index1 = 1; index1 <= frameInfo.VSpaceDimension; index1++)
{
componentsText.Clear();
var id1 = FrameUtils.BasisBladeId(1, index1 - 1);
commandsList.AddFixedCode("let newOm.ImageV" + index1 + " = Multivector(");
for (var index2 = 1; index2 <= frameInfo.VSpaceDimension; index2++)
{
var id2 = FrameUtils.BasisBladeId(1, index2 - 1);
componentsText.Add(" #E" + id2 + "# = om.ImageV" + index2 + ".#E" + id1 + "#");
}
commandsList.AddFixedCode(componentsText.ToString());
commandsList.AddFixedCode(")");
commandsList.AddEmptyLine();
}
var commandsText = GMacLanguage.CodeGenerator.GenerateCode(commandsList);
GenerateMacro(
frameInfo,
DefaultMacro.Outermorphism.Transpose,
inputsText,
DefaultStructure.Outermorphism,
commandsText,
"newOm"
);
}
public static byte[] Create(byte functionCode, byte[] data)
{
var frame = new byte[5 + data.Length];
frame[0] = MetersFrameConstants.FRAME_HEADER; //Header
frame[1] = functionCode; //Function
frame[2] = byte.Parse((data.Length + 1).ToString(), NumberStyles.HexNumber); //Dimension
frame[3] = 0x01; //Size
for (var i = 0; i < data.Length; i++)
{
frame[i + 4] = data[i];
}
frame[frame.Length - 1] = FrameUtils.CalcChecksum(frame, (data.Length + 5)); //Checksum
return(frame);
}
//public GAOuterMorphismFull(ISymbolicMatrix vector_transform_matrix)
// : base(vector_transform_matrix.CAS)
//{
// int domain_ga_space_dim = GAUtils.GASpaceDim(vector_transform_matrix.Columns);
// int codomain_ga_space_dim = GAUtils.GASpaceDim(vector_transform_matrix.Rows);
// _TransformedBasisBlades = new Multivector[domain_ga_space_dim];
// _TransformedBasisBlades[0] = Multivector.CreateScalar(codomain_ga_space_dim, MathematicaScalar.Create(CAS, 1));
// for (int id = 1 ; id <= domain_ga_space_dim - 1)
// {
// if (GAUtils.is_ID_Vector(id))
// {
// _TransformedBasisBlades[id] = CreateFromMatrixColumn(vector_transform_matrix, GAUtils.ID_To_Index(id));
// }
// else
// {
// int id1, id2;
// GAUtils.SeparateIDs(id, out id1, out id2);
// _TransformedBasisBlades[id] = Multivector.OuterProduct(_TransformedBasisBlades[id1], _TransformedBasisBlades[id2]);
// }
// }
//}
private void ComputeVectorTransformMatrix()
{
var matrixArray = new MathematicaScalar[CodomainVSpaceDim, DomainVSpaceDim];
for (var col = 0; col < DomainVSpaceDim; col++)
{
var id = FrameUtils.BasisBladeId(1, col);
var mv = _transformedBasisBlades[id];
foreach (var term in mv)
{
var row = term.Key.BasisBladeIndex();
matrixArray[row, col] = term.Value;
}
}
_vectorTransformMatrix = MathematicaMatrix.CreateFullMatrix(CasInterface, matrixArray);
}
public async Task ShouldFireForIframes()
{
var requests = new List <Request>();
Page.Request += (sender, e) =>
{
if (!TestUtils.IsFavicon(e.Request))
{
requests.Add(e.Request);
}
};
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
Assert.Equal(2, requests.Count);
}
public async Task PageWaitForSelectorAsyncIsShortcutForMainFrame()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var otherFrame = Page.Frames.ElementAt(1);
var added = false;
var waitForSelectorTask = Page.WaitForSelectorAsync("div").ContinueWith(_ => added = true);
await otherFrame.EvaluateFunctionAsync(AddElement, "div");
Assert.False(added);
await Page.EvaluateFunctionAsync(AddElement, "div");
Assert.True(await waitForSelectorTask);
Assert.True(added);
}
public async Task ShouldHaveDifferentExecutionContexts()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
Assert.Equal(2, Page.Frames.Count());
var frame1 = Page.MainFrame;
var frame2 = Page.FirstChildFrame();
await frame1.EvaluateExpressionAsync("window.FOO = 'foo'");
await frame2.EvaluateExpressionAsync("window.FOO = 'bar'");
Assert.Equal("foo", await frame1.EvaluateExpressionAsync <string>("window.FOO"));
Assert.Equal("bar", await frame2.EvaluateExpressionAsync <string>("window.FOO"));
}
public async Task ShouldReportDifferentFrameInstanceWhenFrameReAttaches()
{
var frame1 = await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
await Page.EvaluateAsync(@"() => {
window.frame = document.querySelector('#frame1');
window.frame.remove();
}");
Assert.True(frame1.IsDetached);
var(frame2, _) = await TaskUtils.WhenAll(
Page.WaitForEventAsync(PageEvent.FrameNavigated),
Page.EvaluateAsync("() => document.body.appendChild(window.frame)")
);
Assert.False(frame2.Frame.IsDetached);
Assert.NotSame(frame1, frame2);
}
public async Task ShouldFire()
{
List <Request> requests = new List <Request>();
Page.RequestCreated += (sender, e) => requests.Add(e.Request);
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrame(Page, "frame1", TestConstants.EmptyPage);
Assert.Equal(2, requests.Count);
Assert.Equal(TestConstants.EmptyPage, requests[0].Url);
Assert.Equal(Page.MainFrame, requests[0].Frame);
Assert.Equal(TestConstants.EmptyPage, requests[0].Frame.Url);
Assert.Equal(TestConstants.EmptyPage, requests[1].Url);
Assert.Equal(Page.Frames.ElementAt(1), requests[1].Frame);
Assert.Equal(TestConstants.EmptyPage, requests[1].Frame.Url);
}
public async Task ShouldRunInSpecifiedFrame()
{
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame2", TestConstants.EmptyPage);
var frame1 = Page.Frames[1];
var frame2 = Page.Frames[2];
var added = false;
var waitForXPathPromise = frame2.WaitForXPathAsync("//div").ContinueWith(_ => added = true);
Assert.False(added);
await frame1.EvaluateFunctionAsync(addElement, "div");
Assert.False(added);
await frame2.EvaluateFunctionAsync(addElement, "div");
await waitForXPathPromise;
}
public async Task ShouldWorkForSubframeNavigationRequest()
{
var requests = new List <Request>();
Page.Request += (_, e) =>
{
if (!TestUtils.IsFavicon(e.Request))
{
requests.Add(e.Request);
}
};
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
Assert.Equal(2, requests.Count);
Assert.Equal(Page.FirstChildFrame(), requests[1].Frame);
}
/// <summary>
/// Returns the basis blades having the given grades grouped by their grade
/// </summary>
/// <param name="startGrade"></param>
/// <returns></returns>
public Dictionary <int, List <AstFrameBasisBlade> > BasisBladesGroupedByGrade(int startGrade = 0)
{
var result = new Dictionary <int, List <AstFrameBasisBlade> >();
for (var grade = startGrade; grade <= VSpaceDimension; grade++)
{
var kvSpaceDim = FrameUtils.KvSpaceDimension(VSpaceDimension, grade);
var newList = new List <AstFrameBasisBlade>(kvSpaceDim);
for (var index = 0; index < kvSpaceDim; index++)
{
newList.Add(BasisBlade(grade, index));
}
result.Add(grade, newList);
}
return(result);
}
public async Task ShouldReportDifferentFrameInstanceWhenFrameReAttaches()
{
var frame1 = await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
await Page.EvaluateFunctionAsync(@"() => {
window.frame = document.querySelector('#frame1');
window.frame.remove();
}");
Assert.True(frame1.Detached);
var frame2tsc = new TaskCompletionSource <Frame>();
Page.FrameAttached += (_, e) => frame2tsc.TrySetResult(e.Frame);
await Page.EvaluateExpressionAsync("document.body.appendChild(window.frame)");
var frame2 = await frame2tsc.Task;
Assert.False(frame2.Detached);
Assert.NotSame(frame1, frame2);
}
/// <summary>
/// Returns the basis blades having the given grades grouped by their grade
/// </summary>
/// <param name="gradesSeq"></param>
/// <returns></returns>
public Dictionary <int, List <AstFrameBasisBlade> > BasisBladesGroupedByGrade(params int[] gradesSeq)
{
var result = new Dictionary <int, List <AstFrameBasisBlade> >();
foreach (var grade in gradesSeq)
{
var kvSpaceDim = FrameUtils.KvSpaceDimension(VSpaceDimension, grade);
var newList = new List <AstFrameBasisBlade>(kvSpaceDim);
for (var index = 0; index < kvSpaceDim; index++)
{
newList.Add(BasisBlade(grade, index));
}
result.Add(grade, newList);
}
return(result);
}
public async Task ShouldRunInSpecifiedFrame()
{
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame2", TestConstants.EmptyPage);
var frame1 = Page.Frames.ElementAt(1);
var frame2 = Page.Frames.ElementAt(2);
var added = false;
var selectorTask = frame2.WaitForSelectorAsync("div").ContinueWith(_ => added = true);
Assert.False(added);
await frame1.EvaluateFunctionAsync(AddElement, "div");
Assert.False(added);
await frame2.EvaluateFunctionAsync(AddElement, "div");
Assert.True(added);
}
public async Task ShouldClickTheButtonWithFixedPositionInsideAnIframe()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await Page.SetViewportAsync(new ViewPortOptions
{
Width = 500,
Height = 500
});
await Page.SetContentAsync("<div style=\"width:100px;height:2000px\">spacer</div>");
await FrameUtils.AttachFrameAsync(Page, "button-test", TestConstants.ServerUrl + "/input/button.html");
var frame = Page.FirstChildFrame();
await frame.QuerySelectorAsync("button").EvaluateFunctionAsync("button => button.style.setProperty('position', 'fixed')");
await frame.ClickAsync("button");
Assert.Equal("Clicked", await frame.EvaluateExpressionAsync <string>("window.result"));
}
//TODO: This requires more acceleration (try to build the expressions then evaluate once per basis blade id for result_mv)
//private GAMultivectorCoefficients BilinearProduct(GAMultivectorCoefficients mv1, GAMultivectorCoefficients mv2, Func<int, int, bool> term_discard_function)
//{
// if (mv1.GASpaceDim != mv2.GASpaceDim || mv1.GASpaceDim != GASpaceDim)
// throw new GMacSymbolicException("Multivector size mismatch");
// GAMultivectorCoefficients mv = GAMultivectorCoefficients.CreateZero(mv1.GASpaceDim);
// foreach (var term1 in mv1)
// {
// int id1 = term1.Key;
// MathematicaScalar coef1 = term1.Value;
// foreach (var term2 in mv2.FilterTermsUsing(id1, term_discard_function))
// {
// int id2 = term2.Key;
// MathematicaScalar coef2 = term2.Value;
// int id = id1 ^ id2;
// if (GAUtils.IDs_To_EGP_Sign(id1, id2))
// mv[id] -= coef1 * coef2 * _BasisBladesSignatures[id];
// else
// mv[id] += coef1 * coef2 * _BasisBladesSignatures[id];
// }
// }
// return mv;
//}
private GaMultivector BilinearProduct(GaMultivector mv1, GaMultivector mv2, Func <int, int, bool> termDiscardFunction)
{
if (mv1.GaSpaceDim != mv2.GaSpaceDim || mv1.GaSpaceDim != GaSpaceDimension)
{
throw new GMacSymbolicException("Multivector size mismatch");
}
var terms1 = mv1.ToStringsDictionary();
var terms2 = mv2.ToStringsDictionary();
var accumExprDict = new Dictionary <int, ListComposer>();
foreach (var term1 in terms1)
{
var id1 = term1.Key;
var coef1 = term1.Value;
foreach (var term2 in terms2.FilterTermsUsing(id1, termDiscardFunction))
{
var id2 = term2.Key;
var coef2 = term2.Value;
var resultId = id1 ^ id2;
var sigId = id1 & id2;
var resultCoefDelta =
EuclideanUtils.Times(
coef1,
coef2,
_basisBladesSignatures[sigId].MathExpr.ToString(),
FrameUtils.IsNegativeEGp(id1, id2)
);
accumExprDict.AddTerm(resultId, resultCoefDelta);
}
}
return(accumExprDict.ToMultivector(mv1.GaSpaceDim));
}
public async Task ShouldBypassCSPInIframesAsWell()
{
await using (var context = await Browser.NewContextAsync())
{
var page = await context.NewPageAsync();
await page.GoToAsync(TestConstants.EmptyPage);
// Make sure CSP prohibits addScriptTag in an iframe.
var frame = await FrameUtils.AttachFrameAsync(page, "frame1", TestConstants.ServerUrl + "/csp.html");
await frame.AddScriptTagAsync(new AddTagOptions
{
Content = "window.__injected = 42;"
}).ContinueWith(_ => Task.CompletedTask);
Assert.Null(await frame.EvaluateAsync <int?>("() => window.__injected"));
}
// By-pass CSP and try one more time.
await using (var context = await Browser.NewContextAsync(new BrowserContextOptions {
BypassCSP = true
}))
{
var page = await context.NewPageAsync();
await page.GoToAsync(TestConstants.EmptyPage);
// Make sure CSP prohibits addScriptTag in an iframe.
var frame = await FrameUtils.AttachFrameAsync(page, "frame1", TestConstants.ServerUrl + "/csp.html");
await frame.AddScriptTagAsync(new AddTagOptions
{
Content = "window.__injected = 42;"
}).ContinueWith(_ => Task.CompletedTask);
Assert.Equal(42, await frame.EvaluateAsync <int?>("() => window.__injected"));
}
}
public async Task ShouldWorkForSubframes()
{
await using (var context = await Browser.NewContextAsync())
{
var page = await context.NewPageAsync();
Assert.Contains("Mozilla", await page.EvaluateAsync <string>("navigator.userAgent"));
}
await using (var context = await Browser.NewContextAsync(new BrowserContextOptions {
UserAgent = "foobar"
}))
{
var page = await context.NewPageAsync();
var(userAgent, _) = await TaskUtils.WhenAll(
Server.WaitForRequest <string>("/empty.html", (request) => request.Headers["user-agent"]),
FrameUtils.AttachFrameAsync(page, "frame1", TestConstants.EmptyPage));
Assert.Equal("foobar", userAgent);
}
}
private void translate_BasisBladesSet_List_Item_GASpan(ParseTreeNode node)
{
var nodeIdentifierList = node.ChildNodes[0];
//Create the set of unique spanning vectors for the GA subspace
var basisVectorsList = new List <int>(nodeIdentifierList.ChildNodes.Count);
foreach (var nodeIdentifier in nodeIdentifierList.ChildNodes)
{
GMacFrameBasisVector basisVector;
var basisVectorName = GenUtils.Translate_Identifier(nodeIdentifier);
if (_frame.LookupBasisVector(basisVectorName, out basisVector) == false)
{
CompilationLog.RaiseGeneratorError <int>("Basis vector not recognized", nodeIdentifier);
}
//Only add unique basis vectors to the spanning set
if (basisVectorsList.Exists(x => x == basisVector.BasisVectorId) == false)
{
basisVectorsList.Add(basisVector.BasisVectorId);
}
}
//Compute the dimension of the GA spanned by the basis vectors
var subspaceDimension = 1 << basisVectorsList.Count;
//Scalars are always part of the GA subspace based on any given set of basis vectors
AddBasisBladeId(0);
//Add the remaining basis blades to the GA subspace
for (var idIndex = 1; idIndex <= subspaceDimension - 1; idIndex++)
{
var id = FrameUtils.ComposeGaSubspaceBasisBladeId(basisVectorsList, idIndex);
AddBasisBladeId(id);
}
}
public virtual System.Collections.IEnumerator Execute()
{
ActionNode127_Milliseconds = IntNode83;
// ActionNode
while (this.DebugInfo("bf1a89a3-98e0-4803-b7a0-808be2646fd3", "d9eb14db-b5db-40c3-bd01-a36f90258104", this) == 1)
{
yield return(null);
}
// Visit uFrame.Actions.MillitTimer
ActionNode127.Milliseconds = ActionNode127_Milliseconds;
ActionNode127.System = System;
ActionNode127.Complete = () => { System.StartCoroutine(ActionNode127_Complete()); };
ActionNode127.Execute();
// ActionNode
while (this.DebugInfo("9fe12bc1-ff95-4ca9-87af-04bf3d20f34d", "730a328a-620a-408f-b020-1ec2c12ed328", this) == 1)
{
yield return(null);
}
// Visit FrameUtils.getFrame
ActionNode74_Result = FrameUtils.getFrame();
ActionNode75_frame = ActionNode74_Result;
// ActionNode
while (this.DebugInfo("730a328a-620a-408f-b020-1ec2c12ed328", "b83a3922-04bf-45ae-86ef-4cf556cad129", this) == 1)
{
yield return(null);
}
// Visit FrameUtils.getLeftHandFromFrame
FrameUtils.getLeftHandFromFrame(ActionNode75_frame, out ActionNode75_left);
ActionNode76_toCheck = ActionNode75_left;
// ActionNode
while (this.DebugInfo("b83a3922-04bf-45ae-86ef-4cf556cad129", "222aae32-7144-4f27-8cfc-34f6ccaad846", this) == 1)
{
yield return(null);
}
// Visit ConditionsUtils.isNull
ConditionsUtils.isNull(ActionNode76_toCheck, () => { System.StartCoroutine(ActionNode76_yes()); }, () => { System.StartCoroutine(ActionNode76_no()); });
yield break;
}
