private Item QueryRoot(IExtObjectContainer container ) { var q = ItemQuery(container); q.Descend("id").Constrain(-1); return (Item) q.Execute().Next(); }
private ConcurrentLazyQueriesTestCase.Item QueryRoot(IExtObjectContainer container ) { IQuery q = ItemQuery(container); q.Descend("id").Constrain(-1); return (ConcurrentLazyQueriesTestCase.Item)q.Execute().Next(); }
protected override void AssertArrays(IExtObjectContainer objectContainer, object obj) { var itemArrays = (ItemArrays ) obj; AssertPrimitiveArray(itemArrays._typedPrimitiveArray); if (Db4oHeaderVersion() == VersionServices.Header3040) { } else { // Bug in the oldest format: It accidentally byte[] arrays to Byte[] // arrays. if (Db4oHandlerVersion() == 1 && Db4oHeaderVersion() == 100 && itemArrays._primitiveArrayInObject == null) { } else { // do nothing // We started treating byte[] in untyped variables differently // but we forgot to update the handler version. // Concerns only 6.3.500: Updates are not possible. AssertPrimitiveArray((byte[]) itemArrays._primitiveArrayInObject); } } }
public virtual void Conc(IExtObjectContainer oc) { IQuery q = oc.Query(); q.Constrain(this.GetType()); IObjectSet res = q.Execute(); Assert.AreEqual(Count, res.Count); long[] ids1 = new long[res.Count]; int i = 0; while (res.HasNext()) { ids1[i++] = oc.GetID(res.Next()); } res.Reset(); long[] ids2 = res.Ext().GetIDs(); Assert.AreEqual(Count, ids1.Length); Assert.AreEqual(Count, ids2.Length); for (int j = 0; j < ids1.Length; j++) { bool found = false; for (int k = 0; k < ids2.Length; k++) { if (ids1[j] == ids2[k]) { found = true; break; } } Assert.IsTrue(found); } }
private void AssertDateTimeQuery(IExtObjectContainer objectContainer, DateTime value) { IQuery query = objectContainer.Query(); query.Constrain(typeof (Item)); query.Descend("_dateTime").Constrain(value); Assert.AreEqual(1, query.Execute().Count); }
public virtual void Conc(IExtObjectContainer oc) { var nr = (NestedArraysTestCase) RetrieveOnlyInstance (oc, typeof (NestedArraysTestCase)); Check((object[]) nr._object, Depth); Check(nr._objectArray, Depth); }
public virtual void Conc(IExtObjectContainer oc) { int[] expect = {3, 4, 5}; var q = oc.Query(); q.Constrain(typeof (GreaterOrEqualTestCase )); q.Descend("val").Constrain(3).Greater().Equal(); var res = q.Execute(); while (res.HasNext()) { var r = (GreaterOrEqualTestCase ) res.Next(); for (var i = 0; i < expect.Length; i++) { if (expect[i] == r.val) { expect[i] = 0; } } } for (var i = 0; i < expect.Length; i++) { Assert.AreEqual(0, expect[i]); } }
protected override void AssertValues(IExtObjectContainer objectContainer, object[] values) { var holder = (HashtableHolder) values[0]; AssertHashtable(holder._dictionary); AssertHashtable(holder._hashtable); AssertHashtable(holder._untyped); }
// do nothing protected override void AssertValues(IExtObjectContainer objectContainer, object[] values) { EncryptedFileMigrationTestCase.Item item = (EncryptedFileMigrationTestCase.Item)values [0]; Assert.AreEqual("one", item._name); }
public virtual void Conc(IExtObjectContainer oc) { int[] expect = new int[] { 3, 4, 5 }; IQuery q = oc.Query(); q.Constrain(typeof(Db4objects.Db4o.Tests.Common.Concurrency.GreaterOrEqualTestCase )); q.Descend("val").Constrain(3).Greater().Equal(); IObjectSet res = q.Execute(); while (res.HasNext()) { Db4objects.Db4o.Tests.Common.Concurrency.GreaterOrEqualTestCase r = (Db4objects.Db4o.Tests.Common.Concurrency.GreaterOrEqualTestCase )res.Next(); for (int i = 0; i < expect.Length; i++) { if (expect[i] == r.val) { expect[i] = 0; } } } for (int i = 0; i < expect.Length; i++) { Assert.AreEqual(0, expect[i]); } }
public void SetUp() { _FilePath = Path.GetTempFileName(); _db = Db4oFactory.OpenFile(_FilePath).Ext(); TestClass testClass = new TestClass(); testClass.Label = "Meal times"; testClass.Times = new List<Time>(); testClass.Times.Add(new Time(7, 30)); testClass.Times.Add(new Time(12, 0)); testClass.Times.Add(new Time(17, 20)); _db.Set(testClass, 5); testClass = new TestClass(); testClass.Label = "Free time"; testClass.Times = new List<Time>(); _db.Set(testClass, 5); testClass = new TestClass(); testClass.Label = "Bed time"; testClass.Times = new List<Time>(); testClass.Times.Add(new Time(21, 30)); _db.Set(testClass, 5); _db.Commit(); }
/// <exception cref="System.Exception"></exception> public virtual void Conc(IExtObjectContainer oc) { IObjectSet os = oc.Query(typeof(InvalidUUIDTestCase)); if (os.Count == 0) { // already deleted by other threads return; } Assert.AreEqual(1, os.Count); InvalidUUIDTestCase iu = (InvalidUUIDTestCase)os.Next(); Db4oUUID myUuid = oc.GetObjectInfo(iu).GetUUID(); Assert.IsNotNull(myUuid); byte[] mySignature = myUuid.GetSignaturePart(); long myLong = myUuid.GetLongPart(); long unknownLong = long.MaxValue - 100; byte[] unknownSignature = new byte[] { 1, 2, 4, 99, 33, 22 }; Db4oUUID unknownLongPart = new Db4oUUID(unknownLong, mySignature); Db4oUUID unknownSignaturePart = new Db4oUUID(myLong, unknownSignature); Db4oUUID unknownBoth = new Db4oUUID(unknownLong, unknownSignature); Assert.IsNull(oc.GetByUUID(unknownLongPart)); Assert.IsNull(oc.GetByUUID(unknownSignaturePart)); Assert.IsNull(oc.GetByUUID(unknownBoth)); Assert.IsNull(oc.GetByUUID(unknownLongPart)); Thread.Sleep(500); oc.Delete(iu); oc.Commit(); Assert.IsNull(oc.GetByUUID(myUuid)); }
private IObjectSet QueryContains(IExtObjectContainer oc, string str) { var q = oc.Query(); q.Constrain(typeof (ParameterizedEvaluationTestCase)); q.Constrain(new MyEvaluation(str)); return q.Execute(); }
/// <exception cref="System.Exception"></exception> public virtual void ConcReadDifferentObject(IExtObjectContainer oc, int seq) { var example = new SimpleObject(testString + seq, seq); var result = oc.QueryByExample(example); Assert.AreEqual(1, result.Count); Assert.AreEqual(example, result.Next()); }
protected override void Update(IExtObjectContainer objectContainer) { var holder = RetrieveHolderInstance(objectContainer); UpdateValues(holder._values); UpdateArrays(holder._arrays); objectContainer.Store(holder, int.MaxValue); }
/// <exception cref="System.Exception"></exception> public virtual void ConcReadDifferentObject(IExtObjectContainer oc, int seq) { SimpleObject expected = new SimpleObject(testString + seq, seq); IObjectSet result = oc.Query(new ReadObjectNQTestCase.MyPredicate(expected)); Assert.AreEqual(1, result.Count); Assert.AreEqual(expected, result.Next()); }
/// <exception cref="System.Exception"></exception> public virtual void Conc1(IExtObjectContainer oc) { IObjectSet os = oc.Query(typeof(DualDeleteTestCase.Item)); Thread.Sleep(500); DeleteObjectSet(oc, os); oc.Rollback(); }
public virtual void ConcSetRollback(IExtObjectContainer oc, int seq) { if (seq % 2 == 0) { // if the thread sequence is even, store something for (int i = 0; i < 1000; i++) { SimpleObject c = new SimpleObject("oc " + i, i); oc.Store(c); } } else { // if the thread sequence is odd, rollback for (int i = 0; i < 1000; i++) { SimpleObject c = new SimpleObject("oc " + i, i); oc.Store(c); oc.Rollback(); c = new SimpleObject("oc2.2 " + i, i); oc.Store(c); } oc.Rollback(); } }
protected override void AssertObjectsAreUpdated(IExtObjectContainer objectContainer ) { var holder = RetrieveHolderInstance(objectContainer); AssertUpdatedValues(holder._values); AssertUpdatedArrays(holder._arrays); }
// do nothing protected override void AssertValues(IExtObjectContainer objectContainer, object[] values) { var item = (Item) values [0]; Assert.AreEqual("one", item._name); }
protected override void AssertArrays(IExtObjectContainer objectContainer, object obj) { object[] array = (object[])obj; Assert.AreEqual(2, array.Length); Assert.AreSame(array[0], array[1]); }
private Collection4 CommitCapturingUpdatedObjects(IExtObjectContainer container) { var updated = new Collection4(); EventRegistryFor(container).Updated += new _IEventListener4_51(updated).OnEvent; container.Commit(); return updated; }
private static IObjectSet QuerySpecificObjects(IExtObjectContainer objectContainer) { var query = objectContainer.Query(); query.Constrain(typeof (Item)); query.Descend("value").Constrain(42); return query.Execute(); }
private void MembersFirst(IExtObjectContainer oc, string name) { Db4objects.Db4o.Tests.Common.Assorted.CascadeDeleteDeletedTestCase cdd = new Db4objects.Db4o.Tests.Common.Assorted.CascadeDeleteDeletedTestCase (name); cdd.untypedMember = new CascadeDeleteDeletedTestCase.CddMember(); cdd.typedMember = new CascadeDeleteDeletedTestCase.CddMember(); oc.Store(cdd); }
public virtual void Check2(IExtObjectContainer oc) { IQuery q = oc.Query(); q.Constrain(typeof(MultiLevelIndexTestCase)); q.Descend("_child").Descend("_i").Constrain(-200).Smaller(); IObjectSet objectSet = q.Execute(); Assert.AreEqual(ThreadCount(), objectSet.Count); }
/// <exception cref="System.Exception"></exception> public virtual void ConcReadSameObject(IExtObjectContainer oc) { int mid = ThreadCount() / 2; SimpleObject expected = new SimpleObject(testString + mid, mid); IObjectSet result = oc.Query(new ReadObjectNQTestCase.MyPredicate(expected)); Assert.AreEqual(1, result.Count); Assert.AreEqual(expected, result.Next()); }
private void MembersFirst(IExtObjectContainer oc, string name) { var cdd = new CascadeDeleteDeletedTestCase (name); cdd.untypedMember = new CddMember(); cdd.typedMember = new CddMember(); oc.Store(cdd); }
public virtual void Conc(IExtObjectContainer oc) { Db4objects.Db4o.Tests.Common.Concurrency.NestedArraysTestCase nr = (Db4objects.Db4o.Tests.Common.Concurrency.NestedArraysTestCase )((Db4objects.Db4o.Tests.Common.Concurrency.NestedArraysTestCase)RetrieveOnlyInstance (oc, typeof(Db4objects.Db4o.Tests.Common.Concurrency.NestedArraysTestCase))); Check((object[])nr._object, Depth); Check((object[])nr._objectArray, Depth); }
public virtual void Conc(IExtObjectContainer oc) { PersistStaticFieldValuesTestCase psfv = (PersistStaticFieldValuesTestCase)((PersistStaticFieldValuesTestCase )RetrieveOnlyInstance(oc, typeof(PersistStaticFieldValuesTestCase))); Assert.AreSame(One, psfv.one); Assert.AreSame(Two, psfv.two); Assert.AreSame(Three, psfv.three); }
/// <exception cref="System.Exception"></exception> public virtual void ConcReadSameObject(IExtObjectContainer oc) { var mid = ThreadCount()/2; var example = new SimpleObject(testString + mid, mid); var result = oc.QueryByExample(example); Assert.AreEqual(1, result.Count); Assert.AreEqual(example, result.Next()); }
private void TwoRef(IExtObjectContainer oc, string name) { Db4objects.Db4o.Tests.Common.Assorted.CascadeDeleteDeletedTestCase cdd = new Db4objects.Db4o.Tests.Common.Assorted.CascadeDeleteDeletedTestCase (name); cdd.untypedMember = new CascadeDeleteDeletedTestCase.CddMember(); cdd.typedMember = new CascadeDeleteDeletedTestCase.CddMember(); Db4objects.Db4o.Tests.Common.Assorted.CascadeDeleteDeletedTestCase cdd2 = new Db4objects.Db4o.Tests.Common.Assorted.CascadeDeleteDeletedTestCase (name); cdd2.untypedMember = cdd.untypedMember; cdd2.typedMember = cdd.typedMember; oc.Store(cdd); oc.Store(cdd2); }
/// <exception cref="System.Exception"></exception> public virtual void ConcUpdateSameObject(IExtObjectContainer oc, int seq) { IQuery query = oc.Query(); query.Descend("_s").Constrain(testString + Count / 2); IObjectSet result = query.Execute(); Assert.AreEqual(1, result.Count); SimpleObject o = (SimpleObject)result.Next(); o.SetI(Count + seq); oc.Store(o); }
protected override void AssertValues(IExtObjectContainer objectContainer, object[] values) { if (TestNotCompatibleToOldVersion()) { return; } AssertItem(values[0], typeof(ArrayList)); AssertItem(values[1], typeof(ArrayListUpdateTestCase.ArrayListExtensionWithField) ); AssertItem(values[2], typeof(ArrayListUpdateTestCase.ArrayListExtensionWithoutField )); }
/// <exception cref="System.Exception"></exception> public virtual void SetUp() { IServerConfiguration serverConfiguration = Db4oClientServer.NewServerConfiguration (); serverConfiguration.File.Storage = new MemoryStorage(); _server = Db4oClientServer.OpenServer(serverConfiguration, string.Empty, Db4oClientServer .ArbitraryPort).Ext(); _server.GrantAccess(Username, Password); _networkingClient = Db4oClientServer.OpenClient("localhost", _server.Port(), Username , Password).Ext(); this._embeddedClient = ((ObjectContainerSession)_server.OpenClient().Ext()); }
/// <exception cref="System.Exception"></exception> public virtual void CheckUpdateSameObject(IExtObjectContainer oc) { IQuery query = oc.Query(); query.Descend("_s").Constrain(testString + Count / 2); IObjectSet result = query.Execute(); Assert.AreEqual(1, result.Count); SimpleObject o = (SimpleObject)result.Next(); int i = o.GetI(); Assert.IsTrue(Count <= i && i < Count + ThreadCount()); }
public virtual void Check(IExtObjectContainer oc) { CascadeOnUpdate2TestCase.Item item = (CascadeOnUpdate2TestCase.Item)((CascadeOnUpdate2TestCase.Item )RetrieveOnlyInstance(oc, typeof(CascadeOnUpdate2TestCase.Item))); string name = item.child[0].name; Assert.IsTrue(name.StartsWith("updated")); for (int i = 0; i < AtomCount; i++) { Assert.AreEqual(name, item.child[i].name); Assert.AreEqual("storedChild", item.child[i].child.name); } }
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(); }
private void Peek(IExtObjectContainer oc, PeekPersistedTestCase original, int depth ) { PeekPersistedTestCase peeked = (PeekPersistedTestCase)((PeekPersistedTestCase)oc. PeekPersisted(original, depth, true)); for (int i = 0; i <= depth; i++) { Assert.IsNotNull(peeked); Assert.IsFalse(oc.IsStored(peeked)); peeked = peeked.child; } Assert.IsNull(peeked); }
/// <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(); } }
protected override void AssertObjectsAreReadable(IExtObjectContainer objectContainer ) { CascadedDeleteFileFormatUpdateTestCase.ParentItem parentItem = (CascadedDeleteFileFormatUpdateTestCase.ParentItem )RetrieveInstance(objectContainer, typeof(CascadedDeleteFileFormatUpdateTestCase.ParentItem )); Assert.IsNotNull(parentItem._children); Assert.IsNotNull(parentItem._children[0]); Assert.IsNotNull(parentItem._children[1]); objectContainer.Delete(parentItem); Assert.IsFalse(_failed); objectContainer.Store(CascadedDeleteFileFormatUpdateTestCase.ParentItem.NewTestInstance ()); }
public virtual void Conc(IExtObjectContainer oc) { IQuery q = oc.Query(); q.Constrain(typeof(PeekPersistedTestCase)); q.Descend("name").Constrain("1"); IObjectSet objectSet = q.Execute(); PeekPersistedTestCase pp = (PeekPersistedTestCase)objectSet.Next(); for (int i = 0; i < 10; i++) { Peek(oc, pp, i); } }
protected override void AssertValues(IExtObjectContainer objectContainer, object[] values) { for (int i = 0; i < data.Length; i++) { DateHandlerUpdateTestCase.Item item = (DateHandlerUpdateTestCase.Item)values[i]; AssertAreEqual(data[i], item._date); AssertAreEqual(data[i], (DateTime)item._untyped); } DateHandlerUpdateTestCase.Item emptyItem = (DateHandlerUpdateTestCase.Item)values [values.Length - 1]; Assert.AreEqual(EmptyValue(), emptyItem._date); Assert.IsNull(emptyItem._untyped); }
/// <exception cref="System.Exception"></exception> public virtual void ConcReadSameObject(IExtObjectContainer oc) { var mid = ThreadCount() / 2; var query = oc.Query(); query.Descend("_s").Constrain(testString + mid).And(query.Descend("_i").Constrain (mid)); var result = query.Execute(); Assert.AreEqual(1, result.Count); var expected = new SimpleObject(testString + mid, mid); Assert.AreEqual(expected, result.Next()); }
public virtual void Conc(IExtObjectContainer oc) { IQuery q = oc.Query(); q.Constrain(typeof(Db4objects.Db4o.Tests.Common.Concurrency.QueryForUnknownFieldTestCase )); q.Descend("_name").Constrain("name"); Assert.AreEqual(1, q.Execute().Count); q = oc.Query(); q.Constrain(typeof(Db4objects.Db4o.Tests.Common.Concurrency.QueryForUnknownFieldTestCase )); q.Descend("name").Constrain("name"); Assert.AreEqual(0, q.Execute().Count); }
/// <exception cref="System.Exception"></exception> public virtual void ConcUpdateDifferentObject(IExtObjectContainer oc, int seq) { var query = oc.Query(); query.Descend("_s").Constrain(testString + seq).And(query.Descend("_i").Constrain (seq)); var result = query.Execute(); Assert.AreEqual(1, result.Count); var o = (SimpleObject)result.Next(); o.SetI(seq + Count); oc.Store(o); }
public virtual void Conc(IExtObjectContainer oc) { var q = oc.Query(); q.Constrain(typeof(QueryForUnknownFieldTestCase )); q.Descend("_name").Constrain("name"); Assert.AreEqual(1, q.Execute().Count); q = oc.Query(); q.Constrain(typeof(QueryForUnknownFieldTestCase )); q.Descend("name").Constrain("name"); Assert.AreEqual(0, q.Execute().Count); }
public virtual void Conc(IExtObjectContainer oc) { Db4objects.Db4o.Tests.Common.Concurrency.RefreshTestCase r11 = GetRoot(oc); r11.name = "cc"; oc.Refresh(r11, 0); Assert.AreEqual("cc", r11.name); oc.Refresh(r11, 1); Assert.AreEqual("o1", r11.name); r11.child.name = "cc"; oc.Refresh(r11, 1); Assert.AreEqual("cc", r11.child.name); oc.Refresh(r11, 2); Assert.AreEqual("o2", r11.child.name); }
public virtual void Conc(IExtObjectContainer oc, int seq) { DeepSetTestCase example = new DeepSetTestCase(); example.name = "1"; DeepSetTestCase ds = (DeepSetTestCase)oc.QueryByExample(example).Next(); Assert.AreEqual("1", ds.name); Assert.AreEqual("3", ds.child.child.name); ds.name = "1"; ds.child.name = "12" + seq; ds.child.child.name = "13" + seq; oc.Store(ds, 2); }
public virtual void TestOwnedSemaphoreCannotBeTaken() { IExtObjectContainer client1 = OpenNewSession(); try { Assert.IsTrue(Db().SetSemaphore(SemaphoreName, 0)); Assert.IsFalse(client1.SetSemaphore(SemaphoreName, 0)); } finally { 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(); }
protected override void AssertArrays(IExtObjectContainer objectContainer, object obj) { NestedArrayUpdateTestCase.ItemArrays item = (NestedArrayUpdateTestCase.ItemArrays )obj; AssertPrimitiveArray(item._primitiveArray); AssertPrimitiveArray(item._primitiveArrayInObject); AssertStringArray(item._stringArray); AssertStringArray(item._stringArrayInObject); AssertNestedArray(nestedArrayData, item._nestedArray); AssertNestedArray(nestedArrayData, item._nestedArrayInObject); AssertNestedArray(nestedNestedArrayData, item._nestedNestedArray); AssertNestedArray(nestedNestedArrayData, item._nestedNestedArrayInObject); }
private void TimeQueryLoop(IExtObjectContainer oc, string label, Type clazz) { for (int i = 0; i < Iterations; ++i) { IQuery query = oc.Query(); query.Constrain(clazz); IObjectSet os = query.Execute(); Assert.AreEqual(Instances, os.Count); while (os.HasNext()) { Assert.AreEqual(ArrayLength, ((IIByteArrayHolder)os.Next()).GetBytes().Length); } } }
/// <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(); } } } }
protected override void AssertValues(IExtObjectContainer objectContainer, object[] values) { for (int i = 0; i < data.Length; i++) { StringBufferHandlerUpdateTestCase.Item item = (StringBufferHandlerUpdateTestCase.Item )values[i]; AssertAreEqual(data[i], item._typed); AssertAreEqual(data[i], (StringBuilder)item._untyped); } StringBufferHandlerUpdateTestCase.Item nullItem = (StringBufferHandlerUpdateTestCase.Item )values[values.Length - 1]; Assert.IsNull(nullItem._typed); Assert.IsNull(nullItem._untyped); }
private IInternalObjectContainer ContainerFrom(IReplicationProvider provider) { if (!(provider is IDb4oReplicationProvider)) { return(null); } IDb4oReplicationProvider db4oProvider = (IDb4oReplicationProvider)provider; IExtObjectContainer container = db4oProvider.GetObjectContainer(); if (!(container is IInternalObjectContainer)) { return(null); } return((IInternalObjectContainer)container); }
/// <exception cref="System.Exception"></exception> public virtual void Test() { IExtObjectContainer oc = Db(); _item.name = "1"; DeepSetTestCase.Item item = (DeepSetTestCase.Item)oc.QueryByExample(_item).Next(); item.name = "11"; item.child.name = "12"; oc.Store(item, 2); oc.Deactivate(item, int.MaxValue); item.name = "11"; item = (DeepSetTestCase.Item)oc.QueryByExample(item).Next(); Assert.AreEqual("12", item.child.name); Assert.AreEqual("3", item.child.child.name); }
// do nothing protected override void AssertQueries(IExtObjectContainer objectContainer) { for (int i = 0; i < ObjectCount; i++) { IQuery query = objectContainer.Query(); query.Constrain(typeof(QueryingMigrationTestCase.Car)); query.Descend("_pilot").Descend("_name").Constrain("Pilot " + i); IObjectSet objectSet = query.Execute(); Assert.AreEqual(1, objectSet.Count); QueryingMigrationTestCase.Car car = (QueryingMigrationTestCase.Car)objectSet.Next (); Assert.AreEqual("Car " + i, car._name); Assert.AreEqual("Pilot " + i, car._pilot._name); } }
protected override void AssertValues(IExtObjectContainer objectContainer, object[] values) { for (int i = 0; i < data.Length; i++) { Item item = (Item)values[i]; AssertAreEqual(data[i], item._typedPrimitive); AssertAreEqual(data[i], (uint)item._untyped); AssertAreEqual(data[i], (uint)item._nullablePrimitive); } Item nullItem = (Item)values[data.Length]; AssertAreEqual(0, nullItem._typedPrimitive); Assert.IsNull(nullItem._untyped); Assert.IsNull(nullItem._nullablePrimitive); }
/// <exception cref="System.Exception"></exception> public virtual void TestDeleteAll() { IExtObjectContainer oc = Fixture().Db(); IObjectSet os = oc.QueryByExample(null); while (os.HasNext()) { oc.Delete(os.Next()); } Db().Commit(); Fixture().Reopen(this); oc = Fixture().Db(); os = oc.QueryByExample(null); Assert.AreEqual(0, os.Count); }