public virtual void TestDeleteReaddFromOtherClient() { if (!PrepareTest()) { return; } DeleteReaddChildReferenceTestSuite.DeleteReaddChildReferenceTestUnit.ItemParent parent1 = ((DeleteReaddChildReferenceTestSuite.DeleteReaddChildReferenceTestUnit.ItemParent )RetrieveOnlyInstance(client1, typeof(DeleteReaddChildReferenceTestSuite.DeleteReaddChildReferenceTestUnit.ItemParent ))); DeleteReaddChildReferenceTestSuite.DeleteReaddChildReferenceTestUnit.ItemParent parent2 = ((DeleteReaddChildReferenceTestSuite.DeleteReaddChildReferenceTestUnit.ItemParent )RetrieveOnlyInstance(client2, typeof(DeleteReaddChildReferenceTestSuite.DeleteReaddChildReferenceTestUnit.ItemParent ))); client1.Delete(parent1.child); AssertQueries(0, 1); client1.Commit(); AssertQueries(0, 0); client2.Store(parent2.child); AssertQueries(0, 1); client2.Commit(); AssertQueries(1, 1); client2.Close(); AssertRestoredState(); }
private void WithDatabase(string file, IFunction4 function) { Configure(); IExtObjectContainer objectContainer = Db4oFactory.OpenFile(file).Ext(); try { function.Apply(objectContainer); } finally { objectContainer.Close(); } IObjectServer server = Db4oFactory.OpenServer(ClientServerFileName(file), -1); server.GrantAccess(Username, Password); objectContainer = Db4oFactory.OpenClient("localhost", server.Ext().Port(), Username , Password).Ext(); try { function.Apply(objectContainer); } finally { objectContainer.Close(); server.Close(); } }
public virtual void TestSetSemaphore() { string semaphoreName = "sem"; Assert.IsTrue(_client1.SetSemaphore(semaphoreName, 0)); Assert.IsFalse(_client2.SetSemaphore(semaphoreName, 0)); _client1.ReleaseSemaphore(semaphoreName); Assert.IsTrue(_client2.SetSemaphore(semaphoreName, 0)); _client2.Close(); Assert.IsTrue(_client1.SetSemaphore(semaphoreName, 0)); }
public virtual void TestCommitOnClose() { EmbeddedClientObjectContainerTestCase.Item storedItem = StoreItemToClient1AndCommit (); storedItem._name = ChangedName; _client1.Store(storedItem); _client1.Close(); EmbeddedClientObjectContainerTestCase.Item retrievedItem = RetrieveItemFromClient2 (); Assert.AreEqual(ChangedName, retrievedItem._name); }
public virtual void Test() { int[] ids = new int[2]; IObjectSet originalResult = NewQuery(typeof(DeepPrefetchingCacheConcurrencyTestCase.Item )).Execute(); DeepPrefetchingCacheConcurrencyTestCase.Item firstOriginalItem = ((DeepPrefetchingCacheConcurrencyTestCase.Item )originalResult.Next()); Db().Purge(firstOriginalItem); IExtObjectContainer otherClient = OpenNewSession(); IObjectSet updateResult = otherClient.Query(typeof(DeepPrefetchingCacheConcurrencyTestCase.Item )); int idx = 0; for (IEnumerator updateItemIter = updateResult.GetEnumerator(); updateItemIter.MoveNext ();) { DeepPrefetchingCacheConcurrencyTestCase.Item updateItem = ((DeepPrefetchingCacheConcurrencyTestCase.Item )updateItemIter.Current); ids[idx] = (int)otherClient.GetID(updateItem); updateItem._name = "updated"; otherClient.Store(updateItem); idx++; } otherClient.Commit(); otherClient.Close(); for (int i = 0; i < ids.Length; i++) { DeepPrefetchingCacheConcurrencyTestCase.Item checkItem = ((DeepPrefetchingCacheConcurrencyTestCase.Item )Db().GetByID(ids[i])); Db().Activate(checkItem); Assert.AreEqual("updated", checkItem._name); } }
public virtual void TestSeparateSessions() { IExtObjectContainer oc1 = OpenNewSession(); IExtObjectContainer oc2 = OpenNewSession(); try { IObjectSet os1 = oc1.Query(typeof(DualDeleteTestCase.Item)); IObjectSet os2 = oc2.Query(typeof(DualDeleteTestCase.Item)); DeleteObjectSet(oc1, os1); AssertOccurrences(oc1, typeof(Atom), 0); AssertOccurrences(oc2, typeof(Atom), 1); DeleteObjectSet(oc2, os2); AssertOccurrences(oc1, typeof(Atom), 0); AssertOccurrences(oc2, typeof(Atom), 0); oc1.Rollback(); AssertOccurrences(oc1, typeof(Atom), 1); AssertOccurrences(oc2, typeof(Atom), 0); oc1.Commit(); AssertOccurrences(oc1, typeof(Atom), 1); AssertOccurrences(oc2, typeof(Atom), 0); DeleteAll(oc2, typeof(DualDeleteTestCase.Item)); oc2.Commit(); AssertOccurrences(oc1, typeof(Atom), 0); AssertOccurrences(oc2, typeof(Atom), 0); } finally { oc1.Close(); oc2.Close(); } }
public virtual void TestSD() { IExtObjectContainer oc1 = OpenNewSession(); IExtObjectContainer oc2 = OpenNewSession(); IExtObjectContainer oc3 = OpenNewSession(); try { SimpleObject o1 = (SimpleObject)((SimpleObject)RetrieveOnlyInstance(oc1, typeof(SimpleObject ))); oc1.Delete(o1); SimpleObject o2 = (SimpleObject)((SimpleObject)RetrieveOnlyInstance(oc2, typeof(SimpleObject ))); Assert.AreEqual("hello", o2.GetS()); o2.SetS("o2"); oc2.Store(o2); oc2.Commit(); oc1.Commit(); AssertOccurrences(oc1, typeof(SimpleObject), 0); AssertOccurrences(oc2, typeof(SimpleObject), 0); AssertOccurrences(oc3, typeof(SimpleObject), 0); } finally { oc1.Close(); oc2.Close(); oc3.Close(); } }
public virtual void Test() { IExtObjectContainer oc1 = OpenNewSession(); IExtObjectContainer oc2 = OpenNewSession(); try { RefreshTestCase.Item r1 = GetRoot(oc1); r1.name = "cc"; oc1.Refresh(r1, 0); Assert.AreEqual("cc", r1.name); oc1.Refresh(r1, 1); Assert.AreEqual("o1", r1.name); r1.child.name = "cc"; oc1.Refresh(r1, 1); Assert.AreEqual("cc", r1.child.name); oc1.Refresh(r1, 2); Assert.AreEqual("o2", r1.child.name); RefreshTestCase.Item r2 = GetRoot(oc2); r2.name = "o21"; r2.child.name = "o22"; r2.child.child.name = "o23"; oc2.Store(r2); oc2.Commit(); oc1.Refresh(r1, 3); Assert.AreEqual("o21", r1.name); Assert.AreEqual("o22", r1.child.name); Assert.AreEqual("o23", r1.child.child.name); } finally { oc1.Close(); oc2.Close(); } }
internal virtual void RunMethod() { IExtObjectContainer oc = null; try { oc = this._enclosing.Fixture().OpenNewSession(this.toTest); object[] args; if (this.showSeq) { args = new object[2]; args[0] = oc; args[1] = this.seq; } else { args = new object[1]; args[0] = oc; } this.method.Invoke(this.toTest, args); } catch (Exception e) { this._enclosing.failures[this.seq] = e; } finally { if (oc != null) { oc.Close(); } } }
/// <exception cref="System.Exception"></exception> public virtual void TestConcurrentClientModification() { if (!IsMultiSession()) { return; } IExtObjectContainer client1 = Db(); IExtObjectContainer client2 = OpenNewSession(); try { Item foo1 = ItemByName(client1, "Foo"); Item foo2 = ItemByName(client2, "Foo"); foo1.SetName("Foo*"); foo2.SetName("Foo**"); AssertUpdatedObjects(client1, foo1); AssertUpdatedObjects(client2, foo2); client1.Refresh(foo1, 1); Assert.AreEqual(foo2.GetName(), foo1.GetName()); } finally { client2.Close(); } }
public virtual void TestSetRollback() { IExtObjectContainer oc1 = OpenNewSession(); IExtObjectContainer oc2 = OpenNewSession(); try { for (int i = 0; i < 1000; i++) { SimpleObject obj1 = new SimpleObject("oc " + i, i); SimpleObject obj2 = new SimpleObject("oc2 " + i, i); oc1.Store(obj1); oc2.Store(obj2); oc2.Rollback(); obj2 = new SimpleObject("oc2.2 " + i, i); oc2.Store(obj2); } oc1.Commit(); oc2.Rollback(); Assert.AreEqual(1000, oc1.Query(typeof(SimpleObject)).Count); Assert.AreEqual(1000, oc2.Query(typeof(SimpleObject)).Count); } finally { oc1.Close(); oc2.Close(); } }
protected override void PreClose() { if (null != _session) { _session.Close(); } }
private MockActivatable RetrieveMockFromNewClientAndClose() { IExtObjectContainer client = OpenNewSession(); try { return(RetrieveMock(client)); } finally { client.Close(); } }
/// <exception cref="System.Exception"></exception> public override void Close() { if (null != _objectContainer) { IThreadPool4 clientThreadPool = ClientThreadPool(); _objectContainer.Close(); _objectContainer = null; if (null != clientThreadPool) { clientThreadPool.Join(ThreadpoolTimeout); } } CloseServer(); }
private void DeleteAllItemsFromSecondClient() { IExtObjectContainer client = OpenNewSession(); try { DeleteAll(client, typeof(PrefetchConfigurationTestCase.Item)); client.Commit(); } finally { client.Close(); } }
public virtual void TestSingleChild() { IExtObjectContainer client1 = OpenNewSession(); IQuery query = client1.Query(); query.Constrain(typeof(TAUnavailableClassAtServer.ParentWithSingleChild)); IObjectSet result = query.Execute(); Assert.IsTrue(result.HasNext()); TAUnavailableClassAtServer.ParentWithSingleChild parent = (TAUnavailableClassAtServer.ParentWithSingleChild )result.Next(); Assert.AreEqual(43, parent.Child().Value()); client1.Close(); }
public virtual void TestChildArray() { IExtObjectContainer client1 = OpenNewSession(); IQuery query = client1.Query(); query.Constrain(typeof(TAUnavailableClassAtServer.ParentWithMultipleChilds)); IObjectSet result = query.Execute(); Assert.IsTrue(result.HasNext()); TAUnavailableClassAtServer.ParentWithMultipleChilds parent = (TAUnavailableClassAtServer.ParentWithMultipleChilds )result.Next(); Assert.IsNotNull(parent.Children()); client1.Close(); }
public virtual void TestOwnedSemaphoreCannotBeTaken() { IExtObjectContainer client1 = OpenNewSession(); try { Assert.IsTrue(Db().SetSemaphore(SemaphoreName, 0)); Assert.IsFalse(client1.SetSemaphore(SemaphoreName, 0)); } finally { client1.Close(); } }
/// <exception cref="System.Exception"></exception> public virtual void _testDeleteDeleted() { int total = 10; int CddMemberCount = 12; IExtObjectContainer[] containers = new IExtObjectContainer[total]; IExtObjectContainer oc = null; try { for (int i = 0; i < total; i++) { containers[i] = OpenNewSession(); AssertOccurrences(containers[i], typeof(CascadeDeleteDeletedTestCase.CddMember), CddMemberCount); } for (int i = 0; i < total; i++) { DeleteAll(containers[i], typeof(CascadeDeleteDeletedTestCase.CddMember)); } oc = OpenNewSession(); AssertOccurrences(oc, typeof(CascadeDeleteDeletedTestCase.CddMember), CddMemberCount ); // ocs[0] deleted all CddMember objects, and committed the change containers[0].Commit(); containers[0].Close(); // FIXME: following assertion fails AssertOccurrences(oc, typeof(CascadeDeleteDeletedTestCase.CddMember), 0); for (int i = 1; i < total; i++) { containers[i].Close(); } AssertOccurrences(oc, typeof(CascadeDeleteDeletedTestCase.CddMember), 0); } finally { if (oc != null) { oc.Close(); } for (int i = 0; i < total; i++) { if (containers[i] != null) { containers[i].Close(); } } } }
public virtual void Test() { IExtObjectContainer oc1 = OpenNewSession(); IExtObjectContainer oc2 = OpenNewSession(); IExtObjectContainer oc3 = OpenNewSession(); try { IQuery query1 = oc1.Query(); query1.Descend("name").Constrain("root"); IObjectSet os1 = query1.Execute(); Assert.AreEqual(1, os1.Count); Atom o1 = (Atom)os1.Next(); o1.child.child.name = "o1"; oc1.Store(o1); IQuery query2 = oc2.Query(); query2.Descend("name").Constrain("root"); IObjectSet os2 = query2.Execute(); Assert.AreEqual(1, os2.Count); Atom o2 = (Atom)os2.Next(); Assert.AreEqual("child.child", o2.child.child.name); oc1.Rollback(); oc2.Purge(o2); os2 = query2.Execute(); Assert.AreEqual(1, os2.Count); o2 = (Atom)os2.Next(); Assert.AreEqual("child.child", o2.child.child.name); oc1.Store(o1); oc1.Commit(); os2 = query2.Execute(); Assert.AreEqual(1, os2.Count); o2 = (Atom)os2.Next(); oc2.Refresh(o2, int.MaxValue); Assert.AreEqual("o1", o2.child.child.name); IQuery query3 = oc3.Query(); query3.Descend("name").Constrain("root"); IObjectSet os3 = query1.Execute(); Assert.AreEqual(1, os3.Count); Atom o3 = (Atom)os3.Next(); Assert.AreEqual("o1", o3.child.child.name); } finally { oc1.Close(); oc2.Close(); oc3.Close(); } }
public virtual void TestClosingClientReleasesSemaphores() { IExtObjectContainer client1 = OpenNewSession(); Assert.IsTrue(client1.SetSemaphore(SemaphoreName, 0)); Assert.IsFalse(Db().SetSemaphore(SemaphoreName, 0)); if (IsNetworking()) { CloseConnectionInNetworkingCS(client1); } else { client1.Close(); } Assert.IsTrue(Db().SetSemaphore(SemaphoreName, 0)); }
/// <exception cref="System.Exception"></exception> public virtual void Test() { IExtObjectContainer oc1 = OpenNewSession(); IExtObjectContainer oc2 = OpenNewSession(); IExtObjectContainer oc3 = OpenNewSession(); DeepSetClientServerTestCase.Item example = new DeepSetClientServerTestCase.Item(); example.name = "1"; try { DeepSetClientServerTestCase.Item item1 = (DeepSetClientServerTestCase.Item)oc1.QueryByExample (example).Next(); Assert.AreEqual("1", item1.name); Assert.AreEqual("2", item1.child.name); Assert.AreEqual("3", item1.child.child.name); DeepSetClientServerTestCase.Item item2 = (DeepSetClientServerTestCase.Item)oc2.QueryByExample (example).Next(); Assert.AreEqual("1", item2.name); Assert.AreEqual("2", item2.child.name); Assert.AreEqual("3", item2.child.child.name); item1.child.name = "12"; item1.child.child.name = "13"; oc1.Store(item1, 2); oc1.Commit(); // check result DeepSetClientServerTestCase.Item item = (DeepSetClientServerTestCase.Item)oc1.QueryByExample (example).Next(); Assert.AreEqual("1", item.name); Assert.AreEqual("12", item.child.name); Assert.AreEqual("13", item.child.child.name); item = (DeepSetClientServerTestCase.Item)oc2.QueryByExample(example).Next(); oc2.Refresh(item, 3); Assert.AreEqual("1", item.name); Assert.AreEqual("12", item.child.name); Assert.AreEqual("3", item.child.child.name); item = (DeepSetClientServerTestCase.Item)oc3.QueryByExample(example).Next(); Assert.AreEqual("1", item.name); Assert.AreEqual("12", item.child.name); Assert.AreEqual("3", item.child.child.name); } finally { oc1.Close(); oc2.Close(); oc3.Close(); } }
public virtual void TestPreviouslyOwnedSemaphoreCannotBeTaken() { IExtObjectContainer client1 = OpenNewSession(); try { Assert.IsTrue(Db().SetSemaphore(SemaphoreName, 0)); Assert.IsFalse(client1.SetSemaphore(SemaphoreName, 0)); Db().ReleaseSemaphore(SemaphoreName); EnsureMessageProcessed(Db()); Assert.IsTrue(client1.SetSemaphore(SemaphoreName, 0)); Assert.IsFalse(Db().SetSemaphore(SemaphoreName, 0)); } finally { client1.Close(); } }
public virtual void TestRepeatedStore() { IExtObjectContainer client1 = Db(); IExtObjectContainer client2 = OpenNewSession(); CsCascadedDeleteReaddChildReferenceTestCase.ItemParent parent1 = ((CsCascadedDeleteReaddChildReferenceTestCase.ItemParent )RetrieveOnlyInstance(client1, typeof(CsCascadedDeleteReaddChildReferenceTestCase.ItemParent ))); CsCascadedDeleteReaddChildReferenceTestCase.ItemParent parent2 = ((CsCascadedDeleteReaddChildReferenceTestCase.ItemParent )RetrieveOnlyInstance(client2, typeof(CsCascadedDeleteReaddChildReferenceTestCase.ItemParent ))); client1.Ext().Store(parent1, int.MaxValue); client1.Commit(); client2.Ext().Store(parent2, int.MaxValue); client2.Commit(); client2.Close(); AssertInstanceCountAndFieldIndexes(client1); }
public virtual void TestRefresh() { IExtObjectContainer client1 = OpenNewSession(); IExtObjectContainer client2 = OpenNewSession(); NonTARefreshTestCase.TAItem item1 = (NonTARefreshTestCase.TAItem)RetrieveInstance (client1); NonTARefreshTestCase.TAItem item2 = (NonTARefreshTestCase.TAItem)RetrieveInstance (client2); AssertDescendingRange(10, item1); AssertDescendingRange(10, item2); item1.Value(100); item1.Next().Value(200); client1.Store(item1, 2); client1.Commit(); Assert.AreEqual(100, item1.Value()); Assert.AreEqual(200, item1.Next().Value()); Assert.AreEqual(10, item2.Value()); Assert.AreEqual(9, item2.Next().Value()); //refresh 0 client2.Refresh(item2, 0); Assert.AreEqual(10, item2.Value()); Assert.AreEqual(9, item2.Next().Value()); //refresh 1 client2.Refresh(item2, 1); Assert.AreEqual(100, item2.Value()); Assert.AreEqual(9, item2.Next().Value()); //refresh 2 client2.Refresh(item2, 2); Assert.AreEqual(100, item2.Value()); Assert.AreEqual(200, item2.Next().Value()); UpdateAscendingWithRange(item1, 1000); client1.Store(item1, 5); client1.Commit(); client2.Refresh(item2, 5); NonTARefreshTestCase.TAItem next2 = item2; for (int i = 1000; i < 1005; i++) { Assert.AreEqual(i, next2.Value()); next2 = next2.Next(); } client1.Close(); client2.Close(); }
public virtual void Test() { IExtObjectContainer oc1 = OpenNewSession(); IExtObjectContainer oc2 = OpenNewSession(); IExtObjectContainer oc3 = OpenNewSession(); try { SimpleObject o1 = (SimpleObject)((SimpleObject)RetrieveOnlyInstance(oc1, typeof(SimpleObject ))); o1.SetS("o1"); oc1.Store(o1); SimpleObject o2 = (SimpleObject)((SimpleObject)RetrieveOnlyInstance(oc2, typeof(SimpleObject ))); Assert.AreEqual("hello", o2.GetS()); oc1.Rollback(); o2 = (SimpleObject)((SimpleObject)RetrieveOnlyInstance(oc2, typeof(SimpleObject)) ); oc2.Refresh(o2, int.MaxValue); Assert.AreEqual("hello", o2.GetS()); oc1.Commit(); o2 = (SimpleObject)((SimpleObject)RetrieveOnlyInstance(oc2, typeof(SimpleObject)) ); Assert.AreEqual("hello", o2.GetS()); oc1.Store(o1); oc1.Commit(); oc2.Refresh(o2, int.MaxValue); o2 = (SimpleObject)((SimpleObject)RetrieveOnlyInstance(oc2, typeof(SimpleObject)) ); Assert.AreEqual("o1", o2.GetS()); SimpleObject o3 = (SimpleObject)((SimpleObject)RetrieveOnlyInstance(oc3, typeof(SimpleObject ))); Assert.AreEqual("o1", o3.GetS()); } finally { oc1.Close(); oc2.Close(); oc3.Close(); } }
/// <exception cref="System.Exception"></exception> private void CheckConcurrencyMethod(AbstractDb4oTestCase toTest, string testMethodName ) { MethodInfo checkMethod = CheckMethodFor(toTest.GetType(), testMethodName); if (null == checkMethod) { return; } // pass ExtObjectContainer as a param to check method IExtObjectContainer oc = Fixture().Db(); try { checkMethod.Invoke(toTest, new object[] { oc }); } finally { oc.Close(); } }
/// <exception cref="System.Exception"></exception> public override void Close() { try { PreClose(); } finally { if (null != _db) { Assert.IsTrue(_db.Close()); try { ThreadPool().Join(3000); } finally { _db = null; } } } }
public virtual void TestRefreshIsUnaffectedByPrefetchingBehavior() { IExtObjectContainer oc1 = Db(); IExtObjectContainer oc2 = OpenNewSession(); oc1.Configure().ClientServer().PrefetchDepth(1); oc2.Configure().ClientServer().PrefetchDepth(1); try { PrefetchConfigurationTestCase.Item itemFromClient1 = new PrefetchConfigurationTestCase.RootItem (new PrefetchConfigurationTestCase.Item()); oc1.Store(itemFromClient1); oc1.Commit(); itemFromClient1.child = null; oc1.Store(itemFromClient1); PrefetchConfigurationTestCase.Item itemFromClient2 = ((PrefetchConfigurationTestCase.RootItem )RetrieveOnlyInstance(oc2, typeof(PrefetchConfigurationTestCase.RootItem))); Assert.IsNotNull(itemFromClient2.child); oc1.Rollback(); itemFromClient2 = ((PrefetchConfigurationTestCase.RootItem)RetrieveOnlyInstance(oc2 , typeof(PrefetchConfigurationTestCase.RootItem))); oc2.Refresh(itemFromClient2, int.MaxValue); Assert.IsNotNull(itemFromClient2.child); oc1.Commit(); itemFromClient2 = ((PrefetchConfigurationTestCase.RootItem)RetrieveOnlyInstance(oc2 , typeof(PrefetchConfigurationTestCase.RootItem))); Assert.IsNotNull(itemFromClient2.child); oc1.Store(itemFromClient1); oc1.Commit(); oc2.Refresh(itemFromClient2, int.MaxValue); itemFromClient2 = ((PrefetchConfigurationTestCase.RootItem)RetrieveOnlyInstance(oc2 , typeof(PrefetchConfigurationTestCase.RootItem))); Assert.IsNull(itemFromClient2.child); } finally { oc2.Close(); } }
/// <exception cref="System.Exception"></exception> public virtual void _concDelete(IExtObjectContainer oc, int seq) { ClientObjectContainer client = (ClientObjectContainer)oc; try { if (seq % 2 == 0) { // ok to get something client.QueryByExample(null); } else { client.Socket().Close(); Assert.IsFalse(oc.IsClosed()); Assert.Expect(typeof(Db4oException), new _ICodeBlock_27(client)); } } finally { oc.Close(); Assert.IsTrue(oc.IsClosed()); } }
public virtual void TestDisconnect() { IExtObjectContainer oc1 = OpenNewSession(); IExtObjectContainer oc2 = OpenNewSession(); try { ClientObjectContainer client1 = (ClientObjectContainer)oc1; ClientObjectContainer client2 = (ClientObjectContainer)oc2; client1.Socket().Close(); Assert.IsFalse(oc1.IsClosed()); Assert.Expect(typeof(Db4oException), new _ICodeBlock_27(client1)); // It's ok for client2 to get something. client2.QueryByExample(null); } finally { oc1.Close(); oc2.Close(); Assert.IsTrue(oc1.IsClosed()); Assert.IsTrue(oc2.IsClosed()); } }