public void BranchedStringSliceWire_Execute_BothSinksHaveCorrectValues() { DfirRoot function = DfirRoot.Create(); Constant stringSliceConstant = Constant.Create(function.BlockDiagram, "test", DataTypes.StringSliceType.CreateImmutableReference()); var inspect1Node = new FunctionalNode(function.BlockDiagram, Signatures.InspectType); ExplicitBorrowNode borrow1 = ConnectExplicitBorrowToInputTerminals(inspect1Node.InputTerminals[0]); var inspect2Node = new FunctionalNode(function.BlockDiagram, Signatures.InspectType); ExplicitBorrowNode borrow2 = ConnectExplicitBorrowToInputTerminals(inspect2Node.InputTerminals[0]); Wire.Create(function.BlockDiagram, stringSliceConstant.OutputTerminal, borrow1.InputTerminals[0], borrow2.InputTerminals[0]); TestExecutionInstance executionInstance = CompileAndExecuteFunction(function); #if LLVM_TEST const int stringSliceReferenceSize = 16; #else const int stringSliceReferenceSize = 8; #endif byte[] inspect1Value = executionInstance.GetLastValueFromInspectNode(inspect1Node); Assert.AreEqual(stringSliceReferenceSize, inspect1Value.Length); byte[] inspect2Value = executionInstance.GetLastValueFromInspectNode(inspect2Node); Assert.AreEqual(stringSliceReferenceSize, inspect2Value.Length); Assert.IsTrue(inspect1Value.Zip(inspect2Value, (a, b) => a == b).All(b => b)); }
private PrimitiveTypeNode ConnectPrimitiveTypeToInputTerminal(Terminal inputTerminal, NIType type) { var primitive = new PrimitiveTypeNode(inputTerminal.ParentDiagram, type); Wire.Create(inputTerminal.ParentDiagram, primitive.OutputTerminal, inputTerminal); return(primitive); }
public void InitializeVectorAndSumWithSliceIterator_Execute_CorrectSumValue() { DfirRoot function = DfirRoot.Create(); FunctionalNode initializeVector = CreateInitializeVectorWithIntegerConstants(function.BlockDiagram, 4, 4); FunctionalNode vectorToSlice = new FunctionalNode(function.BlockDiagram, Signatures.VectorToSliceType); Wire.Create(function.BlockDiagram, initializeVector.OutputTerminals[0], vectorToSlice.InputTerminals[0]); FunctionalNode sliceToIterator = new FunctionalNode(function.BlockDiagram, Signatures.SliceToIteratorType); Wire.Create(function.BlockDiagram, vectorToSlice.OutputTerminals[0], sliceToIterator.InputTerminals[0]); Loop loop = new Loop(function.BlockDiagram); CreateLoopConditionTunnel(loop); IterateTunnel iterateTunnel = CreateIterateTunnel(loop); BorrowTunnel borrowTunnel = CreateBorrowTunnel(loop, BorrowMode.Mutable); ConnectConstantToInputTerminal(borrowTunnel.InputTerminals[0], NITypes.Int32, 0, true); Wire.Create(function.BlockDiagram, sliceToIterator.OutputTerminals[0], iterateTunnel.InputTerminals[0]) .SetWireBeginsMutableVariable(true); FunctionalNode accumulateAdd = new FunctionalNode(loop.Diagrams[0], Signatures.DefineMutatingBinaryFunction("AccumulateAdd", NITypes.Int32)); Wire.Create(loop.Diagrams[0], borrowTunnel.OutputTerminals[0], accumulateAdd.InputTerminals[0]); Wire.Create(loop.Diagrams[0], iterateTunnel.OutputTerminals[0], accumulateAdd.InputTerminals[1]); FunctionalNode inspectNode = ConnectInspectToOutputTerminal(borrowTunnel.TerminateLifetimeTunnel.OutputTerminals[0]); TestExecutionInstance executionInstance = CompileAndExecuteFunction(function); byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspectNode); AssertByteArrayIsInt32(inspectValue, 16); }
internal static FunctionalNode ConnectSomeConstructorToInputTerminal(Terminal inputTerminal) { FunctionalNode someConstructor = new FunctionalNode(inputTerminal.ParentDiagram, Signatures.SomeConstructorType); Wire wire = Wire.Create(inputTerminal.ParentDiagram, someConstructor.OutputTerminals[0], inputTerminal); return(someConstructor); }
public void SumItemsFromRangeIterator_Execute_CorrectFinalResult() { DfirRoot function = DfirRoot.Create(); Loop loop = new Loop(function.BlockDiagram); LoopConditionTunnel conditionTunnel = CreateLoopConditionTunnel(loop); IterateTunnel iterateTunnel = CreateIterateTunnel(loop); FunctionalNode range = new FunctionalNode(function.BlockDiagram, Signatures.RangeType); Wire rangeWire = Wire.Create(function.BlockDiagram, range.OutputTerminals[0], iterateTunnel.InputTerminals[0]); rangeWire.SetWireBeginsMutableVariable(true); Constant lowConstant = ConnectConstantToInputTerminal(range.InputTerminals[0], NITypes.Int32, 0, false); Constant highConstant = ConnectConstantToInputTerminal(range.InputTerminals[1], NITypes.Int32, 10, false); BorrowTunnel borrow = CreateBorrowTunnel(loop, BorrowMode.Mutable); Constant accumulateConstant = ConnectConstantToInputTerminal(borrow.InputTerminals[0], NITypes.Int32, 0, true); FunctionalNode accumulateAdd = new FunctionalNode(loop.Diagram, Signatures.DefineMutatingBinaryFunction("AccumulateAdd", NITypes.Int32)); Wire.Create(loop.Diagram, borrow.OutputTerminals[0], accumulateAdd.InputTerminals[0]); Wire.Create(loop.Diagram, iterateTunnel.OutputTerminals[0], accumulateAdd.InputTerminals[1]); FunctionalNode inspect = ConnectInspectToOutputTerminal(borrow.TerminateLifetimeTunnel.OutputTerminals[0]); TestExecutionInstance executionInstance = CompileAndExecuteFunction(function); byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect); AssertByteArrayIsInt32(inspectValue, 45); }
private static FunctionalNode ConnectCreateLockingCellToInputTerminal(Terminal inputTerminal) { FunctionalNode createLockingCell = new FunctionalNode(inputTerminal.ParentDiagram, Signatures.CreateLockingCellType); Wire wire = Wire.Create(inputTerminal.ParentDiagram, createLockingCell.OutputTerminals[0], inputTerminal); return(createLockingCell); }
public static FunctionalNode ConnectOutputToOutputTerminal(this CompilerTestBase test, Terminal outputTerminal) { var output = new FunctionalNode(outputTerminal.ParentDiagram, Signatures.OutputType); Wire.Create(outputTerminal.ParentDiagram, outputTerminal, output.InputTerminals[0]); return(output); }
public void UnwrapOptionTunnelWithSomeInputAndYieldingFrameInterior_Execute_FrameExecutes() { DfirRoot function = DfirRoot.Create(); FunctionalNode some = new FunctionalNode(function.BlockDiagram, Signatures.SomeConstructorType); ConnectConstantToInputTerminal(some.InputTerminals[0], NITypes.Int32, 5, false); Frame frame = Frame.Create(function.BlockDiagram); UnwrapOptionTunnel unwrapOptionTunnel = new UnwrapOptionTunnel(frame); Wire.Create(function.BlockDiagram, some.OutputTerminals[0], unwrapOptionTunnel.InputTerminals[0]); BorrowTunnel borrowTunnel = CreateBorrowTunnel(frame, BorrowMode.Mutable); ConnectConstantToInputTerminal(borrowTunnel.InputTerminals[0], NITypes.Int32, 0, true); FunctionalNode assign = new FunctionalNode(frame.Diagram, Signatures.AssignType); var yieldNode = new FunctionalNode(frame.Diagram, Signatures.YieldType); Wire.Create(frame.Diagram, borrowTunnel.OutputTerminals[0], yieldNode.InputTerminals[0]); Wire.Create(frame.Diagram, yieldNode.OutputTerminals[0], assign.InputTerminals[0]); Wire.Create(frame.Diagram, unwrapOptionTunnel.OutputTerminals[0], assign.InputTerminals[1]); FunctionalNode inspect = ConnectInspectToOutputTerminal(borrowTunnel.TerminateLifetimeTunnel.OutputTerminals[0]); TestExecutionInstance executionInstance = CompileAndExecuteFunction(function); byte[] finalValue = executionInstance.GetLastValueFromInspectNode(inspect); AssertByteArrayIsInt32(finalValue, 5); }
public void OpenFileHandleAndReadLine_Execute_LineReadFromFile() { string filePath = Path.Combine(TestContext.DeploymentDirectory, Path.GetRandomFileName()); const string data = "data"; CreateFileAndWriteData(filePath, data + "\r\n"); DfirRoot function = DfirRoot.Create(); FunctionalNode openFileHandle = new FunctionalNode(function.BlockDiagram, Signatures.OpenFileHandleType); Constant pathConstant = ConnectStringConstantToInputTerminal(openFileHandle.InputTerminals[0], filePath); Frame frame = Frame.Create(function.BlockDiagram); UnwrapOptionTunnel unwrapOption = new UnwrapOptionTunnel(frame); Wire.Create(function.BlockDiagram, openFileHandle.OutputTerminals[1], unwrapOption.InputTerminals[0]); FunctionalNode readLineFromFileHandle = new FunctionalNode(frame.Diagram, Signatures.ReadLineFromFileHandleType); Wire.Create(frame.Diagram, unwrapOption.OutputTerminals[0], readLineFromFileHandle.InputTerminals[0]); Frame innerFrame = Frame.Create(frame.Diagram); UnwrapOptionTunnel innerUnwrapOption = new UnwrapOptionTunnel(innerFrame); Wire.Create(frame.Diagram, readLineFromFileHandle.OutputTerminals[1], innerUnwrapOption.InputTerminals[0]); FunctionalNode output = new FunctionalNode(innerFrame.Diagram, Signatures.OutputType); Wire.Create(innerFrame.Diagram, innerUnwrapOption.OutputTerminals[0], output.InputTerminals[0]); TestExecutionInstance executionInstance = CompileAndExecuteFunction(function); Assert.AreEqual(data, executionInstance.RuntimeServices.LastOutputValue); }
public void UnwrapOptionTunnelWithNoneInputAndDroppableUnwrapOptionTunnel_Execute_DroppableValueIsDropped() { DfirRoot function = DfirRoot.Create(); FunctionalNode some = CreateInt32SomeConstructor(function.BlockDiagram, 0); var none = new FunctionalNode(function.BlockDiagram, Signatures.NoneConstructorType); var assign = new FunctionalNode(function.BlockDiagram, Signatures.AssignType); Wire.Create(function.BlockDiagram, some.OutputTerminals[0], assign.InputTerminals[0]) .SetWireBeginsMutableVariable(true); Wire.Create(function.BlockDiagram, none.OutputTerminals[0], assign.InputTerminals[1]); Frame frame = Frame.Create(function.BlockDiagram); var unwrapOptionTunnel = new UnwrapOptionTunnel(frame); Wire.Create(function.BlockDiagram, assign.OutputTerminals[0], unwrapOptionTunnel.InputTerminals[0]); FunctionalNode createFakeDrop = CreateFakeDropWithId(function.BlockDiagram, 1); var someFakeDrop = new FunctionalNode(function.BlockDiagram, Signatures.SomeConstructorType); Wire.Create(function.BlockDiagram, createFakeDrop.OutputTerminals[0], someFakeDrop.InputTerminals[0]); var someUnwrapOptionTunnel = new UnwrapOptionTunnel(frame); Wire.Create(function.BlockDiagram, someFakeDrop.OutputTerminals[0], someUnwrapOptionTunnel.InputTerminals[0]); TestExecutionInstance executionInstance = CompileAndExecuteFunction(function); Assert.IsTrue(executionInstance.RuntimeServices.DroppedFakeDropIds.Contains(1), "Expected FakeDrop value to be dropped."); }
public void PanickingMethodCallWithTwoOutputsThatDoesNotPanicIntoAdd_Execute_CorrectValue() { using (FeatureToggleSupport.TemporarilyEnableFeature(RebarFeatureToggles.ParametersAndCalls)) { string calleeName = "callee"; NIType calleeType = DefineFunctionTypeWithTwoIntOuts(calleeName); CompilableDefinitionName calleeDefinitionName = CreateTestCompilableDefinitionName(calleeName); DfirRoot calleeFunction = calleeType.CreateFunctionFromSignature(calleeDefinitionName); DataAccessor outputDataAccessor0 = DataAccessor.Create(calleeFunction.BlockDiagram, calleeFunction.DataItems[0], Direction.Input); DataAccessor outputDataAccessor1 = DataAccessor.Create(calleeFunction.BlockDiagram, calleeFunction.DataItems[1], Direction.Input); FunctionalNode unwrap = new FunctionalNode(calleeFunction.BlockDiagram, Signatures.UnwrapOptionType); ConnectSomeOfIntegerToInputTerminal(unwrap.InputTerminals[0], 1); Wire.Create(calleeFunction.BlockDiagram, unwrap.OutputTerminals[0], outputDataAccessor0.Terminal, outputDataAccessor1.Terminal); DfirRoot callerFunction = DfirRoot.Create(); var methodCall = new MethodCallNode(callerFunction.BlockDiagram, calleeDefinitionName, calleeType); FunctionalNode add = new FunctionalNode(callerFunction.BlockDiagram, Signatures.DefinePureBinaryFunction("Add", NITypes.Int32, NITypes.Int32)); Wire.Create(callerFunction.BlockDiagram, methodCall.OutputTerminals[0], add.InputTerminals[0]); Wire.Create(callerFunction.BlockDiagram, methodCall.OutputTerminals[1], add.InputTerminals[1]); FunctionalNode inspect = ConnectInspectToOutputTerminal(add.OutputTerminals[2]); TestExecutionInstance executionInstance = CompileAndExecuteFunction(callerFunction, calleeFunction); byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect); AssertByteArrayIsInt32(inspectValue, 2); } }
internal FunctionalNode ConnectInspectToOutputTerminal(Terminal outputTerminal) { FunctionalNode inspect = new FunctionalNode(outputTerminal.ParentDiagram, Signatures.InspectType); Wire.Create(outputTerminal.ParentDiagram, outputTerminal, inspect.InputTerminals[0]); return(inspect); }
public void LifetimeWithLiveVariablesOnMainAndNestedDiagrams_ValidateVariableUsages_TerminateLifetimeNodeHasCorrectInputTerminalCount() { var signatureBuilder = NITypes.Factory.DefineFunction("outputString"); NIType outputOwnerStringSignature = signatureBuilder.AddOutput(NITypes.String, "owner").CreateType(); DfirRoot function = DfirRoot.Create(); var outputString = new FunctionalNode(function.BlockDiagram, outputOwnerStringSignature); ExplicitBorrowNode borrow = new ExplicitBorrowNode(function.BlockDiagram, BorrowMode.Immutable, 1, true, true); Wire.Create(function.BlockDiagram, outputString.OutputTerminals[0], borrow.InputTerminals[0]); Frame outerFrame = Frame.Create(function.BlockDiagram); Tunnel outerFrameInputTunnel = CreateInputTunnel(outerFrame); Wire.Create(function.BlockDiagram, borrow.OutputTerminals[0], outerFrameInputTunnel.InputTerminals[0]); Frame innerFrame = Frame.Create(outerFrame.Diagram); Tunnel innerFrameInputTunnel = CreateInputTunnel(innerFrame), innerFrameOutputTunnel = CreateOutputTunnel(innerFrame); FunctionalNode outerStringToSlice = new FunctionalNode(outerFrame.Diagram, Signatures.StringToSliceType); Wire.Create(outerFrame.Diagram, outerFrameInputTunnel.OutputTerminals[0], innerFrameInputTunnel.InputTerminals[0], outerStringToSlice.InputTerminals[0]); FunctionalNode innerStringToSlice = new FunctionalNode(innerFrame.Diagram, Signatures.StringToSliceType); Wire.Create(innerFrame.Diagram, innerFrameInputTunnel.OutputTerminals[0], innerStringToSlice.InputTerminals[0]); Wire.Create(innerFrame.Diagram, innerStringToSlice.OutputTerminals[0], innerFrameOutputTunnel.InputTerminals[0]); Tunnel outerFrameOutputTunnel = CreateOutputTunnel(outerFrame); Wire.Create(outerFrame.Diagram, outerStringToSlice.OutputTerminals[0], outerFrameOutputTunnel.InputTerminals[0]); TerminateLifetimeNode terminateLifetime = new TerminateLifetimeNode(function.BlockDiagram, 1, 1); Wire.Create(function.BlockDiagram, outerFrameOutputTunnel.OutputTerminals[0], terminateLifetime.InputTerminals[0]); RunSemanticAnalysisUpToValidation(function); Assert.AreEqual(2, terminateLifetime.InputTerminals.Count); }
protected Constant ConnectConstantToInputTerminal(Terminal inputTerminal, NIType variableType, bool mutable) { Constant constant = Constant.Create(inputTerminal.ParentDiagram, variableType.CreateDefaultValue(), variableType); Wire wire = Wire.Create(inputTerminal.ParentDiagram, constant.OutputTerminal, inputTerminal); wire.SetWireBeginsMutableVariable(mutable); return(constant); }
private void AssignFalseToLoopConditionOutputTerminal(LoopConditionTunnel condition) { Diagram loopDiagram = condition.OutputTerminals[0].ParentDiagram; var assign = new FunctionalNode(loopDiagram, Signatures.AssignType); Wire.Create(loopDiagram, condition.OutputTerminals[0], assign.InputTerminals[0]); ConnectConstantToInputTerminal(assign.InputTerminals[1], NITypes.Boolean, false, false); }
private FunctionalNode ConnectOutputToOutputTerminal(Terminal outputTerminal) { Diagram diagram = outputTerminal.ParentDiagram; var output = new FunctionalNode(diagram, Signatures.OutputType); Wire.Create(diagram, outputTerminal, output.InputTerminals[0]); return(output); }
internal FunctionalNode ConnectSomeConstructorToInputTerminal(Terminal inputTerminal, bool mutableOutput = false) { var someConstructor = new FunctionalNode(inputTerminal.ParentDiagram, Signatures.SomeConstructorType); Wire.Create(inputTerminal.ParentDiagram, someConstructor.OutputTerminals[0], inputTerminal) .SetWireBeginsMutableVariable(mutableOutput); return(someConstructor); }
private FunctionalNode CreatePanickingUnwrapOption(Diagram parentDiagram) { FunctionalNode createNoneInteger = CreateNoneOfOptionIntegerType(parentDiagram); var unwrap = new FunctionalNode(parentDiagram, Signatures.UnwrapOptionType); Wire.Create(parentDiagram, createNoneInteger.OutputTerminals[0], unwrap.InputTerminals[0]); return(unwrap); }
public void Execute(DfirRoot dfirRoot, CompileCancellationToken cancellationToken) { var lifetimeGraphTree = dfirRoot.GetLifetimeGraphTree(); BoundedLifetimeLiveVariableSet boundedLifetimeLiveVariableSet; while (_lifetimeVariableAssociation.TryGetBoundedLifetimeWithLiveVariables(out boundedLifetimeLiveVariableSet)) { if (lifetimeGraphTree.IsDiagramLifetimeOfAnyLifetimeGraph(boundedLifetimeLiveVariableSet.Lifetime)) { // Since we assume there are no semantic errors at this point, just mark any remaining live variables // in a diagram lifetime as consumed. boundedLifetimeLiveVariableSet.LiveVariables.Select(l => l.Variable).ForEach(_lifetimeVariableAssociation.MarkVariableConsumed); continue; } int inputVariableCount = boundedLifetimeLiveVariableSet.LiveVariables.Count(); IEnumerable <VariableReference> interruptedVariables = _lifetimeVariableAssociation.GetVariablesInterruptedByLifetime(boundedLifetimeLiveVariableSet.Lifetime); int outputVariableCount = interruptedVariables.Count(); Diagram startSearch = boundedLifetimeLiveVariableSet.LiveVariables.First().Terminal.ParentDiagram; LifetimeGraphIdentifier originGraphIdentifier = lifetimeGraphTree.GetBoundedLifetimeGraphIdentifier(boundedLifetimeLiveVariableSet.Lifetime); Diagram originDiagram = originGraphIdentifier.FindDiagramForGraphIdentifier(startSearch); LiveVariable[] liveVariables = boundedLifetimeLiveVariableSet.LiveVariables.ToArray(); for (int i = 0; i < liveVariables.Length; ++i) { LiveVariable liveVariable = liveVariables[i]; while (liveVariable.Terminal.ParentDiagram != originDiagram) { liveVariable = PullLiveVariableUpToNextHigherDiagram(liveVariable); } liveVariables[i] = liveVariable; } TerminateLifetimeNode terminateLifetime = TerminateLifetimeNodeHelpers.CreateTerminateLifetimeWithFacades(originDiagram, inputVariableCount, outputVariableCount); int inputIndex = 0; foreach (LiveVariable liveVariable in liveVariables) { // TODO: maybe assert that liveVariable.Terminal is unwired here? Terminal terminateLifetimeInputTerminal = terminateLifetime.InputTerminals[inputIndex]; Wire.Create(originDiagram, liveVariable.Terminal, terminateLifetimeInputTerminal); terminateLifetimeInputTerminal.GetFacadeVariable().MergeInto(liveVariable.Variable); _lifetimeVariableAssociation.MarkVariableConsumed(liveVariable.Variable); ++inputIndex; } int outputIndex = 0; foreach (VariableReference interruptedVariable in interruptedVariables) { Terminal terminateLifetimeOutputTerminal = terminateLifetime.OutputTerminals[outputIndex]; terminateLifetimeOutputTerminal.GetFacadeVariable().MergeInto(interruptedVariable); _lifetimeVariableAssociation.MarkVariableLive(interruptedVariable, terminateLifetimeOutputTerminal); ++outputIndex; } } }
private FunctionalNode CreateNoneOfOptionIntegerType(Diagram parentDiagram) { var assign = new FunctionalNode(parentDiagram, Signatures.AssignType); ConnectSomeOfIntegerToInputTerminal(assign.InputTerminals[0], 0, true); var noneConstructor = new FunctionalNode(parentDiagram, Signatures.NoneConstructorType); Wire.Create(parentDiagram, noneConstructor.OutputTerminals[0], assign.InputTerminals[1]); return(assign); }
private void CreateAssignToSomeInt32ValueAndInspect(Diagram diagram, out FunctionalNode assign, out FunctionalNode inspect) { FunctionalNode initialSome = CreateInt32SomeConstructor(diagram, 0); assign = new FunctionalNode(diagram, Signatures.AssignType); Wire initialAssignWire = Wire.Create(diagram, initialSome.OutputTerminals[0], assign.InputTerminals[0]); initialAssignWire.SetWireBeginsMutableVariable(true); inspect = ConnectInspectToOutputTerminal(assign.OutputTerminals[0]); }
internal static ExplicitBorrowNode ConnectExplicitBorrowToInputTerminals(BorrowMode borrowMode, params Terminal[] inputTerminals) { Diagram parentDiagram = inputTerminals[0].ParentDiagram; ExplicitBorrowNode borrow = new ExplicitBorrowNode(parentDiagram, borrowMode, inputTerminals.Length, true, true); for (int i = 0; i < inputTerminals.Length; ++i) { Wire.Create(parentDiagram, borrow.OutputTerminals[i], inputTerminals[i]); } return(borrow); }
private FunctionalNode ConnectRangeWithIntegerInputsToInputTerminal(Terminal inputTerminal, bool mutable = true) { FunctionalNode range = new FunctionalNode(inputTerminal.ParentDiagram, Signatures.RangeType); ConnectConstantToInputTerminal(range.InputTerminals[0], PFTypes.Int32, false); ConnectConstantToInputTerminal(range.InputTerminals[1], PFTypes.Int32, false); Wire wire = Wire.Create(inputTerminal.ParentDiagram, range.OutputTerminals[0], inputTerminal); wire.SetWireBeginsMutableVariable(mutable); return(range); }
public void StructConstructorContainingDroppableType_Execute_DroppableValueDropped() { DfirRoot function = DfirRoot.Create(); var structConstructorNode = new StructConstructorNode(function.BlockDiagram, FakeDropStructType); FunctionalNode fakeDrop = CreateFakeDropWithId(function.BlockDiagram, 1); Wire.Create(function.BlockDiagram, fakeDrop.OutputTerminals[0], structConstructorNode.InputTerminals[0]); TestExecutionInstance executionInstance = CompileAndExecuteFunction(function); Assert.IsTrue(executionInstance.RuntimeServices.DroppedFakeDropIds.Contains(1)); }
public void DropSomeValueWithDroppableInnerValue_Execute_InnerValueIsDropped() { DfirRoot function = DfirRoot.Create(); FunctionalNode someConstructor = new FunctionalNode(function.BlockDiagram, Signatures.SomeConstructorType); FunctionalNode fakeDropCreate = CreateFakeDropWithId(function.BlockDiagram, 1); Wire.Create(function.BlockDiagram, fakeDropCreate.OutputTerminals[0], someConstructor.InputTerminals[0]); TestExecutionInstance executionInstance = CompileAndExecuteFunction(function); Assert.IsTrue(executionInstance.RuntimeServices.DroppedFakeDropIds.Contains(1)); }
public void VariantConstructorContainingDroppableValue_Execute_ValueIsDropped() { DfirRoot function = DfirRoot.Create(); var variantConstructorNode = new VariantConstructorNode(function.BlockDiagram, VariantWithDropField, 1); FunctionalNode createFakeDrop = CreateFakeDropWithId(function.BlockDiagram, 1); Wire.Create(function.BlockDiagram, createFakeDrop.OutputTerminals[0], variantConstructorNode.InputTerminals[0]); TestExecutionInstance executionInstance = CompileAndExecuteFunction(function); Assert.IsTrue(executionInstance.RuntimeServices.DroppedFakeDropIds.Contains(1)); }
public void NoneConstructorWithUsageThatDoesNotDetermineType_ValidateVariableUsage_ErrorReported() { DfirRoot function = DfirRoot.Create(); FunctionalNode none = new FunctionalNode(function.BlockDiagram, Signatures.NoneConstructorType); FunctionalNode immutablePassthrough = new FunctionalNode(function.BlockDiagram, Signatures.ImmutablePassthroughType); Wire.Create(function.BlockDiagram, none.OutputTerminals[0], immutablePassthrough.InputTerminals[0]); RunSemanticAnalysisUpToValidation(function); Assert.IsTrue(none.OutputTerminals[0].GetDfirMessages().Any(message => message.Descriptor == Messages.TypeNotDetermined.Descriptor)); }
public void BorrowNodeWithUnwiredOutput_AutomaticNodeInsertion_TerminateLifetimeNodeInserted() { DfirRoot function = DfirRoot.Create(); FunctionalNode outputOwner = new FunctionalNode(function.BlockDiagram, _outputOwnerSignature); ExplicitBorrowNode borrow = new ExplicitBorrowNode(function.BlockDiagram, BorrowMode.Immutable, 1, true, true); Wire.Create(function.BlockDiagram, outputOwner.OutputTerminals[0], borrow.InputTerminals[0]); RunCompilationUpToAutomaticNodeInsertion(function); AssertDiagramContainsNodeWithSources <TerminateLifetimeNode>(function.BlockDiagram, borrow.OutputTerminals[0]); }
private IterateTunnel CreateRangeAndIterateTunnel(Loop loop, int rangeLow, int rangeHigh) { var range = new FunctionalNode(loop.ParentDiagram, Signatures.RangeType); ConnectConstantToInputTerminal(range.InputTerminals[0], NITypes.Int32, 1, false); ConnectConstantToInputTerminal(range.InputTerminals[1], NITypes.Int32, 7, false); IterateTunnel iterateTunnel = CreateIterateTunnel(loop); Wire.Create(loop.ParentDiagram, range.OutputTerminals[0], iterateTunnel.InputTerminals[0]) .SetWireBeginsMutableVariable(true); return(iterateTunnel); }
private DfirRoot CreateStringIntoStringConcatFunction() { DfirRoot function = DfirRoot.Create(); Constant constant = Constant.Create(function.BlockDiagram, string.Empty, DataTypes.StringSliceType.CreateImmutableReference()); FunctionalNode stringFromSlice = new FunctionalNode(function.BlockDiagram, Signatures.StringFromSliceType); Wire.Create(function.BlockDiagram, constant.OutputTerminal, stringFromSlice.InputTerminals[0]); FunctionalNode stringConcat = new FunctionalNode(function.BlockDiagram, Signatures.StringConcatType); Wire.Create(function.BlockDiagram, stringFromSlice.OutputTerminals[1], stringConcat.InputTerminals[0]); return(function); }