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);
}
