Example #1
0
        public void NTreeDeletesByLocationIndividualUnique()
        {
            var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());

            using (var tree = new NTree<int, MockClassA, long>("Id", true))
            {
                foreach (var o in objs)
                    tree.AddOrUpdate(new Tuple<MockClassA, long>(o, seedSegment.Increment()));

                Assert.AreEqual(50, tree.Length);

                Assert.AreEqual(5, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(5).Count());

                tree.DeleteAt(5L);

                Assert.AreEqual(50, tree.Length);

                Assert.AreEqual(0, tree[5].Index);
            }
        }
Example #2
0
        public void NTreeChecksAllWithLargeCount()
        {
            using (var tree = new NTree<int, MockClassA, long>("Id", true))
            {
                var objs = new List<MockClassA>();
                var seedIndex = new Seed32();
                var seedSegment = new Seed64();

                for (var i = 0; i < 5; i++)
                {
                    var additions = TestResourceFactory.GetMockClassAObjects(100000).ToList();

                    additions.ForEach(o => o.Id = seedIndex.Increment());

                    tree.AddOrUpdateRange(additions.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList());
                }

                Assert.AreEqual(500000, tree.Length);

                Assert.AreEqual(5, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(5).Count());

                tree.AddOrUpdate(new Tuple<MockClassA, long>(TestResourceFactory.CreateRandom().WithId(seedIndex.Increment()), seedSegment.Increment()));

                Assert.AreEqual(500001, tree.Length);

                tree.AddOrUpdateRange(
                    tree.AsEnumerable().First().Take(100)
                    .Select(s => new NTreeItem<int, long>(s.Item2.Index, s.Item2.Segment))
                    .ToList());

                Assert.AreEqual(500001, tree.Length);
            }
        }
Example #3
0
        public void PTreeDeletesByIndexIndividualUnique()
        {
            _testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
            Cleanup();

            var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());

            using (var tree = new PTree<int, MockClassA, long>("Id", _testName + ".index", true))
            {
                tree.Load();

                foreach (var o in objs)
                    tree.AddOrUpdate(new Tuple<MockClassA, long>(o, seedSegment.Increment()));

                Assert.AreEqual(50, tree.Length);

                Assert.AreEqual(5, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(5).Count());

                Assert.AreEqual(1, tree.Delete(5).Length);

                Assert.AreEqual(50, tree.Length);

                Assert.AreEqual(0, tree.GetFirstByIndex(5));
            }
        }
        public void NTreeFetchesByIndexRange()
        {
            var objs = TestResourceFactory.GetMockClassAObjects(5000).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());
            var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();

            using (var tree = new NTree<int, MockClassA, long>("Id"))
            {
                var ids = tree.AddOrUpdateRange(toAdd);

                Assert.AreEqual(5000, tree.Length);

                Assert.AreEqual(5, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(5).Count());

                tree.AddOrUpdate(new Tuple<MockClassA, long>(TestResourceFactory.CreateRandom().WithId(seedIndex.Increment()), seedSegment.Increment()));

                Assert.AreEqual(5001, tree.Length);

                long[] loc;
                var range = tree.GetByIndexRangeInclusive(51, 250, out loc);

                Assert.AreEqual(200, range.Length);
            }
        }
Example #5
0
        public void PTreePushesEntities()
        {
            _testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
            Cleanup();

            var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());
            var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();

            using (var tree = new PTree<int, MockClassA, long>("Id", _testName + ".index", true))
            {
                tree.Load();

                var ids = tree.AddOrUpdateRange(toAdd);
                tree.AddOrUpdate(toAdd.First());

                Assert.AreEqual(50, tree.Length);

                Assert.AreEqual(5L, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(1).Count());
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
            }
        }
        public void SingleRelationshipSavesAndDeletes()
        {
            _testName = System.Reflection.MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();

            var seed = new Seed32();
            List<MockClassE> objs = null;
            var ids = new List<int>();

            using (var fLock = new ManagedFileLock(_testName))
            {
                Cleanup();

                using (var db = new RelationalDatabase<int, MockClassD>(_testName + ".database", "Id"))
                {
                    db.Load();

                    using (var t = db.BeginTransaction())
                    {
                        objs = TestResourceFactory.GetMockClassDObjects(3, db).ToList();

                        objs.ToList().ForEach(o => o.Id = db.Add(o));

                        t.Commit();
                    }
                }

                using (var db = new RelationalDatabase<int, MockClassD>(_testName + ".database"))
                {
                    db.Load();

                    var first = db.Fetch(objs[0].Id);

                    using (var t = db.BeginTransaction())
                    {
                        first.LowBall = new List<MockClassD>();

                        db.Update(first, first.Id);

                        t.Commit();
                    }

                    first = db.Fetch(objs[0].Id);

                    Assert.AreEqual(0, first.LowBall.Count());
                }

                using (var db = new RelationalDatabase<int, MockClassD>(_testName + ".database"))
                {
                    db.Load();

                    var first = db.Fetch(objs.First().Id);

                    Assert.AreEqual(0, first.LowBall.Count());
                }
            }
        }
