public void AddConsumption_InConsistentContext_Test() { var volatileStore = new VolatilePackStore(1, new[] { 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); var sozu = GetSozuTable(volatileStore, hash); var context = new BlockAlias(123, 0); var coin1 = GetCoin(rand); var ret1 = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret1); for (var i = 0; i < 3; ++i) { var coin = GetCoin(rand); var ret = sozu.AddProduction(hash.Hash(ref coin.Outpoint), ref coin.Outpoint, false, coin.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret); } ret1 = sozu.AddConsumption(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, context, new MockLineage(() => false)); Assert.Equal(CoinChangeStatus.InvalidContext, ret1); }
public void TryGetTest() { var volatileStore = new VolatilePackStore(1, new[] { 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); var pack = volatileStore.Read(0, 0); pack.Append(GetCoin(rand, new BlockAlias(123, 0))); pack.Append(GetCoin(rand, new BlockAlias(123, 0))); var coin1 = GetCoin(rand, new BlockAlias(123, 0)); pack.Append(coin1); var context = new BlockAlias(123, 0); Coin coin2; var sozu = GetSozuTable(volatileStore, hash); bool res = sozu.TryGet(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, context, new MockLineage((out BlockAlias result) => result = context, MockLineage.Undefined), out coin2, out var production, out var consumption); Assert.True(res, "Sozu2 TryGet failed to get an existing outpoint."); Assert.True(coin1.Span.SequenceEqual(coin2.Span), "Sozu2 TryGet mismatch."); Assert.Equal(production, context); Assert.False(consumption.IsDefined); Coin coin3 = GetCoin(rand); res = sozu.TryGet(hash.Hash(ref coin3.Outpoint), ref coin3.Outpoint, context, new MockLineage(), out coin2, out var production3, out var consumption3); Assert.False(res, "Sozu2 TryGet returns an nonexistent outpoint."); }
public void AddOversizedProductionTest() { var volatileStore = new VolatilePackStore(1, new[] { 4096, 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); var sozu = GetSozuTable(volatileStore, hash); var context = new BlockAlias(123, 0); for (var i = 0; i < 3; ++i) { var coin = GetCoin(rand); var ret = sozu.AddProduction(hash.Hash(ref coin.Outpoint), ref coin.Outpoint, false, coin.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret); } var coin2 = GetCoin(rand, SozuTable.PayloadOversizeInBytes + 10, new BlockAlias(123, 0)); var ret2 = sozu.AddProduction(hash.Hash(ref coin2.Outpoint), ref coin2.Outpoint, false, coin2.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret2); var pl = volatileStore.Read(volatileStore.LayerCount - 1, 0); Assert.True(pl.TryGet(ref coin2.Outpoint, out var coin2_p0)); Assert.True(coin2.Span.SequenceEqual(coin2_p0.Span)); }
public void OverflowToLastLayerTest() { var volatileStore = new VolatilePackStore(1, new[] { 4096, 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); var sozu = GetSozuTable(volatileStore, hash); int cumulSize = 0; do { var coin = GetCoin(rand); var context = new BlockAlias(123, 0); var ret = sozu.AddProduction(hash.Hash(ref coin.Outpoint), ref coin.Outpoint, false, coin.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret); cumulSize += coin.SizeInBytes; } while (cumulSize <= 4096 * 2); var p0 = volatileStore.Read(0, 0); Assert.True(p0.OutpointSigCount > 0, "First layer doesn't have probabilistic filter."); var p1 = volatileStore.Read(1, 0); var pl = volatileStore.Read(volatileStore.LayerCount - 1, 0); Assert.True(pl.CoinCount > 0, "Last layer doesn't have any coin."); Assert.True(p1.CoinCount + pl.CoinCount == p0.OutpointSigCount, "probabilistic filter count mismatches" + "deeper layers coins count."); }
public void AddProductionThenOverflowTest() { var volatileStore = new VolatilePackStore(1, new[] { 4096, 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); var sozu = GetSozuTable(volatileStore, hash); int cumulSize = 0; do { var coin = GetCoin(rand); var context = new BlockAlias(123, 0); var ret = sozu.AddProduction(hash.Hash(ref coin.Outpoint), ref coin.Outpoint, false, coin.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret); cumulSize += coin.SizeInBytes; } while (cumulSize <= 4096); var p0 = volatileStore.Read(0, 0); Assert.True(p0.OutpointSigCount > 0); }
public void RemoveSigsAfterPruningTest() { var hash = GetMockHash().Object; var rand = new Random(2); var volatileStore = new VolatilePackStore(1, new[] { 4096, 4096 }); var sozu = GetSozuTable(volatileStore, hash); var lineage = new MockLineage(); var pruneCount = 3; int cumulSize = 0; for (var i = 0; i < pruneCount; i++) { var coin1 = GetCoin(rand); var ret1 = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, MockLineage.CoinEventToPrune.BlockAlias, lineage); Assert.Equal(CoinChangeStatus.Success, ret1); cumulSize += coin1.SizeInBytes; } do { var coin = GetCoin(rand); var context = new BlockAlias(123, 0); var ret = sozu.AddProduction(hash.Hash(ref coin.Outpoint), ref coin.Outpoint, false, coin.Payload, context, lineage); Assert.Equal(CoinChangeStatus.Success, ret); cumulSize += coin.SizeInBytes; } while (cumulSize <= 4096); var p0 = volatileStore.Read(0, 0); cumulSize = p0.SizeInBytes; int sigsCount = 0; int opCount = 0; do { var coin = GetCoin(rand); var context = new BlockAlias(123, 0); if (cumulSize + coin.SizeInBytes > 4096) { p0 = volatileStore.Read(0, 0); sigsCount = p0.OutpointSigCount; opCount = p0.CoinCount + 1; lineage.PruningActive = true; } var ret = sozu.AddProduction(hash.Hash(ref coin.Outpoint), ref coin.Outpoint, false, coin.Payload, context, lineage); Assert.Equal(CoinChangeStatus.Success, ret); cumulSize += coin.SizeInBytes; } while (cumulSize <= 4096); p0 = volatileStore.Read(0, 0); Assert.True(opCount - p0.CoinCount + sigsCount - p0.OutpointSigCount == pruneCount); }
public void TryAddConsumptionInSideChainTest() { var volatileStore = new VolatilePackStore(1, new[] { 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); // Create a real lineage var cBlocks = new List <CommittedBlock>(); cBlocks.Add(new CommittedBlock(CommittedBlockId.Genesis, BlockAlias.Genesis, BlockAlias.GenesisParent)); var uncBlocks = new List <UncommittedBlock>(); var firstBlockAlias = new BlockAlias(1, 0); var uncId = new byte[16]; rand.NextBytes(uncId); uncBlocks.Add(new UncommittedBlock( UncommittedBlockId.ReadFrom(uncId), firstBlockAlias, BlockAlias.Genesis)); var parallelBlockAlias = new BlockAlias(1, 1); rand.NextBytes(uncId); uncBlocks.Add(new UncommittedBlock( UncommittedBlockId.ReadFrom(uncId), parallelBlockAlias, BlockAlias.Genesis)); var realLineage = new Lineage(cBlocks, uncBlocks, 100); var sozu = GetSozuTable(volatileStore, hash); var coin1 = GetCoin(rand); var ret = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, firstBlockAlias, realLineage); Assert.Equal(CoinChangeStatus.Success, ret); var cons = sozu.AddConsumption(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, parallelBlockAlias, realLineage); Assert.Equal(CoinChangeStatus.InvalidContext, cons); }
public void RemoveConsumption_Test() { var volatileStore = new VolatilePackStore(1, new[] { 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); var sozu = GetSozuTable(volatileStore, hash); var context = new BlockAlias(123, 0); var coin1 = GetCoin(rand); var ret1 = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret1); ret1 = sozu.AddConsumption(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret1); for (var i = 0; i < 3; ++i) { var coin = GetCoin(rand); var ret = sozu.AddProduction(hash.Hash(ref coin.Outpoint), ref coin.Outpoint, false, coin.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret); } ret1 = sozu.Remove(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, context, CoinRemoveOption.RemoveConsumption, new MockLineage(MockLineage.Undefined, (out BlockAlias result) => result = context)); Assert.Equal(CoinChangeStatus.Success, ret1); var p0 = volatileStore.Read(0, 0); Assert.True(p0.TryGet(ref coin1.Outpoint, out var coin1_p0)); Assert.Equal(1, coin1_p0.Events.Length); Assert.Equal(coin1_p0.Events[0], new CoinEvent(context, CoinEventKind.Production)); Assert.True(coin1_p0.Payload.Span.SequenceEqual(coin1.Payload.Span)); }
public void AddConsumptionTest() { var volatileStore = new VolatilePackStore(1, new[] { 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); var sozu = GetSozuTable(volatileStore, hash); var context = new BlockAlias(123, 0); var coin1 = GetCoin(rand); var ret1 = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret1); for (var i = 0; i < 3; ++i) { var coin = GetCoin(rand); var ret = sozu.AddProduction(hash.Hash(ref coin.Outpoint), ref coin.Outpoint, false, coin.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret); } ret1 = sozu.AddConsumption(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret1); // test add consumption idempotence ret1 = sozu.AddConsumption(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, context, new MockLineage(() => false)); Assert.Equal(CoinChangeStatus.Success, ret1); var p0 = volatileStore.Read(0, 0); Assert.True(p0.TryGet(ref coin1.Outpoint, out var coin1_p0)); Assert.Equal(2, coin1_p0.Events.Length); Assert.True(coin1_p0.Payload.Span.SequenceEqual(coin1.Payload.Span)); }
public void TryAddConsumptionInPastTest() { var volatileStore = new VolatilePackStore(1, new[] { 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); // Create a real lineage var cBlocks = new List <CommittedBlock>(); cBlocks.Add(new CommittedBlock(CommittedBlockId.Genesis, BlockAlias.Genesis, BlockAlias.GenesisParent)); var firstBlockAlias = new BlockAlias(1, 0); cBlocks.Add(new CommittedBlock( CommittedBlockId.ReadFromHex("AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD"), firstBlockAlias, BlockAlias.Genesis)); var futureBlockAlias = new BlockAlias(2, 0); cBlocks.Add(new CommittedBlock( CommittedBlockId.ReadFromHex("AAAABBBBBBBBCCCCCCCCDDDDDDDDAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDAAAA"), futureBlockAlias, firstBlockAlias)); var realLineage = new Lineage(cBlocks, new List <UncommittedBlock>(), 100); var sozu = GetSozuTable(volatileStore, hash); var coin1 = GetCoin(rand); // The next two commands will work because the fact that a block is uncommitted is not verified anymore. // If this test is moved into the ICoinStore at any point, adding a previous consumption should fail // already because a 'previous' block always has to be committed. var ret = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, futureBlockAlias, realLineage); Assert.Equal(CoinChangeStatus.Success, ret); var cons = sozu.AddConsumption(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, firstBlockAlias, realLineage); Assert.Equal(CoinChangeStatus.InvalidContext, cons); }
public void AddProductionSideChainTest() { var volatileStore = new VolatilePackStore(1, new[] { 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); var coin1 = GetCoin(rand); var context = new BlockAlias(123, 0); var context2 = new BlockAlias(123, 1); var sozu = GetSozuTable(volatileStore, hash); var ret = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret); // Test add production idempotence ret = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, context, new MockLineage(() => false)); Assert.Equal(CoinChangeStatus.Success, ret); for (var i = 0; i < 3; ++i) { var coin = GetCoin(rand); ret = sozu.AddProduction(hash.Hash(ref coin.Outpoint), ref coin.Outpoint, false, coin.Payload, context, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret); } // add side chain production ret = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, context2, new MockLineage()); Assert.Equal(CoinChangeStatus.Success, ret); var p0 = volatileStore.Read(0, 0); // assert that two add of coin1 are merged into one. Assert.Equal(4, p0.CoinCount); }
public void OverflowThenPruneTest() { var hash = GetMockHash().Object; var rand = new Random(2); var volatileStore = new VolatilePackStore(1, new[] { 4096, 4096 }); var sozu = GetSozuTable(volatileStore, hash); var lineage = new MockLineage(); lineage.PruningActive = true; int cumulSize = 0; for (var i = 0; i < 3; i++) { var coin1 = GetCoin(rand); var ret1 = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, MockLineage.CoinEventToPrune.BlockAlias, lineage); Assert.Equal(CoinChangeStatus.Success, ret1); cumulSize += coin1.SizeInBytes; } do { var coin = GetCoin(rand); var context = new BlockAlias(123, 0); var ret = sozu.AddProduction(hash.Hash(ref coin.Outpoint), ref coin.Outpoint, false, coin.Payload, context, lineage); Assert.Equal(CoinChangeStatus.Success, ret); cumulSize += coin.SizeInBytes; } while (cumulSize <= 4096); var p0 = volatileStore.Read(0, 0); Assert.True(p0.OutpointSigCount == 0); var p1 = volatileStore.Read(1, 0); Assert.True(p1.CoinCount == 0); }
public void TryGetCoinInFutureTest() { var volatileStore = new VolatilePackStore(1, new[] { 4096 }); var hash = GetMockHash().Object; var rand = new Random(2); // Create a real lineage. It doesn't matter if all blocks are committed because we are just reading. var cBlocks = new List <CommittedBlock>(); cBlocks.Add(new CommittedBlock(CommittedBlockId.Genesis, BlockAlias.Genesis, BlockAlias.GenesisParent)); var firstBlockAlias = new BlockAlias(1, 0); cBlocks.Add(new CommittedBlock( CommittedBlockId.ReadFromHex("AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD"), firstBlockAlias, BlockAlias.Genesis)); var futureBlockAlias = new BlockAlias(2, 0); cBlocks.Add(new CommittedBlock( CommittedBlockId.ReadFromHex("AAAABBBBBBBBCCCCCCCCDDDDDDDDAAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDAAAA"), futureBlockAlias, firstBlockAlias)); var realLineage = new Lineage(cBlocks, new List <UncommittedBlock>(), 100); var sozu = GetSozuTable(volatileStore, hash); var coin1 = GetCoin(rand); var ret = sozu.AddProduction(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, false, coin1.Payload, futureBlockAlias, realLineage); Assert.Equal(CoinChangeStatus.Success, ret); var read = sozu.TryGet(hash.Hash(ref coin1.Outpoint), ref coin1.Outpoint, firstBlockAlias, realLineage, out var coin, out var prod, out var cons); Assert.False(read); }