public void every_prepare_can_be_commited()
{
var res = ReadIndex.CheckCommitStartingAt(_prepare0.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(-1, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
res = ReadIndex.CheckCommitStartingAt(_prepare1.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(-1, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
res = ReadIndex.CheckCommitStartingAt(_prepare2.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(-1, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
public override void When()
{
_followers = new [] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() };
BecomeLeader();
// All of the nodes have acked the first write
WriterCheckpoint.Write(_firstLogPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
foreach (var follower in _followers)
{
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(follower, _firstLogPosition));
}
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent());
ReplicatedTos.Clear();
// Followers 3 and 4 are lagging behind, they ack the previous positions
WriterCheckpoint.Write(_secondLogPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_followers[0], _secondLogPosition));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_followers[1], _secondLogPosition));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_followers[2], _firstLogPosition));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_followers[3], _firstLogPosition));
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent());
}
protected override void WriteTestScenario()
{
// Stream that will be kept
_event1 = WriteSingleEventWithLogVersion0(Guid.NewGuid(), _eventStreamId, WriterCheckpoint.ReadNonFlushed(),
0);
_event2 = WriteSingleEventWithLogVersion0(Guid.NewGuid(), _eventStreamId, WriterCheckpoint.ReadNonFlushed(),
1);
// Stream that will be deleted
WriteSingleEventWithLogVersion0(Guid.NewGuid(), _deletedEventStreamId, WriterCheckpoint.ReadNonFlushed(),
0);
WriteSingleEventWithLogVersion0(Guid.NewGuid(), _deletedEventStreamId, WriterCheckpoint.ReadNonFlushed(),
1);
_deleted = WriteSingleEventWithLogVersion0(Guid.NewGuid(), _deletedEventStreamId,
WriterCheckpoint.ReadNonFlushed(), int.MaxValue - 1,
PrepareFlags.StreamDelete | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd);
// Stream that will be kept
_event3 = WriteSingleEventWithLogVersion0(Guid.NewGuid(), _eventStreamId, WriterCheckpoint.ReadNonFlushed(),
2);
_event4 = WriteSingleEventWithLogVersion0(Guid.NewGuid(), _eventStreamId, WriterCheckpoint.ReadNonFlushed(),
3);
Writer.CompleteChunk();
Scavenge(completeLast: false, mergeChunks: true);
}
private void ReOpenDb()
{
Db = new TFChunkDb(new TFChunkDbConfig(PathName,
new VersionedPatternFileNamingStrategy(PathName, "chunk-"),
10000,
0,
WriterCheckpoint,
ChaserCheckpoint,
new InMemoryCheckpoint(-1),
new InMemoryCheckpoint(-1)));
Db.Open();
TableIndex = new TableIndex(Path.Combine(PathName, "index"),
() => new HashListMemTable(MaxEntriesInMemTable * 2),
MaxEntriesInMemTable);
ReadIndex = new ReadIndex(new NoopPublisher(),
2,
5,
() => new TFChunkReader(Db, Db.Config.WriterCheckpoint),
TableIndex,
new ByLengthHasher(),
new NoLRUCache <string, StreamCacheInfo>(),
additionalCommitChecks: true,
metastreamMaxCount: MetastreamMaxCount);
ReadIndex.Init(WriterCheckpoint.Read(), ChaserCheckpoint.Read());
}
public void should_be_able_to_read_all_backwards()
{
var checkpoint = WriterCheckpoint.Read();
var pos = new TFPos(checkpoint, checkpoint);
var result = ReadIndex.ReadAllEventsBackward(pos, 10);
Assert.AreEqual(3, result.Records.Count);
}
public void should_be_able_to_read_all_backwards_and_get_events_before_replication_checkpoint()
{
var checkpoint = WriterCheckpoint.Read();
var pos = new TFPos(checkpoint, checkpoint);
var result = ReadIndex.ReadAllEventsBackward(pos, 10);
Assert.AreEqual(2, result.Records.Count);
}
public override void When()
{
BecomeLeader();
WriterCheckpoint.Write(_logPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent());
}
public override void When()
{
BecomeMaster();
WriterCheckpoint.Write(_logPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(Guid.NewGuid(), _logPosition));
AssertEx.IsOrBecomesTrue(() => Service.IsIdle());
}
protected override void WriteTestScenario()
{
long pos;
string stream = "ES";
_streamNameIndex.GetOrAddId(stream, out var streamId, out _, out _);
var prepare1 = LogRecord.SingleWrite(_recordFactory, WriterCheckpoint.ReadNonFlushed(), // prepare1
Guid.NewGuid(),
Guid.NewGuid(),
streamId,
-1,
"some-type",
LogRecord.NoData,
null,
DateTime.UtcNow);
Assert.IsTrue(Writer.Write(prepare1, out pos));
var prepare2 = LogRecord.SingleWrite(_recordFactory, WriterCheckpoint.ReadNonFlushed(), // prepare2
Guid.NewGuid(),
Guid.NewGuid(),
streamId,
-1,
"some-type",
LogRecord.NoData,
null,
DateTime.UtcNow);
Assert.IsTrue(Writer.Write(prepare2, out pos));
var deletePrepare = LogRecord.DeleteTombstone(_recordFactory, WriterCheckpoint.ReadNonFlushed(), // delete prepare
Guid.NewGuid(), Guid.NewGuid(), streamId, -1);
_deleteTombstone = new EventRecord(EventNumber.DeletedStream, deletePrepare, stream);
Assert.IsTrue(Writer.Write(deletePrepare, out pos));
var prepare3 = LogRecord.SingleWrite(_recordFactory, WriterCheckpoint.ReadNonFlushed(), // prepare3
Guid.NewGuid(),
Guid.NewGuid(),
streamId,
-1,
"some-type",
LogRecord.NoData,
null,
DateTime.UtcNow);
Assert.IsTrue(Writer.Write(prepare3, out pos));
var commit = LogRecord.Commit(WriterCheckpoint.ReadNonFlushed(), // committing delete
deletePrepare.CorrelationId,
deletePrepare.LogPosition,
EventNumber.DeletedStream);
Assert.IsTrue(Writer.Write(commit, out pos));
}
public void check_commmit_on_not_expected_prepare_should_return_wrong_expected_version()
{
var res = ReadIndex.CheckCommitStartingAt(_prepare4.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.WrongExpectedVersion, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(2, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
public void check_commmit_on_2nd_prepare_should_return_ok_decision()
{
var res = ReadIndex.CheckCommitStartingAt(_prepare1.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(0, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
protected override void WriteTestScenario()
{
_event0 = WriteSingleEvent("ES", 0, "bla1");
var prepare = LogRecord.DeleteTombstone(WriterCheckpoint.ReadNonFlushed(), Guid.NewGuid(), Guid.NewGuid(), "ES", 1);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
_event1 = WriteSingleEvent("ES", 1, "bla1");
}
protected override void WriteTestScenario()
{
_event0 = WriteSingleEvent("ES", 0, "bla1");
_streamNameIndex.GetOrAddId("ES", out var esStreamId, out _, out _);
var prepare = LogRecord.DeleteTombstone(_recordFactory, WriterCheckpoint.ReadNonFlushed(), Guid.NewGuid(), Guid.NewGuid(),
esStreamId, 1);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
_event1 = WriteSingleEvent("ES", 1, "bla1");
}
protected override void WriteTestScenario()
{
_event0 = WriteSingleEvent("ES", 0, "bla1");
var prepare = LogRecord.DeleteTombstone(_recordFactory, WriterCheckpoint.ReadNonFlushed(), Guid.NewGuid(), Guid.NewGuid(),
"ES", 2);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
_event1 = WriteSingleEvent("ES", 1, "bla1");
Scavenge(completeLast: false, mergeChunks: false);
}
public void check_commmit_should_return_ok_decision()
{
var res = ReadIndex.IndexWriter.CheckCommitStartingAt(_prepare.LogPosition,
WriterCheckpoint.ReadNonFlushed());
_streamNameIndex.GetOrAddId("ES", out var streamId, out _, out _);
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual(streamId, res.EventStreamId);
Assert.AreEqual(-1, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
public void check_commmit_should_return_ok_decision()
{
var res = ReadIndex.IndexWriter.CheckCommitStartingAt(_prepare.LogPosition,
WriterCheckpoint.ReadNonFlushed());
var streamId = _logFormat.StreamIds.LookupValue("ES");
Assert.AreEqual(CommitDecision.Ok, res.Decision);
Assert.AreEqual(streamId, res.EventStreamId);
Assert.AreEqual(-1, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
public override void When()
{
BecomeMaster();
// All of the nodes have acked the first write
WriterCheckpoint.Write(_firstLogPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replica1, _firstLogPosition));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replica2, _firstLogPosition - 100));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(Guid.NewGuid(), _firstLogPosition - 100));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(Guid.NewGuid(), _firstLogPosition - 100));
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent());
}
protected override void WriteTestScenario()
{
var firstEvent = WriteSingleEvent(_allowedStream1, 1, new string('.', 3000), eventId: Guid.NewGuid(),
eventType: "event-type-1", retryOnFail: true);
WriteSingleEvent(_disallowedStream, 1, new string('.', 3000), eventId: Guid.NewGuid(), eventType: "event-type-2",
retryOnFail: true); //disallowed
WriteSingleEvent(_allowedStream2, 1, new string('.', 3000), eventId: Guid.NewGuid(), eventType: "event-type-3",
retryOnFail: true); //allowed
_forwardReadPos = new TFPos(firstEvent.LogPosition, firstEvent.LogPosition);
_backwardReadPos = new TFPos(WriterCheckpoint.ReadNonFlushed(), WriterCheckpoint.ReadNonFlushed());
}
protected override void WriteTestScenario()
{
_survivors = new List <ILogRecord>();
_scavenged = new List <ILogRecord>();
GetOrReserve("s1", out var s1StreamId, out _);
GetOrReserveEventType("event-type", out var eventTypeId, out _);
var transPos = WriterCheckpoint.ReadNonFlushed();
for (int i = 0; i < 10; ++i)
{
long tmp;
var r = LogRecord.Prepare(_recordFactory, WriterCheckpoint.ReadNonFlushed(),
Guid.NewGuid(),
Guid.NewGuid(),
transPos,
i,
s1StreamId,
i == 0 ? -1 : -2,
PrepareFlags.Data | (i == 9 ? PrepareFlags.TransactionEnd : PrepareFlags.None),
eventTypeId,
new byte[3],
new byte[3]);
Assert.IsTrue(Writer.Write(r, out tmp));
Writer.CompleteChunk();
_scavenged.Add(r);
}
var r2 = WriteCommit(transPos, "s1", 0);
_survivors.Add(r2);
Writer.CompleteChunk();
var r3 = WriteDeletePrepare("s1");
_survivors.Add(r3);
Writer.CompleteChunk();
var r4 = WriteDeleteCommit(r3);
_survivors.Add(r4);
Writer.CompleteChunk();
Scavenge(completeLast: false, mergeChunks: true);
Assert.AreEqual(13, _survivors.Count + _scavenged.Count);
}
public override void When()
{
BecomeMaster();
WriterCheckpoint.Write(_logPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId1, _logPosition));
Service.Handle(new SystemMessage.VNodeConnectionLost(
PortsHelper.GetLoopback(),
Guid.NewGuid(),
_replicaId1));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId2, _logPosition));
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent());
}
protected override void WriteTestScenario()
{
var eventTypeId = LogFormatHelper <TLogFormat, TStreamId> .EventTypeId;
_event0 = WriteSingleEvent("ES", 0, "bla1");
Assert.True(_logFormat.StreamNameIndex.GetOrReserve("ES", out var esStreamId, out _, out _));
var prepare = LogRecord.DeleteTombstone(_recordFactory, WriterCheckpoint.ReadNonFlushed(), Guid.NewGuid(), Guid.NewGuid(),
esStreamId, eventTypeId, 1);
long pos;
Assert.IsTrue(Writer.Write(prepare, out pos));
_event1 = WriteSingleEvent("ES", 1, "bla1");
}
protected override void WriteTestScenario()
{
var firstEvent = WriteSingleEvent("ES1", 1, new string('.', 3000), eventId: Guid.NewGuid(),
eventType: "event-type-1", retryOnFail: true);
WriteSingleEvent("ES2", 1, new string('.', 3000), eventId: Guid.NewGuid(), eventType: "other-event-type-2",
retryOnFail: true);
WriteSingleEvent("ES3", 1, new string('.', 3000), eventId: Guid.NewGuid(), eventType: "event-type-3",
retryOnFail: true);
WriteSingleEvent("ES4", 1, new string('.', 3000), eventId: Guid.NewGuid(), eventType: "other-event-type-4",
retryOnFail: true);
_forwardReadPos = new TFPos(firstEvent.LogPosition, firstEvent.LogPosition);
_backwardReadPos = new TFPos(WriterCheckpoint.ReadNonFlushed(), WriterCheckpoint.ReadNonFlushed());
}
private void WriteV0HardDelete(string eventStreamId)
{
long pos;
var logPosition = WriterCheckpoint.ReadNonFlushed();
var prepare = new PrepareLogRecord(logPosition, Guid.NewGuid(), Guid.NewGuid(), logPosition, 0, eventStreamId,
int.MaxValue - 1, DateTime.UtcNow,
PrepareFlags.StreamDelete | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
SystemEventTypes.StreamDeleted, new byte[0], new byte[0], prepareRecordVersion: LogRecordVersion.LogRecordV0);
Writer.Write(prepare, out pos);
var commit = new CommitLogRecord(WriterCheckpoint.ReadNonFlushed(), prepare.CorrelationId, prepare.LogPosition, DateTime.UtcNow, int.MaxValue,
commitRecordVersion: LogRecordVersion.LogRecordV0);
Writer.Write(commit, out pos);
}
public void other_prepares_cannot_be_committed()
{
var res = ReadIndex.IndexWriter.CheckCommitStartingAt(_prepare0.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.WrongExpectedVersion, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(0, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
res = ReadIndex.IndexWriter.CheckCommitStartingAt(_prepare2.LogPosition, WriterCheckpoint.ReadNonFlushed());
Assert.AreEqual(CommitDecision.WrongExpectedVersion, res.Decision);
Assert.AreEqual("ES", res.EventStreamId);
Assert.AreEqual(0, res.CurrentVersion);
Assert.AreEqual(-1, res.StartEventNumber);
Assert.AreEqual(-1, res.EndEventNumber);
}
public override void When()
{
BecomeMaster();
WriterCheckpoint.Write(_logPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId1, _logPosition));
Service.Handle(new SystemMessage.VNodeConnectionLost(
PortsHelper.GetLoopback(),
Guid.NewGuid(),
_replicaId1));
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); //n.b. we still don't have quorum here
//moving directly to log position 2 after rejoin
WriterCheckpoint.Write(_logPosition2);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId1, _logPosition2));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId2, _logPosition2));
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent());
}
public override void When()
{
BecomeLeader();
// All of the nodes have acked the first write
WriterCheckpoint.Write(_firstLogPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_follower1, _firstLogPosition));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_follower2, _firstLogPosition));
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent());
ReplicatedTos.Clear();
// Follower 2 has lost connection and does not ack the write
WriterCheckpoint.Write(_secondLogPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_follower1, _secondLogPosition));
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent());
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
ReadIndex.Close();
ReadIndex.Dispose();
TableIndex.Close(removeFiles: false);
TableIndex = new TableIndex(GetFilePathFor("index"),
() => new HashListMemTable(maxSize: MaxEntriesInMemTable * 2),
maxSizeForMemory: MaxEntriesInMemTable);
ReadIndex = new ReadIndex(new NoopPublisher(),
2,
2,
() => new TFChunkReader(Db, WriterCheckpoint, 0),
TableIndex,
new ByLengthHasher(),
new NoLRUCache <string, StreamCacheInfo>(),
additionalCommitChecks: true,
metastreamMaxCount: 1);
ReadIndex.Init(WriterCheckpoint.Read(), ChaserCheckpoint.Read());
}
protected override void WriteTestScenario()
{
var t1 = WriteTransactionBeginV0(Guid.NewGuid(), WriterCheckpoint.ReadNonFlushed(), _streamIdOne,
ExpectedVersion.NoStream);
var t2 = WriteTransactionBeginV0(Guid.NewGuid(), WriterCheckpoint.ReadNonFlushed(), _streamIdTwo,
ExpectedVersion.NoStream);
_p1 = WriteTransactionEventV0(t1.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t1.LogPosition, 0,
t1.EventStreamId, 0, "es1", PrepareFlags.Data);
_p2 = WriteTransactionEventV0(t2.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t2.LogPosition, 0,
t2.EventStreamId, 0, "abc1", PrepareFlags.Data);
_p3 = WriteTransactionEventV0(t1.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t1.LogPosition, 1,
t1.EventStreamId, 1, "es1", PrepareFlags.Data);
_p4 = WriteTransactionEventV0(t2.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t2.LogPosition, 1,
t2.EventStreamId, 1, "abc1", PrepareFlags.Data);
_p5 = WriteTransactionEventV0(t1.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t1.LogPosition, 2,
t1.EventStreamId, 2, "es1", PrepareFlags.Data);
WriteTransactionEndV0(t2.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t2.TransactionPosition,
t2.EventStreamId);
WriteTransactionEndV0(t1.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t1.TransactionPosition,
t1.EventStreamId);
_t2CommitPos = WriteCommitV0(t2.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t2.TransactionPosition,
t2.EventStreamId, 0, out _postCommitPos);
_t1CommitPos = WriteCommitV0(t1.CorrelationId, WriterCheckpoint.ReadNonFlushed(), t1.TransactionPosition,
t1.EventStreamId, 0, out _postCommitPos);
Writer.CompleteChunk();
// Need to have a second chunk as otherwise the checkpoints will be off
_random1 = WriteSingleEventWithLogVersion0(Guid.NewGuid(), "random-stream",
WriterCheckpoint.ReadNonFlushed(), 0);
Scavenge(completeLast: false, mergeChunks: true);
}
public void checksums_should_be_equal_to_ack_checksum()
{
Assert.AreEqual(TruncateCheckpoint, WriterCheckpoint.Read());
Assert.AreEqual(TruncateCheckpoint, ChaserCheckpoint.Read());
}
public void checksums_should_be_equal_to_beginning_of_intersected_scavenged_chunk()
{
Assert.AreEqual(chunkEdge.TransactionPosition, WriterCheckpoint.Read());
Assert.AreEqual(chunkEdge.TransactionPosition, ChaserCheckpoint.Read());
}