Example #7
0
        public void Seed32StartsAtOne()
        {
            var seed = new Seed32();

            Assert.AreEqual(1, seed.Peek());

            Assert.AreEqual(1, seed.Increment());

            Assert.AreEqual(1, seed.LastSeed);
        }
Example #8
0
        public void Seed32StartsWithParameter()
        {
            var seed = new Seed32(999);

            Assert.AreEqual(1000, seed.Peek());

            Assert.AreEqual(1000, seed.Increment());

            Assert.AreEqual(1000, seed.LastSeed);
        }
Example #9
0
        public void Seed32OpensUnused()
        {
            var seed = new Seed32(999);

            Assert.AreEqual(1000, seed.Increment());

            seed.Open(500);

            Assert.AreEqual(500, seed.Peek());

            Assert.AreEqual(500, seed.Increment());

            Assert.AreEqual(1000, seed.LastSeed);
        }
Example #10
0
        public void DatabaseCacheAllAroundTest()
        {
            _testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
            Cleanup();

            var seed = new Seed32();

            var cleanEntities = TestResourceFactory.GetMockClassAObjects(500);
            var dirtyEntities = TestResourceFactory.GetMockClassAObjects(500);

            cleanEntities.ToList().ForEach(c => c.Id = seed.Increment());
            dirtyEntities.ToList().ForEach(d => d.Id = seed.Increment());

            var db = new DatabaseCache<int, MockClassA>(false, 2048, new BinConverter32());

            db.CacheItem(cleanEntities.First().Id);

            //with manual caching
            foreach (var e in cleanEntities)
                db.UpdateCache(e.Id, e, false, false);

            Assert.AreEqual(1, db.Count);
            Assert.IsTrue(db.Contains(cleanEntities.First().Id));
            Assert.AreEqual(cleanEntities.First().Name, db.GetFromCache(cleanEntities.First().Id).Name);

            //with autoCache
            foreach (var e in cleanEntities)
                db.UpdateCache(e.Id, e, true, false);

            Assert.AreEqual(500, db.Count);

            db.Detach(cleanEntities.First().Id);

            Assert.AreEqual(499, db.Count);
            Assert.IsFalse(db.Contains(cleanEntities.First().Id));
            Assert.IsNull(db.GetFromCache(cleanEntities.First().Id));

            db.CacheSize = 400;

            db.UpdateCache(cleanEntities.First().Id, cleanEntities.First(), true, false);

            Assert.AreEqual(201, db.Count);
            Assert.IsFalse(db.IsNew(cleanEntities.First().Id));

            db.ClearCache();

            Assert.AreEqual(0, db.Count);
        }
Example #11
0
        public void Seed32IsThreadSafe()
        {
            var seed = new Seed32(999);

            var ids = new List<int>();

            Parallel.For(0, 50, delegate(int i)
            {
                ids.Add(seed.Increment());
            });

            Assert.AreEqual(50, ids.Distinct().Count());

            Assert.AreEqual(1050, seed.Increment());

            Assert.AreEqual(1050, seed.LastSeed);
        }
