public void UsingFindElement_TheCorrectCallIsMadeFromTheDriver( [Values] LocatorType rootLocatorType, [Values] LocatorType childLocatorType) { // Arrange bool expectedAtomicCall = rootLocatorType.IsSubAtomic() && childLocatorType.IsSubAtomic(); TestBlock block = GetBlockDefinedByLocatorType(rootLocatorType); this.findElementMethodLookup.TryGetValue(childLocatorType, out Func <TestBlock, IWebElement> method); // Act _ = method(block); // Log var driverCalls = Fake.GetCalls(this.driver).Where(c => c.Method.Name.StartsWith("FindElement")).ToList(); TestContext.WriteLine($"There were {driverCalls.Count} call(s) to the IWebDriver."); foreach (var call in driverCalls) { TestContext.WriteLine($"The method called on the IWebDriver was {call.Method.Name}({call.ArgumentsAfterCall[0]})"); } // Assert using (new AssertionScope()) { driverCalls.Count.Should().Be(1); if (expectedAtomicCall) { driverCalls[0].ArgumentsAfterCall[0].ToString().Should().StartWith("By.CssSelector"); } } }
public void UsingFindElement_NoCallIsMadeFromTheDriverWithAFoundRootElement( [Values] LocatorType childLocatorType) { // Arrange TestBlock block = new TestBlock(this.rootElement); this.findElementMethodLookup.TryGetValue(childLocatorType, out Func <TestBlock, IWebElement> method); // Act IWebElement element = method(block); // Log TestContext.WriteLine(element.Text); var driverCalls = Fake.GetCalls(this.driver).Where(c => c.Method.Name.StartsWith("FindElement")).ToList(); TestContext.WriteLine($"There were {driverCalls.Count} call(s) to the IWebDriver."); foreach (var call in driverCalls) { TestContext.WriteLine($"The method called on the IWebDriver was {call.Method.Name}({call.ArgumentsAfterCall[0]})"); } // Assert using (new AssertionScope()) { driverCalls.Count.Should().Be(0); } }
public async Task ChainNoAttestations() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); BeaconState state = TestState.PrepareTestState(testServiceProvider); MiscellaneousParameters miscellaneousParameters = testServiceProvider.GetService <IOptions <MiscellaneousParameters> >().Value; MaxOperationsPerBlock maxOperationsPerBlock = testServiceProvider.GetService <IOptions <MaxOperationsPerBlock> >().Value; // Initialization ICryptographyService cryptographyService = testServiceProvider.GetService <ICryptographyService>(); ForkChoice forkChoice = testServiceProvider.GetService <ForkChoice>(); IStore store = forkChoice.GetGenesisStore(state); // On receiving a block of `GENESIS_SLOT + 1` slot BeaconBlock block1 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: true); TestState.StateTransitionAndSignBlock(testServiceProvider, state, block1); await AddBlockToStore(testServiceProvider, store, block1); // On receiving a block of next epoch BeaconBlock block2 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: true); TestState.StateTransitionAndSignBlock(testServiceProvider, state, block2); await AddBlockToStore(testServiceProvider, store, block2); // Act Hash32 headRoot = await forkChoice.GetHeadAsync(store); // Assert Hash32 expectedRoot = cryptographyService.SigningRoot(block2); headRoot.ShouldBe(expectedRoot); }
public async Task ChainNoAttestations() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); BeaconState state = TestState.PrepareTestState(testServiceProvider); // Initialization ICryptographyService cryptographyService = testServiceProvider.GetService <ICryptographyService>(); IForkChoice forkChoice = testServiceProvider.GetService <IForkChoice>(); IStore store = testServiceProvider.GetService <IStore>(); await forkChoice.InitializeForkChoiceStoreAsync(store, state); // On receiving a block of `GENESIS_SLOT + 1` slot BeaconBlock block1 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, BlsSignature.Zero); SignedBeaconBlock signedBlock1 = TestState.StateTransitionAndSignBlock(testServiceProvider, state, block1); await AddBlockToStore(testServiceProvider, store, signedBlock1); // On receiving a block of next epoch BeaconBlock block2 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, BlsSignature.Zero); SignedBeaconBlock signedBlock2 = TestState.StateTransitionAndSignBlock(testServiceProvider, state, block2); await AddBlockToStore(testServiceProvider, store, signedBlock2); // Act Root headRoot = await forkChoice.GetHeadAsync(store); // Assert Root expectedRoot = cryptographyService.HashTreeRoot(block2); headRoot.ShouldBe(expectedRoot); }
public static void TestCode(TestBlock testBlock) { if (Util_Test.TestMode) { testBlock(PureAppli.syuturyoku1); } }
public async Task ChainNoAttestations() { // Arrange var testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); var state = TestState.PrepareTestState(testServiceProvider); var miscellaneousParameters = testServiceProvider.GetService <IOptions <MiscellaneousParameters> >().Value; var maxOperationsPerBlock = testServiceProvider.GetService <IOptions <MaxOperationsPerBlock> >().Value; // Initialization var forkChoice = testServiceProvider.GetService <ForkChoice>(); var store = forkChoice.GetGenesisStore(state); // On receiving a block of `GENESIS_SLOT + 1` slot var block1 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: true); TestState.StateTransitionAndSignBlock(testServiceProvider, state, block1); AddBlockToStore(testServiceProvider, store, block1); // On receiving a block of next epoch var block2 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: true); TestState.StateTransitionAndSignBlock(testServiceProvider, state, block2); AddBlockToStore(testServiceProvider, store, block2); // Act var headRoot = await forkChoice.GetHeadAsync(store); // Assert var expectedRoot = block2.SigningRoot(miscellaneousParameters, maxOperationsPerBlock); headRoot.ShouldBe(expectedRoot); }
public void UsingFindElements_AnAtomicCallIsMadeWhenBothLocatorsAreSubAtomic( [Values] LocatorType rootLocatorType, [Values] LocatorType childLocatorType) { // Arrange bool expectedAtomicCall = rootLocatorType.IsSubAtomic() && childLocatorType.IsSubAtomic(); TestBlock block = GetBlockDefinedByLocatorType(rootLocatorType); this.findElementsMethodLookup.TryGetValue(childLocatorType, out Func <TestBlock, ReadOnlyCollection <IWebElement> > method); // Act ReadOnlyCollection <IWebElement> elements = method(block); // Log TestContext.WriteLine(elements[0]?.Text); // Assert using (new AssertionScope()) { elements.Count.Should().Be(1); elements[0].Should().Be(expectedAtomicCall ? this.elementInElementsReturnedByDriver : this.elementInElementsReturnedByFoundElement, "the wrong IWebElement was returned."); } }
public void OnAttestationPreviousEpoch() { // Arrange var testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); var state = TestState.PrepareTestState(testServiceProvider); var initialValues = testServiceProvider.GetService <IOptions <InitialValues> >().Value; var timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; var forkChoice = testServiceProvider.GetService <ForkChoice>(); // Initialization var store = forkChoice.GetGenesisStore(state); var time = store.Time + timeParameters.SecondsPerSlot * (ulong)timeParameters.SlotsPerEpoch; forkChoice.OnTick(store, time); var block = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: true); TestState.StateTransitionAndSignBlock(testServiceProvider, state, block); // Store block in store forkChoice.OnBlock(store, block); var attestation = TestAttestation.GetValidAttestation(testServiceProvider, state, block.Slot, CommitteeIndex.None, signed: true); attestation.Data.Target.Epoch.ShouldBe(initialValues.GenesisEpoch); var beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>(); var currentSlot = forkChoice.GetCurrentSlot(store); var currentEpoch = beaconChainUtility.ComputeEpochAtSlot(currentSlot); currentEpoch.ShouldBe(initialValues.GenesisEpoch + new Epoch(1)); RunOnAttestation(testServiceProvider, state, store, attestation, expectValid: true); }
public SweepStakeTests() { var block = new TestBlock { Coinbase = contractOwnerAddress, Number = 2 }; var message = new TestMessage { ContractAddress = contractAddress, GasLimit = (Gas)(ulong)10000, Sender = punter1Address, Value = 0 }; this.transactionExecutor = Substitute.For <IInternalTransactionExecutor>(); this.smartContractState = new TestSmartContractState( block, message, new InMemoryState(), null, transactionExecutor, () => (ulong)0, new TestInternalHashHelper() ); }
public (Vector3, Vector3Int) RegisterBlock(TestBlock block) { Vector3Int gridPos = WorldToGrid(block.transform.position); Blocks[gridPos.x, gridPos.y, gridPos.z] = block; return(GridToWorld(gridPos), gridPos); }
/// <summary> /// When using the TestLoader scene to setup an experiment, this function fetches some parameters of importance from the block that was generated. /// </summary> /// <param name="testBlock"> </param> public void LoadTestData(TestBlock testBlock) { /*Eyes = new List<Camera>(); * switch (testBlock.SelectedVRHMD) * { * case TestBlock.VRHMD.VIVE: * Eyes.Add(VRCamera); * break; * case TestBlock.VRHMD.FOVE: * Eyes.Add(_foveInterface.GetEyeCamera(EFVR_Eye.Left)); * Eyes.Add(_foveInterface.GetEyeCamera(EFVR_Eye.Right)); * break; * }*/ GazeCursor.Instance.SetColor(testBlock.CursorColor); CurrentControlMethod = testBlock.SelectedControlMethod; CurrentConfirmationMethod = testBlock.SelectedConfirmationMethod; GazeCursor.Instance.TargetHovered += OnCursorHover; GazeCursor.Instance.TargetStayed += OnCursorStay; GazeCursor.Instance.TargetUnhovered += OnCursorUnhover; if (CurrentConfirmationMethod == TestBlock.ConfirmationMethod.Click) { HasClickedDown += OnClickDown; HasClickedUp += OnClickUp; } _eyeRayCache = new Ray[Mathf.Clamp(testBlock.EyeSmoothFactor, 1, int.MaxValue)]; }
public void TestCorrectIntialReadyOperationsParallelDFG() { TestBlock operation1 = new TestBlock(new List <FluidBlock> { }, null, new TestModule()); TestBlock operation2 = new TestBlock(new List <FluidBlock> { }, null, new TestModule()); TestBlock operation3 = new TestBlock(new List <FluidBlock> { }, null, new TestModule()); TestBlock operation4 = new TestBlock(new List <FluidBlock> { }, null, new TestModule()); DFG <Block> dfg = new DFG <Block>(); dfg.AddNode(operation1); dfg.AddNode(operation2); dfg.AddNode(operation3); dfg.AddNode(operation4); dfg.FinishDFG(); Assay assay = new Assay(dfg); Assert.AreEqual(assay.GetReadyOperations().Count, dfg.Nodes.Count); foreach (var node in dfg.Nodes) { //Even the pointers should be the same. Assert.IsTrue(assay.GetReadyOperations().Contains(node.value)); } }
public static void TestCode(TestBlock testBlock) { if (Util_Test.TestMode) { testBlock(Util_Machine.Syuturyoku); } }
public async Task OnAttestationCurrentEpoch() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); BeaconState state = TestState.PrepareTestState(testServiceProvider); InitialValues initialValues = testServiceProvider.GetService <IOptions <InitialValues> >().Value; TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; ForkChoice forkChoice = testServiceProvider.GetService <ForkChoice>(); // Initialization IStore store = forkChoice.GetGenesisStore(state); ulong time = store.Time + timeParameters.SecondsPerSlot * 2; await forkChoice.OnTickAsync(store, time); BeaconBlock block = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: true); TestState.StateTransitionAndSignBlock(testServiceProvider, state, block); // Store block in store await forkChoice.OnBlockAsync(store, block); Attestation attestation = TestAttestation.GetValidAttestation(testServiceProvider, state, block.Slot, CommitteeIndex.None, signed: true); attestation.Data.Target.Epoch.ShouldBe(initialValues.GenesisEpoch); BeaconChainUtility beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>(); Slot currentSlot = forkChoice.GetCurrentSlot(store); Epoch currentEpoch = beaconChainUtility.ComputeEpochAtSlot(currentSlot); currentEpoch.ShouldBe(initialValues.GenesisEpoch); await RunOnAttestation(testServiceProvider, state, store, attestation, expectValid : true); }
public AuctionTests() { var block = new TestBlock { Coinbase = ContractOwnerAddress, Number = 1 }; var message = new TestMessage { ContractAddress = ContractOwnerAddress, GasLimit = (Gas)GasLimit, Sender = ContractOwnerAddress, Value = Value }; this.transactionExecutor = Substitute.For <IInternalTransactionExecutor>(); this.smartContractState = new TestSmartContractState( block, message, new InMemoryState(), null, transactionExecutor, () => Balance, new TestInternalHashHelper() ); }
public void UsingFindElement_ACallIsMadeFromTheReturnedElementOnlyOnNonAtomicCalls( [Values] LocatorType rootLocatorType, [Values] LocatorType childLocatorType ) { // Arrange bool expectedAtomicCall = rootLocatorType.IsSubAtomic() && childLocatorType.IsSubAtomic(); TestBlock block = GetBlockDefinedByLocatorType(rootLocatorType); this.findElementMethodLookup.TryGetValue(childLocatorType, out Func <TestBlock, IWebElement> method); // Act _ = method(block); // Log var returnedElementCalls = Fake.GetCalls(this.elementReturnedByDriver).Where(c => c.Method.Name.StartsWith("FindElement")).ToList(); TestContext.WriteLine($"There were {returnedElementCalls.Count} call(s) to the returned Element."); foreach (var call in returnedElementCalls) { TestContext.WriteLine($"The Call made to the returnedElement was {call.Method.Name}({call.ArgumentsAfterCall[0]})"); } // Assert returnedElementCalls.Count.Should().Be(expectedAtomicCall ? 0 : 1); }
// [DataRow(42uL, "0xab48aa2cc6f4a0bb63b5d67be54ac3aed10326dda304c5aeb9e942b40d6e7610478377680ab90e092ef1895e62786008", 0uL, 5uL, 1uL, null)] // [DataRow(42uL, "0x8aea7d8eb22063bcfe882e2b7efc0b3713e1a48dd8343bed523b1ab4546114be84d00f896d33c605d1f67456e8e2ed93", 0uL, 5uL, 1uL, null)] // [DataRow(42uL, "0x89db41a6183c2fe47cf54d1e00c3cfaae53df634a32cccd5cf0c0a73e95ee0450fc3d060bb6878780fbf5f30d9e29aac", 0uL, 5uL, 1uL, null)] // [DataRow(42uL, "0xb783a70a1cf9f53e7d2ddf386bea81a947e5360c5f1e0bf004fceedb2073e4dd180ef3d2d91bee7b1c5a88d1afd11c49", 0uL, 5uL, 1uL, null)] // [DataRow(42uL, "0x8fe55d12257709ae842f8594f9a0a40de3d38dabdf82b21a60baac927e52ed00c5fd42f4c905410eacdaf8f8a9952490", 0uL, 5uL, 1uL, null)] // [DataRow(42uL, "0x95906ec0660892c205634e21ad540cbe0b6f7729d101d5c4639b864dea09be7f42a4252c675d46dd90a2661b3a94e8ca", 0uL, 5uL, 1uL, null)] public async Task ValidatorDutyAtSpecificTimeDuplicateProposal(ulong targetTime, string publicKey, ulong epoch, ulong attestationSlot, ulong attestationShard, ulong?blockProposalSlot) { // NOTE: Current algorithm for GetBeaconProposerIndex() someimtes allocates multiple proposal slots in an epoch, e.g. above index 23 gets slot 2 and 6 // It could be an error in the algorithm (need to check; domain type could be wrong), or due to the pre-shard algorithm. // The algorithm before shards were removed was different, so maybe ignore for now, implement phase 1 (with shards), and worry about it then. // This test for now will simply detect if things unintentionally change. // Arrange IServiceCollection testServiceCollection = TestSystem.BuildTestServiceCollection(useStore: true); testServiceCollection.AddSingleton <IHostEnvironment>(Substitute.For <IHostEnvironment>()); ServiceProvider testServiceProvider = testServiceCollection.BuildServiceProvider(); BeaconState state = TestState.PrepareTestState(testServiceProvider); IForkChoice forkChoice = testServiceProvider.GetService <IForkChoice>(); // Get genesis store initialise MemoryStoreProvider with the state IStore store = testServiceProvider.GetService <IStore>(); await forkChoice.InitializeForkChoiceStoreAsync(store, state); // Move forward time TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; for (ulong timeSinceGenesis = 1; timeSinceGenesis <= targetTime; timeSinceGenesis++) { ulong time = state.GenesisTime + timeSinceGenesis; await forkChoice.OnTickAsync(store, time); if (timeSinceGenesis % timeParameters.SecondsPerSlot == 0) { BeaconBlock block = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, BlsSignature.Zero); SignedBeaconBlock signedBlock = TestState.StateTransitionAndSignBlock(testServiceProvider, state, block); await forkChoice.OnBlockAsync(store, signedBlock); } } Console.WriteLine(""); Console.WriteLine("***** State advanced to slot {0}, time {1}, ready to start tests *****", state.Slot, store.Time); Console.WriteLine(""); // Act ValidatorAssignments validatorAssignments = testServiceProvider.GetService <ValidatorAssignments>(); BlsPublicKey validatorPublicKey = new BlsPublicKey(publicKey); Epoch targetEpoch = new Epoch(epoch); ValidatorDuty validatorDuty = await validatorAssignments.GetValidatorDutyAsync(validatorPublicKey, targetEpoch); Console.WriteLine("Validator {0}, epoch {1}: attestation slot {2}, shard {3}, proposal slot {4}", validatorPublicKey, targetEpoch, validatorDuty.AttestationSlot, (ulong)validatorDuty.AttestationShard, validatorDuty.BlockProposalSlot); // Assert validatorDuty.ValidatorPublicKey.ShouldBe(validatorPublicKey); Slot expectedBlockProposalSlot = blockProposalSlot.HasValue ? new Slot(blockProposalSlot.Value) : Slot.None; Slot expectedAttestationSlot = new Slot(attestationSlot); Shard expectedAttestationShard = new Shard(attestationShard); validatorDuty.BlockProposalSlot.ShouldBe(expectedBlockProposalSlot); validatorDuty.AttestationSlot.ShouldBe(expectedAttestationSlot); validatorDuty.AttestationShard.ShouldBe(expectedAttestationShard); }
public void ProposerIndexForFirstTwoEpochsMustBeValid() { // Arrange IServiceCollection testServiceCollection = TestSystem.BuildTestServiceCollection(useStore: true); testServiceCollection.AddSingleton <IHostEnvironment>(Substitute.For <IHostEnvironment>()); ServiceProvider testServiceProvider = testServiceCollection.BuildServiceProvider(); BeaconState state = TestState.PrepareTestState(testServiceProvider); ForkChoice forkChoice = testServiceProvider.GetService <ForkChoice>(); // Get genesis store initialise MemoryStoreProvider with the state IStore store = forkChoice.GetGenesisStore(state); // Move forward time BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>(); TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; ulong time = state.GenesisTime + 1; ulong nextSlotTime = state.GenesisTime; ValidatorIndex maximumValidatorIndex = new ValidatorIndex((ulong)state.Validators.Count - 1); ValidatorIndex validatorIndex0 = beaconStateAccessor.GetBeaconProposerIndex(state); Console.WriteLine("Slot {0}, time {1} = proposer index {2}", state.Slot, time, validatorIndex0); validatorIndex0.ShouldBeLessThanOrEqualTo(maximumValidatorIndex); List <ValidatorIndex> proposerIndexes = new List <ValidatorIndex>(); proposerIndexes.Add(validatorIndex0); for (int slotIndex = 1; slotIndex <= 16; slotIndex++) { // Slot 1 nextSlotTime = nextSlotTime + timeParameters.SecondsPerSlot; while (time < nextSlotTime) { forkChoice.OnTick(store, time); time++; } forkChoice.OnTick(store, time); time++; BeaconBlock block = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: true); TestState.StateTransitionAndSignBlock(testServiceProvider, state, block); forkChoice.OnBlock(store, block); forkChoice.OnTick(store, time); time++; ValidatorIndex validatorIndex = beaconStateAccessor.GetBeaconProposerIndex(state); Console.WriteLine("Slot {0}, time {1} = proposer index {2}", state.Slot, time, validatorIndex); validatorIndex.ShouldBeLessThanOrEqualTo(maximumValidatorIndex); proposerIndexes.Add(validatorIndex); } for (var slotIndex = 0; slotIndex < proposerIndexes.Count; slotIndex++) { ValidatorIndex proposerIndex = proposerIndexes[slotIndex]; Validator proposer = state.Validators[(int)(ulong)proposerIndex]; Console.WriteLine("Slot {0} = proposer index {1}, public key {2}", slotIndex, proposerIndex, proposer.PublicKey); } }
public void ProgramPoint_Equivalence() { var block = new TestBlock(); var pp1 = new ProgramPoint(block, 1); var pp2 = new ProgramPoint(block, 1); pp2.Should().Be(pp1); pp2.GetHashCode().Should().Be(pp1.GetHashCode()); }
public void ProgramPoint_Equivalence() { var block = new TestBlock(); var pp1 = new ProgramPoint(block, 1); var pp2 = new ProgramPoint(block, 1); Assert.AreEqual(pp1, pp2); Assert.AreEqual(pp1.GetHashCode(), pp2.GetHashCode()); }
public void ProgramPoint_Diff_Offset() { var block = new TestBlock(); var pp1 = new ProgramPoint(block, 1); var pp2 = new ProgramPoint(block, 2); Assert.AreNotEqual(pp1, pp2); Assert.AreNotEqual(pp1.GetHashCode(), pp2.GetHashCode()); }
public void ProgramPoint_Diff_Offset() { var block = new TestBlock(); var pp1 = new ProgramPoint(block, 1); var pp2 = new ProgramPoint(block, 2); pp2.Should().NotBe(pp1); pp2.GetHashCode().Should().NotBe(pp1.GetHashCode()); }
public void TestUpdateReadyOperationsMultiDependecy() { TestBlock operation1 = new TestBlock(new List <FluidBlock> { }, "op1", new TestModule()); TestBlock operation3 = new TestBlock(new List <FluidBlock> { }, "op3", new TestModule()); TestBlock operation2 = new TestBlock(new List <FluidBlock> { operation1, operation3 }, "op2", new TestModule()); TestBlock operation4 = new TestBlock(new List <FluidBlock> { }, "op4", new TestModule()); DFG <Block> dfg = new DFG <Block>(); dfg.AddNode(operation1); dfg.AddNode(operation3); dfg.AddNode(operation2); dfg.AddNode(operation4); dfg.FinishDFG(); //Now the operations associated with node 1, //should wait for the operation assocaited with node 0 and 2. Assay assay = new Assay(dfg); //Remove first dependecy assay.UpdateReadyOperations(dfg.Nodes[2].value); Assert.AreEqual(assay.GetReadyOperations().Count, dfg.Nodes.Count - 2); Assert.IsTrue(assay.GetReadyOperations().Contains(dfg.Nodes[0].value)); Assert.IsTrue(assay.GetReadyOperations().Contains(dfg.Nodes[3].value)); Assert.IsFalse(assay.GetReadyOperations().Contains(dfg.Nodes[1].value)); Assert.IsFalse(assay.GetReadyOperations().Contains(dfg.Nodes[2].value)); Assert.IsFalse(dfg.Nodes[0].value.IsDone); Assert.IsFalse(dfg.Nodes[1].value.IsDone); Assert.IsTrue(dfg.Nodes[2].value.IsDone); Assert.IsFalse(dfg.Nodes[3].value.IsDone); //remove last dependecy assay.UpdateReadyOperations(dfg.Nodes[0].value); Assert.AreEqual(assay.GetReadyOperations().Count, dfg.Nodes.Count - 2); Assert.IsTrue(assay.GetReadyOperations().Contains(dfg.Nodes[1].value)); Assert.IsTrue(assay.GetReadyOperations().Contains(dfg.Nodes[3].value)); Assert.IsFalse(assay.GetReadyOperations().Contains(dfg.Nodes[0].value)); Assert.IsFalse(assay.GetReadyOperations().Contains(dfg.Nodes[2].value)); Assert.IsTrue(dfg.Nodes[0].value.IsDone); Assert.IsFalse(dfg.Nodes[1].value.IsDone); Assert.IsTrue(dfg.Nodes[2].value.IsDone); Assert.IsFalse(dfg.Nodes[3].value.IsDone); }
public void It_renders_its_child_parts_only_once_if_name_evaluates_to_a_collection() { var a = new TestBlock("a", new LiteralText("b")); var writer = new StringWriter(); var context = new RenderContext(null, new { a = new[] { 1, 2, 3 } }, writer, null); a.Render(context); Assert.AreEqual("b", writer.GetStringBuilder().ToString()); }
public void InvalidSignatureBlockHeader() { // Arrange var testServiceProvider = TestSystem.BuildTestServiceProvider(); var state = TestState.PrepareTestState(testServiceProvider); var block = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: false); RunBlockHeaderProcessing(testServiceProvider, state, block, expectValid: false); }
public void SuccessBlockHeader() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(); BeaconState state = TestState.PrepareTestState(testServiceProvider); BeaconBlock block = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, BlsSignature.Zero); RunBlockHeaderProcessing(testServiceProvider, state, block, expectValid: true); }
public static List <TestTrial> GetStepsFromBlock(TestBlock block) { List <TestTrial> steps = new List <TestTrial>(); foreach (TestSequence trial in block.Sequences) { steps.AddRange(trial.Trials); } return(steps); }
public void InvalidSlotBlockHeader() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(); BeaconState state = TestState.PrepareTestState(testServiceProvider); BeaconBlock block = TestBlock.BuildEmptyBlock(testServiceProvider, state, state.Slot + new Slot(2), BlsSignature.Zero); RunBlockHeaderProcessing(testServiceProvider, state, block, expectValid: false); }
public void It_supports_accessing_members_of_child_objects() { var a = new TestBlock("a.b", new LiteralText("c")); var writer = new StringWriter(); var context = new RenderContext(null, new { a = new { b = new[] { 1, 2, 3 } } }, writer, null); a.Render(context); Assert.AreEqual("c", writer.GetStringBuilder().ToString()); }
public void It_does_not_render_its_child_parts_if_name_evaluates_to_empty_string() { var a = new TestBlock("a", new LiteralText("b")); var writer = new StringWriter(); var context = new RenderContext(null, new { a = "" }, writer, null); a.Render(context); Assert.AreEqual("", writer.GetStringBuilder().ToString()); }
public void Block_CreateAndGetFace_ShouldFindFace() { // 1. Prepare SphericalVector faceOrientation = new SphericalVector(Math.PI, Math.PI); // 2. Execute Block b = new TestBlock(new BlockFace("test", faceOrientation)); BlockFace f = b.GetBlockFace(faceOrientation); // 3. Verify Assert.NotNull(f); }
public void Block_CreateAndGetFaceWithBadOrientation_ReturnNull() { // 1. Prepare SphericalVector faceOrientation = new SphericalVector(Math.PI, Math.PI); Block b = new TestBlock(new BlockFace("test", faceOrientation)); // 2. Execute BlockFace f = b.GetBlockFace(new SphericalVector(100, 100)); // 3. Verify Assert.Null(f); }
public async Task ShorterChainButHeavierWeight() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); BeaconState state = TestState.PrepareTestState(testServiceProvider); // Initialization ICryptographyService cryptographyService = testServiceProvider.GetService <ICryptographyService>(); IForkChoice forkChoice = testServiceProvider.GetService <IForkChoice>(); IStore store = testServiceProvider.GetService <IStore>(); await forkChoice.InitializeForkChoiceStoreAsync(store, state); BeaconState genesisState = BeaconState.Clone(state); // build longer tree Root longRoot = Root.Zero; BeaconState longState = BeaconState.Clone(genesisState); for (int i = 0; i < 3; i++) { BeaconBlock longBlock = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, longState, BlsSignature.Zero); SignedBeaconBlock signedLongBlock = TestState.StateTransitionAndSignBlock(testServiceProvider, longState, longBlock); await AddBlockToStore(testServiceProvider, store, signedLongBlock); if (i == 2) { longRoot = cryptographyService.HashTreeRoot(longBlock); } } // build short tree BeaconState shortState = BeaconState.Clone(genesisState); BeaconBlock shortBlock = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, shortState, BlsSignature.Zero); shortBlock.Body.SetGraffiti(new Bytes32(Enumerable.Repeat((byte)0x42, 32).ToArray())); TestBlock.SignBlock(testServiceProvider, shortState, shortBlock, ValidatorIndex.None); SignedBeaconBlock signedShortBlock = TestState.StateTransitionAndSignBlock(testServiceProvider, shortState, shortBlock); await AddBlockToStore(testServiceProvider, store, signedShortBlock); Attestation shortAttestation = TestAttestation.GetValidAttestation(testServiceProvider, shortState, shortBlock.Slot, CommitteeIndex.None, signed: true); await AddAttestationToStore(testServiceProvider, store, shortAttestation); // Act Root headRoot = await forkChoice.GetHeadAsync(store); // Assert Root expectedRoot = cryptographyService.HashTreeRoot(shortBlock); headRoot.ShouldBe(expectedRoot); headRoot.ShouldNotBe(longRoot); }
public void It_has_a_useful_ToString_method() { var a = new TestBlock("a"); Assert.AreEqual("TestBlock(\"a\")", a.ToString()); }