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();
}