Example #12
0
        public void NTreePushesIndividualEntities()
        {
            var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());

            using (var tree = new NTree<int, MockClassA, long>("Id"))
            {
                foreach (var o in objs)
                    tree.AddOrUpdate(new Tuple<MockClassA, long>(o, seedSegment.Increment()));

                Assert.AreEqual(50, tree.Length);

                Assert.AreEqual(5, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(5).Count());
            }
        }
        public void SingleRelationshipSaves()
        {
            _testName = System.Reflection.MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();

            var seed = new Seed32();
            IList<MockClassE> objs = null;
            var ids = new List<int>();

            using (var fLock = new ManagedFileLock(_testName))
            {
                Cleanup();

                using (var db = new RelationalDatabase<int, MockClassD>(_testName + ".database", "Id"))
                {
                    db.Load();

                    using (var t = db.BeginTransaction())
                    {
                        objs = TestResourceFactory.GetMockClassDObjects(3, db).ToList();

                        objs.ToList().ForEach(o => o.Id = db.Add(o));

                        t.Commit();
                    }
                }

                using (var db = new RelationalDatabase<int, MockClassD>(_testName + ".database"))
                {
                    db.Load();

                    foreach (var obj in objs)
                    {
                        var orig = obj as MockClassE;
                        var item = db.Fetch(obj.Id) as MockClassE;

                        AssertMockClassE(item, orig, db);
                    }
                }
            }
        }
        public void AmbientTransactionCommitsIteself()
        {
            var seed = new Seed32();
            var hits = 0;

            using (var manager = new TransactionManager<int, MockClassA>() )
            {
                manager.TransactionCommitted += new TransactionCommit<int, MockClassA>
                    (delegate(ITransaction<int, MockClassA> transaction)
                    {
                        Assert.AreEqual(3, transaction.GetEnlistedActions().Count());
                        hits++;

                        transaction.MarkComplete();

                        hits = 1;
                    });

                var testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                testEntities.ForEach(e => e.Id = seed.Increment());

                using (var tLock1 = manager.GetActiveTransaction(false))
                {
                    foreach (var entity in testEntities)
                        tLock1.Transaction.Enlist(Action.Create, entity.Id, entity);

                    var sw = new Stopwatch();
                    sw.Start();

                    while (sw.ElapsedMilliseconds < 5500)
                        Thread.Sleep(10);
                }

                Thread.Sleep(500);

                Assert.AreEqual(1, hits);
            }
        }
Example #15
0
        public void NTreePushesEntities()
        {
            var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());
            var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();

            using (var tree = new NTree<int, MockClassA, long>("Id", true))
            {
                var ids = tree.AddOrUpdateRange(toAdd);
                tree.AddOrUpdate(toAdd.First());

                Assert.AreEqual(50, tree.Length);

                Assert.AreEqual(5L, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(1).Count());
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
            }
        }
        public void TransactionLockAutoCommitsTransactions()
        {
            var seed = new Seed32();
            int committed = 0;

            using (var manager = new TransactionManager<int, MockClassA>() )
            {
                manager.TransactionCommitted += new TransactionCommit<int, MockClassA>
                    (delegate(ITransaction<int, MockClassA> transaction)
                    {
                        Assert.AreEqual(3, transaction.GetEnlistedActions().Count());
                        committed += transaction.GetEnlistedActions().Count();

                        transaction.MarkComplete();
                    });

                var testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                testEntities.ForEach(e => e.Id = seed.Increment());

                using (var tLock1 = manager.BeginTransaction())
                {
                    foreach (var entity in testEntities)
                        tLock1.Transaction.Enlist(Action.Create, entity.Id, entity);

                    using (var tLock2 = manager.BeginTransaction())
                    {
                        testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                        testEntities.ForEach(e => e.Id = seed.Increment());

                        foreach (var entity in testEntities)
                            tLock2.Transaction.Enlist(Action.Create, entity.Id, entity);

                        using (var tLock3 = manager.BeginTransaction())
                        {
                            testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                            testEntities.ForEach(e => e.Id = seed.Increment());

                            foreach (var entity in testEntities)
                                tLock3.Transaction.Enlist(Action.Create, entity.Id, entity);

                            using (var tLock4 = manager.BeginTransaction())
                            {
                                testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                                testEntities.ForEach(e => e.Id = seed.Increment());

                                foreach (var entity in testEntities)
                                    tLock4.Transaction.Enlist(Action.Create, entity.Id, entity);

                                using (var tLock5 = manager.BeginTransaction())
                                {
                                    testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                                    testEntities.ForEach(e => e.Id = seed.Increment());

                                    foreach (var entity in testEntities)
                                        tLock5.Transaction.Enlist(Action.Create, entity.Id, entity);
                                }
                            }
                        }
                    }

                    tLock1.Transaction.Commit();

                    var sw = new Stopwatch();

                    while (!tLock1.Transaction.IsComplete && sw.ElapsedMilliseconds < 1000)
                        Thread.Sleep(100);

                    sw.Stop();

                    Assert.AreEqual(15, committed);
                    Assert.IsTrue(tLock1.Transaction.IsComplete);
                }
            }
        }
