public void AfmReturnsRightNumberOfJObjects()
{
_testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
Cleanup();
var formatter = new BSONFormatter();
var core = new FileCore<int, long>() { IdSeed = new Seed32(999), SegmentSeed = new Seed64(), MinimumCoreStride = 512 };
var addEntities = TestResourceFactory.GetMockClassAObjects(10000).ToList();
foreach (var entity in addEntities)
entity.Id = _seed.Increment();
IDictionary<int, long> returnSegments = null;
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", core))
{
afm.Load<int>();
using (var manager = new TransactionManager<int, MockClassA>
(new MockTransactionFactory<int, MockClassA>()
, new TransactionSynchronizer<int, MockClassA>()))
{
manager.TransactionCommitted += new TransactionCommit<int, MockClassA>(
delegate(ITransaction<int, MockClassA> tranny)
{
returnSegments = afm.CommitTransaction(tranny, new Dictionary<int, long>());
tranny.MarkComplete();
});
using (var tLock1 = manager.BeginTransaction())
{
addEntities.ForEach(delegate(MockClassA entity)
{
tLock1.Transaction.Enlist(Action.Create, entity.Id, entity);
});
tLock1.Transaction.Commit();
Assert.AreEqual(10000, afm.Length);
}
foreach (var group in afm.AsEnumerable())
{
var match = group.Where(i => i.SelectToken("Id").Value<int>() > 9999).ToList();
if (match == null || !match.Any())
continue;
var result = match.First(r => r.Value<int>("Id") == 10000).ToObject<MockClassC>();
Assert.IsNotNull(result);
Assert.AreEqual(10000, result.Id);
break;
}
}
}
}
public void Lz4BinFormatsToStream()
{
var test = TestResourceFactory.CreateRandom() as MockClassC;
var bson = new BSONFormatter();
var zip = new LZ4ZipFormatter(bson);
var bytes = bson.FormatObjStream(test);
var binFormatted = zip.Format(bytes);
var buffer = zip.Unformat(binFormatted);
var unformatted = bson.UnformatObj<MockClassA>(buffer) as MockClassC;
Assert.AreEqual(unformatted.Id, test.Id);
Assert.AreEqual(unformatted.Name, test.Name);
Assert.AreEqual(unformatted.GetSomeCheckSum[0], test.GetSomeCheckSum[0]);
Assert.AreEqual(unformatted.Location.X, test.Location.X);
Assert.AreEqual(unformatted.Location.Y, test.Location.Y);
Assert.AreEqual(unformatted.Location.Z, test.Location.Z);
Assert.AreEqual(unformatted.Location.W, test.Location.W);
Assert.AreEqual(unformatted.ReferenceCode, test.ReferenceCode);
Assert.AreEqual(unformatted.ReplicationID, test.ReplicationID);
}
public void AtomicFileManagerReturnsPagedStream()
{
_testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
Cleanup();
var formatter = new BSONFormatter();
var core = new FileCore<int, long>() { IdSeed = new Seed32(999), SegmentSeed = new Seed64(), MinimumCoreStride = 512 };
var addEntities = TestResourceFactory.GetMockClassAObjects(20480).ToList();
foreach (var entity in addEntities)
entity.Id = core.IdSeed.Increment();
var updateEntities = new List<MockClassC>();
IDictionary<int, long> returnSegments = null;
IDictionary<int, long> deletedSegments = new Dictionary<int, long>();
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", core))
{
afm.Load<int>();
afm.Rebuilt += new Rebuild<MockClassA>(delegate(Guid transactionId, int newStride, long newLength, int newSeedStride)
{
afm.SaveCore<int>();
});
var segs = AtomicFileManagerHelper.SaveSegments(afm, addEntities.ToDictionary(e => e.Id));
afm.SaveCore<int>();
var s = afm.GetPageStream(1);
Assert.IsNotNull(s);
Assert.GreaterOrEqual(s.Length, 1441792);
Assert.AreEqual(8, afm.AsStreaming().Count());
}
}
public void AfmCommitsComplexTransaction()
{
_testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
Cleanup();
var formatter = new BSONFormatter();
var core = new FileCore<int, long>() { IdSeed = new Seed32(999), SegmentSeed = new Seed64(), Stride = 32 };
var addEntities = TestResourceFactory.GetMockClassAObjects(25).ToList();
foreach (var entity in addEntities)
entity.Id = core.IdSeed.Increment();
var updateEntities = new List<MockClassC>();
IDictionary<int, long> returnSegments = null;
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", core, formatter))
{
afm.Load<int>();
using (var manager = new TransactionManager<int, MockClassA>
(new MockTransactionFactory<int, MockClassA>()
, new TransactionSynchronizer<int, MockClassA>()))
{
afm.Rebuilt += new Rebuild<MockClassA>(delegate(Guid transactionId, int newStride, long newLength, int newSeedStride)
{
var c = (IFileCore<int, long>)afm.Core;
c.Stride = newStride;
c.MinimumCoreStride = newSeedStride;
afm.SaveCore<int>();
});
manager.TransactionCommitted += new TransactionCommit<int, MockClassA>(
delegate(ITransaction<int, MockClassA> tranny)
{
returnSegments = afm.CommitTransaction(tranny, new Dictionary<int, long>());
tranny.MarkComplete();
});
using (var tLock = manager.BeginTransaction())
{
addEntities.ForEach(delegate(MockClassA entity)
{
tLock.Transaction.Enlist(Action.Create, entity.Id, entity);
});
tLock.Transaction.Commit();
Assert.AreEqual(25, afm.Length);
}
}
}
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", formatter))
{
afm.Load<int>();
Assert.AreEqual(25, afm.Length);
using (var manager = new TransactionManager<int, MockClassA>
(new MockTransactionFactory<int, MockClassA>()
, new TransactionSynchronizer<int, MockClassA>()))
{
afm.Rebuilt += new Rebuild<MockClassA>(delegate(Guid transactionId, int newStride, long newLength, int newSeedStride)
{
var c = (IFileCore<int, long>)afm.Core;
c.Stride = newStride;
c.MinimumCoreStride = newSeedStride;
afm.SaveCore<int>();
});
manager.TransactionCommitted += new TransactionCommit<int, MockClassA>(
delegate(ITransaction<int, MockClassA> tranny)
{
returnSegments = afm.CommitTransaction(tranny, returnSegments);
tranny.MarkComplete();
});
using (var tLock = manager.BeginTransaction())
{
foreach (var kvp in returnSegments)
updateEntities.Add(afm.LoadSegmentFrom(kvp.Value) as MockClassC);
updateEntities.ForEach(u => u.Name = (u.Location.X + u.Location.Y).ToString() + u.Name);
updateEntities.ForEach(u => tLock.Transaction.Enlist(Action.Update, u.Id, u));
var insert = TestResourceFactory.CreateRandom().WithName("numb nugget") as MockClassC;
insert.Id = core.IdSeed.Increment();
updateEntities.Add(insert);
tLock.Transaction.Enlist(Action.Create, insert.Id, insert);
tLock.Transaction.Commit();
Assert.AreEqual(26, afm.Length);
}
}
}
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", formatter))
{
afm.Load<int>();
Assert.LessOrEqual(461, afm.Stride);
Assert.AreEqual(10240, afm.CorePosition);
foreach (var entity in updateEntities)
{
var obj = afm.LoadSegmentFrom(returnSegments[entity.Id]) as MockClassC;
Assert.IsNotNull(obj);
Assert.AreEqual(entity.Id, obj.Id);
Assert.AreEqual(entity.Name, obj.Name);
Assert.AreEqual(entity.GetSomeCheckSum, obj.GetSomeCheckSum);
Assert.AreEqual(entity.Location.X, obj.Location.X);
Assert.AreEqual(entity.Location.Y, obj.Location.Y);
Assert.AreEqual(entity.Location.Z, obj.Location.Z);
Assert.AreEqual(entity.Location.W, obj.Location.W);
Assert.AreEqual(entity.ReferenceCode, obj.ReferenceCode);
Assert.AreEqual(entity.ReplicationID, obj.ReplicationID);
}
}
}
public void Lz4UnparsesJObjectToStream()
{
var arraySettings = BSONFormatter.GetDefaultSettings();
arraySettings.TypeNameHandling = BESSy.Json.TypeNameHandling.Objects;
var bson = new BSONFormatter(arraySettings);
var zip = new LZ4ZipFormatter(bson);
var test = TestResourceFactory.CreateRandom() as MockClassC;
var stream = zip.FormatObjStream(test);
var len = stream.Length;
var copy = new MemoryStream();
stream.CopyTo(copy);
var unformatted = zip.Parse(stream);
var formatted = zip.Unparse(unformatted);
Assert.AreEqual(new StreamReader(copy).ReadToEnd(), new StreamReader(formatted).ReadToEnd());
Stream os;
zip.TryUnparse(unformatted, out os);
}
public void Lz4ParsesJObjectFromStream()
{
var arraySettings = BSONFormatter.GetDefaultSettings();
arraySettings.TypeNameHandling = BESSy.Json.TypeNameHandling.Objects;
var bson = new BSONFormatter(arraySettings);
var zip = new LZ4ZipFormatter(bson);
var test = TestResourceFactory.CreateRandom() as MockClassC;
var stream = zip.FormatObjStream(test);
var unformatted = zip.Parse(stream);
Assert.AreEqual(unformatted.Value<int>("Id"), test.Id);
Assert.AreEqual(unformatted.Value<string>("Name"), test.Name);
Assert.AreEqual((double)unformatted["GetSomeCheckSum"][0], test.GetSomeCheckSum[0]);
Assert.AreEqual((double)unformatted["Location"]["X"], test.Location.X);
Assert.AreEqual((double)unformatted["Location"]["Y"], test.Location.Y);
Assert.AreEqual((double)unformatted["Location"]["Z"], test.Location.Z);
Assert.AreEqual((double)unformatted["Location"]["W"], test.Location.W);
Assert.AreEqual((string)unformatted["ReferenceCode"], test.ReferenceCode);
Assert.AreEqual((Guid)unformatted["ReplicationID"], test.ReplicationID);
}
public void PubSubNeverPicksUpOwnTransactions()
{
_testName = System.Reflection.MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
using (var fLock = new ManagedFileLock(_testName))
{
Cleanup();
using (var pdb1 = new Database<Guid, MockClassA>(_testName + ".subscriber" + ".database", "ReplicationID", new FileCore<Guid, long>())
.WithPublishing("Test", new FilePublisher<Guid, MockClassA>(Path.Combine(Environment.CurrentDirectory, _testName)))
.WithSubscription("Test", new FileSubscriber<Guid, MockClassA>(Path.Combine(Environment.CurrentDirectory, _testName), new TimeSpan(0, 0, 0, 0, 500))))
{
pdb1.Load();
pdb1.Clear();
using (var t = pdb1.BeginTransaction())
{
pdb1.Delete(o => o != null);
t.Commit();
}
Assert.IsTrue(Directory.Exists(Path.Combine(Environment.CurrentDirectory, _testName)));
var objects = TestResourceFactory.GetMockClassAObjects(25).OfType<MockClassC>().ToList();
var negativeObjects = TestResourceFactory.GetMockClassAObjects(25).OfType<MockClassC>().ToList();
using (var t = pdb1.BeginTransaction())
{
objects.ForEach(o => pdb1.Add(o));
t.Commit();
}
var testTran = new MockTransaction<Guid, MockClassA>(
new TransactionManager<Guid, MockClassA>(
new MockTransactionFactory<Guid, MockClassA>()
, new TransactionSynchronizer<Guid, MockClassA>()));
testTran.Source = pdb1.TransactionSource;
foreach (var no in negativeObjects)
testTran.Enlist(Action.Create, no.ReplicationID, (MockClassA)no);
testTran.Commit();
var formatter = new BSONFormatter();
using (var fs = new FileStream(
Path.Combine(Environment.CurrentDirectory, _testName, testTran.Id.ToString() + ".trans")
, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, 4096, false))
{
var s = formatter.FormatObjStream(testTran);
s.WriteAllTo(fs);
fs.Flush();
fs.Close();
}
Thread.Sleep(750);
var sw = new Stopwatch();
sw.Start();
while (pdb1.FileFlushQueueActive && sw.ElapsedMilliseconds < 3000)
Thread.Sleep(100);
Assert.AreEqual(25, pdb1.Length);
}
}
}
public void FormatterCompressesVeryLargeFiles()
{
var test = new Mocks.MockImageContainer(testRes.IronAsteroid_NRM) { Name = "IronAsteroid_NRM" };
var bson = new BSONFormatter();
var zip = new LZ4ZipFormatter(bson);
var bytes = bson.FormatObjStream(test);
var binFormatted = zip.Format(bytes);
var buffer = zip.Unformat(binFormatted);
var unformatted = bson.UnformatObj<ResourceContainer>(buffer) as MockImageContainer;
Assert.AreEqual(unformatted.Name, test.Name);
Assert.AreEqual(unformatted.GetResource<Bitmap>().Size.Width, test.GetResource<Bitmap>().Size.Width);
}
public void BSONFormatsToBytes()
{
var test = TestResourceFactory.CreateRandom() as MockClassC;
var bson = new BSONFormatter();
var formatted = bson.FormatObj(test);
var unformatted = bson.UnformatObj<MockClassA>(formatted) as MockClassC;
Assert.AreEqual(unformatted.Id, test.Id);
Assert.AreEqual(unformatted.Name, test.Name);
Assert.AreEqual(unformatted.GetSomeCheckSum[0], test.GetSomeCheckSum[0]);
Assert.AreEqual(unformatted.Location.X, test.Location.X);
Assert.AreEqual(unformatted.Location.Y, test.Location.Y);
Assert.AreEqual(unformatted.Location.Z, test.Location.Z);
Assert.AreEqual(unformatted.Location.W, test.Location.W);
Assert.AreEqual(unformatted.ReferenceCode, test.ReferenceCode);
Assert.AreEqual(unformatted.ReplicationID, test.ReplicationID);
}
public void FormatterCompressesVeryLargeFileStreams()
{
var test = new Mocks.MockStreamContainer(new MemoryStream(testRes.MiscAngelic)) { Name = "MiscAngelic" };
var bson = new BSONFormatter();
var zip = new LZ4ZipFormatter(bson);
var bytes = bson.FormatObjStream(test);
var binFormatted = zip.Format(bytes);
var buffer = zip.Unformat(binFormatted);
var unformatted = bson.UnformatObj<ResourceStreamContainer>(buffer) as MockStreamContainer;
Assert.AreEqual(unformatted.Name, test.Name);
Assert.AreEqual(unformatted.GetResource<Stream>().Length, test.GetResource<Stream>().Length);
}
public void BSONWritesJObjectToStream()
{
var arraySettings = BSONFormatter.GetDefaultSettings();
arraySettings.TypeNameHandling = BESSy.Json.TypeNameHandling.Objects;
var test = TestResourceFactory.CreateRandom() as MockClassC;
var bson = new BSONFormatter(arraySettings);
var stream = bson.FormatObjStream(test);
var len = stream.Length;
var copy = new MemoryStream();
stream.Position = 0;
stream.CopyTo(copy);
var unformatted = bson.Parse(stream);
var formatted = bson.Unparse(unformatted);
copy.Position = formatted.Position = 0;
var orig = new StreamReader(copy).ReadToEnd();
var unparsed = new StreamReader(formatted).ReadToEnd();
//Console.Write(b);
//Console.WriteLine();
//Console.Write(unparsed);
Assert.AreEqual(copy.Length, formatted.Length);
var reformatted = bson.Parse(formatted);
Assert.AreEqual(unformatted, reformatted);
MockClassC.Validate(unformatted.ToObject<MockClassC>(), reformatted.ToObject<MockClassC>());
Stream os;
bson.TryUnparse(reformatted, out os);
Assert.AreEqual(len, os.Length);
}
public void BSONSafeFormatsToStream()
{
var test = TestResourceFactory.CreateRandom() as MockClassC;
var bson = new BSONFormatter();
Stream formatted;
Assert.IsTrue(bson.TryFormatObj(test, out formatted));
MockClassA raw;
Assert.IsTrue(bson.TryUnformatObj<MockClassA>(formatted, out raw));
var unformatted = raw as MockClassC;
Assert.AreEqual(unformatted.Id, test.Id);
Assert.AreEqual(unformatted.Name, test.Name);
Assert.AreEqual(unformatted.GetSomeCheckSum[0], test.GetSomeCheckSum[0]);
Assert.AreEqual(unformatted.Location.X, test.Location.X);
Assert.AreEqual(unformatted.Location.Y, test.Location.Y);
Assert.AreEqual(unformatted.Location.Z, test.Location.Z);
Assert.AreEqual(unformatted.Location.W, test.Location.W);
Assert.AreEqual(unformatted.ReferenceCode, test.ReferenceCode);
Assert.AreEqual(unformatted.ReplicationID, test.ReplicationID);
var invalid = new MemoryStream(Encoding.UTF8.GetBytes("{ this is invalid."));
//Check false conditions.
Assert.IsFalse(bson.TryFormatObj(default(MockClassA), out formatted));
Assert.IsFalse(bson.TryUnformatObj((Stream)null, out raw));
Assert.IsFalse(bson.TryUnformatObj(invalid, out raw));
}
public void AfmRebuildsOnFailedTransaction()
{
_testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
var formatter = new BSONFormatter();
var core = new FileCore<int, long>() { IdSeed = new Seed32(999), SegmentSeed = new Seed64(), MinimumCoreStride = 512 };
var entity = TestResourceFactory.CreateRandom() as MockClassC;
var largeEntity = TestResourceFactory.CreateRandom().WithName(new String('a', 2000)) as MockClassC;
IDictionary<int, long> returnSegments = null;
using (var fLock = new ManagedFileLock(_testName))
{
Cleanup();
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", core, formatter))
{
afm.Load<int>();
using (var manager = new TransactionManager<int, MockClassA>
(new MockTransactionFactory<int, MockClassA>()
, new TransactionSynchronizer<int, MockClassA>()))
{
manager.TransactionCommitted += new TransactionCommit<int, MockClassA>(
delegate(ITransaction<int, MockClassA> tranny)
{
returnSegments = afm.CommitTransaction(tranny, new Dictionary<int, long>());
while (afm.FileFlushQueueActive)
Thread.Sleep(100);
tranny.MarkComplete();
afm.SaveCore<int>();
});
using (var tLock = manager.BeginTransaction())
{
tLock.Transaction.Enlist(Action.Create, entity.Id, entity);
tLock.Transaction.Commit();
}
}
}
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", formatter))
{
afm.Load<int>();
using (var manager = new TransactionManager<int, MockClassA>
(new MockTransactionFactory<int, MockClassA>()
, new TransactionSynchronizer<int, MockClassA>()))
{
manager.TransactionCommitted += new TransactionCommit<int, MockClassA>(
delegate(ITransaction<int, MockClassA> tranny)
{
returnSegments = afm.CommitTransaction(tranny, returnSegments);
while (afm.FileFlushQueueActive)
Thread.Sleep(100);
tranny.MarkComplete();
afm.SaveCore<int>();
});
using (var tLock = manager.BeginTransaction())
{
tLock.Transaction.Enlist(Action.Update, largeEntity.Id, largeEntity);
tLock.Transaction.Commit();
}
}
}
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", formatter))
{
afm.Load<int>();
Assert.Greater(afm.Stride, 2200);
Assert.AreEqual(1024, afm.CorePosition);
var obj = afm.LoadSegmentFrom(returnSegments.First().Value) as MockClassC;
Assert.IsNotNull(obj);
Assert.AreEqual(largeEntity.Id, obj.Id);
Assert.AreEqual(largeEntity.Name, obj.Name);
Assert.AreEqual(largeEntity.GetSomeCheckSum, obj.GetSomeCheckSum);
Assert.AreEqual(largeEntity.Location.X, obj.Location.X);
Assert.AreEqual(largeEntity.Location.Y, obj.Location.Y);
Assert.AreEqual(largeEntity.Location.Z, obj.Location.Z);
Assert.AreEqual(largeEntity.Location.W, obj.Location.W);
Assert.AreEqual(largeEntity.ReferenceCode, obj.ReferenceCode);
Assert.AreEqual(largeEntity.ReplicationID, obj.ReplicationID);
}
}
}
public void AfmReorganizesWithCorrectNumberOfRows()
{
_testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
var formatter = new BSONFormatter();
var core = new FileCore<int, long>() { IdSeed = new Seed32(999), SegmentSeed = new Seed64(), MinimumCoreStride = 512, InitialDbSize = 10240 };
var addEntities = TestResourceFactory.GetMockClassAObjects(10000).ToList();
foreach (var entity in addEntities)
entity.Id = core.IdSeed.Increment();
addEntities.Reverse();
using (var fLock = new ManagedFileLock(_testName))
{
Cleanup();
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", 4096, 20000, 4096, core, formatter, new RowSynchronizer<long>(new BinConverter64())))
{
afm.Load<int>();
afm.Rebuilt += new Rebuild<MockClassA>(delegate(Guid transactionId, int newStride, long newLength, int newSeedStride)
{
afm.SaveCore<int>();
});
AtomicFileManagerHelper.SaveSegments(afm, addEntities.ToDictionary(e => e.Id));
}
addEntities.Reverse();
var seg = 1;
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", 4096, 20000, 4096, formatter, new RowSynchronizer<long>(new BinConverter64())))
{
afm.Load<int>();
Assert.AreNotEqual(1, afm.LoadSegmentFrom(seg).Id);
afm.Reorganized += new Reorganized<MockClassA>(delegate(int recordsWritten)
{
afm.SaveCore<int>();
});
afm.Reorganize<int>(new BinConverter32(), j => j.Value<int>("Id"));
}
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", 4096, 20000, 4096, core, formatter, new RowSynchronizer<long>(new BinConverter64())))
{
afm.Load<int>();
foreach (var entity in addEntities)
{
Assert.AreEqual(entity.Id, afm.LoadSegmentFrom(seg).Id, "Id {0} was not found in the right order, Id {1} was found instead.", entity.Id, afm.LoadSegmentFrom(seg).Id);
seg++;
}
}
}
}
public void AfmRebuildsWithNewSeedSize()
{
_testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
Cleanup();
var formatter = new BSONFormatter();
var core = new FileCore<int, long>() { IdSeed = new Seed32(999), SegmentSeed = new Seed64(), MinimumCoreStride = 512 };
var addEntities = TestResourceFactory.GetMockClassAObjects(20480).ToList();
foreach (var entity in addEntities)
entity.Id = core.IdSeed.Increment();
var updateEntities = new List<MockClassC>();
IDictionary<int, long> returnSegments = null;
IDictionary<int, long> deletedSegments = new Dictionary<int, long>();
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", core))
{
afm.Load<int>();
using (var manager = new TransactionManager<int, MockClassA>
(new MockTransactionFactory<int, MockClassA>()
, new TransactionSynchronizer<int, MockClassA>()))
{
manager.TransactionCommitted += new TransactionCommit<int, MockClassA>(
delegate(ITransaction<int, MockClassA> tranny)
{
returnSegments = afm.CommitTransaction(tranny, new Dictionary<int, long>());
while (afm.FileFlushQueueActive)
Thread.Sleep(100);
tranny.MarkComplete();
afm.SaveCore<int>();
});
using (var tLock = manager.BeginTransaction())
{
addEntities.ForEach(delegate(MockClassA entity)
{
tLock.Transaction.Enlist(Action.Create, entity.Id, entity);
});
Assert.AreEqual(20480, tLock.Transaction.EnlistCount);
tLock.Transaction.Commit();
Assert.AreEqual(20480, afm.Length);
}
}
}
using (var afm = new AtomicFileManager<MockClassA>(_testName + ".database", core))
{
afm.Load<int>();
Assert.AreEqual(20480, afm.Length);
using (var manager = new TransactionManager<int, MockClassA>
(new MockTransactionFactory<int, MockClassA>()
, new TransactionSynchronizer<int, MockClassA>()))
{
manager.TransactionCommitted += new TransactionCommit<int, MockClassA>(
delegate(ITransaction<int, MockClassA> tranny)
{
returnSegments = afm.CommitTransaction(tranny, returnSegments);
while (afm.FileFlushQueueActive)
Thread.Sleep(100);
tranny.MarkComplete();
afm.SaveCore<int>();
core.MinimumCoreStride = (int)formatter.FormatObjStream(core).Length;
});
using (var tLock = manager.BeginTransaction())
{
deletedSegments = returnSegments.Take(9000).ToDictionary(k => k.Key, k => k.Value);
foreach (var kvp in deletedSegments)
updateEntities.Add(afm.LoadSegmentFrom(kvp.Value) as MockClassC);
updateEntities.ForEach(u => tLock.Transaction.Enlist(Action.Delete, u.Id, u));
tLock.Transaction.Commit();
afm.SaveCore<int>();
}
Assert.AreEqual(512, afm.Stride);
//Deleting items from the database adds those idsToDelete to the segmentSeed'aqn open Ids list, increasing it'aqn size. It'aqn an easy way to check for segmentSeed rebuilding.
Assert.Greater(afm.Core.MinimumCoreStride, 23000);
}
}
}
