public AtomicActionRendererTest()
{
_record = new RecordingActionRenderer <Arithmetic>();
_renderer = new AtomicActionRenderer <Arithmetic>(_record);
_fx = new IntegerSet(new BigInteger?[] { 0 }, null, new[] { _renderer });
(_successTx, _) = _fx.Sign(
0,
Arithmetic.Add(1),
Arithmetic.Mul(2),
Arithmetic.Add(3)
);
// failing transaction; should not be rendered:
_fx.Sign(
0,
Arithmetic.Add(1),
new Arithmetic(),
Arithmetic.Add(3)
);
_record.ResetRecords();
}
public async Task BroadcastBlockWithSkip()
{
var policy = new BlockPolicy <DumbAction>(new MinerReward(1));
var fx1 = new DefaultStoreFixture(memory: true);
var blockChain = TestUtils.MakeBlockChain(policy, fx1.Store, fx1.StateStore);
var privateKey = new PrivateKey();
var minerSwarm = CreateSwarm(blockChain, privateKey);
var fx2 = new DefaultStoreFixture(memory: true);
var receiverRenderer = new RecordingActionRenderer <DumbAction>();
var loggedRenderer = new LoggedActionRenderer <DumbAction>(
receiverRenderer,
_logger);
var receiverChain = TestUtils.MakeBlockChain(
policy,
fx2.Store,
fx2.StateStore,
renderers: new[] { loggedRenderer });
Swarm <DumbAction> receiverSwarm = CreateSwarm(receiverChain);
int renderCount = 0;
receiverRenderer.RenderEventHandler += (_, a) => renderCount += a is DumbAction ? 1 : 0;
Transaction <DumbAction>[] transactions =
{
fx1.MakeTransaction(
new[]
{
new DumbAction(fx1.Address2, "foo"),
new DumbAction(fx1.Address2, "bar"),
},
timestamp: DateTimeOffset.MinValue,
nonce: 0,
privateKey: privateKey),
fx1.MakeTransaction(
new[]
{
new DumbAction(fx1.Address2, "baz"),
new DumbAction(fx1.Address2, "qux"),
},
timestamp: DateTimeOffset.MinValue.AddSeconds(5),
nonce: 1,
privateKey: privateKey),
};
try
{
await StartAsync(minerSwarm);
await StartAsync(receiverSwarm);
await BootstrapAsync(receiverSwarm, minerSwarm.AsPeer);
Block <DumbAction> block1 = TestUtils.MineNext(
blockChain.Genesis,
policy.GetHashAlgorithm,
new[] { transactions[0] },
null,
policy.GetNextBlockDifficulty(blockChain),
miner: TestUtils.GenesisMiner.PublicKey
).Evaluate(TestUtils.GenesisMiner, blockChain);
blockChain.Append(block1, true, true, false);
Block <DumbAction> block2 = TestUtils.MineNext(
block1,
policy.GetHashAlgorithm,
new[] { transactions[1] },
null,
policy.GetNextBlockDifficulty(blockChain),
miner: TestUtils.GenesisMiner.PublicKey
).Evaluate(TestUtils.GenesisMiner, blockChain);
blockChain.Append(block2, true, true, false);
Log.Debug("Ready to broadcast blocks.");
minerSwarm.BroadcastBlock(block2);
await receiverSwarm.BlockAppended.WaitAsync();
Assert.Equal(3, receiverChain.Count);
Assert.Equal(4, renderCount);
}
finally
{
await StopAsync(minerSwarm);
await StopAsync(receiverSwarm);
fx1.Dispose();
minerSwarm.Dispose();
}
}
public async Task RenderInPreload()
{
var policy = new BlockPolicy <DumbAction>(new MinerReward(1));
var renderer1 = new RecordingActionRenderer <DumbAction>();
var renderer2 = new RecordingActionRenderer <DumbAction>();
var chain1 = TestUtils.MakeBlockChain(
policy,
new DefaultStore(null),
new TrieStateStore(new MemoryKeyValueStore()),
renderers: new[] { renderer1 }
);
var chain2 = TestUtils.MakeBlockChain(
policy,
new DefaultStore(null),
new TrieStateStore(new MemoryKeyValueStore()),
renderers: new[] { renderer2 }
);
var senderKey = new PrivateKey();
var receiver1 = CreateSwarm(chain1);
var receiver2 = CreateSwarm(chain2);
var sender = CreateSwarm(
TestUtils.MakeBlockChain(
policy,
new DefaultStore(null),
new TrieStateStore(new MemoryKeyValueStore())
),
senderKey
);
int renderCount1 = 0, renderCount2 = 0;
var privKey = new PrivateKey();
var addr = sender.Address;
var item = "foo";
const int iteration = 3;
for (var i = 0; i < iteration; i++)
{
sender.BlockChain.MakeTransaction(privKey, new[] { new DumbAction(addr, item) });
await sender.BlockChain.MineBlock(senderKey);
}
renderer1.RenderEventHandler += (_, a) =>
renderCount1 += a is DumbAction ? 1 : 0;
renderer2.RenderEventHandler += (_, a) =>
renderCount2 += a is DumbAction ? 1 : 0;
await StartAsync(receiver1);
await StartAsync(sender);
await BootstrapAsync(receiver1, sender.AsPeer);
await BootstrapAsync(receiver2, sender.AsPeer);
await receiver1.PreloadAsync(render : false);
await receiver2.PreloadAsync(render : true);
Assert.Equal(sender.BlockChain.Tip, receiver1.BlockChain.Tip);
Assert.Equal(sender.BlockChain.Count, receiver1.BlockChain.Count);
Assert.Equal(sender.BlockChain.Count, receiver2.BlockChain.Count);
Assert.Equal(sender.BlockChain.Count, receiver2.BlockChain.Count);
Assert.Equal(0, renderCount1);
Assert.Equal(1, renderCount2);
}