Example #17
0
        public void DatabaseFetchesUpdatesAndDeletesWithSecondaryIndex()
        {
            _testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
            Cleanup();

            var seed = new Seed32();
            var objs = TestResourceFactory.GetMockClassAObjects(100).ToList();
            var ids = new List<int>();

            using (var db = new Database<int, MockClassA>(_testName + ".database", "Id", new FileCore<int, long>())
                .WithIndex<string>("catIndex", "CatalogName", new BinConverterString()))
            {
                db.Load();

                objs.ToList().ForEach(o => ids.Add(db.Add(o)));

                db.FlushAll();
            }

            using (var db = new Database<int, MockClassA>(_testName + ".database", "Id")
                .WithIndex<string>("catIndex", "CatalogName", new BinConverterString()))
            {
                db.Load();

                var last = db.Fetch(objs.Last().Id);

                Assert.IsNotNull(last);

                last.Name = "last";

                db.Update(last, last.Id);

                db.FlushAll();
            }

            using (var db = new Database<int, MockClassA>(_testName + ".database", "Id", new FileCore<int, long>())
                .WithIndex<string>("catIndex", "CatalogName", new BinConverterString()))
            {
                db.Load();

                var last = db.Fetch(objs.Last().Id);

                Assert.IsNotNull(last);
                Assert.AreEqual("last", last.Name);

                Assert.IsNotNull(db.Fetch(objs.First().Id));

                db.Delete(objs.First().Id);

                Assert.IsNull(db.Fetch(objs.First().Id));

                db.FlushAll();
            }

            using (var db = new Database<int, MockClassA>(_testName + ".database", "Id", new FileCore<int, long>())
                .WithIndex<string>("catIndex", "CatalogName", new BinConverterString()))
            {
                db.Load();

                Assert.IsNull(db.Fetch(objs.First().Id));

                db.Clear();
            }
        }
