public void SetUp() { this.game = new Game(); this.system = new TestSystem(); this.entityComponent = new TestEntityComponent(); this.testPassed = false; }
public void CallAllSystemTasksAsynchronous_10000SystemsExist_10000CallsCounted() { // arrange ILogManager lmMock = this.mocks.NewMock<ILogManager>(); Stub.On( lmMock ).Method( "Trace" ).WithAnyArguments(); int systemsCount = 10000; ISystem systemOne = new TestSystem( lmMock ); //TestSystem.ResetUpdateCallsList(); IList<ISystem> systems = new List<ISystem>( systemsCount ); for ( int i = 0; i < systemsCount; i++ ) { systems.Add( systemOne ); } int taskCounter = 0; object taskCounterLock = new object(); systemOne.TaskStarted += x => { lock ( taskCounterLock ) { taskCounter++; } }; Assert.AreEqual( systemsCount, systems.Count ); ISystemsManager smMock = this.mocks.NewMock<ISystemsManager>(); Stub.On( smMock ).GetProperty( "RegisteredSystems" ).Will( Return.Value( systems ) ); IMainLoopManager mlmMock = this.mocks.NewMock<IMainLoopManager>(); Stub.On( mlmMock ).EventAdd( "HeartbeatStarted" ); Stub.On( mlmMock ).EventAdd( "HeartbeatEnded" ); IStateManager stmMock = this.mocks.NewMock<IStateManager>(); ITaskManager tm = new TaskManager( lmMock, smMock, mlmMock, stmMock ); // act tm.CallAllSystemTasksAsynchronous(); // assert //Assert.AreEqual( systemsCount, TestSystem.UpdateCalls.Count ); Assert.AreEqual( systemsCount, taskCounter ); //SortedList<int, int> usedThreads = new SortedList<int, int>(); //foreach ( int threadId in TestSystem.UpdateCalls ) //{ // if ( !usedThreads.ContainsKey( threadId ) ) // { // usedThreads.Add( threadId, threadId ); // } //} //if ( Environment.ProcessorCount == 1 ) //{ // Assert.AreEqual( 1, usedThreads ); // Assert.Inconclusive( "This machine only has one CPU. Asynchronous behavious or the task manager can only work parallel on a machine with more than one CPU." ); //} //if ( Environment.ProcessorCount > 1 && usedThreads.Count == 1 ) //{ // Assert.Inconclusive( "The asynchronous method seems to have only used 1 thread even though this machine has more than one CPU. Run the test again to ensure it usually uses more threads." ); //} }
public void SuccessAttestation() { // Arrange var testServiceProvider = TestSystem.BuildTestServiceProvider(); var state = TestState.PrepareTestState(testServiceProvider); var attestation = TestAttestation.GetValidAttestation(testServiceProvider, state, Slot.None, CommitteeIndex.None, signed: true); var timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; var slot = state.Slot + timeParameters.MinimumAttestationInclusionDelay; state.SetSlot(slot); RunAttestationProcessing(testServiceProvider, state, attestation, expectValid: true); }
public async Task ValidateRegisterAsyncThrowsInvalidServerResponseForBadResponse() { var testSystem = new TestSystem().WithDirectoryResponse(); var(acmeClient, restClient) = testSystem.Build(); var testContacts = new[] { "mailto:[email protected]", "+1 012-3456-789" }; var returnAccount = new Account { }; restClient.Setup(rc => rc.PostAsync <Account>(TestHelpers.acmeDirectory.NewAccount, It.IsAny <Account>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(((Account)null, string.Empty))); await acmeClient.RegisterAsync(testContacts); }
public async Task BasicOnTick() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); BeaconState state = TestState.PrepareTestState(testServiceProvider); IForkChoice forkChoice = testServiceProvider.GetService <IForkChoice>(); IStore store = testServiceProvider.GetService <IStore>(); await forkChoice.InitializeForkChoiceStoreAsync(store, state); // Act await RunOnTick(testServiceProvider, store, store.Time + 1, expectNewJustifiedCheckpoint : false); // Assert }
public void IsValidGenesisStateFalseInvalidTimestamp() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); ChainConstants chainConstants = testServiceProvider.GetService <ChainConstants>(); TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; MiscellaneousParameters miscellaneousParameters = testServiceProvider.GetService <IOptions <MiscellaneousParameters> >().Value; // Act BeaconState state = CreateValidBeaconState(testServiceProvider, eth1TimestampOverride: (miscellaneousParameters.MinimumGenesisTime - 3 * timeParameters.MinimumGenesisDelay)); // Assert IsValidGenesisState(testServiceProvider, state, false); }
public void IsValidGenesisStateTrueMoreBalance() { // Arrange var testServiceProvider = TestSystem.BuildTestServiceProvider(); var gweiValues = testServiceProvider.GetService <IOptions <GweiValues> >().Value; // Act var state = CreateValidBeaconState(testServiceProvider); state.Validators[0].SetEffectiveBalance(gweiValues.MaximumEffectiveBalance + (Gwei)1); // Assert IsValidGenesisState(testServiceProvider, state, true); }
public override void TearDown() { if (runSystemEntity != Entity.Null) { m_Manager.DestroyEntity(runSystemEntity); runSystemEntity = Entity.Null; } if (system != null) { World.Active.DestroySystem(system); system = null; } base.TearDown(); }
public void GetSystem_ShouldReturnSystemOfType() { // arrange var system = new TestSystem(); var manager = new SystemManager { Subjects = { system, Mock.Of <System>() } }; // act var result = manager.GetSystem <TestSystem>(); // assert Assert.Equal(system, result); }
protected void btnAddSys_Click(object sender, EventArgs e) { if (Systems.Any(a => a.Value.Name.Equals(txtSysName.Text))) { ltlError.Text = "A system with this name already exists."; } else { TestSystem sys = new TestSystem(); sys.Name = txtSysName.Text; sys.ID = (Systems.Any()) ? Systems.OrderBy(a => a.Key).Last().Key + 1 : 0; Systems.Add(sys.ID, sys); UpdateSys(); ResetForm(); } }
public async Task SplitTieBreakerNoAttestations() { // 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); BeaconState genesisState = BeaconState.Clone(state); // block at slot 1 BeaconState block1State = BeaconState.Clone(genesisState); BeaconBlock block1 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, block1State, signed: true); TestState.StateTransitionAndSignBlock(testServiceProvider, block1State, block1); await AddBlockToStore(testServiceProvider, store, block1); Hash32 block1Root = cryptographyService.SigningRoot(block1); // build short tree BeaconState block2State = BeaconState.Clone(genesisState); BeaconBlock block2 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, block2State, signed: true); block2.Body.SetGraffiti(new Bytes32(Enumerable.Repeat((byte)0x42, 32).ToArray())); TestBlock.SignBlock(testServiceProvider, block2State, block2, ValidatorIndex.None); TestState.StateTransitionAndSignBlock(testServiceProvider, block2State, block2); await AddBlockToStore(testServiceProvider, store, block2); Hash32 block2Root = cryptographyService.SigningRoot(block2); // Act Hash32 headRoot = await forkChoice.GetHeadAsync(store); // Assert Console.WriteLine("block1 {0}", block1Root); Console.WriteLine("block2 {0}", block2Root); Hash32 highestRoot = block1Root.CompareTo(block2Root) > 0 ? block1Root : block2Root; Console.WriteLine("highest {0}", highestRoot); headRoot.ShouldBe(highestRoot); }
public async Task SplitTieBreakerNoAttestations() { // 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); // block at slot 1 BeaconState block1State = BeaconState.Clone(genesisState); BeaconBlock block1 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, block1State, BlsSignature.Zero); SignedBeaconBlock signedBlock1 = TestState.StateTransitionAndSignBlock(testServiceProvider, block1State, block1); await AddBlockToStore(testServiceProvider, store, signedBlock1); Root block1Root = cryptographyService.HashTreeRoot(block1); // build short tree BeaconState block2State = BeaconState.Clone(genesisState); BeaconBlock block2 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, block2State, BlsSignature.Zero); block2.Body.SetGraffiti(new Bytes32(Enumerable.Repeat((byte)0x42, 32).ToArray())); TestBlock.SignBlock(testServiceProvider, block2State, block2, ValidatorIndex.None); SignedBeaconBlock signedBlock2 = TestState.StateTransitionAndSignBlock(testServiceProvider, block2State, block2); await AddBlockToStore(testServiceProvider, store, signedBlock2); Root block2Root = cryptographyService.HashTreeRoot(block2); // Act Root headRoot = await forkChoice.GetHeadAsync(store); // Assert Console.WriteLine("block1 {0}", block1Root); Console.WriteLine("block2 {0}", block2Root); Root highestRoot = block1Root.CompareTo(block2Root) > 0 ? block1Root : block2Root; Console.WriteLine("highest {0}", highestRoot); headRoot.ShouldBe(highestRoot); }
public static void Check_Instruction_68_LD_Address_Register16() { StringBuilder testProgram = new StringBuilder(); // TStatesByMachineCycle = "10 (4, 3, 3)" testProgram.AppendLine("LD HL,4163"); // TStatesByMachineCycle = "10 (4, 3, 3)" testProgram.AppendLine("LD BC,4164"); // TStatesByMachineCycle = "14 (4, 4, 3, 3)" testProgram.AppendLine("LD IY,4165"); // TStatesByMachineCycle = "10 (4, 3, 3)" testProgram.AppendLine("LD SP,4166"); // TStatesByMachineCycle = "16 (4, 3, 3, 3, 3)" testProgram.AppendLine("LD (4253),HL"); // TStatesByMachineCycle = "20 (4, 4, 3, 3, 3, 3)" testProgram.AppendLine("LD DE,(4253)"); // TStatesByMachineCycle = "20 (4, 4, 3, 3, 3, 3)" testProgram.AppendLine("LD (4253),BC"); // TStatesByMachineCycle = "20 (4, 4, 3, 3, 3, 3)" testProgram.AppendLine("LD DE,(4253)"); // TStatesByMachineCycle = "20 (4, 4, 3, 3, 3, 3)" testProgram.AppendLine("LD (4253),IY"); // TStatesByMachineCycle = "20 (4, 4, 3, 3, 3, 3)" testProgram.AppendLine("LD DE,(4253)"); // TStatesByMachineCycle = "20 (4, 4, 3, 3, 3, 3)" testProgram.AppendLine("LD (4253),SP"); // TStatesByMachineCycle = "20 (4, 4, 3, 3, 3, 3)" testProgram.AppendLine("LD DE,(4253)"); TestSystem testSystem = new TestSystem(); testSystem.LoadProgramInMemory(testProgram.ToString()); CPUStateLogger logger = new CPUStateLogger(testSystem.CPU); logger.StartLogging( CPUStateLogger.CPUStateElements.InternalState | CPUStateLogger.CPUStateElements.Registers, new Z80CPU.LifecycleEventType[] { Z80CPU.LifecycleEventType.MachineCycleEnd }); testSystem.ExecuteInstructionCount(12); logger.StopLogging(); if (!logger.CompareWithSavedLog("CPU/Load16Bit/Logs/Check_Instruction_68_LD_Address_Register16")) { throw new Exception("Log compare failed"); } }
public void InjectGroupTest() { var context = ContextFactory.CreateEntitiesContext(); context.GetManager <EntityManager>().CreateEntity(ComponentType.Create <StructComponent>()); var systems = context.GetManager <SystemManager>(); var system = new TestSystem(); Assert.IsNull(system.group); Assert.IsNull(system.group2); systems.AddSystem(system); Assert.NotNull(system.group); Assert.IsNull(system.group2); }
public void ActivationQueueSorting() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(); BeaconState state = TestState.PrepareTestState(testServiceProvider); ChainConstants chainConstants = testServiceProvider.GetService <ChainConstants>(); BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>(); int mockActivations = 10; Epoch currentEpoch = beaconStateAccessor.GetCurrentEpoch(state); for (int index = 0; index < mockActivations; index++) { MockDeposit(testServiceProvider, state, index); state.Validators[index].SetEligible(currentEpoch + Epoch.One); } // eligibility must be finalized state.SetFinalizedCheckpoint(new Checkpoint(currentEpoch + new Epoch(2), Root.Zero)); // give the last priority over the others state.Validators[mockActivations - 1].SetEligible(currentEpoch); // make sure we are hitting the churn int churnLimit = (int)beaconStateAccessor.GetValidatorChurnLimit(state); mockActivations.ShouldBeGreaterThan(churnLimit); // Act RunProcessRegistryUpdates(testServiceProvider, state); // Assert //# the first got in as second state.Validators[0].ActivationEpoch.ShouldNotBe(chainConstants.FarFutureEpoch); //# the prioritized got in as first state.Validators[mockActivations - 1].ActivationEpoch.ShouldNotBe(chainConstants.FarFutureEpoch); //# the second last is at the end of the queue, and did not make the churn, //# hence is not assigned an activation_epoch yet. state.Validators[mockActivations - 2].ActivationEpoch.ShouldBe(chainConstants.FarFutureEpoch); //# the one at churn_limit - 1 did not make it, it was out-prioritized state.Validators[churnLimit - 1].ActivationEpoch.ShouldBe(chainConstants.FarFutureEpoch); //# but the the one in front of the above did state.Validators[churnLimit - 2].ActivationEpoch.ShouldNotBe(chainConstants.FarFutureEpoch); }
public static void Check_Instruction_60_LD_Register_Register() { StringBuilder testProgram = new StringBuilder(); // TStatesByMachineCycle = "7 (4,3)" testProgram.AppendLine("LD C,10"); // TStatesByMachineCycle = "1 (4)" testProgram.AppendLine("LD D,C"); // TStatesByMachineCycle = "8 (4,4)" testProgram.AppendLine("LD IXh,D"); // TStatesByMachineCycle = "8 (4,4)" testProgram.AppendLine("LD E,IXh"); // TStatesByMachineCycle = "8 (4,4)" testProgram.AppendLine("LD IXl,IXh"); // TStatesByMachineCycle = "11 (4,4,3)" testProgram.AppendLine("LD IYh,32"); // TStatesByMachineCycle = "8 (4,4)" testProgram.AppendLine("LD IYl,IYh"); // TStatesByMachineCycle = "7 (4,3)" testProgram.AppendLine("LD A,55"); // TStatesByMachineCycle = "9 (4, 5)" testProgram.AppendLine("LD R,A"); // TStatesByMachineCycle = "7 (4,3)" testProgram.AppendLine("LD A,0"); // TStatesByMachineCycle = "9 (4, 5)" testProgram.AppendLine("LD A,R"); // TStatesByMachineCycle = "9 (4, 5)" testProgram.AppendLine("LD A,I"); TestSystem testSystem = new TestSystem(); testSystem.LoadProgramInMemory(testProgram.ToString()); CPUStateLogger logger = new CPUStateLogger(testSystem.CPU); logger.StartLogging( CPUStateLogger.CPUStateElements.InternalState | CPUStateLogger.CPUStateElements.Registers, new Z80CPU.LifecycleEventType[] { Z80CPU.LifecycleEventType.MachineCycleEnd }); testSystem.ExecuteInstructionCount(12); logger.StopLogging(); if (!logger.CompareWithSavedLog("CPU/Load_8Bit/Logs/Check_Instruction_60_LD_Register_Register")) { throw new Exception("Log compare failed"); } }
/// <summary> /// 重载基类 SetVerticesDirty 函数 /// </summary> public override void SetVerticesDirty() { TestLog("SetVerticesDirty"); base.SetVerticesDirty(); //if (lastText != m_Text) { // lastText = m_Text; perfectSize = new Vector2(0, 0); TestSystem.startTimer("Parse Text Start"); createParser().parseText(m_Text); TestSystem.endTimer("Parse Text End"); //} }
public void NewDepositUnderMax() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(); BeaconState state = TestState.PrepareTestState(testServiceProvider); // fresh deposit = next validator index = validator appended to registry ValidatorIndex validatorIndex = new ValidatorIndex((ulong)state.Validators.Count); // effective balance will be 1 EFFECTIVE_BALANCE_INCREMENT smaller because of this small decrement. GweiValues gweiValues = testServiceProvider.GetService <IOptions <GweiValues> >().Value; Gwei amount = gweiValues.MaximumEffectiveBalance - new Gwei(1); Deposit deposit = TestDeposit.PrepareStateAndDeposit(testServiceProvider, state, validatorIndex, amount, Bytes32.Zero, signed: true); RunDepositProcessing(testServiceProvider, state, deposit, validatorIndex, expectValid: true, effective: true); }
public static void Check_Instruction_122_RST_ResetAddress() { StringBuilder testProgram = new StringBuilder(); testProgram.AppendLine("LD A,0"); testProgram.AppendLine("RST 08H"); testProgram.AppendLine("ORG 08H"); testProgram.AppendLine("LD A,1"); testProgram.AppendLine("RST 10H"); testProgram.AppendLine("ORG 10H"); testProgram.AppendLine("LD A,2"); testProgram.AppendLine("RST 18H"); testProgram.AppendLine("ORG 18H"); testProgram.AppendLine("LD A,3"); testProgram.AppendLine("RST 20H"); testProgram.AppendLine("ORG 20H"); testProgram.AppendLine("LD A,4"); testProgram.AppendLine("RST 28H"); testProgram.AppendLine("ORG 28H"); testProgram.AppendLine("LD A,5"); testProgram.AppendLine("RST 30H"); testProgram.AppendLine("ORG 30H"); testProgram.AppendLine("LD A,6"); testProgram.AppendLine("RST 38H"); testProgram.AppendLine("ORG 38H"); testProgram.AppendLine("LD A,7"); testProgram.AppendLine("RST 00H"); TestSystem testSystem = new TestSystem(); testSystem.LoadProgramInMemory(testProgram.ToString()); CPUStateLogger logger = new CPUStateLogger(testSystem.CPU); logger.StartLogging( CPUStateLogger.CPUStateElements.InternalState | CPUStateLogger.CPUStateElements.Registers, new Z80CPU.LifecycleEventType[] { Z80CPU.LifecycleEventType.MachineCycleEnd }); testSystem.ExecuteInstructionCount(17); logger.StopLogging(); if (!logger.CompareWithSavedLog("CPU/CallAndReturn/Logs/Check_Instruction_122_RST_ResetAddress")) { throw new Exception("Log compare failed"); } }
public static void Check_Memptr(int launchAddress, string testDescription) { TestSystem testSystem = new TestSystem(); string testSourcePath = "FlagsAndMemptr/z80tests-Memptr.asm"; using (Stream stream = PlatformSpecific.GetStreamForProjectFile(testSourcePath)) { testSystem.LoadProgramInMemory(testSourcePath, stream, Encoding.UTF8, false); } testSystem.CPU.InitProgramCounter((ushort)launchAddress); testSystem.AddBreakpointOnProgramLine(1974); /*StringBuilder sb = new StringBuilder(); * int counter = 1; * foreach (string variable in testSystem.ProgramInMemory.Variables.Keys) * { * if (variable.Contains("LAUNCH")) * { * sb.AppendLine("public static int " + variable.Replace("LAUNCH", "ADDR") + " = 0x" + testSystem.ProgramInMemory.Variables[variable].GetValue(testSystem.ProgramInMemory.Variables, null).ToString("X4") +";"); * sb.AppendLine("public static string " + variable.Replace("LAUNCH", "DESC") + " = \"" + testSystem.ProgramInMemory.Lines.First(line => (line.Comment !=null && line.Comment.Contains("test "+counter.ToString("D2")+" : "))).Comment.Split(':')[1].Trim() + "\";"); * counter++; * } * } * sb.Clear(); * for (counter = 1; counter <= 58; counter++) * { * sb.AppendLine("FlagsAndMemptrTests.Check_Memptr(FlagsAndMemptrTests.MEMPTR_TEST_" + counter.ToString("D2") + "_ADDR, FlagsAndMemptrTests.MEMPTR_TEST_" + counter.ToString("D2") + "_DESC);"); * }*/ /*CPUStateLogger logger = new CPUStateLogger(testSystem.CPU); * logger.StartLogging( * CPUStateLogger.CPUStateElements.InternalState | * CPUStateLogger.CPUStateElements.Registers, * new Z80CPU.LifecycleEventType[] { * Z80CPU.LifecycleEventType.InstructionEnd * });*/ testSystem.ExecuteUntilNextBreakpoint(); //logger.StopLogging(); if (testSystem.CPU.A != 0) { throw new Exception("Memptr test for " + testDescription + " failed"); } }
public void HistoricalRootAccumulator() { // Arrange var testServiceProvider = TestSystem.BuildTestServiceProvider(); var state = TestState.PrepareTestState(testServiceProvider); var timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; // skip ahead to near the end of the historical roots period (excl block before epoch processing) state.SetSlot((Slot)(timeParameters.SlotsPerHistoricalRoot - 1UL)); var historyLength = state.HistoricalRoots.Count; // Act RunProcessFinalUpdates(testServiceProvider, state); // Assert state.HistoricalRoots.Count.ShouldBe(historyLength + 1); }
public void Start_DoesNothingWhenEcsContainsAllRequiredSystems() { // arrange var system = new TestSystem { Ecs = Mock.Of <EcsManager>() }; system.Ecs.SystemManager = Mock.Of <SystemManager>(); system.Ecs.SystemManager.Subjects = new List <System> { new RequiredSystem1(), new RequiredSystem2() }; // act system.Start(); // assert Assert.True(true); }
/// <summary> /// The get test system. /// </summary> /// <param name="id"> /// The id. /// </param> /// <returns> /// The <see cref="TestSystem"/>. /// </returns> public TestSystem GetTestSystem(int id) { Dictionary <string, string> parameters = new Dictionary <string, string>(); string query = "Select id, name from TestSystems where component_id = @id"; SqlCommand command = new SqlCommand(query, this.con); command.Parameters.AddWithValue("@id", id); command.ExecuteNonQuery(); TestSystem system = new TestSystem(); SqlDataReader reader = command.ExecuteReader(); while (reader.Read()) { system.ID = reader.GetInt32(reader.GetOrdinal("id")); system.Name = reader.GetString(reader.GetOrdinal("name")); } reader.Close(); command = new SqlCommand("select tep.parametername, tsp.defaultvalue from TestEnvironmentParameters tep, TestSystemParameters tsp where tep.id in (select parameter_id from TestSystemParameters where system_id = @id) and tep.id = tsp.parameter_id", this.con); command.Parameters.AddWithValue("@id", system.ID); command.ExecuteNonQuery(); reader = command.ExecuteReader(); while (reader.Read()) { string paramName = reader.GetString(reader.GetOrdinal("parametername")); string paramDefaultValue = reader.GetString(reader.GetOrdinal("defaultvalue")); if (paramName != null) { parameters.Add(paramName, paramDefaultValue); } } system.Parameters = parameters; reader.Close(); return(system); }
public async Task ValidateSuccesfullValidationFlow() { TestSystem testSystem = new TestSystem() .WithDirectoryResponse() .WithResponse(TestHelpers.AcmeDirectory.RevokeCertificate, string.Empty); (ACMEClient acmeClient, _) = testSystem.Build(); var testCertificate = new CertificateMock(Guid.NewGuid().ToString()); await acmeClient.GetDirectoryAsync(); await acmeClient.RevokeCertificateAsync(testCertificate, RevocationReason.PriviledgeWithdrawn); /* * restClient.Verify(rc => rc.PostAsyn<string>(TestHelpers.acmeDirectory.RevokeCertificate, * It.Is<CertificateRevocationRequest>(req => req.Reason == RevocationReason.PriviledgeWithdrawn), * It.IsAny<CancellationToken>()), Times.Once, "Rest Client wasn't called with expected parameters."); */ }
public async Task ValidateSuccesfullValidationFlow() { var testSystem = new TestSystem().WithDirectoryResponse(); var(acmeClient, restClient) = testSystem.Build(); restClient.Setup(rc => rc.PostAsync <string>(TestHelpers.acmeDirectory.RevokeCertificate, It.IsAny <CertificateRevocationRequest>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult((string.Empty, string.Empty))); var testCertificate = new CertificateMock(Guid.NewGuid().ToString()); await acmeClient.GetDirectoryAsync(); await acmeClient.RevokeCertificateAsync(testCertificate, RevocationReason.PriviledgeWithdrawn); restClient.Verify(rc => rc.PostAsync <string>(TestHelpers.acmeDirectory.RevokeCertificate, It.Is <CertificateRevocationRequest>(req => req.Certificate == testCertificate.GetPublicKeyString() && req.Reason == RevocationReason.PriviledgeWithdrawn), It.IsAny <CancellationToken>()), Times.Once, "Rest Client wasn't called with expected parameters."); }
public void BasicOnBlock() { // Arrange var testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); var state = TestState.PrepareTestState(testServiceProvider); var timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; var forkChoice = testServiceProvider.GetService <ForkChoice>(); // Initialization var store = forkChoice.GetGenesisStore(state); var time = 100uL; forkChoice.OnTick(store, time); store.Time.ShouldBe(time); // On receiving a block of `GENESIS_SLOT + 1` slot var block = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: true); TestState.StateTransitionAndSignBlock(testServiceProvider, state, block); RunOnBlock(testServiceProvider, store, block, expectValid: true); // On receiving a block of next epoch var time2 = time + timeParameters.SecondsPerSlot * (ulong)timeParameters.SlotsPerEpoch; store.SetTime(time2); var block2 = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, signed: true); var slot2 = block.Slot + timeParameters.SlotsPerEpoch; block2.SetSlot(slot2); TestBlock.SignBlock(testServiceProvider, state, block2, ValidatorIndex.None); TestState.StateTransitionAndSignBlock(testServiceProvider, state, block2); //var options = new System.Text.Json.JsonSerializerOptions { WriteIndented = true }; //options.AddCortexContainerConverters(); //var debugState = System.Text.Json.JsonSerializer.Serialize(state, options); RunOnBlock(testServiceProvider, store, block2, expectValid: true); // Assert // TODO: add tests for justified_root and finalized_root }
public unsafe void LookupInCache_DoesNotAlloc() { // insert into cache int index; { var builder = new EntityQueryBuilder().WithAll <EcsTestTag>(); var delegateTypes = stackalloc int[] { TypeManager.GetTypeIndex <EcsTestData>() }; index = TestSystem.GetOrCreateEntityQueryCache().CreateCachedQuery(0, new EntityQuery(null, null, null, null), ref builder, delegateTypes, 1); Assert.Zero(index); // sanity } ValidateNoGCAllocs(() => { var testBuilder = new EntityQueryBuilder().WithAll <EcsTestTag>(); var testDelegateTypes = stackalloc int[] { TypeManager.GetTypeIndex <EcsTestData>() }; TestSystem.EntityQueryCache.ValidateMatchesCache(index, ref testBuilder, testDelegateTypes, 1); }); }
public void Ejection() { // Arrange var testServiceProvider = TestSystem.BuildTestServiceProvider(); var state = TestState.PrepareTestState(testServiceProvider); var chainConstants = testServiceProvider.GetService <ChainConstants>(); var gweiValues = testServiceProvider.GetService <IOptions <GweiValues> >().Value; var timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; var beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>(); var beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>(); var index = 0; var currentEpoch = beaconStateAccessor.GetCurrentEpoch(state); var validator = state.Validators[index]; var isActive = beaconChainUtility.IsActiveValidator(validator, currentEpoch); isActive.ShouldBeTrue(); validator.ExitEpoch.ShouldBe(chainConstants.FarFutureEpoch); // Mock an ejection state.Validators[index].SetEffectiveBalance(gweiValues.EjectionBalance); for (var count = (ulong)0; count < (ulong)timeParameters.MaximumSeedLookahead + 1; count++) { TestState.NextEpoch(testServiceProvider, state); } // Act RunProcessRegistryUpdates(testServiceProvider, state); // Assert var epochAfter = beaconStateAccessor.GetCurrentEpoch(state); var validatorAfter = state.Validators[index]; var isActiveAfter = beaconChainUtility.IsActiveValidator(validatorAfter, epochAfter); isActiveAfter.ShouldBeFalse(); validatorAfter.ExitEpoch.ShouldNotBe(chainConstants.FarFutureEpoch); }
public async Task BasicOnBlock() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); BeaconState state = TestState.PrepareTestState(testServiceProvider); TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; IForkChoice forkChoice = testServiceProvider.GetService <IForkChoice>(); // Initialization IStore store = testServiceProvider.GetService <IStore>(); await forkChoice.InitializeForkChoiceStoreAsync(store, state); ulong time = 100uL; await forkChoice.OnTickAsync(store, time); store.Time.ShouldBe(time); // On receiving a block of `GENESIS_SLOT + 1` slot BeaconBlock block = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, state, BlsSignature.Zero); SignedBeaconBlock signedBlock = TestState.StateTransitionAndSignBlock(testServiceProvider, state, block); await RunOnBlock(testServiceProvider, store, signedBlock, expectValid : true); // On receiving a block of next epoch ulong time2 = time + timeParameters.SecondsPerSlot * (ulong)timeParameters.SlotsPerEpoch; await store.SetTimeAsync(time2); Slot slot2 = (Slot)(block.Slot + timeParameters.SlotsPerEpoch); BeaconBlock block2 = TestBlock.BuildEmptyBlock(testServiceProvider, state, slot2, BlsSignature.Zero); SignedBeaconBlock signedBlock2 = TestState.StateTransitionAndSignBlock(testServiceProvider, state, block2); //var options = new System.Text.Json.JsonSerializerOptions { WriteIndented = true }; //options.AddCortexContainerConverters(); //var debugState = System.Text.Json.JsonSerializer.Serialize(state, options); await RunOnBlock(testServiceProvider, store, signedBlock2, expectValid : true); // Assert // TODO: add tests for justified_root and finalized_root }
public static void Check_Instruction_91_PUSH_Register16() { StringBuilder testProgram = new StringBuilder(); // TStatesByMachineCycle = "7 (4,3)" testProgram.AppendLine("LD A,21"); // TStatesByMachineCycle = "10 (4, 3, 3)" testProgram.AppendLine("LD BC,4370"); // TStatesByMachineCycle = "14 (4, 4, 3, 3)" testProgram.AppendLine("LD IY,4884"); // TStatesByMachineCycle = "11 (5, 3, 3)" testProgram.AppendLine("PUSH AF"); // TStatesByMachineCycle = "11 (5, 3, 3)" testProgram.AppendLine("PUSH BC"); // TStatesByMachineCycle = "15 (4, 5, 3, 3)" testProgram.AppendLine("PUSH IY"); // TStatesByMachineCycle = "10 (4, 3, 3)", testProgram.AppendLine("POP DE"); // TStatesByMachineCycle = "10 (4, 3, 3)", testProgram.AppendLine("POP DE"); // TStatesByMachineCycle = "10 (4, 3, 3)", testProgram.AppendLine("POP DE"); TestSystem testSystem = new TestSystem(); testSystem.LoadProgramInMemory(testProgram.ToString()); CPUStateLogger logger = new CPUStateLogger(testSystem.CPU); logger.StartLogging( CPUStateLogger.CPUStateElements.InternalState | CPUStateLogger.CPUStateElements.Registers, new Z80CPU.LifecycleEventType[] { Z80CPU.LifecycleEventType.MachineCycleEnd }); testSystem.ExecuteInstructionCount(9); logger.StopLogging(); if (!logger.CompareWithSavedLog("CPU/Load16Bit/Logs/Check_Instruction_91_PUSH_Register16")) { throw new Exception("Log compare failed"); } }
public static void Check_Instruction_70_LD_Register16Address_Register() { StringBuilder testProgram = new StringBuilder(); // TStatesByMachineCycle = "7 (4,3)" testProgram.AppendLine("LD E,30"); // TStatesByMachineCycle = "10 (4,3,3)" testProgram.AppendLine("LD HL,100"); // TStatesByMachineCycle = "7 (4, 3)" testProgram.AppendLine("LD (HL),E"); // TStatesByMachineCycle = "13 (4, 3, 3, 3)" testProgram.AppendLine("LD A,(100)"); // TStatesByMachineCycle = "7 (4,3)" testProgram.AppendLine("LD A,40"); // TStatesByMachineCycle = "10 (4,3,3)" testProgram.AppendLine("LD BC,110"); // TStatesByMachineCycle = "7 (4, 3)" testProgram.AppendLine("LD (BC),A"); // TStatesByMachineCycle = "7 (4,3)" testProgram.AppendLine("LD A,0"); // TStatesByMachineCycle = "13 (4, 3, 3, 3)" testProgram.AppendLine("LD A,(110)"); TestSystem testSystem = new TestSystem(); testSystem.LoadProgramInMemory(testProgram.ToString()); CPUStateLogger logger = new CPUStateLogger(testSystem.CPU); logger.StartLogging( CPUStateLogger.CPUStateElements.InternalState | CPUStateLogger.CPUStateElements.Registers, new Z80CPU.LifecycleEventType[] { Z80CPU.LifecycleEventType.MachineCycleEnd }); testSystem.ExecuteInstructionCount(9); logger.StopLogging(); if (!logger.CompareWithSavedLog("CPU/Load_8Bit/Logs/Check_Instruction_70_LD_Register16Address_Register")) { throw new Exception("Log compare failed"); } }
public async Task ValidateRegisterAsyncPositiveFlow() { var testContacts = new[] { "mailto:[email protected]", "+1 012-3456-789" }; var returnAccount = new Account { }; TestSystem testSystem = new TestSystem() .WithDirectoryResponse() .WithResponse(TestHelpers.AcmeDirectory.NewAccount, returnAccount, locationHeader: new Uri(TestHelpers.BaseUri, "/account/1234")); (ACMEClient acmeClient, _) = testSystem.Build(); await acmeClient.RegisterAsync(testContacts); /* * restClient.Verify(rc => rc.PostAsync<Account>(TestHelpers.acmeDirectory.NewAccount, * It.Is<Account>(req => req.Contacts == testContacts && req.TermsOfServiceAgreed), * It.IsAny<CancellationToken>()), Times.Once, "Rest Client wasn't called with expected parameters."); * * restClient.Verify(rc => rc.GetAsync<ACMEDirectory>(new Uri(TestHelpers.baseUri, "directory"), It.IsAny<CancellationToken>()), * Times.Once, "Rest Client wasn't called with expected parameters.");*/ }
protected override void Given() { testSystem = new TestSystem(); system = new SystemDriver(testSystem); }
protected override void GivenCleanup() { system.Stop(); system = null; testSystem = null; }
public void SetUp() { this.game = new Game(); this.systemManager = new SystemManager(this.game); this.system = new TestSystem(); }