Example #18
0
        public void NTreeStreamsData()
        {
            var objs = TestResourceFactory.GetMockClassAObjects(5000).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());
            var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();

            using (var tree = new NTree<int, MockClassA, long>("Id"))
            {
                var ids = tree.AddOrUpdateRange(toAdd);

                Assert.AreEqual(5000, tree.Length);

                Assert.AreEqual(5, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(5).Count());

                foreach (var p in tree.AsStreaming())
                {
                    if (p == null)
                        continue;

                    p.Dispose();
                }
            }
        }
        public void TransactionManagerRollsbackAmbientTransactionsOnAllThreads()
        {
            var seed = new Seed32();

            using (var manager = new TransactionManager<int, MockClassA>() )
            {
                manager.TransactionCommitted += new TransactionCommit<int, MockClassA>
                    (delegate(ITransaction<int, MockClassA> transaction)
                    {
                        transaction.MarkComplete();

                        Assert.Fail();
                    });

                var testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                testEntities.ForEach(e => e.Id = seed.Increment());

                using (var tLock1 = manager.GetActiveTransaction(false))
                {
                    foreach (var entity in testEntities)
                        tLock1.Transaction.Enlist(Action.Create, entity.Id, entity);

                    using (var tLock2 = manager.GetActiveTransaction(false))
                    {
                        testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                        testEntities.ForEach(e => e.Id = seed.Increment());

                        foreach (var entity in testEntities)
                            tLock2.Transaction.Enlist(Action.Create, entity.Id, entity);

                        manager.RollBackAll(true);
                    }
                }

                Assert.AreEqual(manager.GetCached().Count(), 0);
            }
        }
        public void TransactionManagerRollsbackAll()
        {
            var seed = new Seed32();

            using (var manager = new TransactionManager<int, MockClassA>() )
            {
                manager.TransactionCommitted += new TransactionCommit<int, MockClassA>
                    (delegate(ITransaction<int, MockClassA> transaction)
                    {
                        transaction.MarkComplete();

                        Assert.Fail();
                    });

                var testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                testEntities.ForEach(e => e.Id = seed.Increment());

                using (var tLock1 = manager.BeginTransaction())
                {
                    foreach (var entity in testEntities)
                        tLock1.Transaction.Enlist(Action.Create, entity.Id, entity);

                    using (var tLock2 = manager.BeginTransaction())
                    {
                        testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                        testEntities.ForEach(e => e.Id = seed.Increment());

                        foreach (var entity in testEntities)
                            tLock2.Transaction.Enlist(Action.Create, entity.Id, entity);

                        using (var tLock3 = manager.BeginTransaction())
                        {
                            testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                            testEntities.ForEach(e => e.Id = seed.Increment());

                            foreach (var entity in testEntities)
                                tLock3.Transaction.Enlist(Action.Create, entity.Id, entity);

                            using (var tLock4 = manager.BeginTransaction())
                            {
                                testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                                testEntities.ForEach(e => e.Id = seed.Increment());

                                foreach (var entity in testEntities)
                                    tLock4.Transaction.Enlist(Action.Create, entity.Id, entity);

                                using (var tLock5 = manager.BeginTransaction())
                                {
                                    testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                                    testEntities.ForEach(e => e.Id = seed.Increment());

                                    foreach (var entity in testEntities)
                                        tLock5.Transaction.Enlist(Action.Create, entity.Id, entity);

                                    manager.RollBackAll(true);

                                    while (manager.HasActiveTransactions)
                                        Thread.Sleep(100);

                                    Assert.IsTrue(tLock5.Transaction.IsComplete);
                                }

                                Assert.IsTrue(tLock4.Transaction.IsComplete);
                            }

                            Assert.IsTrue(tLock3.Transaction.IsComplete);
                        }

                        Assert.IsTrue(tLock2.Transaction.IsComplete);
                    }

                    Assert.IsTrue(tLock1.Transaction.IsComplete);
                }
            }
        }
Example #21
0
        public void NTreeDeletesManyUnique()
        {
            var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());

            using (var tree = new NTree<int, MockClassA, long>("Id", true))
            {
                foreach (var o in objs)
                    tree.AddOrUpdate(new Tuple<MockClassA, long>(o, seedSegment.Increment()));

                Assert.AreEqual(50, tree.Length);

                Assert.AreEqual(5, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(5).Count());

                tree.DeleteMany(new int[] { 1, 2, 3, 4, 5, 48, 49 });

                Assert.AreEqual(50, tree.Length);

                Assert.AreEqual(0, tree.GetFirstByIndex(1));
                Assert.AreEqual(0, tree.GetFirstByIndex(2));
                Assert.AreEqual(0, tree.GetFirstByIndex(3));
                Assert.AreEqual(0, tree.GetFirstByIndex(4));
                Assert.AreEqual(0, tree.GetFirstByIndex(5));
                Assert.AreEqual(0, tree.GetFirstByIndex(48));
                Assert.AreEqual(0, tree.GetFirstByIndex(49));
            }
        }
        public void SingleRelationshipSavesAndSelects()
        {
            _testName = System.Reflection.MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();

            var seed = new Seed32();
            List<MockClassE> objs = null;
            var ids = new List<int>();

            using (var fLock = new ManagedFileLock(_testName))
            {
                Cleanup();

                using (var db = new RelationalDatabase<int, MockClassD>(_testName + ".database", "Id"))
                {
                    db.Load();

                    using (var t = db.BeginTransaction())
                    {
                        objs = TestResourceFactory.GetMockClassDObjects(3, db).ToList();

                        objs.ToList().ForEach(o => o.Id = db.Add(o));

                        t.Commit();
                    }
                }

                using (var db = new RelationalDatabase<int, MockClassD>(_testName + ".database"))
                {
                    db.Load();

                    var first = db.SelectFirst(s => s.Value<int>("Id") > 0, 50);

                    foreach (var obj in objs)
                        AssertMockClassE((MockClassE)first.First(f => f.Id == obj.Id), obj as MockClassE, db);

                    var last = db.SelectLast(s => s.Value<int>("Id") > 0, 50);

                    foreach (var obj in objs)
                        AssertMockClassE((MockClassE)last.First(f => f.Id == obj.Id), obj as MockClassE, db);
                }
            }
        }
Example #23
0
        public void FlushRequestAndUnloadDirtyTest()
        {
            _testName = MethodInfo.GetCurrentMethod().Name.GetHashCode().ToString();
            Cleanup();

            var seed = new Seed32();

            var dirtyEntities = TestResourceFactory.GetMockClassAObjects(500);

            dirtyEntities.ToList().ForEach(d => d.Id = seed.Increment());

            var db = new DatabaseCache<int, MockClassA>(false, 2048, new BinConverter32());
            db.CacheSize = 400;

            db.FlushRequested += new EventHandler(delegate(object sender, EventArgs e)
            {
                var dbparam = sender as DatabaseCache<int, MockClassA>;
                Assert.AreEqual(dbparam.CacheSize + 1, dbparam.DirtyCount);

                var dirtyItems = dbparam.UnloadDirtyItems();

                Assert.AreEqual(0, dbparam.DirtyCount);
                Assert.AreEqual(0, dbparam.Count);
            });

            foreach (var d in dirtyEntities)
                db.UpdateCache(d.Id, d, true, true);

            db.Sweep();
        }
        public void TransactionManagerCommitAllCommitsAllTransactions()
        {
            var sync = new object();
            var seed = new Seed32();
            var hits = 0;

            using (var manager = new TransactionManager<int, MockClassA>())
            {
                manager.TransactionCommitted += new TransactionCommit<int, MockClassA>
                    (delegate(ITransaction<int, MockClassA> transaction)
                    {
                        Assert.AreEqual(3, transaction.GetEnlistedActions().Count());
                        hits++;

                        transaction.MarkComplete();
                    });

                var transList = new List<TransactionLock<int, MockClassA>>();

                Parallel.For(0, 5, delegate(int i)
                {
                    var testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                    testEntities.ForEach(e => e.Id = seed.Increment());

                    var trans = manager.BeginTransaction();

                    foreach (var entity in testEntities)
                        trans.Transaction.Enlist(Action.Create, entity.Id, entity);

                    if (i == 1)
                    {
                        lock (sync)
                            transList.Add(trans);

                        Assert.AreEqual(3, manager.GetCached().Count());
                    }
                    else
                        trans.Transaction.Commit();

                });

                manager.CommitAll(true);

                Assert.AreEqual(0, manager.GetCached().Count());
            }

            Assert.AreEqual(5, hits);
        }
        public void TransactionManagerCommitsChildTransactions()
        {
            var seed = new Seed32();
            var hits = 0;

            using (var manager = new TransactionManager<int, MockClassA>() )
            {
                manager.TransactionCommitted += new TransactionCommit<int, MockClassA>
                    (delegate(ITransaction<int, MockClassA> transaction)
                    {
                        Assert.AreEqual(3, transaction.GetEnlistedActions().Count());
                        hits++;

                        transaction.MarkComplete();
                    });

                var testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                testEntities.ForEach(e => e.Id = seed.Increment());

                using (var tLock1 = manager.BeginTransaction())
                {
                    foreach (var entity in testEntities)
                        tLock1.Transaction.Enlist(Action.Create, entity.Id, entity);

                    using (var tLock2 = manager.BeginTransaction())
                    {
                        testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                        testEntities.ForEach(e => e.Id = seed.Increment());

                        foreach (var entity in testEntities)
                            tLock2.Transaction.Enlist(Action.Create, entity.Id, entity);

                        using (var tLock3 = manager.BeginTransaction())
                        {
                            testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                            testEntities.ForEach(e => e.Id = seed.Increment());

                            foreach (var entity in testEntities)
                                tLock3.Transaction.Enlist(Action.Create, entity.Id, entity);

                            using (var tLock4 = manager.BeginTransaction())
                            {
                                testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                                testEntities.ForEach(e => e.Id = seed.Increment());

                                foreach (var entity in testEntities)
                                    tLock4.Transaction.Enlist(Action.Create, entity.Id, entity);

                                using (var tLock5 = manager.BeginTransaction())
                                {
                                    testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                                    testEntities.ForEach(e => e.Id = seed.Increment());

                                    foreach (var entity in testEntities)
                                        tLock5.Transaction.Enlist(Action.Create, entity.Id, entity);

                                    tLock1.Transaction.Commit();
                                }
                            }
                        }
                    }
                }
            }

            Assert.AreEqual(5, hits);
        }
Example #26
0
        public void NTreeDeletesManyEntities()
        {
            var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());

            using (var tree = new NTree<int, MockClassA, long>("Id", true))
            {
                foreach (var o in objs)
                    tree.AddOrUpdate(new Tuple<MockClassA, long>(o, seedSegment.Increment()));

                Assert.AreEqual(50, tree.Length);

                Assert.AreEqual(5, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(5).Count());

                tree.DeleteMany(objs.Take(15));

                Assert.AreEqual(50, tree.Length);

                foreach (var o in objs.Take(15))
                    Assert.AreEqual(0, tree.GetFirstByIndex(o.Id));

                Assert.AreEqual(0, tree.DeleteMany(new List<MockClassA>() { null }).Length);
            }
        }
Example #27
0
        public void NTreePushesLotsOfDuplicateEntities()
        {
            var objs = TestResourceFactory.GetMockClassAObjects(20480).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());
            var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();

            using (var tree = new NTree<int, MockClassA, long>("Id", true))
            {
                var ids = tree.AddOrUpdateRange(toAdd);

                Assert.AreEqual(20480, tree.Length);

                Assert.AreEqual(5, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(5).Count());

                tree.AddOrUpdate(new Tuple<MockClassA, long>(TestResourceFactory.CreateRandom().WithId(seedIndex.Increment()), seedSegment.Increment()));

                Assert.AreEqual(20481, tree.Length);

                tree.AddOrUpdateRange(toAdd.Skip(100).Take(100).ToList());

                Assert.AreEqual(20481, tree.Length);
            }
        }
Example #28
0
        public void NTreeReturnsEmptyPageWithWrongPageId()
        {
            var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());
            var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();

            using (var tree = new NTree<int, MockClassA, long>("Id", true))
            {
                var ids = tree.AddOrUpdateRange(toAdd);
                tree.AddOrUpdate(toAdd.First());

                Assert.AreEqual(50, tree.Length);

                var p = tree.GetPage(8);

                Assert.AreEqual(0, p.Length);
            }
        }
        public void TransactionManagerRollsbackOnDispose()
        {
            var seed = new Seed32();

            using (var manager = new TransactionManager<int, MockClassA>() )
            {
                manager.TransactionCommitted += new TransactionCommit<int, MockClassA>
                    (delegate(ITransaction<int, MockClassA> transaction)
                    {
                        transaction.MarkComplete();

                        Assert.Fail();
                    });

                var testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                testEntities.ForEach(e => e.Id = seed.Increment());

                using (var tLock1 = manager.BeginTransaction())
                {
                    foreach (var entity in testEntities)
                        tLock1.Transaction.Enlist(Action.Create, entity.Id, entity);

                    tLock1.Transaction.Dispose();

                    Assert.IsTrue(tLock1.Transaction.IsComplete);
                }
            }
        }
Example #30
0
        public void NTreeReturnsEmptyStreamOnWrongPage()
        {
            var objs = TestResourceFactory.GetMockClassAObjects(5000).ToList();

            var seedIndex = new Seed32();
            var seedSegment = new Seed64();

            objs.ForEach(o => o.Id = seedIndex.Increment());
            var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();

            using (var tree = new NTree<int, MockClassA, long>("Id"))
            {
                var ids = tree.AddOrUpdateRange(toAdd);

                Assert.AreEqual(5000, tree.Length);

                Assert.AreEqual(5, tree.GetFirstByIndex(5));
                Assert.AreEqual(5, tree.GetFirstBySegment(5));
                Assert.AreEqual(1, tree.GetByIndex(5).Count());

                using (var p = tree.GetPageStream(8))
                {
                    Assert.AreEqual(0, p.Length);
                }
            }
        }